4 * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
6 * Contact: Jeongmo Yang <jm80.yang@samsung.com>
8 * Licensed under the Apache License, Version 2.0 (the "License");
9 * you may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
12 * http://www.apache.org/licenses/LICENSE-2.0
14 * Unless required by applicable law or agreed to in writing, software
15 * distributed under the License is distributed on an "AS IS" BASIS,
16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 * See the License for the specific language governing permissions and
18 * limitations under the License.
22 /*===========================================================================================
26 ========================================================================================== */
28 #include <gst/app/gstappsrc.h>
29 #include <gst/video/videooverlay.h>
31 #include <gst/wayland/wayland.h>
42 #include "mm_camcorder_client.h"
43 #include "mm_camcorder_internal.h"
49 static _MMCamcorderInfoConverting g_client_display_info[] = {
52 CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT,
53 MM_CAM_CLIENT_DISPLAY_DEVICE,
54 MM_CAMCORDER_ATTR_NONE,
56 MM_CAMCONVERT_TYPE_INT_ARRAY,
61 CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT,
62 MM_CAM_CLIENT_DISPLAY_MODE,
63 MM_CAMCORDER_ATTR_NONE,
65 MM_CAMCONVERT_TYPE_INT_ARRAY,
70 CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT,
71 MM_CAM_CLIENT_DISPLAY_SURFACE,
72 MM_CAMCORDER_ATTR_NONE,
74 MM_CAMCONVERT_TYPE_INT_ARRAY,
80 static int _storage_device_supported_cb(int storage_id, storage_type_e type, storage_state_e state, const char *path, void *user_data)
82 char **root_directory = (char **)user_data;
84 if (root_directory == NULL) {
85 _mmcam_dbg_warn("user data is NULL");
89 _mmcam_dbg_log("storage id %d, type %d, state %d, path %s",
90 storage_id, type, state, path ? path : "NULL");
92 if (type == STORAGE_TYPE_INTERNAL && path) {
93 if (*root_directory) {
94 free(*root_directory);
95 *root_directory = NULL;
98 *root_directory = strdup(path);
99 if (*root_directory) {
100 _mmcam_dbg_log("get root directory %s", *root_directory);
103 _mmcam_dbg_warn("strdup %s failed");
110 bool _mmcamcorder_client_commit_display_handle(MMHandleType handle, int attr_idx, const mmf_value_t *value)
112 int current_state = MM_CAMCORDER_STATE_NONE;
113 const char *videosink_name = NULL;
114 void *p_handle = NULL;
116 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
117 _MMCamcorderSubContext *sc = NULL;
119 mmf_return_val_if_fail(handle, FALSE);
122 if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
123 _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
127 /* check current state */
128 current_state = _mmcamcorder_get_state(handle);
129 if (current_state < MM_CAMCORDER_STATE_READY) {
130 _mmcam_dbg_log("NOT initialized. this will be applied later");
134 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
136 p_handle = value->value.p_val;
138 /* get videosink name */
139 _mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name);
140 if (videosink_name == NULL) {
141 _mmcam_dbg_err("Please check videosink element in configuration file");
145 _mmcam_dbg_log("Commit : videosinkname[%s]", videosink_name);
147 if (!strcmp(videosink_name, "xvimagesink") ||
148 !strcmp(videosink_name, "ximagesink")) {
149 _mmcam_dbg_log("Commit : Set XID[%x]", *(int*)(p_handle));
150 gst_video_overlay_set_window_handle(GST_VIDEO_OVERLAY(sc->element[_MMCAMCORDER_CLIENT_VIDEOSINK_SINK].gst), *(int*)(p_handle));
151 } else if (!strcmp(videosink_name, "evasimagesink") ||
152 !strcmp(videosink_name, "evaspixmapsink")) {
153 _mmcam_dbg_log("Commit : Set evas object [%p]", p_handle);
154 MMCAMCORDER_G_OBJECT_SET_POINTER(sc->element[_MMCAMCORDER_CLIENT_VIDEOSINK_SINK].gst, "evas-object", p_handle);
156 } else if (!strcmp(videosink_name, "waylandsink")) {
157 MMCamWaylandInfo *wl_info = (MMCamWaylandInfo *)p_handle;
158 GstContext *context = NULL;
160 context = gst_wayland_display_handle_context_new((struct wl_display *)wl_info->display);
162 gst_element_set_context(sc->element[_MMCAMCORDER_CLIENT_VIDEOSINK_SINK].gst, context);
164 _mmcam_dbg_warn("gst_wayland_display_handle_context_new failed");
167 gst_video_overlay_set_window_handle(GST_VIDEO_OVERLAY(sc->element[_MMCAMCORDER_CLIENT_VIDEOSINK_SINK].gst), (guintptr)wl_info->surface);
168 gst_video_overlay_set_render_rectangle(GST_VIDEO_OVERLAY(sc->element[_MMCAMCORDER_CLIENT_VIDEOSINK_SINK].gst),
171 wl_info->window_width,
172 wl_info->window_height);
173 #endif /* HAVE_WAYLAND */
175 _mmcam_dbg_warn("Commit : Nothing to commit with this element[%s]", videosink_name);
179 _mmcam_dbg_warn("Display handle is NULL");
186 bool _mmcamcorder_client_commit_display_rect(MMHandleType handle, int attr_idx, const mmf_value_t *value)
188 int current_state = MM_CAMCORDER_STATE_NONE;
190 const char *videosink_name = NULL;
192 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
193 _MMCamcorderSubContext *sc = NULL;
195 mmf_return_val_if_fail(handle, FALSE);
198 if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
199 _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
203 /* check current state */
204 current_state = _mmcamcorder_get_state(handle);
205 if (current_state < MM_CAMCORDER_STATE_READY) {
206 _mmcam_dbg_log("NOT initialized. this will be applied later");
210 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
212 /* check current method */
213 mm_camcorder_get_attributes(handle, NULL,
214 MMCAM_DISPLAY_GEOMETRY_METHOD, &method,
216 if (method != MM_DISPLAY_METHOD_CUSTOM_ROI) {
217 _mmcam_dbg_log("current method[%d] is not supported rect", method);
221 /* Get videosink name */
222 _mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name);
223 if (videosink_name == NULL) {
224 _mmcam_dbg_err("Please check videosink element in configuration file");
228 if (!strcmp(videosink_name, "xvimagesink") ||
229 !strcmp(videosink_name, "evaspixmapsink")) {
234 int flags = MM_ATTRS_FLAG_NONE;
237 mm_camcorder_get_attributes(handle, NULL,
238 MMCAM_DISPLAY_RECT_X, &rect_x,
239 MMCAM_DISPLAY_RECT_Y, &rect_y,
240 MMCAM_DISPLAY_RECT_WIDTH, &rect_width,
241 MMCAM_DISPLAY_RECT_HEIGHT, &rect_height,
244 case MM_CAM_CLIENT_DISPLAY_RECT_X:
245 mm_camcorder_get_attribute_info(handle, MMCAM_DISPLAY_RECT_Y, &info);
247 memset(&info, 0x00, sizeof(info));
248 mm_camcorder_get_attribute_info(handle, MMCAM_DISPLAY_RECT_WIDTH, &info);
250 memset(&info, 0x00, sizeof(info));
251 mm_camcorder_get_attribute_info(handle, MMCAM_DISPLAY_RECT_HEIGHT, &info);
253 rect_x = value->value.i_val;
255 case MM_CAM_CLIENT_DISPLAY_RECT_Y:
256 mm_camcorder_get_attribute_info(handle, MMCAM_DISPLAY_RECT_WIDTH, &info);
258 memset(&info, 0x00, sizeof(info));
259 mm_camcorder_get_attribute_info(handle, MMCAM_DISPLAY_RECT_HEIGHT, &info);
261 rect_y = value->value.i_val;
263 case MM_CAM_CLIENT_DISPLAY_RECT_WIDTH:
264 mm_camcorder_get_attribute_info(handle, MMCAM_DISPLAY_RECT_HEIGHT, &info);
266 rect_width = value->value.i_val;
268 case MM_CAM_CLIENT_DISPLAY_RECT_HEIGHT:
269 rect_height = value->value.i_val;
272 _mmcam_dbg_err("Wrong attr_idx!");
276 if (!(flags & MM_ATTRS_FLAG_MODIFIED)) {
277 _mmcam_dbg_log("RECT(x,y,w,h) = (%d,%d,%d,%d)",
278 rect_x, rect_y, rect_width, rect_height);
279 g_object_set(sc->element[_MMCAMCORDER_CLIENT_VIDEOSINK_SINK].gst,
282 "dst-roi-w", rect_width,
283 "dst-roi-h", rect_height,
289 _mmcam_dbg_warn("videosink[%s] does not support display rect.", videosink_name);
294 bool _mmcamcorder_client_commit_display_rotation(MMHandleType handle, int attr_idx, const mmf_value_t *value)
296 int current_state = MM_CAMCORDER_STATE_NONE;
298 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
300 mmf_return_val_if_fail(handle, FALSE);
303 if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
304 _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
308 /* check current state */
309 current_state = _mmcamcorder_get_state(handle);
310 if (current_state < MM_CAMCORDER_STATE_READY) {
311 _mmcam_dbg_log("NOT initialized. this will be applied later [rotate:%d]", value->value.i_val);
315 return _mmcamcorder_set_display_rotation(handle, value->value.i_val);
318 bool _mmcamcorder_client_commit_display_visible(MMHandleType handle, int attr_idx, const mmf_value_t *value)
320 int current_state = MM_CAMCORDER_STATE_NONE;
321 const char *videosink_name = NULL;
323 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
324 _MMCamcorderSubContext *sc = NULL;
326 mmf_return_val_if_fail(handle, FALSE);
329 if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
330 _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
334 /* check current state */
335 current_state = _mmcamcorder_get_state(handle);
336 if (current_state < MM_CAMCORDER_STATE_READY) {
337 _mmcam_dbg_log("NOT initialized. this will be applied later");
341 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
343 /* Get videosink name */
344 _mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name);
345 if (videosink_name == NULL) {
346 _mmcam_dbg_err("Please check videosink element in configuration file");
350 if (!strcmp(videosink_name, "xvimagesink") || !strcmp(videosink_name, "evasimagesink") ||
351 !strcmp(videosink_name, "evaspixmapsink")) {
352 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_CLIENT_VIDEOSINK_SINK].gst, "visible", value->value.i_val);
353 _mmcam_dbg_log("Set visible [%d] done.", value->value.i_val);
356 _mmcam_dbg_warn("videosink[%s] does not support VISIBLE.", videosink_name);
361 bool _mmcamcorder_client_commit_display_geometry_method (MMHandleType handle, int attr_idx, const mmf_value_t *value)
364 int current_state = MM_CAMCORDER_STATE_NONE;
365 const char *videosink_name = NULL;
367 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
368 _MMCamcorderSubContext *sc = NULL;
370 mmf_return_val_if_fail(handle, FALSE);
373 if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
374 _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
378 /* check current state */
379 current_state = _mmcamcorder_get_state(handle);
380 if (current_state < MM_CAMCORDER_STATE_READY) {
381 _mmcam_dbg_log("NOT initialized. this will be applied later");
385 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
387 /* Get videosink name */
388 _mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name);
389 if (videosink_name == NULL) {
390 _mmcam_dbg_err("Please check videosink element in configuration file");
394 if (!strcmp(videosink_name, "xvimagesink") || !strcmp(videosink_name, "evasimagesink") ||
395 !strcmp(videosink_name, "evaspixmapsink")) {
396 method = value->value.i_val;
397 MMCAMCORDER_G_OBJECT_SET( sc->element[_MMCAMCORDER_CLIENT_VIDEOSINK_SINK].gst, "display-geometry-method", method);
400 _mmcam_dbg_warn("videosink[%s] does not support geometry method.", videosink_name);
405 bool _mmcamcorder_client_commit_display_scale(MMHandleType handle, int attr_idx, const mmf_value_t *value)
408 int current_state = MM_CAMCORDER_STATE_NONE;
409 const char *videosink_name = NULL;
410 GstElement *vs_element = NULL;
412 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
413 _MMCamcorderSubContext *sc = NULL;
415 mmf_return_val_if_fail(handle, FALSE);
418 if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
419 _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
423 /* check current state */
424 current_state = _mmcamcorder_get_state(handle);
425 if (current_state < MM_CAMCORDER_STATE_READY) {
426 _mmcam_dbg_log("NOT initialized. this will be applied later");
430 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
432 /* Get videosink name */
433 _mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name);
434 if (videosink_name == NULL) {
435 _mmcam_dbg_err("Please check videosink element in configuration file");
439 zoom = value->value.i_val;
440 if (!strcmp(videosink_name, "xvimagesink")) {
441 vs_element = sc->element[_MMCAMCORDER_CLIENT_VIDEOSINK_SINK].gst;
443 MMCAMCORDER_G_OBJECT_SET(vs_element, "zoom", (float)(zoom + 1));
444 _mmcam_dbg_log("Set display zoom to %d", zoom + 1);
448 _mmcam_dbg_warn("videosink[%s] does not support scale", videosink_name);
453 bool _mmcamcorder_client_commit_display_mode(MMHandleType handle, int attr_idx, const mmf_value_t *value)
455 int current_state = MM_CAMCORDER_STATE_NONE;
456 const char *videosink_name = NULL;
458 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
459 _MMCamcorderSubContext *sc = NULL;
461 mmf_return_val_if_fail(handle, FALSE);
464 if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
465 _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
469 /* check current state */
470 current_state = _mmcamcorder_get_state(handle);
471 if (current_state < MM_CAMCORDER_STATE_READY) {
472 _mmcam_dbg_log("NOT initialized. this will be applied later");
476 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
478 _mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name);
479 if (videosink_name == NULL) {
480 _mmcam_dbg_err("Please check videosink element in configuration file");
484 _mmcam_dbg_log("Commit : videosinkname[%s]", videosink_name);
486 if (!strcmp(videosink_name, "xvimagesink")) {
487 _mmcam_dbg_log("Commit : display mode [%d]", value->value.i_val);
488 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_CLIENT_VIDEOSINK_SINK].gst, "display-mode", value->value.i_val);
491 _mmcam_dbg_warn("Commit : This element [%s] does not support display mode", videosink_name);
496 bool _mmcamcorder_client_commit_display_evas_do_scaling(MMHandleType handle, int attr_idx, const mmf_value_t *value)
498 int current_state = MM_CAMCORDER_STATE_NONE;
500 const char *videosink_name = NULL;
502 mmf_camcorder_t *hcamcorder= MMF_CAMCORDER( handle);
503 _MMCamcorderSubContext *sc = NULL;
505 mmf_return_val_if_fail(handle, FALSE);
508 if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
509 _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
513 /* check current state */
514 current_state = _mmcamcorder_get_state(handle);
515 if (current_state < MM_CAMCORDER_STATE_READY) {
516 _mmcam_dbg_log("NOT initialized. this will be applied later");
520 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
522 do_scaling = value->value.i_val;
524 /* Get videosink name */
525 _mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name);
526 if (videosink_name == NULL) {
527 _mmcam_dbg_err("Please check videosink element in configuration file");
531 if (!strcmp(videosink_name, "evaspixmapsink")) {
532 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_CLIENT_VIDEOSINK_SINK].gst, "origin-size", !do_scaling);
533 _mmcam_dbg_log("Set origin-size to %d", !(value->value.i_val));
536 _mmcam_dbg_warn("videosink[%s] does not support scale", videosink_name);
541 bool _mmcamcorder_client_commit_display_flip(MMHandleType handle, int attr_idx, const mmf_value_t *value)
543 int current_state = MM_CAMCORDER_STATE_NONE;
545 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
547 mmf_return_val_if_fail(handle, FALSE);
550 if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
551 _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
555 /* check current state */
556 current_state = _mmcamcorder_get_state(handle);
557 if (current_state < MM_CAMCORDER_STATE_READY) {
558 _mmcam_dbg_log("NOT initialized. this will be applied later [flip:%d]", value->value.i_val);
562 return _mmcamcorder_set_display_flip(handle, value->value.i_val);
565 int _mmcamcorder_client_videosink_window_set(MMHandleType handle, type_element* VideosinkElement)
567 int err = MM_ERROR_NONE;
574 int rotation = MM_DISPLAY_ROTATION_NONE;
575 int flip = MM_FLIP_NONE;
576 int display_mode = MM_DISPLAY_MODE_DEFAULT;
577 int display_geometry_method = MM_DISPLAY_METHOD_LETTER_BOX;
581 int do_scaling = FALSE;
584 char *err_name = NULL;
585 const char *videosink_name = NULL;
587 GstElement *vsink = NULL;
589 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
590 _MMCamcorderSubContext *sc = NULL;
592 mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
593 mmf_return_val_if_fail(VideosinkElement, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
597 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
598 mmf_return_val_if_fail(sc, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
599 mmf_return_val_if_fail(sc->element, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
600 mmf_return_val_if_fail(sc->element[_MMCAMCORDER_CLIENT_VIDEOSINK_SINK].gst, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
602 vsink = sc->element[_MMCAMCORDER_CLIENT_VIDEOSINK_SINK].gst;
604 /* Get video display information */
605 err = mm_camcorder_get_attributes(handle, &err_name,
606 MMCAM_DISPLAY_RECT_X, &retx,
607 MMCAM_DISPLAY_RECT_Y, &rety,
608 MMCAM_DISPLAY_RECT_WIDTH, &retwidth,
609 MMCAM_DISPLAY_RECT_HEIGHT, &retheight,
610 MMCAM_DISPLAY_ROTATION, &rotation,
611 MMCAM_DISPLAY_FLIP, &flip,
612 MMCAM_DISPLAY_VISIBLE, &visible,
613 MMCAM_DISPLAY_HANDLE, (void**)&overlay, &size,
614 MMCAM_DISPLAY_MODE, &display_mode,
615 MMCAM_DISPLAY_GEOMETRY_METHOD, &display_geometry_method,
616 MMCAM_DISPLAY_SCALE, &zoom_attr,
617 MMCAM_DISPLAY_EVAS_DO_SCALING, &do_scaling,
619 if (err != MM_ERROR_NONE) {
621 _mmcam_dbg_err("failed to get attributes [%s][0x%x]", err_name, err);
625 _mmcam_dbg_err("failed to get attributes [0x%x]", err);
631 _mmcam_dbg_log("(overlay=%p, size=%d)", overlay, size);
633 _mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name);
635 if (videosink_name == NULL) {
636 _mmcam_dbg_err("videosink_name is empty");
637 return MM_ERROR_CAMCORDER_INVALID_CONDITION;
641 /* Set display handle */
642 if (!strcmp(videosink_name, "xvimagesink") ||
643 !strcmp(videosink_name, "ximagesink")) {
646 _mmcam_dbg_log("xid = %lu )", xid);
647 gst_video_overlay_set_window_handle(GST_VIDEO_OVERLAY(vsink), xid);
649 _mmcam_dbg_warn("Handle is NULL. Set xid as 0.. but, it's not recommended.");
650 gst_video_overlay_set_window_handle(GST_VIDEO_OVERLAY(vsink), 0);
652 } else if (!strcmp(videosink_name, "evasimagesink") ||
653 !strcmp(videosink_name, "evaspixmapsink")) {
654 _mmcam_dbg_log("videosink : %s, handle : %p", videosink_name, overlay);
656 MMCAMCORDER_G_OBJECT_SET_POINTER(vsink, "evas-object", overlay);
657 MMCAMCORDER_G_OBJECT_SET(vsink, "origin-size", !do_scaling);
659 _mmcam_dbg_err("display handle(eavs object) is NULL");
660 return MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
663 } else if (!strcmp(videosink_name, "waylandsink")) {
664 MMCamWaylandInfo *wl_info = (MMCamWaylandInfo *)overlay;
666 GstContext *context = NULL;
668 context = gst_wayland_display_handle_context_new((struct wl_display *)wl_info->display);
670 gst_element_set_context(vsink, context);
672 _mmcam_dbg_warn("gst_wayland_display_handle_context_new failed");
675 gst_video_overlay_set_window_handle(GST_VIDEO_OVERLAY(vsink), (guintptr)wl_info->surface);
676 gst_video_overlay_set_render_rectangle(GST_VIDEO_OVERLAY(vsink),
679 wl_info->window_width,
680 wl_info->window_height);
682 _mmcam_dbg_warn("Handle is NULL. skip setting.");
684 #endif /* HAVE_WAYLAND */
686 _mmcam_dbg_warn("Who are you?? (Videosink: %s)", videosink_name);
689 _mmcam_dbg_log("%s set: display_geometry_method[%d],origin-size[%d],visible[%d],rotate[%d],flip[%d]",
690 videosink_name, display_geometry_method, origin_size, visible, rotation, flip);
693 if (!strcmp(videosink_name, "xvimagesink") ||
694 !strcmp(videosink_name, "evaspixmapsink")) {
696 MMCAMCORDER_G_OBJECT_SET(vsink, "rotate", rotation);
699 MMCAMCORDER_G_OBJECT_SET(vsink, "flip", flip);
702 case MM_DISPLAY_SCALE_DEFAULT:
705 case MM_DISPLAY_SCALE_DOUBLE_LENGTH:
708 case MM_DISPLAY_SCALE_TRIPLE_LENGTH:
712 _mmcam_dbg_warn("Unsupported zoom value. set as default.");
717 MMCAMCORDER_G_OBJECT_SET(vsink, "display-geometry-method", display_geometry_method);
718 MMCAMCORDER_G_OBJECT_SET(vsink, "display-mode", display_mode);
719 MMCAMCORDER_G_OBJECT_SET(vsink, "visible", visible);
720 MMCAMCORDER_G_OBJECT_SET(vsink, "zoom", zoom_level);
722 if (display_geometry_method == MM_DISPLAY_METHOD_CUSTOM_ROI) {
726 "dst-roi-w", retwidth,
727 "dst-roi-h", retheight,
732 return MM_ERROR_NONE;
735 int _mmcamcorder_client_init_attr_from_configure(MMHandleType handle)
737 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
738 _MMCamcorderInfoConverting *info = NULL;
741 int ret = MM_ERROR_NONE;
743 mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
745 /* Initialize attribute related to display */
746 info = g_client_display_info;
747 table_size = sizeof(g_client_display_info) / sizeof(_MMCamcorderInfoConverting);
748 ret = __mmcamcorder_set_info_to_attr(handle, info, table_size);
749 if (ret != MM_ERROR_NONE) {
750 _mmcam_dbg_err("display info set error : 0x%x", ret);
754 _mmcam_dbg_log("done");
759 MMHandleType _mmcamcorder_client_alloc_attribute(MMHandleType handle)
761 _mmcam_dbg_log( "" );
763 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
764 MMHandleType attrs = 0;
765 mmf_attrs_construct_info_t *attrs_const_info = NULL;
766 unsigned int attr_count = 0;
768 static int visible_values[] = { 0, 1 }; /*0: off, 1:on*/
770 mmf_return_val_if_fail(hcamcorder, NULL);
772 /* Create attribute constructor */
773 _mmcam_dbg_log("start");
775 /* alloc 'mmf_attrs_construct_info_t' */
776 attr_count = MM_CAM_CLIENT_ATTRIBUTE_NUM;
777 attrs_const_info = malloc(attr_count * sizeof(mmf_attrs_construct_info_t));
778 if (!attrs_const_info) {
779 _mmcam_dbg_err("Fail to alloc constructor.");
783 /* alloc default attribute info */
784 hcamcorder->cam_attrs_const_info = (mm_cam_attr_construct_info *)malloc(sizeof(mm_cam_attr_construct_info) * attr_count);
785 if (hcamcorder->cam_attrs_const_info == NULL) {
786 _mmcam_dbg_err("failed to alloc default attribute info");
787 free(attrs_const_info);
788 attrs_const_info = NULL;
792 /* basic attributes' info */
793 mm_cam_attr_construct_info temp_info[] = {
795 MM_CAM_CLIENT_DISPLAY_SOCKET_PATH,
796 MMCAM_DISPLAY_SOCKET_PATH,
797 MMF_VALUE_TYPE_STRING,
800 MM_ATTRS_VALID_TYPE_NONE,
806 MM_CAM_CLIENT_DISPLAY_HANDLE,
811 MM_ATTRS_VALID_TYPE_NONE,
814 _mmcamcorder_client_commit_display_handle,
817 MM_CAM_CLIENT_DISPLAY_DEVICE,
821 {(void*)MM_DISPLAY_DEVICE_MAINLCD},
822 MM_ATTRS_VALID_TYPE_INT_ARRAY,
829 MM_CAM_CLIENT_DISPLAY_SURFACE,
833 {(void*)MM_DISPLAY_SURFACE_X},
834 MM_ATTRS_VALID_TYPE_INT_ARRAY,
840 MM_CAM_CLIENT_DISPLAY_RECT_X,
845 MM_ATTRS_VALID_TYPE_INT_RANGE,
847 {.int_max = _MMCAMCORDER_MAX_INT},
848 _mmcamcorder_client_commit_display_rect,
851 MM_CAM_CLIENT_DISPLAY_RECT_Y,
856 MM_ATTRS_VALID_TYPE_INT_RANGE,
858 {.int_max = _MMCAMCORDER_MAX_INT},
859 _mmcamcorder_client_commit_display_rect,
862 MM_CAM_CLIENT_DISPLAY_RECT_WIDTH,
863 "display-rect-width",
867 MM_ATTRS_VALID_TYPE_INT_RANGE,
869 {.int_max = _MMCAMCORDER_MAX_INT},
870 _mmcamcorder_client_commit_display_rect,
873 MM_CAM_CLIENT_DISPLAY_RECT_HEIGHT,
874 "display-rect-height",
878 MM_ATTRS_VALID_TYPE_INT_RANGE,
880 {.int_max = _MMCAMCORDER_MAX_INT},
881 _mmcamcorder_client_commit_display_rect,
884 MM_CAM_CLIENT_DISPLAY_SOURCE_X,
889 MM_ATTRS_VALID_TYPE_INT_RANGE,
891 {.int_max = _MMCAMCORDER_MAX_INT},
895 MM_CAM_CLIENT_DISPLAY_SOURCE_Y,
900 MM_ATTRS_VALID_TYPE_INT_RANGE,
902 {.int_max = _MMCAMCORDER_MAX_INT},
906 MM_CAM_CLIENT_DISPLAY_SOURCE_WIDTH,
911 MM_ATTRS_VALID_TYPE_INT_RANGE,
913 {.int_max = _MMCAMCORDER_MAX_INT},
917 MM_CAM_CLIENT_DISPLAY_SOURCE_HEIGHT,
918 "display-src-height",
922 MM_ATTRS_VALID_TYPE_INT_RANGE,
924 {.int_max = _MMCAMCORDER_MAX_INT},
928 MM_CAM_CLIENT_DISPLAY_ROTATION,
932 {(void*)MM_DISPLAY_ROTATION_NONE},
933 MM_ATTRS_VALID_TYPE_INT_RANGE,
934 {.int_min = MM_DISPLAY_ROTATION_NONE},
935 {.int_max = MM_DISPLAY_ROTATION_270},
936 _mmcamcorder_client_commit_display_rotation,
939 MM_CAM_CLIENT_DISPLAY_VISIBLE,
944 MM_ATTRS_VALID_TYPE_INT_ARRAY,
946 {ARRAY_SIZE(visible_values)},
947 _mmcamcorder_client_commit_display_visible,
950 MM_CAM_CLIENT_DISPLAY_SCALE,
955 MM_ATTRS_VALID_TYPE_INT_RANGE,
956 {.int_min = MM_DISPLAY_SCALE_DEFAULT},
957 {.int_max = MM_DISPLAY_SCALE_TRIPLE_LENGTH},
958 _mmcamcorder_client_commit_display_scale,
961 MM_CAM_CLIENT_DISPLAY_GEOMETRY_METHOD,
962 "display-geometry-method",
966 MM_ATTRS_VALID_TYPE_INT_RANGE,
967 {.int_min = MM_DISPLAY_METHOD_LETTER_BOX},
968 {.int_max = MM_DISPLAY_METHOD_CUSTOM_ROI},
969 _mmcamcorder_client_commit_display_geometry_method,
972 MM_CAM_CLIENT_DISPLAY_MODE,
976 {(void*)MM_DISPLAY_MODE_DEFAULT},
977 MM_ATTRS_VALID_TYPE_INT_ARRAY,
980 _mmcamcorder_client_commit_display_mode,
983 MM_CAM_CLIENT_DISPLAY_EVAS_SURFACE_SINK,
984 "display-evas-surface-sink",
985 MMF_VALUE_TYPE_STRING,
986 MM_ATTRS_FLAG_READABLE,
988 MM_ATTRS_VALID_TYPE_NONE,
994 MM_CAM_CLIENT_DISPLAY_EVAS_DO_SCALING,
995 "display-evas-do-scaling",
999 MM_ATTRS_VALID_TYPE_INT_RANGE,
1002 _mmcamcorder_client_commit_display_evas_do_scaling,
1005 MM_CAM_CLIENT_DISPLAY_FLIP,
1009 {(void*)MM_FLIP_NONE},
1010 MM_ATTRS_VALID_TYPE_INT_RANGE,
1011 {.int_min = MM_FLIP_NONE},
1012 {.int_max = MM_FLIP_BOTH},
1013 _mmcamcorder_client_commit_display_flip,
1017 memcpy(hcamcorder->cam_attrs_const_info, temp_info, sizeof(mm_cam_attr_construct_info) * attr_count);
1019 for (idx = 0 ; idx < attr_count ; idx++) {
1020 /* attribute order check. This should be same. */
1021 if (idx != hcamcorder->cam_attrs_const_info[idx].attrid) {
1022 _mmcam_dbg_err("Please check attributes order. Is the idx same with enum val?");
1023 free(attrs_const_info);
1024 attrs_const_info = NULL;
1025 free(hcamcorder->cam_attrs_const_info);
1026 hcamcorder->cam_attrs_const_info = NULL;
1030 attrs_const_info[idx].name = hcamcorder->cam_attrs_const_info[idx].name;
1031 attrs_const_info[idx].value_type = hcamcorder->cam_attrs_const_info[idx].value_type;
1032 attrs_const_info[idx].flags = hcamcorder->cam_attrs_const_info[idx].flags;
1033 attrs_const_info[idx].default_value = hcamcorder->cam_attrs_const_info[idx].default_value.value_void;
1036 /* Camcorder Attributes */
1037 _mmcam_dbg_log("Create Camcorder Attributes[%p, %d]", attrs_const_info, attr_count);
1039 attrs = mmf_attrs_new_from_data("Camcorder_Mused_Attributes",
1042 _mmcamcorder_commit_camcorder_attrs,
1045 free(attrs_const_info);
1046 attrs_const_info = NULL;
1049 _mmcam_dbg_err("Fail to alloc attribute handle");
1050 free(hcamcorder->cam_attrs_const_info);
1051 hcamcorder->cam_attrs_const_info = NULL;
1055 for (idx = 0; idx < attr_count; idx++)
1057 _mmcam_dbg_log("Valid type [%s]", hcamcorder->cam_attrs_const_info[idx].name);
1059 mmf_attrs_set_valid_type (attrs, idx, hcamcorder->cam_attrs_const_info[idx].validity_type);
1061 switch (hcamcorder->cam_attrs_const_info[idx].validity_type)
1063 case MM_ATTRS_VALID_TYPE_INT_ARRAY:
1064 if (hcamcorder->cam_attrs_const_info[idx].validity_value_1.int_array &&
1065 hcamcorder->cam_attrs_const_info[idx].validity_value_2.count > 0) {
1066 mmf_attrs_set_valid_array(attrs, idx,
1067 (const int *)(hcamcorder->cam_attrs_const_info[idx].validity_value_1.int_array),
1068 hcamcorder->cam_attrs_const_info[idx].validity_value_2.count,
1069 hcamcorder->cam_attrs_const_info[idx].default_value.value_int);
1072 case MM_ATTRS_VALID_TYPE_INT_RANGE:
1073 _mmcam_dbg_err("MM_ATTRS_VALID_TYPE_INT_RANGE");
1074 mmf_attrs_set_valid_range(attrs, idx,
1075 hcamcorder->cam_attrs_const_info[idx].validity_value_1.int_min,
1076 hcamcorder->cam_attrs_const_info[idx].validity_value_2.int_max,
1077 hcamcorder->cam_attrs_const_info[idx].default_value.value_int);
1079 case MM_ATTRS_VALID_TYPE_DOUBLE_ARRAY:
1080 if (hcamcorder->cam_attrs_const_info[idx].validity_value_1.double_array &&
1081 hcamcorder->cam_attrs_const_info[idx].validity_value_2.count > 0) {
1082 mmf_attrs_set_valid_double_array(attrs, idx,
1083 (const double *)(hcamcorder->cam_attrs_const_info[idx].validity_value_1.double_array),
1084 hcamcorder->cam_attrs_const_info[idx].validity_value_2.count,
1085 hcamcorder->cam_attrs_const_info[idx].default_value.value_double);
1088 case MM_ATTRS_VALID_TYPE_DOUBLE_RANGE:
1089 mmf_attrs_set_valid_double_range(attrs, idx,
1090 hcamcorder->cam_attrs_const_info[idx].validity_value_1.double_min,
1091 hcamcorder->cam_attrs_const_info[idx].validity_value_2.double_max,
1092 hcamcorder->cam_attrs_const_info[idx].default_value.value_double);
1094 case MM_ATTRS_VALID_TYPE_NONE:
1096 case MM_ATTRS_VALID_TYPE_INVALID:
1098 _mmcam_dbg_err("Valid type error.");
1107 __mmcamcorder_client_gstreamer_init(camera_conf * conf)
1109 static const int max_argc = 10;
1113 gchar **argv = NULL;
1115 gboolean ret = FALSE;
1116 type_string_array *GSTInitOption = NULL;
1118 mmf_return_val_if_fail(conf, FALSE);
1123 argc = malloc(sizeof(int));
1124 argv = malloc(sizeof(gchar *) * max_argc);
1126 if (!argc || !argv) {
1130 memset(argv, 0, sizeof(gchar *) * max_argc);
1134 argv[0] = g_strdup("mmcamcorder");
1137 _mmcamcorder_conf_get_value_string_array(conf,
1138 CONFIGURE_CATEGORY_MAIN_GENERAL,
1141 if (GSTInitOption != NULL && GSTInitOption->value) {
1142 cnt_str = GSTInitOption->count;
1143 for( ; *argc < max_argc && *argc <= cnt_str ; (*argc)++ )
1145 argv[*argc] = g_strdup(GSTInitOption->value[(*argc)-1]);
1149 _mmcam_dbg_log("initializing gstreamer with following parameter[argc:%d]", *argc);
1151 for (i = 0; i < *argc; i++) {
1152 _mmcam_dbg_log("argv[%d] : %s", i, argv[i]);
1155 /* initializing gstreamer */
1156 ret = gst_init_check (argc, &argv, &err);
1158 _mmcam_dbg_err("Could not initialize GStreamer: %s ",
1159 err ? err->message : "unknown error occurred");
1166 for (i = 0; i < *argc; i++) {
1182 _mmcam_dbg_err("failed to initialize gstreamer");
1197 int _mmcamcorder_client_create_preview_elements(MMHandleType handle, const char *videosink_name, char *string_caps)
1199 int ret = MM_ERROR_NONE;
1200 GList *element_list = NULL;
1201 GstElement *pipeline = NULL;
1202 char *socket_path = NULL;
1203 int socket_path_length;
1206 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1207 mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
1208 mmf_return_val_if_fail(hcamcorder->sub_context, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
1210 _MMCamcorderSubContext *sc = MMF_CAMCORDER_SUBCONTEXT(handle);
1212 /* create pipeline */
1213 _MMCAMCORDER_PIPELINE_MAKE(sc, sc->element, _MMCAMCORDER_CLIENT_MAIN_PIPE, "camera_client", ret);
1216 if (hcamcorder->use_zero_copy_format) {
1217 _MMCAMCORDER_ELEMENT_MAKE(sc, sc->element, _MMCAMCORDER_CLIENT_VIDEOSRC_SRC, "tizenipcsrc", "client_videosrc_src", element_list, ret);
1219 _MMCAMCORDER_ELEMENT_MAKE(sc, sc->element, _MMCAMCORDER_CLIENT_VIDEOSRC_SRC, "shmsrc", "client_videosrc_src", element_list, ret);
1222 mm_camcorder_get_attributes(handle, NULL,
1223 MMCAM_DISPLAY_SOCKET_PATH, &socket_path, &socket_path_length,
1226 if (socket_path == NULL ) {
1227 _mmcam_dbg_err("socket path is not set");
1228 goto set_videosrc_error;
1231 _mmcam_dbg_err("ipc src socket path : %s", socket_path);
1233 g_object_set(sc->element[_MMCAMCORDER_CLIENT_VIDEOSRC_SRC].gst,
1234 "socket-path", socket_path,
1238 /* create capsfilter */
1239 _MMCAMCORDER_ELEMENT_MAKE(sc, sc->element, _MMCAMCORDER_CLIENT_VIDEOSRC_FILT, "capsfilter", "client_vidoesrc_filt", element_list, ret);
1241 caps = gst_caps_from_string(string_caps);
1242 MMCAMCORDER_G_OBJECT_SET_POINTER(sc->element[_MMCAMCORDER_CLIENT_VIDEOSRC_FILT].gst, "caps", caps);
1244 gst_caps_unref(caps);
1248 /* Making Video sink from here */
1249 _MMCAMCORDER_ELEMENT_MAKE(sc, sc->element, _MMCAMCORDER_CLIENT_VIDEOSINK_QUE, "queue", "client_videosink_queue", element_list, ret);
1251 /* Add color converting element */
1252 if (!strcmp(videosink_name, "evasimagesink") || !strcmp(videosink_name, "ximagesink")) {
1253 _MMCAMCORDER_ELEMENT_MAKE(sc, sc->element, _MMCAMCORDER_CLIENT_VIDEOSINK_CLS, "videoconvert", "client_videosrc_convert", element_list, ret);
1257 _MMCAMCORDER_ELEMENT_MAKE(sc, sc->element, _MMCAMCORDER_CLIENT_VIDEOSINK_SINK, videosink_name, "client_videosink_sink", element_list, ret);
1259 if (strcmp(videosink_name, "fakesink") &&
1260 strcmp(videosink_name, "tizenipcsink") &&
1261 strcmp(videosink_name, "shmsink")) {
1262 if (_mmcamcorder_client_videosink_window_set(handle, sc->VideosinkElement) != MM_ERROR_NONE) {
1263 _mmcam_dbg_err("_mmcamcorder_videosink_window_set error");
1264 ret = MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
1265 goto pipeline_creation_error;
1269 _mmcamcorder_conf_set_value_element_property(sc->element[_MMCAMCORDER_CLIENT_VIDEOSINK_SINK].gst, sc->VideosinkElement);
1271 /* add elements to main pipeline */
1272 if (!_mmcamcorder_add_elements_to_bin(GST_BIN(sc->element[_MMCAMCORDER_CLIENT_MAIN_PIPE].gst), element_list)) {
1273 _mmcam_dbg_err("element_list add error.");
1274 ret = MM_ERROR_CAMCORDER_RESOURCE_CREATION;
1275 goto pipeline_creation_error;
1279 if (!_mmcamcorder_link_elements(element_list)) {
1280 _mmcam_dbg_err( "element link error." );
1281 ret = MM_ERROR_CAMCORDER_GST_LINK;
1282 goto pipeline_creation_error;
1285 pipeline = sc->element[_MMCAMCORDER_CLIENT_MAIN_PIPE].gst;
1287 ret = _mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_PLAYING);
1288 if (ret != MM_ERROR_NONE) {
1289 _mmcam_dbg_err("error : destroy pipeline");
1290 goto pipeline_creation_error;
1294 g_list_free(element_list);
1295 element_list = NULL;
1298 return MM_ERROR_NONE;
1300 pipeline_creation_error:
1301 _MMCAMCORDER_ELEMENT_REMOVE(sc->element, _MMCAMCORDER_CLIENT_VIDEOSINK_SINK);
1302 if (!strcmp(videosink_name, "evasimagesink") || !strcmp(videosink_name, "ximagesink")) {
1303 _MMCAMCORDER_ELEMENT_REMOVE(sc->element, _MMCAMCORDER_CLIENT_VIDEOSINK_CLS);
1305 _MMCAMCORDER_ELEMENT_REMOVE(sc->element, _MMCAMCORDER_CLIENT_VIDEOSINK_QUE);
1307 _MMCAMCORDER_ELEMENT_REMOVE(sc->element, _MMCAMCORDER_CLIENT_VIDEOSRC_SRC);
1308 _MMCAMCORDER_ELEMENT_REMOVE(sc->element, _MMCAMCORDER_CLIENT_MAIN_PIPE);
1311 g_list_free(element_list);
1312 element_list = NULL;
1318 void __mmcamcorder_client_gst_destroy_pipeline(MMHandleType handle)
1320 _MMCamcorderSubContext *sc;
1321 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
1323 if (sc->element[_MMCAMCORDER_CLIENT_MAIN_PIPE].gst) {
1324 MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_CLIENT_VIDEOSINK_QUE].gst, "empty-buffers", TRUE);
1326 _mmcamcorder_gst_set_state(handle, sc->element[_MMCAMCORDER_CLIENT_MAIN_PIPE].gst, GST_STATE_NULL);
1327 _mmcamcorder_remove_all_handlers(handle, _MMCAMCORDER_HANDLER_CATEGORY_ALL);
1329 gst_object_unref(sc->element[_MMCAMCORDER_CLIENT_MAIN_PIPE].gst);
1335 int _mmcamcorder_client_realize(MMHandleType handle, char *string_caps)
1337 int ret = MM_ERROR_NONE;
1338 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1340 _MMCamcorderSubContext *sc;
1341 int display_surface_type = MM_DISPLAY_SURFACE_X;
1342 char *videosink_element_type = NULL;
1343 const char *videosink_name = NULL;
1344 char *err_name = NULL;
1346 mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
1347 _mmcam_dbg_log("Enter");
1349 if (!_MMCAMCORDER_TRYLOCK_CMD(hcamcorder)) {
1350 _mmcam_dbg_err("Another command is running.");
1351 ret = MM_ERROR_CAMCORDER_CMD_IS_RUNNING;
1352 goto _ERR_CAMCORDER_CMD_PRECON;
1355 /* alloc sub context */
1356 hcamcorder->sub_context = _mmcamcorder_alloc_subcontext(hcamcorder->type);
1357 if(!hcamcorder->sub_context) {
1358 ret = MM_ERROR_CAMCORDER_RESOURCE_CREATION;
1359 goto _ERR_CAMCORDER_CMD;
1362 sc = MMF_CAMCORDER_SUBCONTEXT(handle);
1364 ret = mm_camcorder_get_attributes(handle, &err_name,
1365 MMCAM_DISPLAY_SURFACE, &display_surface_type,
1368 if (ret != MM_ERROR_NONE) {
1369 _mmcam_dbg_warn("Get attrs fail. (%s:%x)", err_name, ret);
1370 SAFE_FREE(err_name);
1371 goto _ERR_CAMCORDER_SET_DISPLAY;
1374 _mmcam_dbg_warn("display_surface_type : %d", display_surface_type);
1376 switch (display_surface_type) {
1377 case MM_DISPLAY_SURFACE_X:
1378 videosink_element_type = strdup("VideosinkElementX");
1380 case MM_DISPLAY_SURFACE_EVAS:
1381 videosink_element_type = strdup("VideosinkElementEvas");
1383 case MM_DISPLAY_SURFACE_GL:
1384 videosink_element_type = strdup("VideosinkElementGL");
1386 case MM_DISPLAY_SURFACE_NULL:
1387 videosink_element_type = strdup("VideosinkElementNull");
1390 videosink_element_type = strdup("VideosinkElementX");
1394 /* check string of videosink element */
1395 if (videosink_element_type) {
1396 _mmcamcorder_conf_get_element(handle, hcamcorder->conf_main,
1397 CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT,
1398 videosink_element_type,
1399 &sc->VideosinkElement);
1400 free(videosink_element_type);
1401 videosink_element_type = NULL;
1403 _mmcam_dbg_warn("strdup failed(display_surface_type %d). Use default X type",
1404 display_surface_type);
1406 _mmcamcorder_conf_get_element(handle, hcamcorder->conf_main,
1407 CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT,
1408 _MMCAMCORDER_DEFAULT_VIDEOSINK_TYPE,
1409 &sc->VideosinkElement);
1412 _mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name);
1414 if(videosink_name != NULL) {
1415 _mmcam_dbg_log("Videosink name : %s", videosink_name);
1416 ret = _mmcamcorder_client_create_preview_elements(handle, videosink_name, string_caps);
1417 if (ret != MM_ERROR_NONE) {
1418 _mmcam_dbg_err("create client's preview elements Failed.");
1419 goto _ERR_CAMCORDER_SET_DISPLAY;
1422 _mmcam_dbg_err("Get Videosink name error");
1423 goto _ERR_CAMCORDER_SET_DISPLAY;
1426 /* set command function */
1427 _mmcamcorder_set_state(handle, MM_CAMCORDER_STATE_READY);
1429 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1432 _ERR_CAMCORDER_SET_DISPLAY:
1433 if (hcamcorder->sub_context) {
1434 _mmcamcorder_dealloc_subcontext(hcamcorder->sub_context);
1435 hcamcorder->sub_context = NULL;
1438 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1439 _ERR_CAMCORDER_CMD_PRECON:
1443 int _mmcamcorder_client_unrealize(MMHandleType handle)
1445 int ret = MM_ERROR_NONE;
1446 int state = MM_CAMCORDER_STATE_NONE;
1447 int state_FROM = MM_CAMCORDER_STATE_READY;
1448 int state_TO = MM_CAMCORDER_STATE_NULL;
1450 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1451 mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
1452 _mmcam_dbg_log("Enter");
1455 _mmcam_dbg_err("Not initialized");
1456 ret = MM_ERROR_CAMCORDER_NOT_INITIALIZED;
1460 _mmcam_dbg_log("try lock");
1461 if (!_MMCAMCORDER_TRYLOCK_CMD(hcamcorder)) {
1462 _mmcam_dbg_err("Another command is running.");
1463 ret = MM_ERROR_CAMCORDER_CMD_IS_RUNNING;
1464 goto _ERR_CAMCORDER_CMD_PRECON;
1467 state = _mmcamcorder_get_state(handle);
1468 if (state != state_FROM) {
1469 _mmcam_dbg_err("Wrong state(%d)", state);
1470 ret = MM_ERROR_CAMCORDER_INVALID_STATE;
1471 goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
1474 /* Release SubContext */
1475 if (hcamcorder->sub_context) {
1476 /* destroy pipeline */
1477 _mmcam_dbg_warn("destroy pipeline");
1478 __mmcamcorder_client_gst_destroy_pipeline(handle);
1479 /* Deallocate SubContext */
1480 _mmcamcorder_dealloc_subcontext(hcamcorder->sub_context);
1481 hcamcorder->sub_context = NULL;
1484 /* Deinitialize main context member */
1485 hcamcorder->command = NULL;
1487 _mmcam_dbg_log("un lock");
1488 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1490 _mmcamcorder_set_state(handle, state_TO);
1492 return MM_ERROR_NONE;
1494 _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK:
1495 _mmcam_dbg_log("un lock");
1496 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1498 _ERR_CAMCORDER_CMD_PRECON:
1500 _mmcam_dbg_err("Unrealize fail (type %d, ret %x)",
1501 hcamcorder->type, ret);
1506 static int _mm_camcorder_client_set_socket_path(MMHandleType handle, const char *path)
1508 int ret = MM_ERROR_NONE;
1510 _mmcam_dbg_log("handle : 0x%x, path:%s", handle, path);
1512 mm_camcorder_set_attributes(handle, NULL,
1513 MMCAM_DISPLAY_SOCKET_PATH, path, strlen(path),
1519 int mm_camcorder_client_create(MMHandleType *handle)
1521 int ret = MM_ERROR_NONE;
1522 mmf_camcorder_t *hcamcorder = NULL;
1524 _mmcam_dbg_log("Enter");
1525 mmf_return_val_if_fail(handle, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
1527 /* Create mmf_camcorder_t handle and initialize every variable */
1528 hcamcorder = (mmf_camcorder_t *)malloc(sizeof(mmf_camcorder_t));
1529 mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_LOW_MEMORY);
1530 memset(hcamcorder, 0x00, sizeof(mmf_camcorder_t));
1533 hcamcorder->type = 0;
1534 hcamcorder->state = MM_CAMCORDER_STATE_NONE;
1535 hcamcorder->sub_context = NULL;
1536 hcamcorder->target_state = MM_CAMCORDER_STATE_NULL;
1537 hcamcorder->capture_in_recording = FALSE;
1539 g_mutex_init(&(hcamcorder->mtsafe).lock);
1540 g_cond_init(&(hcamcorder->mtsafe).cond);
1541 g_mutex_init(&(hcamcorder->mtsafe).cmd_lock);
1542 g_mutex_init(&(hcamcorder->mtsafe).state_lock);
1543 g_mutex_init(&(hcamcorder->mtsafe).gst_state_lock);
1544 g_mutex_init(&(hcamcorder->mtsafe).message_cb_lock);
1545 g_mutex_init(&hcamcorder->restart_preview_lock);
1547 /* Get Camera Configure information from Camcorder INI file */
1548 _mmcamcorder_conf_get_info((MMHandleType)hcamcorder, CONFIGURE_TYPE_MAIN, CONFIGURE_MAIN_FILE, &hcamcorder->conf_main);
1550 if (!(hcamcorder->conf_main)) {
1551 _mmcam_dbg_err( "Failed to get configure(main) info." );
1553 ret = MM_ERROR_CAMCORDER_CREATE_CONFIGURE;
1554 goto _ERR_CAMCORDER_CREATE_CONFIGURE;
1556 _mmcam_dbg_log("aloc attribute handle : 0x%x", (MMHandleType)hcamcorder);
1557 hcamcorder->attributes = _mmcamcorder_client_alloc_attribute((MMHandleType)hcamcorder);
1558 if (!(hcamcorder->attributes)) {
1559 _mmcam_dbg_err("_mmcamcorder_create::alloc attribute error.");
1561 ret = MM_ERROR_CAMCORDER_RESOURCE_CREATION;
1562 goto _ERR_CAMCORDER_RESOURCE_CREATION;
1565 ret = __mmcamcorder_client_gstreamer_init(hcamcorder->conf_main);
1567 _mmcam_dbg_err( "Failed to initialize gstreamer!!" );
1568 ret = MM_ERROR_CAMCORDER_NOT_INITIALIZED;
1569 goto _ERR_DEFAULT_VALUE_INIT;
1572 ret = _mmcamcorder_client_init_attr_from_configure((MMHandleType)hcamcorder);
1573 if (ret != MM_ERROR_NONE) {
1574 _mmcam_dbg_warn("client_init_attr_from_configure error!!");
1575 ret = MM_ERROR_CAMCORDER_INTERNAL;
1576 goto _ERR_DEFAULT_VALUE_INIT;
1579 /* Get UseZeroCopyFormat value from INI */
1580 _mmcamcorder_conf_get_value_int((MMHandleType)hcamcorder, hcamcorder->conf_main,
1581 CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
1582 "UseZeroCopyFormat",
1583 &(hcamcorder->use_zero_copy_format));
1585 /* Set initial state */
1586 _mmcamcorder_set_state((MMHandleType)hcamcorder, MM_CAMCORDER_STATE_NULL);
1588 _mmcam_dbg_log("created handle %p - UseZeroCopyFormat %d",
1589 hcamcorder, hcamcorder->use_zero_copy_format);
1591 *handle = (MMHandleType)hcamcorder;
1592 _mmcam_dbg_log("created client handle : 0x%x", *handle);
1594 return MM_ERROR_NONE;
1596 _ERR_CAMCORDER_CREATE_CONFIGURE:
1597 _ERR_CAMCORDER_RESOURCE_CREATION:
1598 _ERR_DEFAULT_VALUE_INIT:
1599 /* Release lock, cond */
1600 g_mutex_clear(&(hcamcorder->mtsafe).lock);
1601 g_cond_clear(&(hcamcorder->mtsafe).cond);
1602 g_mutex_clear(&(hcamcorder->mtsafe).cmd_lock);
1603 g_mutex_clear(&(hcamcorder->mtsafe).state_lock);
1604 g_mutex_clear(&(hcamcorder->mtsafe).gst_state_lock);
1605 g_mutex_clear(&(hcamcorder->mtsafe).gst_encode_state_lock);
1606 g_mutex_clear(&(hcamcorder->mtsafe).message_cb_lock);
1608 g_mutex_clear(&(hcamcorder->restart_preview_lock));
1610 if (hcamcorder->conf_ctrl) {
1611 _mmcamcorder_conf_release_info(handle, &hcamcorder->conf_ctrl);
1614 if (hcamcorder->conf_main) {
1615 _mmcamcorder_conf_release_info(handle, &hcamcorder->conf_main);
1618 /* Release handle */
1619 memset(hcamcorder, 0x00, sizeof(mmf_camcorder_t));
1625 void mm_camcorder_client_destroy(MMHandleType handle)
1627 mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
1629 _mmcam_dbg_log("try lock");
1631 if (!_MMCAMCORDER_TRYLOCK_CMD(hcamcorder)) {
1632 _mmcam_dbg_err("Another command is running.");
1633 goto _ERR_CAMCORDER_CMD_PRECON;
1636 if (hcamcorder->attributes) {
1637 _mmcamcorder_dealloc_attribute(handle, hcamcorder->attributes);
1640 _mmcam_dbg_log("unlock");
1641 _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
1643 g_mutex_clear(&((hcamcorder->mtsafe).lock));
1644 g_cond_clear(&((hcamcorder->mtsafe).cond));
1645 g_mutex_clear(&((hcamcorder->mtsafe).cmd_lock));
1646 g_mutex_clear(&((hcamcorder->mtsafe).state_lock));
1647 g_mutex_clear(&((hcamcorder->mtsafe).gst_state_lock));
1648 g_mutex_clear(&((hcamcorder->mtsafe).message_cb_lock));
1649 g_mutex_clear(&(hcamcorder->restart_preview_lock));
1650 _mmcamcorder_set_state((MMHandleType)hcamcorder, MM_CAMCORDER_STATE_NONE);
1651 /* Release handle */
1652 memset(hcamcorder, 0x00, sizeof(mmf_camcorder_t));
1655 _ERR_CAMCORDER_CMD_PRECON:
1659 int mm_camcorder_client_realize(MMHandleType handle, char *caps)
1661 int ret = MM_ERROR_NONE;
1662 ret = _mmcamcorder_client_realize(handle, caps);
1666 int mm_camcorder_client_unrealize(MMHandleType handle)
1668 int ret = MM_ERROR_NONE;
1669 ret = _mmcamcorder_client_unrealize(handle);
1673 int mm_camcorder_client_set_socket_path(MMHandleType handle, const char *path)
1675 int ret = MM_ERROR_NONE;
1676 _mmcam_dbg_log("Entered ");
1677 ret = _mm_camcorder_client_set_socket_path(handle, path);
1681 int mm_camcorder_client_get_root_directory(char **root_directory)
1683 int ret = STORAGE_ERROR_NONE;
1685 if (root_directory == NULL) {
1686 _mmcam_dbg_warn("user data is NULL");
1687 return MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
1690 ret = storage_foreach_device_supported((storage_device_supported_cb)_storage_device_supported_cb, root_directory);
1691 if (ret != STORAGE_ERROR_NONE) {
1692 _mmcam_dbg_err("storage_foreach_device_supported failed 0x%x", ret);
1693 return MM_ERROR_CAMCORDER_INTERNAL;
1696 return MM_ERROR_NONE;