include/camera_private.h

   1 /*
   2 * Copyright (c) 2011 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 #ifndef __TIZEN_MULTIMEDIA_CAMERA_PRIVATE_H__
  18 #define __TIZEN_MULTIMEDIA_CAMERA_PRIVATE_H__
  19
  20 #include <glib.h>
  21 #include <dlog.h>
  22 #include <camera_internal.h>
  23 #include <media_bridge_internal.h>
  24 #include <muse_core.h>
  25 #include <muse_camera.h>
  26 #include <mm_display_interface.h>
  27 #include <mm_camcorder.h>
  28
  29 #ifdef __cplusplus
  30 extern "C" {
  31 #endif
  32
  33 #define CAMERA_CB_TIMEOUT                   4
  34 #ifndef TIZEN_FEATURE_NO_TIMEOUT_FOR_PREVIEW
  35 #define CAMERA_CB_TIMEOUT_FOR_PREVIEW       10
  36 #endif
  37 #define CAMERA_CB_NO_TIMEOUT                0
  38 #define CAMERA_FD_INIT                      -1
  39 #define CAMERA_IS_FD_VALID(fd)              (fd > CAMERA_FD_INIT)
  40 #define CAMERA_MONITORING_INFO_STREAM_ID_PREVIEW       -1
  41 #define CAMERA_MONITORING_INFO_STREAM_ID_PREVIEW_MP    -2
  42
  43
  44 #define CAMERA_MSG_PARAM_SET(param, msg_type, set_value) { \
  45         param.type = MUSE_TYPE_##msg_type; \
  46         param.name = #set_value; \
  47         param.value.value_##msg_type = set_value; \
  48 }
  49
  50 #define CAMERA_MSG_PARAM_SET_ARRAY(param, msg_type, set_value, size) { \
  51         param.type = MUSE_TYPE_##msg_type; \
  52         param.name = #set_value; \
  53         param.value.value_##msg_type = set_value; \
  54         param.value_size = size; \
  55 }
  56
  57 #define CAM_LOG_CRITICAL(format, args...) \
  58         do { \
  59                 if (_camera_get_log_level() >= CAMERA_LOG_LEVEL_CRITICAL) \
  60                         LOGF(format, ##args); \
  61         } while (0)
  62
  63 #define CAM_LOG_ERROR(format, args...) \
  64         do { \
  65                 if (_camera_get_log_level() >= CAMERA_LOG_LEVEL_ERROR) \
  66                         LOGE(format, ##args); \
  67         } while (0)
  68
  69 #define CAM_LOG_WARNING(format, args...) \
  70         do { \
  71                 if (_camera_get_log_level() >= CAMERA_LOG_LEVEL_WARNING) \
  72                         LOGW(format, ##args); \
  73         } while (0)
  74
  75 #define CAM_LOG_INFO(format, args...) \
  76         do { \
  77                 if (_camera_get_log_level() >= CAMERA_LOG_LEVEL_INFO) \
  78                         LOGI(format, ##args); \
  79         } while (0)
  80
  81 #define CAM_LOG_DEBUG(format, args...) \
  82         do { \
  83                 if (_camera_get_log_level() >= CAMERA_LOG_LEVEL_DEBUG) \
  84                         LOGD(format, ##args); \
  85         } while (0)
  86
  87 #define CAM_LOG_VERBOSE(format, args...) \
  88         do { \
  89                 if (_camera_get_log_level() >= CAMERA_LOG_LEVEL_VERBOSE) \
  90                         LOGD("[V] "format, ##args); \
  91         } while (0)
  92
  93 #define CAMERA_CHECK_HANDLE_RETURN(pc) \
  94         do {\
  95                 if (!pc || !pc->cb_info) {\
  96                         CAM_LOG_ERROR("NULL handle[%p]", pc);\
  97                         return;\
  98                 }\
  99         } while (0)
 100
 101 #define CAMERA_CHECK_HANDLE_RETURN_VAL(pc, val) \
 102         do {\
 103                 if (!pc || !pc->cb_info) {\
 104                         CAM_LOG_ERROR("NULL handle[%p]", pc);\
 105                         return (val);\
 106                 }\
 107         } while (0)
 108
 109 #define CAMERA_CHECK_THREAD_RETURN_VAL(thread_to_check, val, error_msg) \
 110         do {\
 111                 if (thread_to_check == g_thread_self()) {\
 112                         CAM_LOG_ERROR(error_msg);\
 113                         return (val);\
 114                 }\
 115         } while (0)
 116
 117
 118 enum {
 119         CAMERA_MESSAGE_HANDLER_TYPE_GENERAL,
 120         CAMERA_MESSAGE_HANDLER_TYPE_PREVIEW_CB,
 121         CAMERA_MESSAGE_HANDLER_TYPE_CAPTURE_CB
 122 };
 123
 124 enum {
 125         CAMERA_LOG_LEVEL_CRITICAL = 0,
 126         CAMERA_LOG_LEVEL_ERROR,
 127         CAMERA_LOG_LEVEL_WARNING,
 128         CAMERA_LOG_LEVEL_INFO,
 129         CAMERA_LOG_LEVEL_DEBUG,
 130         CAMERA_LOG_LEVEL_VERBOSE
 131 };
 132
 133 typedef struct _camera_msg_handler_info_s {
 134         int type;
 135         void *cb_info;
 136         int running;
 137         GCond cond;
 138         GMutex lock;
 139         GQueue *queue;
 140         GThread *thread;
 141 } camera_msg_handler_info_s;
 142
 143 typedef struct _monitoring_info_sub_s {
 144         unsigned long long frame_count;
 145         gdouble elapsed_sec_accum;
 146         gdouble elapsed_sec_peak;
 147 } monitoring_info_sub_s;
 148
 149 typedef struct _camera_preview_cb_monitoring_info_s {
 150         int stream_id;
 151         GTimer *timer_calling;
 152         GTimer *timer_interval;
 153         monitoring_info_sub_s *total;
 154         monitoring_info_sub_s *interval;
 155 } camera_preview_cb_monitoring_info_s;
 156
 157 typedef struct _camera_cb_info_s {
 158         /* server connection */
 159         gint fd;
 160         GMutex fd_lock;
 161         gboolean is_server_connected;
 162
 163         /* message receive thread */
 164         GThread *msg_recv_thread;
 165         gint msg_recv_running;
 166         gchar recv_msg[MUSE_MSG_MAX_LENGTH + 1];
 167         GCond api_cond[MUSE_CAMERA_API_MAX];
 168         GMutex api_lock[MUSE_CAMERA_API_MAX];
 169         gint api_activating[MUSE_CAMERA_API_MAX];
 170         gint api_waiting[MUSE_CAMERA_API_MAX];
 171         gint api_ret[MUSE_CAMERA_API_MAX];
 172
 173         /* general message handler info */
 174         camera_msg_handler_info_s msg_handler_info;
 175
 176         /* preview cb message handler info */
 177         camera_msg_handler_info_s preview_cb_info;
 178
 179         /* capture cb message handler info */
 180         camera_msg_handler_info_s capture_cb_info;
 181
 182         /* idle event */
 183         GList *idle_event_list;
 184
 185         /* user callback */
 186         gpointer user_cb[MUSE_CAMERA_EVENT_TYPE_NUM];
 187         gpointer user_data[MUSE_CAMERA_EVENT_TYPE_NUM];
 188         GMutex user_cb_lock[MUSE_CAMERA_EVENT_TYPE_NUM];
 189         gboolean invoke_preview_cb;
 190
 191         /* tbm */
 192         tbm_bufmgr bufmgr;
 193         gboolean user_buffer_supported;
 194         tbm_bo bos[MUSE_NUM_FD];
 195         tbm_fd fds[MUSE_NUM_FD];
 196
 197         /* media packet */
 198         media_format_h pkt_fmt;
 199         GMutex mp_data_lock;
 200
 201         /* preview */
 202         camera_pixel_format_e preview_format;
 203
 204         /* display */
 205         muse_camera_display_info_s dp_info;
 206         mm_display_interface_h dp_interface;
 207         gboolean run_evas_render;
 208         gboolean is_evas_render;
 209
 210         /* get values */
 211         gint get_int[MUSE_CAMERA_GET_INT_NUM];
 212         gint get_int_pair[MUSE_CAMERA_GET_INT_PAIR_NUM][2];
 213         gchar get_string[MUSE_CAMERA_GET_STRING_NUM][MUSE_CAMERA_MSG_MAX_LENGTH];
 214         gdouble get_geotag[3];
 215         gint get_display_roi_area[4];
 216         gint get_extra_preview_stream_format[4];
 217
 218         /* media bridge */
 219         media_bridge_h bridge;
 220         GMutex bridge_lock;
 221
 222         /* preview stream */
 223         MMCamcorderVideoStreamDataType *stream_data;
 224         camera_preview_cb_monitoring_info_s *monitoring_info_preview;
 225         camera_preview_cb_monitoring_info_s *monitoring_info_preview_mp;
 226         camera_preview_cb_monitoring_info_s *monitoring_info_preview_ex[MM_CAMCORDER_EXTRA_PREVIEW_STREAM_MAX];
 227
 228         /* network */
 229         gboolean is_network;
 230 } camera_cb_info_s;
 231
 232 typedef struct _camera_message_s {
 233         gchar recv_msg[MUSE_CAMERA_MSG_MAX_LENGTH + 1];
 234         muse_camera_api_e api;
 235         muse_camera_event_e event;
 236         muse_camera_event_class_e event_class;
 237         int tfd[MUSE_NUM_FD];
 238 } camera_message_s;
 239
 240 typedef struct _camera_idle_event_s {
 241         camera_cb_info_s *cb_info;
 242         gchar recv_msg[MUSE_CAMERA_MSG_MAX_LENGTH + 1];
 243         muse_camera_event_e event;
 244         int tfd[MUSE_NUM_FD];
 245 } camera_idle_event_s;
 246
 247 typedef struct _camera_cli_s {
 248         intptr_t remote_handle;
 249         camera_cb_info_s *cb_info;
 250 } camera_cli_s;
 251
 252 typedef struct _camera_media_packet_data {
 253         int ret_fd;
 254         tbm_fd fd;
 255         tbm_fd data_fd;
 256         tbm_fd buffer_fd[MUSE_NUM_FD];
 257         tbm_bo bo;
 258         tbm_bo buffer_bo[BUFFER_MAX_PLANE_NUM];
 259         int num_buffer_fd;
 260         tbm_bo data_bo;
 261 } camera_media_packet_data;
 262
 263 typedef struct _camera_msg_param {
 264         int type;
 265         const char *name;
 266         union {
 267                 int value_INT;
 268                 const char *value_STRING;
 269                 void *value_ARRAY;
 270         } value;
 271         int value_size;
 272 } camera_msg_param;
 273
 274 typedef struct _camera_cb_info {
 275         int id;
 276         void *callback;
 277         void *user_data;
 278 } camera_cb_info;
 279
 280
 281 int _camera_get_tbm_format(int in_format, uint32_t *out_format);
 282 int _camera_get_media_packet_mimetype(int in_format, media_format_mimetype_e *mimetype);
 283 void _camera_media_packet_dispose(media_packet_h pkt, void *user_data);
 284 int _camera_start_evas_rendering(camera_h camera);
 285 int _camera_stop_evas_rendering(camera_h camera, bool keep_screen);
 286 int _camera_independent_request(int api, int device_type, const char *key, int *value);
 287 int _camera_set_display(camera_h camera, mm_display_type_e type, void *display);
 288 int _camera_create_private(camera_device_e device, bool is_network, camera_h *camera);
 289 void _camera_msg_send(int api, int *fds, camera_cb_info_s *cb_info,
 290         int *ret, int timeout);
 291 void _camera_msg_send_param1(int api, camera_cb_info_s *cb_info,
 292         int *ret, camera_msg_param *param, int timeout);
 293 void _camera_msg_send_param2_int(int api, camera_cb_info_s *cb_info,
 294         int *ret, camera_msg_param *param0, camera_msg_param *param1, int timeout);
 295 void _camera_msg_return_buffer(int ret_fd, camera_cb_info_s *cb_info);
 296 int _camera_client_wait_for_cb_return(muse_camera_api_e api, camera_cb_info_s *cb_info, int time_out);
 297 void _camera_update_api_waiting(camera_cb_info_s *cb_info, int api, int value);
 298 void _camera_send_message_get_return(camera_cb_info_s *cb_info, muse_camera_api_e api, char *msg,
 299         int time_out, int *ret);
 300 int _camera_get_log_level(void);
 301 int _camera_attr_set_level(camera_h camera, muse_camera_api_e api, int level);
 302 int _camera_attr_get_level(camera_h camera, muse_camera_api_e api, muse_camera_get_int_e get_index, int *level);
 303 int _camera_attr_get_range(camera_h camera, muse_camera_api_e api, muse_camera_get_int_pair_e get_index, int *min, int *max);
 304 bool __is_supported(camera_h camera, muse_camera_api_e api);
 305
 306 typedef bool (*camera_supported_cb_param1)(int param, void *user_data);
 307 typedef bool (*camera_supported_cb_param2)(int param1, int param2, void *user_data);
 308
 309 #ifdef __cplusplus
 310 }
 311 #endif
 312
 313 #endif /* __TIZEN_MULTIMEDIA_CAMERA_PRIVATE_H__ */
 314