--- /dev/null
+Jeongmo Yang <jm80.yang at samsung dot com>
+Jonghyuk Choi <jhchoi.choi at samsung dot com>
--- /dev/null
+Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.\r
+\r
+ Apache License\r
+ Version 2.0, January 2004\r
+ http://www.apache.org/licenses/\r
+\r
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\r
+\r
+ 1. Definitions.\r
+\r
+ "License" shall mean the terms and conditions for use, reproduction,\r
+ and distribution as defined by Sections 1 through 9 of this document.\r
+\r
+ "Licensor" shall mean the copyright owner or entity authorized by\r
+ the copyright owner that is granting the License.\r
+\r
+ "Legal Entity" shall mean the union of the acting entity and all\r
+ other entities that control, are controlled by, or are under common\r
+ control with that entity. For the purposes of this definition,\r
+ "control" means (i) the power, direct or indirect, to cause the\r
+ direction or management of such entity, whether by contract or\r
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the\r
+ outstanding shares, or (iii) beneficial ownership of such entity.\r
+\r
+ "You" (or "Your") shall mean an individual or Legal Entity\r
+ exercising permissions granted by this License.\r
+\r
+ "Source" form shall mean the preferred form for making modifications,\r
+ including but not limited to software source code, documentation\r
+ source, and configuration files.\r
+\r
+ "Object" form shall mean any form resulting from mechanical\r
+ transformation or translation of a Source form, including but\r
+ not limited to compiled object code, generated documentation,\r
+ and conversions to other media types.\r
+\r
+ "Work" shall mean the work of authorship, whether in Source or\r
+ Object form, made available under the License, as indicated by a\r
+ copyright notice that is included in or attached to the work\r
+ (an example is provided in the Appendix below).\r
+\r
+ "Derivative Works" shall mean any work, whether in Source or Object\r
+ form, that is based on (or derived from) the Work and for which the\r
+ editorial revisions, annotations, elaborations, or other modifications\r
+ represent, as a whole, an original work of authorship. For the purposes\r
+ of this License, Derivative Works shall not include works that remain\r
+ separable from, or merely link (or bind by name) to the interfaces of,\r
+ the Work and Derivative Works thereof.\r
+\r
+ "Contribution" shall mean any work of authorship, including\r
+ the original version of the Work and any modifications or additions\r
+ to that Work or Derivative Works thereof, that is intentionally\r
+ submitted to Licensor for inclusion in the Work by the copyright owner\r
+ or by an individual or Legal Entity authorized to submit on behalf of\r
+ the copyright owner. For the purposes of this definition, "submitted"\r
+ means any form of electronic, verbal, or written communication sent\r
+ to the Licensor or its representatives, including but not limited to\r
+ communication on electronic mailing lists, source code control systems,\r
+ and issue tracking systems that are managed by, or on behalf of, the\r
+ Licensor for the purpose of discussing and improving the Work, but\r
+ excluding communication that is conspicuously marked or otherwise\r
+ designated in writing by the copyright owner as "Not a Contribution."\r
+\r
+ "Contributor" shall mean Licensor and any individual or Legal Entity\r
+ on behalf of whom a Contribution has been received by Licensor and\r
+ subsequently incorporated within the Work.\r
+\r
+ 2. Grant of Copyright License. Subject to the terms and conditions of\r
+ this License, each Contributor hereby grants to You a perpetual,\r
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable\r
+ copyright license to reproduce, prepare Derivative Works of,\r
+ publicly display, publicly perform, sublicense, and distribute the\r
+ Work and such Derivative Works in Source or Object form.\r
+\r
+ 3. Grant of Patent License. Subject to the terms and conditions of\r
+ this License, each Contributor hereby grants to You a perpetual,\r
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable\r
+ (except as stated in this section) patent license to make, have made,\r
+ use, offer to sell, sell, import, and otherwise transfer the Work,\r
+ where such license applies only to those patent claims licensable\r
+ by such Contributor that are necessarily infringed by their\r
+ Contribution(s) alone or by combination of their Contribution(s)\r
+ with the Work to which such Contribution(s) was submitted. If You\r
+ institute patent litigation against any entity (including a\r
+ cross-claim or counterclaim in a lawsuit) alleging that the Work\r
+ or a Contribution incorporated within the Work constitutes direct\r
+ or contributory patent infringement, then any patent licenses\r
+ granted to You under this License for that Work shall terminate\r
+ as of the date such litigation is filed.\r
+\r
+ 4. Redistribution. You may reproduce and distribute copies of the\r
+ Work or Derivative Works thereof in any medium, with or without\r
+ modifications, and in Source or Object form, provided that You\r
+ meet the following conditions:\r
+\r
+ (a) You must give any other recipients of the Work or\r
+ Derivative Works a copy of this License; and\r
+\r
+ (b) You must cause any modified files to carry prominent notices\r
+ stating that You changed the files; and\r
+\r
+ (c) You must retain, in the Source form of any Derivative Works\r
+ that You distribute, all copyright, patent, trademark, and\r
+ attribution notices from the Source form of the Work,\r
+ excluding those notices that do not pertain to any part of\r
+ the Derivative Works; and\r
+\r
+ (d) If the Work includes a "NOTICE" text file as part of its\r
+ distribution, then any Derivative Works that You distribute must\r
+ include a readable copy of the attribution notices contained\r
+ within such NOTICE file, excluding those notices that do not\r
+ pertain to any part of the Derivative Works, in at least one\r
+ of the following places: within a NOTICE text file distributed\r
+ as part of the Derivative Works; within the Source form or\r
+ documentation, if provided along with the Derivative Works; or,\r
+ within a display generated by the Derivative Works, if and\r
+ wherever such third-party notices normally appear. The contents\r
+ of the NOTICE file are for informational purposes only and\r
+ do not modify the License. You may add Your own attribution\r
+ notices within Derivative Works that You distribute, alongside\r
+ or as an addendum to the NOTICE text from the Work, provided\r
+ that such additional attribution notices cannot be construed\r
+ as modifying the License.\r
+\r
+ You may add Your own copyright statement to Your modifications and\r
+ may provide additional or different license terms and conditions\r
+ for use, reproduction, or distribution of Your modifications, or\r
+ for any such Derivative Works as a whole, provided Your use,\r
+ reproduction, and distribution of the Work otherwise complies with\r
+ the conditions stated in this License.\r
+\r
+ 5. Submission of Contributions. Unless You explicitly state otherwise,\r
+ any Contribution intentionally submitted for inclusion in the Work\r
+ by You to the Licensor shall be under the terms and conditions of\r
+ this License, without any additional terms or conditions.\r
+ Notwithstanding the above, nothing herein shall supersede or modify\r
+ the terms of any separate license agreement you may have executed\r
+ with Licensor regarding such Contributions.\r
+\r
+ 6. Trademarks. This License does not grant permission to use the trade\r
+ names, trademarks, service marks, or product names of the Licensor,\r
+ except as required for reasonable and customary use in describing the\r
+ origin of the Work and reproducing the content of the NOTICE file.\r
+\r
+ 7. Disclaimer of Warranty. Unless required by applicable law or\r
+ agreed to in writing, Licensor provides the Work (and each\r
+ Contributor provides its Contributions) on an "AS IS" BASIS,\r
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or\r
+ implied, including, without limitation, any warranties or conditions\r
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A\r
+ PARTICULAR PURPOSE. You are solely responsible for determining the\r
+ appropriateness of using or redistributing the Work and assume any\r
+ risks associated with Your exercise of permissions under this License.\r
+\r
+ 8. Limitation of Liability. In no event and under no legal theory,\r
+ whether in tort (including negligence), contract, or otherwise,\r
+ unless required by applicable law (such as deliberate and grossly\r
+ negligent acts) or agreed to in writing, shall any Contributor be\r
+ liable to You for damages, including any direct, indirect, special,\r
+ incidental, or consequential damages of any character arising as a\r
+ result of this License or out of the use or inability to use the\r
+ Work (including but not limited to damages for loss of goodwill,\r
+ work stoppage, computer failure or malfunction, or any and all\r
+ other commercial damages or losses), even if such Contributor\r
+ has been advised of the possibility of such damages.\r
+\r
+ 9. Accepting Warranty or Additional Liability. While redistributing\r
+ the Work or Derivative Works thereof, You may choose to offer,\r
+ and charge a fee for, acceptance of support, warranty, indemnity,\r
+ or other liability obligations and/or rights consistent with this\r
+ License. However, in accepting such obligations, You may act only\r
+ on Your own behalf and on Your sole responsibility, not on behalf\r
+ of any other Contributor, and only if You agree to indemnify,\r
+ defend, and hold each Contributor harmless for any liability\r
+ incurred by, or claims asserted against, such Contributor by reason\r
+ of your accepting any such warranty or additional liability.\r
+\r
+ END OF TERMS AND CONDITIONS\r
+\r
+ APPENDIX: How to apply the Apache License to your work.\r
+\r
+ To apply the Apache License to your work, attach the following\r
+ boilerplate notice, with the fields enclosed by brackets "[]"\r
+ replaced with your own identifying information. (Don't include\r
+ the brackets!) The text should be enclosed in the appropriate\r
+ comment syntax for the file format. We also recommend that a\r
+ file or class name and description of purpose be included on the\r
+ same "printed page" as the copyright notice for easier\r
+ identification within third-party archives.\r
+\r
+ Copyright [yyyy] [name of copyright owner]\r
+\r
+ Licensed under the Apache License, Version 2.0 (the "License");\r
+ you may not use this file except in compliance with the License.\r
+ You may obtain a copy of the License at\r
+\r
+ http://www.apache.org/licenses/LICENSE-2.0\r
+\r
+ Unless required by applicable law or agreed to in writing, software\r
+ distributed under the License is distributed on an "AS IS" BASIS,\r
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+ See the License for the specific language governing permissions and\r
+ limitations under the License.\r
+\r
+\r
+\r
--- /dev/null
+Copyright (c) Samsung Electronics Co., Ltd. All rights reserved.
+Except as noted, this software is licensed under Apache License, Version 2.
+Please, see the LICENSE.APLv2 file for Apache License terms and conditions.
AC_SUBST(MM_SOUND_CFLAGS)
AC_SUBST(MM_SOUND_LIBS)
+PKG_CHECK_MODULES(AVSYSTEM, avsysaudio)
+AC_SUBST(AVSYSTEM_CFLAGS)
+AC_SUBST(AVSYSTEM_LIBS)
+
#PKG_CHECK_MODULES(INIPARSER, iniparser)
#AC_SUBST(INIPARSER_CFLAGS)
#AC_SUBST(INIPARSER_LIBS)
AC_SUBST(MMSOUND_CFLAGS)
AC_SUBST(MMSOUND_LIBS)
+PKG_CHECK_MODULES(MMUTIL_IMGP, mmutil-imgp)
+AC_SUBST(MMUTIL_IMGP_CFLAGS)
+AC_SUBST(MMUTIL_IMGP_LIBS)
+
PKG_CHECK_MODULES(SNDFILE, sndfile)
AC_SUBST(SNDFILE_CFLAGS)
AC_SUBST(SNDFILE_LIBS)
AC_SUBST(CAMSRCJPEGENC_CFLAGS)
AC_SUBST(CAMSRCJPEGENC_LIBS)
+PKG_CHECK_MODULES(VCONF, vconf)
+AC_SUBST(VCONF_CFLAGS)
+AC_SUBST(VCONF_LIBS)
# Checks for header files.
AC_HEADER_STDC
--- /dev/null
+<manifest>
+ <request>
+ <domain name="_" />
+ </request>
+</manifest>
Name: libmm-camcorder
-Summary: camcorder library
-Version: 0.5.5
-Release: 1
+Summary: Camera and recorder library
+Version: 0.7.7
+Release: 0
Group: libs
-License: Samsung
-URL: N/A
+License: Apache-2.0
Source0: %{name}-%{version}.tar.gz
+Requires(post): /usr/bin/vconftool
Requires(post): /sbin/ldconfig
Requires(postun): /sbin/ldconfig
BuildRequires: pkgconfig(mm-common)
BuildRequires: pkgconfig(mm-sound)
+BuildRequires: pkgconfig(avsystem)
BuildRequires: pkgconfig(libexif)
BuildRequires: pkgconfig(mmutil-imgp)
-BuildRequires: pkgconfig(elementary)
-BuildRequires: pkgconfig(appcore-efl)
-BuildRequires: pkgconfig(vconf)
BuildRequires: pkgconfig(mm-log)
BuildRequires: pkgconfig(gstreamer-plugins-base-0.10)
BuildRequires: pkgconfig(mm-ta)
+BuildRequires: pkgconfig(sndfile)
BuildRequires: pkgconfig(mm-session)
BuildRequires: pkgconfig(audio-session-mgr)
-BuildRequires: pkgconfig(gstreamer-floatcast-0.10)
-BuildRequires: pkgconfig(gstreamer-check-0.10)
BuildRequires: pkgconfig(camsrcjpegenc)
+BuildRequires: pkgconfig(libpulse)
+BuildRequires: pkgconfig(vconf)
BuildRequires: gst-plugins-base-devel
%description
-camcorder library.
+Camera and recorder library.
%package devel
-Summary: camcorder development library
+Summary: Camera and recorder development library
Group: libdevel
Version: %{version}
Requires: %{name} = %{version}-%{release}
%description devel
-camcorder development library.
+Camera and recorder development library.
%prep
%build
+export CFLAGS+=" -DGST_EXT_TIME_ANALYSIS"
./autogen.sh
%configure --disable-static
make %{?jobs:-j%jobs}
%install
rm -rf %{buildroot}
+mkdir -p %{buildroot}/usr/share/license
+cp LICENSE.APLv2 %{buildroot}/usr/share/license/%{name}
%make_install
-%post -p /sbin/ldconfig
+%post
+/sbin/ldconfig
+
+vconftool set -t int memory/camera/state 0 -i -u 5000
+vconftool set -t int file/camera/shutter_sound_policy 0 -u 5000
%postun -p /sbin/ldconfig
%files
+%manifest libmm-camcorder.manifest
%defattr(-,root,root,-)
%{_bindir}/*
%{_libdir}/*.so.*
-%{_datadir}/edje/*
/usr/share/sounds/mm-camcorder/*
+%{_datadir}/license/%{name}
%files devel
+%manifest libmm-camcorder.manifest
%defattr(-,root,root,-)
%{_includedir}/mmf/mm_camcorder.h
%{_libdir}/pkgconfig/mm-camcorder.pc
$(MM_COMMON_CFLAGS) \
$(MMSESSION_CFLAGS) \
$(MMSOUND_CFLAGS) \
+ $(AVSYSTEM_CFLAGS) \
$(SNDFILE_CFLAGS) \
$(CAMSRCJPEGENC_CFLAGS) \
+ $(VCONF_CFLAGS) \
+ $(MMUTIL_IMGP_CFLAGS) \
$(AUDIOSESSIONMGR_CFLAGS)
libmmfcamcorder_la_LIBADD = \
$(EXIF_LIBS) \
$(MMSESSION_LIBS) \
$(MMSOUND_LIBS) \
+ $(AVSYSTEM_LIBS) \
$(SNDFILE_LIBS) \
$(CAMSRCJPEGENC_LIBS) \
+ $(VCONF_LIBS) \
+ $(MMUTIL_IMGP_LIBS) \
$(AUDIOSESSIONMGR_LIBS)
libmmfcamcorder_la_CFLAGS += $(MMLOGSVR_CFLAGS) -DMMF_LOG_OWNER=0x010 -DMMF_DEBUG_PREFIX=\"MMF-CAMCORDER\" -D_INTERNAL_SESSION_MANAGER_
<td>Audio device ID for capturing audio stream</td>
</tr>
<tr>
- <td>#MMCAM_CAMERA_DEVICE</td>
- <td>Video device ID for capturing video stream</td>
+ <td>#MMCAM_CAMERA_DEVICE_COUNT</td>
+ <td>Video device count</td>
</tr>
<tr>
<td>#MMCAM_AUDIO_ENCODER</td>
<td>Target filename. Only used in Audio/Video recording. This is not used for capturing.</td>
</tr>
<tr>
+ <td>#MMCAM_TARGET_MAX_SIZE</td>
+ <td>Maximum size of recording file(Kbyte). If the size of file reaches this value.</td>
+ </tr>
+ <tr>
<td>#MMCAM_TARGET_TIME_LIMIT</td>
<td>Time limit of recording file. If the elapsed time of recording reaches this value.</td>
</tr>
#define MMCAM_AUDIO_DEVICE "audio-device"
/**
- * Video device ID for capturing video stream.
- * @see MMVideoDeviceType (in mm_types.h)
+ * Video device count.
*/
-#define MMCAM_CAMERA_DEVICE "camera-device"
+#define MMCAM_CAMERA_DEVICE_COUNT "camera-device-count"
+
+/**
+ * Facing direction of camera device.
+ * @see MMCamcorderCameraFacingDirection
+ */
+#define MMCAM_CAMERA_FACING_DIRECTION "camera-facing-direction"
/**
* Audio codec for encoding audio stream.
#define MMCAM_AUDIO_VOLUME "audio-volume"
/**
+ * Disable Audio stream when record.
+ */
+#define MMCAM_AUDIO_DISABLE "audio-disable"
+
+/**
* Set audio input route
* @remarks Deprecated. This will be removed soon.
* @see MMAudioRoutePolicy (in mm_types.h)
#define MMCAM_CAMERA_FORMAT "camera-format"
/**
+ * Slow motion rate when video recording
+ * @remarks Deprecated
+ */
+#define MMCAM_CAMERA_SLOW_MOTION_RATE "camera-slow-motion-rate"
+
+/**
+ * Motion rate when video recording
+ * @remarks This should be bigger than 0(zero).
+ * Default value is 1 and it's for normal video recording.
+ * If the value is smaller than 1, recorded file will be played slower,
+ * otherwise, recorded file will be played faster.
+ */
+#define MMCAM_CAMERA_RECORDING_MOTION_RATE "camera-recording-motion-rate"
+
+/**
* Frames per second. This is an integer field
*
*/
#define MMCAM_CAMERA_ANTI_HANDSHAKE "camera-anti-handshake"
/**
+ * Video Stabilization
+ * @see MMCamcorderVideoStabilizationMode
+ */
+#define MMCAM_CAMERA_VIDEO_STABILIZATION "camera-video-stabilization"
+
+/**
* FPS Auto. When you set true to this attribute, FPS will vary depending on the amount of the light.
*/
#define MMCAM_CAMERA_FPS_AUTO "camera-fps-auto"
#define MMCAM_CAMERA_ROTATION "camera-rotation"
/**
+ * HDR(High Dynamic Range) Capture mode
+ * @see MMCamcorderHDRMode
+ */
+#define MMCAM_CAMERA_HDR_CAPTURE "camera-hdr-capture"
+
+/**
* Bitrate of Audio Encoder
*/
#define MMCAM_AUDIO_ENCODER_BITRATE "audio-encoder-bitrate"
#define MMCAM_CAPTURE_BREAK_CONTINUOUS_SHOT "capture-break-cont-shot"
/**
+ * Raw data of captured image which resolution is same as preview.
+ * This is READ-ONLY attribute and only available in capture callback.
+ * This should be used after casted as MMCamcorderCaptureDataType.
+ */
+#define MMCAM_CAPTURED_SCREENNAIL "captured-screennail"
+
+/**
+ * Raw data of EXIF. This is READ-ONLY attribute and only available in capture callback.
+ */
+#define MMCAM_CAPTURED_EXIF_RAW_DATA "captured-exif-raw-data"
+
+/**
* Pointer of display buffer or ID of xwindow.
*/
#define MMCAM_DISPLAY_HANDLE "display-handle"
#define MMCAM_DISPLAY_SURFACE "display-surface"
/**
+ * Mode of display.
+ * @see MMDisplayModeType (in mm_types.h)
+ */
+#define MMCAM_DISPLAY_MODE "display-mode"
+
+/**
* X position of display rectangle.
* This is only available when #MMCAM_DISPLAY_GEOMETRY_METHOD is MM_CAMCORDER_CUSTOM_ROI.
* @see MMCamcorderGeometryMethod
#define MMCAM_DISPLAY_ROTATION "display-rotation"
/**
+ * Flip of display.
+ * @see MMFlipType (in mm_types.h)
+ */
+#define MMCAM_DISPLAY_FLIP "display-flip"
+
+/**
* Visible of display.
*/
#define MMCAM_DISPLAY_VISIBLE "display-visible"
#define MMCAM_DISPLAY_GEOMETRY_METHOD "display-geometry-method"
/**
+ * A videosink name of evas surface.
+ * This is READ-ONLY attribute.
+ */
+#define MMCAM_DISPLAY_EVAS_SURFACE_SINK "display-evas-surface-sink"
+
+/**
+ * This attribute is only available if value of MMCAM_DISPLAY_EVAS_SURFACE_SINK "evaspixmapsink"
+ */
+#define MMCAM_DISPLAY_EVAS_DO_SCALING "display-evas-do-scaling"
+
+/**
* Target filename. Only used in Audio/Video recording. This is not used for capturing.
*/
#define MMCAM_TARGET_FILENAME "target-filename"
/**
+ * Maximum size(Kbyte) of recording file. If the size of file reaches this value,
+ * camcorder will send 'MM_MESSAGE_CAMCORDER_MAX_SIZE' message.
+ */
+#define MMCAM_TARGET_MAX_SIZE "target-max-size"
+
+/**
* Time limit(Second) of recording file. If the elapsed time of recording reaches this value,
* camcorder will send 'MM_MESSAGE_CAMCORDER_TIME_LIMIT' message.
*/
#define MMCAM_RECOMMEND_DISPLAY_ROTATION "recommend-display-rotation"
/**
- * Rotation angle of video input stream and display for video recording.
+ * Recommend width of camera preview.
+ * This attribute can be used with #mm_camcorder_get_attribute_info and #MMCamcorderPreviewType.
+ * @see mm_camcorder_get_attribute_info, MMCamcorderPreviewType
*/
-#define MMCAM_CAMCORDER_ROTATION "camcorder-rotation"
+#define MMCAM_RECOMMEND_CAMERA_WIDTH "recommend-camera-width"
+
+/**
+ * Recommend height of camera preview
+ * This attribute can be used with #mm_camcorder_get_attribute_info and #MMCamcorderPreviewType.
+ * @see mm_camcorder_get_attribute_info, MMCamcorderPreviewType
+ */
+#define MMCAM_RECOMMEND_CAMERA_HEIGHT "recommend-camera-height"
+
+/**
+ * Flip of video input stream.
+ * @see MMFlipType (in mm_types.h)
+ */
+#define MMCAM_CAMERA_FLIP "camera-flip"
+
+/**
+ * X coordinate of Face zoom.
+ */
+#define MMCAM_CAMERA_FACE_ZOOM_X "camera-face-zoom-x"
+
+/**
+ * Y coordinate of Face zoom.
+ */
+#define MMCAM_CAMERA_FACE_ZOOM_Y "camera-face-zoom-y"
+
+/**
+ * Zoom level of Face zoom.
+ */
+#define MMCAM_CAMERA_FACE_ZOOM_LEVEL "camera-face-zoom-level"
+
+/**
+ * Mode of Face zoom.
+ * @see MMCamcorderFaceZoomMode
+ */
+#define MMCAM_CAMERA_FACE_ZOOM_MODE "camera-face-zoom-mode"
+
/*=======================================================================================
| ENUM DEFINITIONS |
* An enumeration for camcorder mode.
*/
typedef enum {
- MM_CAMCORDER_MODE_IMAGE = 0, /**< Still image capture mode */
- MM_CAMCORDER_MODE_AUDIO, /**< Audio recording mode */
- MM_CAMCORDER_MODE_VIDEO, /**< Video recording mode */
+ MM_CAMCORDER_MODE_VIDEO_CAPTURE = 0, /**< Video recording and Image capture mode */
+ MM_CAMCORDER_MODE_AUDIO, /**< Audio recording mode */
} MMCamcorderModeType;
+/**
+ * An enumeration for facing direction.
+ */
+typedef enum {
+ MM_CAMCORDER_CAMERA_FACING_DIRECTION_REAR = 0, /**< Facing direction of camera is REAR */
+ MM_CAMCORDER_CAMERA_FACING_DIRECTION_FRONT, /**< Facing direction of camera is FRONT */
+} MMCamcorderCameraFacingDirection;
+
/**
* An enumeration of Audio Format.
* seeing through a tinted glass.
*/
enum MMCamcorderColorToneType {
- MM_CAMCORDER_COLOR_TONE_NONE = 0, /**< None */
- MM_CAMCORDER_COLOR_TONE_MONO, /**< Mono */
- MM_CAMCORDER_COLOR_TONE_SEPIA, /**< Sepia */
- MM_CAMCORDER_COLOR_TONE_NEGATIVE, /**< Negative */
- MM_CAMCORDER_COLOR_TONE_BLUE, /**< Blue */
- MM_CAMCORDER_COLOR_TONE_GREEN, /**< Green */
- MM_CAMCORDER_COLOR_TONE_AQUA, /**< Aqua */
- MM_CAMCORDER_COLOR_TONE_VIOLET, /**< Violet */
- MM_CAMCORDER_COLOR_TONE_ORANGE, /**< Orange */
- MM_CAMCORDER_COLOR_TONE_GRAY, /**< Gray */
- MM_CAMCORDER_COLOR_TONE_RED, /**< Red */
- MM_CAMCORDER_COLOR_TONE_ANTIQUE, /**< Antique */
- MM_CAMCORDER_COLOR_TONE_WARM, /**< Warm */
- MM_CAMCORDER_COLOR_TONE_PINK, /**< Pink */
- MM_CAMCORDER_COLOR_TONE_YELLOW, /**< Yellow */
- MM_CAMCORDER_COLOR_TONE_PURPLE, /**< Purple */
- MM_CAMCORDER_COLOR_TONE_EMBOSS, /**< Emboss */
- MM_CAMCORDER_COLOR_TONE_OUTLINE, /**< Outline */
-
- MM_CAMCORDER_COLOR_TONE_SOLARIZATION_1, /**< Solarization1 */
- MM_CAMCORDER_COLOR_TONE_SOLARIZATION_2, /**< Solarization2 */
- MM_CAMCORDER_COLOR_TONE_SOLARIZATION_3, /**< Solarization3 */
- MM_CAMCORDER_COLOR_TONE_SOLARIZATION_4, /**< Solarization4 */
-
- MM_CAMCORDER_COLOR_TONE_SKETCH_1, /**< Sketch1 */
- MM_CAMCORDER_COLOR_TONE_SKETCH_2, /**< Sketch2 */
- MM_CAMCORDER_COLOR_TONE_SKETCH_3, /**< Sketch3 */
- MM_CAMCORDER_COLOR_TONE_SKETCH_4, /**< Sketch4 */
+ MM_CAMCORDER_COLOR_TONE_NONE = 0, /**< None */
+ MM_CAMCORDER_COLOR_TONE_MONO, /**< Mono */
+ MM_CAMCORDER_COLOR_TONE_SEPIA, /**< Sepia */
+ MM_CAMCORDER_COLOR_TONE_NEGATIVE, /**< Negative */
+ MM_CAMCORDER_COLOR_TONE_BLUE, /**< Blue */
+ MM_CAMCORDER_COLOR_TONE_GREEN, /**< Green */
+ MM_CAMCORDER_COLOR_TONE_AQUA, /**< Aqua */
+ MM_CAMCORDER_COLOR_TONE_VIOLET, /**< Violet */
+ MM_CAMCORDER_COLOR_TONE_ORANGE, /**< Orange */
+ MM_CAMCORDER_COLOR_TONE_GRAY, /**< Gray */
+ MM_CAMCORDER_COLOR_TONE_RED, /**< Red */
+ MM_CAMCORDER_COLOR_TONE_ANTIQUE, /**< Antique */
+ MM_CAMCORDER_COLOR_TONE_WARM, /**< Warm */
+ MM_CAMCORDER_COLOR_TONE_PINK, /**< Pink */
+ MM_CAMCORDER_COLOR_TONE_YELLOW, /**< Yellow */
+ MM_CAMCORDER_COLOR_TONE_PURPLE, /**< Purple */
+ MM_CAMCORDER_COLOR_TONE_EMBOSS, /**< Emboss */
+ MM_CAMCORDER_COLOR_TONE_OUTLINE, /**< Outline */
+ MM_CAMCORDER_COLOR_TONE_SOLARIZATION, /**< Solarization */
+ MM_CAMCORDER_COLOR_TONE_SKETCH, /**< Sketch */
+ MM_CAMCORDER_COLOR_TONE_WASHED, /**< Washed */
+ MM_CAMCORDER_COLOR_TONE_VINTAGE_WARM, /**< Vintage warm */
+ MM_CAMCORDER_COLOR_TONE_VINTAGE_COLD, /**< Vintage cold */
+ MM_CAMCORDER_COLOR_TONE_POSTERIZATION, /**< Posterization */
+ MM_CAMCORDER_COLOR_TONE_CARTOON, /**< Cartoon */
+ MM_CAMCORDER_COLOR_TONE_SELECTIVE_RED, /**< Selective color - Red */
+ MM_CAMCORDER_COLOR_TONE_SELECTIVE_GREEN, /**< Selective color - Green */
+ MM_CAMCORDER_COLOR_TONE_SELECTIVE_BLUE, /**< Selective color - Blue */
+ MM_CAMCORDER_COLOR_TONE_SELECTIVE_YELLOW, /**< Selective color - Yellow */
+ MM_CAMCORDER_COLOR_TONE_SELECTIVE_RED_YELLOW, /**< Selective color - Red and Yellow */
};
/**
+ * An enumeration for HDR capture mode
+ */
+enum MMCamcorderHDRMode {
+ MM_CAMCORDER_HDR_OFF = 0, /**< HDR OFF */
+ MM_CAMCORDER_HDR_ON, /**< HDR ON and no original data - capture callback will be come once */
+ MM_CAMCORDER_HDR_ON_AND_ORIGINAL, /**< HDR ON and original data - capture callback will be come twice(1st:Original, 2nd:HDR) */
+};
+
+
+/**
* An enumeration for Anti-handshake mode .
*/
enum MMCamcorderAHSMode {
/**
+ * An enumeration for Video stabilization mode
+ */
+enum MMCamcorderVideoStabilizationMode {
+ MM_CAMCORDER_VIDEO_STABILIZATION_OFF = 0, /**< Video Stabilization OFF*/
+ MM_CAMCORDER_VIDEO_STABILIZATION_ON, /**< Video Stabilization ON*/
+};
+
+
+/**
* Geometry method for camcorder display.
*/
enum MMCamcorderGeometryMethod {
MM_CAMCORDER_ORIGIN_SIZE, /**< Origin size*/
MM_CAMCORDER_FULL, /**< full-screen*/
MM_CAMCORDER_CROPPED_FULL, /**< Cropped full-screen*/
+ MM_CAMCORDER_ORIGIN_OR_LETTER, /**< Origin size or Letter box*/
MM_CAMCORDER_CUSTOM_ROI, /**< Explicitely described destination ROI*/
};
};
+/**
+ * An enumeration for Face zoom mode.
+ */
+enum MMCamcorderFaceZoomMode {
+ MM_CAMCORDER_FACE_ZOOM_MODE_OFF = 0, /**< turn face zoom off */
+ MM_CAMCORDER_FACE_ZOOM_MODE_ON, /**< turn face zoom on */
+};
+
+/**
+ * An enumeration for recommended preview resolution.
+ */
+enum MMCamcorderPreviewType {
+ MM_CAMCORDER_PREVIEW_TYPE_NORMAL = 0, /**< normal ratio like 4:3 */
+ MM_CAMCORDER_PREVIEW_TYPE_WIDE, /**< wide ratio like 16:9 */
+};
+
+
/**********************************
* Attribute info *
**********************************/
MM_CAM_ATTRS_TYPE_DOUBLE, /**< Double type attribute */
MM_CAM_ATTRS_TYPE_STRING, /**< UTF-8 String type attribute */
MM_CAM_ATTRS_TYPE_DATA, /**< Pointer type attribute */
- MM_CAM_ATTRS_TYPE_ARRAY, /**< Array type attribute */
- MM_CAM_ATTRS_TYPE_RANGE, /**< Range type attribute */
}MMCamAttrsType;
} MMCamAttrsFlag;
+/**********************************
+* Stream data *
+**********************************/
+/**
+ * An enumeration for stream data type.
+ */
+typedef enum {
+ MM_CAM_STREAM_DATA_YUV420 = 0, /**< YUV420 Packed type - 1 plane */
+ MM_CAM_STREAM_DATA_YUV422, /**< YUV422 Packed type - 1 plane */
+ MM_CAM_STREAM_DATA_YUV420SP, /**< YUV420 SemiPlannar type - 2 planes */
+ MM_CAM_STREAM_DATA_YUV420P, /**< YUV420 Plannar type - 3 planes */
+ MM_CAM_STREAM_DATA_YUV422P, /**< YUV422 Plannar type - 3 planes */
+} MMCamStreamData;
+
+
/*=======================================================================================
| STRUCTURE DEFINITIONS |
========================================================================================*/
* Structure for video stream data.
*/
typedef struct {
- void *data; /**< pointer of captured stream */
- unsigned int length; /**< length of stream buffer (in byte)*/
- MMPixelFormatType format; /**< image format */
- int width; /**< width of video buffer */
- int height; /**< height of video buffer */
- unsigned int timestamp; /**< timestamp of stream buffer (msec)*/
+ union {
+ struct {
+ unsigned char *yuv;
+ unsigned int length_yuv;
+ } yuv420, yuv422;
+ struct {
+ unsigned char *y;
+ unsigned int length_y;
+ unsigned char *uv;
+ unsigned int length_uv;
+ } yuv420sp;
+ struct {
+ unsigned char *y;
+ unsigned int length_y;
+ unsigned char *u;
+ unsigned int length_u;
+ unsigned char *v;
+ unsigned int length_v;
+ } yuv420p, yuv422p;
+ } data; /**< pointer of captured stream */
+ MMCamStreamData data_type; /**< data type */
+ unsigned int length_total; /**< total length of stream buffer (in byte)*/
+ unsigned int num_planes; /**< number of planes */
+ MMPixelFormatType format; /**< image format */
+ int width; /**< width of video buffer */
+ int height; /**< height of video buffer */
+ unsigned int timestamp; /**< timestamp of stream buffer (msec)*/
} MMCamcorderVideoStreamDataType;
/**
* Report structure of recording file
*/
-typedef struct MMCamRecordingReport {
+typedef struct {
char *recording_filename; /**< File name of stored recording file. Please free after using. */
-}MMCamRecordingReport; /**< report structure definition of recording file */
+} MMCamRecordingReport; /**< report structure definition of recording file */
+
+
+/**
+ * Face detect defailed information
+ */
+typedef struct _MMCamFaceInfo {
+ int id; /**< id of each face */
+ int score; /**< score of each face */
+ MMRectType rect; /**< area of face */
+} MMCamFaceInfo;
+
+/**
+ * Face detect information
+ */
+typedef struct _MMCamFaceDetectInfo {
+ int num_of_faces; /**< number of detected faces */
+ MMCamFaceInfo *face_info; /**< face information, this should be freed after use it. */
+} MMCamFaceDetectInfo;
/*=======================================================================================
{
MM_CAM_MODE, /* 0 */
MM_CAM_AUDIO_DEVICE,
- MM_CAM_CAMERA_DEVICE,
+ MM_CAM_CAMERA_DEVICE_COUNT,
MM_CAM_AUDIO_ENCODER,
MM_CAM_VIDEO_ENCODER,
MM_CAM_IMAGE_ENCODER,
MM_CAM_FILTER_HUE,
MM_CAM_FILTER_SHARPNESS, /* 20 */
MM_CAM_CAMERA_FORMAT,
- MM_CAM_CAMERA_SLOW_MOTION_FPS,
+ MM_CAM_CAMERA_RECORDING_MOTION_RATE,
MM_CAM_CAMERA_FPS,
MM_CAM_CAMERA_WIDTH,
MM_CAM_CAMERA_HEIGHT,
MM_CAM_CAPTURED_SCREENNAIL,
MM_CAM_CAPTURE_SOUND_ENABLE,
MM_CAM_RECOMMEND_DISPLAY_ROTATION,
- MM_CAM_CAMCORDER_ROTATION, /* 100 */
+ MM_CAM_CAMERA_FLIP, /* 100 */
+ MM_CAM_CAMERA_HDR_CAPTURE,
+ MM_CAM_DISPLAY_MODE,
+ MM_CAM_CAMERA_FACE_ZOOM_X,
+ MM_CAM_CAMERA_FACE_ZOOM_Y,
+ MM_CAM_CAMERA_FACE_ZOOM_LEVEL,
+ MM_CAM_CAMERA_FACE_ZOOM_MODE,
+ MM_CAM_AUDIO_DISABLE,
+ MM_CAM_RECOMMEND_CAMERA_WIDTH,
+ MM_CAM_RECOMMEND_CAMERA_HEIGHT,
+ MM_CAM_CAPTURED_EXIF_RAW_DATA, /* 110 */
+ MM_CAM_DISPLAY_EVAS_SURFACE_SINK,
+ MM_CAM_DISPLAY_EVAS_DO_SCALING,
+ MM_CAM_CAMERA_FACING_DIRECTION,
+ MM_CAM_DISPLAY_FLIP,
+ MM_CAM_CAMERA_VIDEO_STABILIZATION,
MM_CAM_NUM
}MMCamcorderAttrsID;
char *name;
int value_type;
int flags;
- void* default_value;
+ union {
+ void *value_void;
+ char *value_string;
+ int value_int;
+ double value_double;
+ } default_value; /* default value */
MMCamAttrsValidType validity_type;
- int validity_value1; /* can be int min, int *array, double *array, or cast to double min. */
- int validity_value2; /* can be int max, int count, int count, or cast to double max. */
+ int validity_value1; /* can be int min, int *array, double *array, or cast to double min. */
+ int validity_value2; /* can be int max, int count, int count, or cast to double max. */
mmf_cam_commit_func_t attr_commit;
} mm_cam_attr_construct_info;
bool _mmcamcorder_commit_capture_height(MMHandleType handle, int attr_idx, const mmf_value_t *value);
bool _mmcamcorder_commit_capture_break_cont_shot(MMHandleType handle, int attr_idx, const mmf_value_t *value);
bool _mmcamcorder_commit_capture_count(MMHandleType handle, int attr_idx, const mmf_value_t *value);
+bool _mmcamcorder_commit_capture_sound_enable(MMHandleType handle, int attr_idx, const mmf_value_t *value);
bool _mmcamcorder_commit_audio_volume(MMHandleType handle, int attr_idx, const mmf_value_t *value);
bool _mmcamcorder_commit_audio_input_route(MMHandleType handle, int attr_idx, const mmf_value_t *value);
+bool _mmcamcorder_commit_audio_disable(MMHandleType handle, int attr_idx, const mmf_value_t *value);
bool _mmcamcorder_commit_camera_fps(MMHandleType handle, int attr_idx, const mmf_value_t *value);
+bool _mmcamcorder_commit_camera_recording_motion_rate(MMHandleType handle, int attr_idx, const mmf_value_t *value);
bool _mmcamcorder_commit_camera_width(MMHandleType handle, int attr_idx, const mmf_value_t *value);
bool _mmcamcorder_commit_camera_height(MMHandleType handle, int attr_idx, const mmf_value_t *value);
bool _mmcamcorder_commit_camera_zoom(MMHandleType handle, int attr_idx, const mmf_value_t *value);
bool _mmcamcorder_commit_camera_capture_mode(MMHandleType handle, int attr_idx, const mmf_value_t *value);
bool _mmcamcorder_commit_camera_wdr(MMHandleType handle, int attr_idx, const mmf_value_t *value);
bool _mmcamcorder_commit_camera_anti_handshake(MMHandleType handle, int attr_idx, const mmf_value_t *value);
+bool _mmcamcorder_commit_camera_video_stabilization(MMHandleType handle, int attr_idx, const mmf_value_t *value);
bool _mmcamcorder_commit_camera_hold_af_after_capturing(MMHandleType handle, int attr_idx, const mmf_value_t *value);
bool _mmcamcorder_commit_camera_rotate(MMHandleType handle, int attr_idx, const mmf_value_t *value);
+bool _mmcamcorder_commit_camera_face_zoom(MMHandleType handle, int attr_idx, const mmf_value_t *value);
bool _mmcamcorder_commit_image_encoder_quality(MMHandleType handle, int attr_idx, const mmf_value_t *value);
bool _mmcamcorder_commit_target_filename(MMHandleType handle, int attr_idx, const mmf_value_t *value);
bool _mmcamcorder_commit_filter(MMHandleType handle, int attr_idx, const mmf_value_t *value);
bool _mmcamcorder_commit_filter_scene_mode(MMHandleType handle, int attr_idx, const mmf_value_t *value);
bool _mmcamcorder_commit_filter_flip(MMHandleType handle, int attr_idx, const mmf_value_t *value);
bool _mmcamcorder_commit_display_handle(MMHandleType handle, int attr_idx, const mmf_value_t *value);
+bool _mmcamcorder_commit_display_mode(MMHandleType handle, int attr_idx, const mmf_value_t *value);
bool _mmcamcorder_commit_display_rotation(MMHandleType handle, int attr_idx, const mmf_value_t *value);
+bool _mmcamcorder_commit_display_flip(MMHandleType handle, int attr_idx, const mmf_value_t *value);
bool _mmcamcorder_commit_display_visible(MMHandleType handle, int attr_idx, const mmf_value_t *value);
bool _mmcamcorder_commit_display_geometry_method(MMHandleType handle, int attr_idx, const mmf_value_t *value);
bool _mmcamcorder_commit_display_rect(MMHandleType handle, int attr_idx, const mmf_value_t *value);
bool _mmcamcorder_commit_display_scale(MMHandleType handle, int attr_idx, const mmf_value_t *value);
+bool _mmcamcorder_commit_display_evas_do_scaling(MMHandleType handle, int attr_idx, const mmf_value_t *value);
bool _mmcamcorder_commit_strobe(MMHandleType handle, int attr_idx, const mmf_value_t *value);
bool _mmcamcorder_commit_detect(MMHandleType handle, int attr_idx, const mmf_value_t *value);
-bool _mmcamcorder_commit_camcorder_rotate(MMHandleType handle, int attr_idx, const mmf_value_t *value);
+bool _mmcamcorder_commit_camera_flip(MMHandleType handle, int attr_idx, const mmf_value_t *value);
+bool _mmcamcorder_commit_camera_hdr_capture(MMHandleType handle, int attr_idx, const mmf_value_t *value);
/**
* This function initialize effect setting.
*
* @param[in] handle Handle of camcorder.
- * @return bool
- * @remarks
- * @see
- *
+ * @return bool Success on TRUE or return FALSE
*/
bool _mmcamcorder_set_attribute_to_camsensor(MMHandleType handle);
* This function removes writable flag from pre-defined attributes.
*
* @param[in] handle Handle of camcorder.
- * @return void
- * @remarks
- * @see
- *
+ * @return int Success on MM_ERROR_NONE or return ERROR with error code
*/
int _mmcamcorder_lock_readonly_attributes(MMHandleType handle);
* This function disable pre-defined attributes.
*
* @param[in] handle Handle of camcorder.
- * @return void
- * @remarks
- * @see
- *
+ * @return int Success on MM_ERROR_NONE or return ERROR with error code
*/
int _mmcamcorder_set_disabled_attributes(MMHandleType handle);
+/**
+ * check whether supported or not
+ *
+ * @param[in] handle Handle of camcorder.
+ * @param[in] attr_index index of attribute to check.
+ * @return bool TRUE if supported or FALSE
+ */
+bool _mmcamcorder_check_supported_attribute(MMHandleType handle, int attr_index);
+
#ifdef __cplusplus
}
#endif
gboolean b_commiting; /**< Is it commiting now? */
gboolean bMuxing; /**< whether muxing */
guint64 filesize; /**< current recorded file size */
+ guint64 max_size; /**< max recording size */
guint64 max_time; /**< max recording time */
int fileformat; /**< recording file format */
} _MMCamcorderAudioInfo;
/**
* Enumerations for AMR bitrate
*/
-typedef enum MMCamcorderAMRBitRate {
+typedef enum _MMCamcorderAMRBitRate {
MM_CAMCORDER_MR475, /**< MR475 : 4.75 kbit/s */
MM_CAMCORDER_MR515, /**< MR515 : 5.15 kbit/s */
MM_CAMCORDER_MR59, /**< MR59 : 5.90 kbit/s */
MM_CAMCORDER_MRDTX /**< MRDTX */
} MMCamcorderAMRBitRate;
+/**
+* Encodebin profile
+*/
+typedef enum _MMCamcorderEncodebinProfile {
+ MM_CAMCORDER_ENCBIN_PROFILE_VIDEO = 0, /**< Video recording profile */
+ MM_CAMCORDER_ENCBIN_PROFILE_AUDIO, /**< Audio recording profile */
+ MM_CAMCORDER_ENCBIN_PROFILE_IMAGE, /**< Image capture profile */
+ MM_CAMCORDER_ENCBIN_PROFILE_NUM
+} MMCamcorderEncodebinProfile;
+
/*=======================================================================================
| STRUCTURE DEFINITIONS |
========================================================================================*/
* This function creates outputsink bin.
*
* @param[in] handle Handle of camcorder context.
+ * @param[in] profile profile of encodesinkbin.
* @return This function returns MM_ERROR_NONE on success, or the other values on error.
* @remarks
* @see __mmcamcorder_create_preview_pipeline()
*/
-int _mmcamcorder_create_encodesink_bin(MMHandleType handle);
+int _mmcamcorder_create_encodesink_bin(MMHandleType handle, MMCamcorderEncodebinProfile profile);
/**
* This function creates bin of still shot sink.
/* plug-in related */
void _mmcamcorder_negosig_handler(GstElement *videosrc, MMHandleType handle);
-bool _mmcamcorder_set_display_rotation(MMHandleType handle, int display_rotate);
-bool _mmcamcorder_set_videosrc_rotation(MMHandleType handle, int videosrc_rotate);
/* etc */
int _mmcamcorder_videosink_window_set(MMHandleType handle, type_element *VideosinkElement);
void _mmcamcorder_remove_element_handle(MMHandleType handle, int first_elem, int last_elem);
int _mmcamcorder_check_audiocodec_fileformat_compatibility(MMHandleType handle);
int _mmcamcorder_check_videocodec_fileformat_compatibility(MMHandleType handle);
+bool _mmcamcorder_set_display_rotation(MMHandleType handle, int display_rotate);
+bool _mmcamcorder_set_display_flip(MMHandleType handle, int display_flip);
+bool _mmcamcorder_set_videosrc_rotation(MMHandleType handle, int videosrc_rotate);
+bool _mmcamcorder_set_videosrc_flip(MMHandleType handle, int viderosrc_flip);
+bool _mmcamcorder_set_videosrc_anti_shake(MMHandleType handle, int anti_shake);
+bool _mmcamcorder_set_videosrc_stabilization(MMHandleType handle, int stabilization);
#ifdef __cplusplus
}
#ifndef __MM_CAMCORDER_INTERNAL_H__
#define __MM_CAMCORDER_INTERNAL_H__
-
/*=======================================================================================
| INCLUDE FILES |
========================================================================================*/
#include <mm_message.h>
#include <mm_ta.h>
#include <sndfile.h>
+#include <vconf.h>
#include "mm_camcorder.h"
#include "mm_debug.h"
_mmcam_dbg_err("The element is existed. element_id=[%d], name=[%s]", eid, name); \
gst_object_unref(sub_context->element[eid].gst); \
} \
- sub_context->element[eid].id = eid; \
sub_context->element[eid].gst = gst_element_factory_make(name, nickname); \
if (sub_context->element[eid].gst == NULL) { \
_mmcam_dbg_err("Element creation fail. element_id=[%d], name=[%s]", eid, name); \
err = MM_ERROR_CAMCORDER_RESOURCE_CREATION; \
goto pipeline_creation_error; \
} else { \
+ _mmcam_dbg_log("Element creation done. element_id=[%d], name=[%s]", eid, name); \
+ sub_context->element[eid].id = eid; \
g_object_weak_ref(G_OBJECT(sub_context->element[eid].gst), (GWeakNotify)_mmcamcorder_element_release_noti, sub_context); \
+ err = MM_ERROR_NONE; \
} \
elist = g_list_append(elist, &(sub_context->element[eid]));
+#define _MMCAMCORDER_ELEMENT_MAKE_IGNORE_ERROR(sub_context, eid, name /*char* */, nickname /*char* */, elist) \
+ if (sub_context->element[eid].gst != NULL) { \
+ _mmcam_dbg_err("The element is existed. element_id=[%d], name=[%s]", eid, name); \
+ gst_object_unref(sub_context->element[eid].gst); \
+ } \
+ sub_context->element[eid].gst = gst_element_factory_make(name, nickname); \
+ if (sub_context->element[eid].gst == NULL) { \
+ _mmcam_dbg_err("Element creation fail. element_id=[%d], name=[%s], but keep going...", eid, name); \
+ } else { \
+ _mmcam_dbg_log("Element creation done. element_id=[%d], name=[%s]", eid, name); \
+ sub_context->element[eid].id = eid; \
+ g_object_weak_ref(G_OBJECT(sub_context->element[eid].gst), (GWeakNotify)_mmcamcorder_element_release_noti, sub_context); \
+ elist = g_list_append(elist, &(sub_context->element[eid])); \
+ }
+
#define _MMCAMCORDER_ENCODEBIN_ELMGET(sub_context, eid, name /*char* */, err) \
if (sub_context->element[eid].gst != NULL) { \
_mmcam_dbg_err("The element is existed. element_id=[%d], name=[%s]", eid, name); \
}
#define _MM_GST_PAD_UNLINK_UNREF( srcpad, sinkpad) \
- gst_pad_unlink( srcpad, sinkpad ); \
- gst_object_unref( srcpad ); srcpad = NULL; \
- gst_object_unref( sinkpad ); sinkpad = NULL;
+ if (srcpad && sinkpad) { \
+ gst_pad_unlink(srcpad, sinkpad); \
+ } else { \
+ _mmcam_dbg_warn("some pad(srcpad:%p,sinkpad:%p) is NULL", srcpad, sinkpad); \
+ } \
+ if (srcpad) { \
+ gst_object_unref(srcpad); srcpad = NULL; \
+ } \
+ if (sinkpad) { \
+ gst_object_unref(sinkpad); sinkpad = NULL; \
+ }
#define _MMCAMCORDER_STATE_SET_COUNT 3 /* checking interval */
#define _MMCAMCORDER_STATE_CHECK_TOTALTIME 5000000L /* total wating time for state change */
#define _MMCAMCORDER_STATE_CHECK_INTERVAL 5000 /* checking interval */
/**
+ * Default videosink type
+ */
+#define _MMCAMCORDER_DEFAULT_VIDEOSINK_TYPE "VideosinkElementX"
+
+/**
+ * Default recording motion rate
+ */
+#define _MMCAMCORDER_DEFAULT_RECORDING_MOTION_RATE 1.0
+
+/**
* Total level count of manual focus */
#define _MMFCAMCORDER_FOCUS_TOTAL_LEVEL 8
/**
* Minimum integer value
*/
-#define _MMCAMCORDER_MIN_INT (-2147483648)
+#define _MMCAMCORDER_MIN_INT (INT_MIN)
/**
* Maximum integer value
*/
-#define _MMCAMCORDER_MAX_INT (2147483647)
+#define _MMCAMCORDER_MAX_INT (INT_MAX)
+
+/**
+ * Minimum double value
+ */
+#define _MMCAMCORDER_MIN_DOUBLE (DBL_MIN)
+
+/**
+ * Maximum integer value
+ */
+#define _MMCAMCORDER_MAX_DOUBLE (DBL_MAX)
/**
* Audio timestamp margin (msec)
* If you increase any enum of attribute values, you also have to increase this.
*/
#define MM_CAMCORDER_MODE_NUM 3 /**< Number of mode type */
-#define MM_CAMCORDER_COLOR_TONE_NUM 27 /**< Number of color-tone modes */
+#define MM_CAMCORDER_COLOR_TONE_NUM 30 /**< Number of color-tone modes */
#define MM_CAMCORDER_WHITE_BALANCE_NUM 10 /**< Number of WhiteBalance modes*/
#define MM_CAMCORDER_SCENE_MODE_NUM 15 /**< Number of program-modes */
#define MM_CAMCORDER_FOCUS_MODE_NUM 6 /**< Number of focus mode*/
#define MM_CAMCORDER_AUTO_EXPOSURE_NUM 9 /**< Number of Auto exposure type */
#define MM_CAMCORDER_WDR_NUM 3 /**< Number of wide dynamic range */
#define MM_CAMCORDER_AHS_NUM 4 /**< Number of anti-handshake */
-#define MM_CAMCORDER_GEOMETRY_METHOD_NUM 4 /**< Number of geometry method */
+#define MM_CAMCORDER_VIDEO_STABILIZATION_NUM 2 /**< Number of video stabilization */
+#define MM_CAMCORDER_HDR_CAPTURE_NUM 3 /**< Number of HDR capture mode */
+#define MM_CAMCORDER_GEOMETRY_METHOD_NUM 5 /**< Number of geometry method */
#define MM_CAMCORDER_TAG_ORT_NUM 8 /**< Number of tag orientation */
#define MM_CAMCORDER_STROBE_MODE_NUM 8 /**< Number of strobe mode type */
#define MM_CAMCORDER_STROBE_CONTROL_NUM 3 /**< Number of strobe control type */
/* Command for Image capture */
_MMCamcorder_CMD_CAPTURE,
- _MMCamcorder_CMD_CAPTURE_CANCEL,
/* Command for Preview(Video/Image only effective) */
_MMCamcorder_CMD_PREVIEW_START,
_MMCAMCORDER_VIDEOSRC_BIN,
_MMCAMCORDER_VIDEOSRC_SRC,
_MMCAMCORDER_VIDEOSRC_FILT,
+ _MMCAMCORDER_VIDEOSRC_QUE,
_MMCAMCORDER_VIDEOSRC_CLS,
_MMCAMCORDER_VIDEOSRC_SCALE,
_MMCAMCORDER_VIDEOSRC_VSFLT,
} _MMCamcorderStateChange;
-
/*=======================================================================================
| STRUCTURE DEFINITIONS |
========================================================================================*/
* MMCamcorder Sub Context
*/
typedef struct {
- bool isMaxsizePausing; /**< Because of size limit, pipeline is paused. */
- bool isMaxtimePausing; /**< Because of time limit, pipeline is paused. */
- int element_num; /**< count of element */
- int cam_stability_count; /**< camsensor stability count. the count of frame will drop */
- GstClockTime pipeline_time; /**< current time of Gstreamer Pipeline */
- GstClockTime pause_time; /** amount of time while pipeline is in PAUSE state.*/
- GstClockTime stillshot_time; /** pipeline time of capturing moment*/
- gboolean is_slow;
- gboolean error_occurs;
- gboolean ferror_send; /** file write/seek error **/
- guint ferror_count; /** file write/seek error count **/
+ bool isMaxsizePausing; /**< Because of size limit, pipeline is paused. */
+ bool isMaxtimePausing; /**< Because of time limit, pipeline is paused. */
+ int element_num; /**< count of element */
+ int cam_stability_count; /**< camsensor stability count. the count of frame will drop */
+ GstClockTime pipeline_time; /**< current time of Gstreamer Pipeline */
+ GstClockTime pause_time; /**< amount of time while pipeline is in PAUSE state.*/
+ GstClockTime stillshot_time; /**< pipeline time of capturing moment*/
+ gboolean is_modified_rate; /**< whether recording motion rate is modified or not */
+ gboolean error_occurs; /**< flag for error */
+ int error_code; /**< error code for internal gstreamer error */
+ gboolean ferror_send; /**< file write/seek error **/
+ guint ferror_count; /**< file write/seek error count **/
GstClockTime previous_slot_time;
- int display_interval; /** This value is set as 'GST_SECOND / display FPS' */
- gboolean bget_eos; /** Whether getting EOS */
- gboolean bencbin_capture; /** Use Encodebin for capturing */
- gboolean now_continuous_af; /** whether continuous af starts */
+ int display_interval; /**< This value is set as 'GST_SECOND / display FPS' */
+ gboolean bget_eos; /**< Whether getting EOS */
+ gboolean bencbin_capture; /**< Use Encodebin for capturing */
+ gboolean audio_disable; /**< whether audio is disabled or not when record */
+ int videosrc_rotate; /**< rotate of videosrc */
/* For dropping video frame when start recording */
- int drop_vframe; /**< When this value is bigger than zero and pass_first_vframe is zero, MSL will drop video frame though cam_stability count is bigger then zero. */
- int pass_first_vframe; /**< When this value is bigger than zero, MSL won't drop video frame though "drop_vframe" is bigger then zero. */
+ int drop_vframe; /**< When this value is bigger than zero and pass_first_vframe is zero, MSL will drop video frame though cam_stability count is bigger then zero. */
+ int pass_first_vframe; /**< When this value is bigger than zero, MSL won't drop video frame though "drop_vframe" is bigger then zero. */
/* INI information */
- unsigned int fourcc; /**< Get fourcc value of camera INI file */
- void *info; /**< extra information for camcorder */
+ unsigned int fourcc; /**< Get fourcc value of camera INI file */
+ _MMCamcorderImageInfo *info_image; /**< extra information for image capture */
+ _MMCamcorderVideoInfo *info_video; /**< extra information for video recording */
+ _MMCamcorderAudioInfo *info_audio; /**< extra information for audio recording */
- _MMCamcorderGstElement *element; /**< array of Gstreamer element */
- _MMCamcorderKPIMeasure kpi; /**< information related with performance measurement */
+ _MMCamcorderGstElement *element; /**< array of Gstreamer element */
+ _MMCamcorderKPIMeasure kpi; /**< information related with performance measurement */
- type_element *VideosinkElement; /**< configure data of videosink element */
- gboolean SensorEncodedCapture; /**< whether camera sensor support encoded image capture */
- gboolean internal_encode; /**< whether use internal encoding function */
+ type_element *VideosinkElement; /**< configure data of videosink element */
+ gboolean SensorEncodedCapture; /**< whether camera sensor support encoded image capture */
+ gboolean internal_encode; /**< whether use internal encoding function */
} _MMCamcorderSubContext;
/**
*/
typedef struct mmf_camcorder {
/* information */
- int type; /**< mmcamcorder_mode_type */
- int state; /**< state of camcorder */
- int target_state; /**< Target state that want to set. This is a flag that
- * stands for async state changing. If this value differ from state,
- * it means state is changing now asychronously. */
+ int type; /**< mmcamcorder_mode_type */
+ int state; /**< state of camcorder */
+ int target_state; /**< Target state that want to set. This is a flag that
+ * stands for async state changing. If this value differ from state,
+ * it means state is changing now asychronously. */
/* handles */
- MMHandleType attributes; /**< Attribute handle */
+ MMHandleType attributes; /**< Attribute handle */
_MMCamcorderSubContext *sub_context; /**< sub context */
- mm_exif_info_t *exif_info; /**< EXIF */
- GList *buffer_probes; /**< a list of buffer probe handle */
- GList *event_probes; /**< a list of event probe handle */
- GList *data_probes; /**< a list of data probe handle */
- GList *signals; /**< a list of signal handle */
- GList *msg_data; /**< a list of msg data */
- camera_conf *conf_main; /**< Camera configure Main structure */
- camera_conf *conf_ctrl; /**< Camera configure Control structure */
- int asm_handle; /**< Audio session manager handle */
- guint pipeline_cb_event_id; /**< Event source ID of pipeline message callback */
- guint setting_event_id; /**< Event source ID of attributes setting to sensor */
- SOUND_INFO snd_info; /**< Sound handle for multishot capture */
+ mm_exif_info_t *exif_info; /**< EXIF */
+ GList *buffer_probes; /**< a list of buffer probe handle */
+ GList *event_probes; /**< a list of event probe handle */
+ GList *data_probes; /**< a list of data probe handle */
+ GList *signals; /**< a list of signal handle */
+ GList *msg_data; /**< a list of msg data */
+ camera_conf *conf_main; /**< Camera configure Main structure */
+ camera_conf *conf_ctrl; /**< Camera configure Control structure */
+ int asm_handle_sh; /**< Audio session manager handle of share session */
+ int asm_handle_ex; /**< Audio session manager handle of exclusive session */
+ guint pipeline_cb_event_id; /**< Event source ID of pipeline message callback */
+ guint setting_event_id; /**< Event source ID of attributes setting to sensor */
+ SOUND_INFO snd_info; /**< Sound handle for multishot capture */
/* callback handlers */
- MMMessageCallback msg_cb; /**< message callback */
- void *msg_cb_param; /**< message callback parameter */
- mm_camcorder_video_stream_callback vstream_cb; /**< Video stream callback */
- void *vstream_cb_param; /**< Video stream callback parameter */
- mm_camcorder_audio_stream_callback astream_cb; /**< Audio stream callback */
- void *astream_cb_param; /**< Audio stream callback parameter */
- mm_camcorder_video_capture_callback vcapture_cb; /**< Video capture callback */
- void *vcapture_cb_param; /**< Video capture callback parameter */
- int (*command)(MMHandleType, int); /**< camcorder's command */
+ MMMessageCallback msg_cb; /**< message callback */
+ void *msg_cb_param; /**< message callback parameter */
+ mm_camcorder_video_stream_callback vstream_cb; /**< Video stream callback */
+ void *vstream_cb_param; /**< Video stream callback parameter */
+ mm_camcorder_audio_stream_callback astream_cb; /**< Audio stream callback */
+ void *astream_cb_param; /**< Audio stream callback parameter */
+ mm_camcorder_video_capture_callback vcapture_cb; /**< Video capture callback */
+ void *vcapture_cb_param; /**< Video capture callback parameter */
+ int (*command)(MMHandleType, int); /**< camcorder's command */
/* etc */
- _MMCamcorderMTSafe mtsafe; /**< Thread safe */
- _MMCamcorderCommand cmd; /**< information for command loop */
- int sync_state_change; /**< Change framework state synchronously */
+ _MMCamcorderMTSafe mtsafe; /**< Thread safe */
+ _MMCamcorderCommand cmd; /**< information for command loop */
+ int sync_state_change; /**< Change framework state synchronously */
int quick_device_close;
- int state_change_by_system; /**< MSL changes its state by itself because of system(ASM,MDM..) **/
- int asm_event_code; /**< event code of audio session manager */
- pthread_mutex_t sound_lock; /**< Capture sound mutex */
- pthread_cond_t sound_cond; /**< Capture sound cond */
- int use_zero_copy_format; /**< Whether use zero copy format for camera input */
+ int state_change_by_system; /**< MSL changes its state by itself because of system(ASM,MDM..) **/
+ int asm_event_code; /**< event code of audio session manager */
+ pthread_mutex_t sound_lock; /**< Capture sound mutex */
+ pthread_cond_t sound_cond; /**< Capture sound cond */
+ int use_zero_copy_format; /**< Whether use zero copy format for camera input */
+ int shutter_sound_policy; /**< shutter sound policy */
+
+ _MMCamcorderInfoConverting caminfo_convert[CAMINFO_CONVERT_NUM]; /**< converting structure of camera info */
+ _MMCamcorderEnumConvert enum_conv[ENUM_CONVERT_NUM]; /**< enum converting list that is modified by ini info */
int reserved[4]; /**< reserved */
} mmf_camcorder_t;
gboolean _mmcamcorder_pipeline_cb_message(GstBus *bus, GstMessage *message, gpointer data);
/**
+ * This function is callback function of main pipeline.
+ * Once this function is registered with certain pipeline using gst_bus_set_sync_handler(),
+ * this callback will be called every time when there is upcomming message from pipeline.
+ * Basically, this function is used as sync error handling function, now.
+ *
+ * @param[in] bus pointer of buf that called this function.
+ * @param[in] message callback message from pipeline.
+ * @param[in] data user data.
+ * @return This function returns true on success, or false value with error
+ * @remarks
+ * @see __mmcamcorder_create_preview_pipeline()
+ *
+ */
+GstBusSyncReply _mmcamcorder_pipeline_bus_sync_callback(GstBus *bus, GstMessage *message, gpointer data);
+
+/**
* This function create main pipeline according to type.
*
* @param[in] handle Handle of camcorder context.
*/
#define _MMCAMCORDER_SENSOR_ENUM_NONE -255
+/* camera information related */
+#define CAMINFO_CONVERT_NUM 40
+
/*=======================================================================================
| ENUM DEFINITIONS |
MM_CAMCONVERT_TYPE_USER, /* user define */
} MMCamConvertingType;
+typedef enum {
+ ENUM_CONVERT_WHITE_BALANCE = 0,
+ ENUM_CONVERT_COLOR_TONE,
+ ENUM_CONVERT_ISO,
+ ENUM_CONVERT_PROGRAM_MODE,
+ ENUM_CONVERT_FOCUS_MODE,
+ ENUM_CONVERT_AF_RANGE,
+ ENUM_CONVERT_EXPOSURE_MODE,
+ ENUM_CONVERT_STROBE_MODE,
+ ENUM_CONVERT_WDR,
+ ENUM_CONVERT_ANTI_HAND_SHAKE,
+ ENUM_CONVERT_VIDEO_STABILIZATION,
+ ENUM_CONVERT_NUM
+} MMCamConvertingEnum;
+
/*=======================================================================================
| STRUCTURE DEFINITIONS |
========================================================================================*/
/*=======================================================================================
| GLOBAL FUNCTION PROTOTYPES |
========================================================================================*/
-int _mmcamcorder_convert_msl_to_sensor(int attr_idx, int mslval);
-int _mmcamcorder_convert_sensor_to_msl(int attr_idx, int sensval);
+int _mmcamcorder_convert_msl_to_sensor(MMHandleType handle, int attr_idx, int mslval);
+int _mmcamcorder_convert_sensor_to_msl(MMHandleType handle, int attr_idx, int sensval);
int _mmcamcorder_set_converted_value(MMHandleType handle, _MMCamcorderEnumConvert *convert);
int _mmcamcorder_init_convert_table(MMHandleType handle);
/*=======================================================================================
| INCLUDE FILES |
========================================================================================*/
+#include <pulse/pulseaudio.h>
#ifdef __cplusplus
extern "C" {
typedef enum {
_MMCAMCORDER_SOUND_STATE_NONE,
_MMCAMCORDER_SOUND_STATE_INIT,
- _MMCAMCORDER_SOUND_STATE_PREPARE,
_MMCAMCORDER_SOUND_STATE_PLAYING,
} _MMCamcorderSoundState;
* Structure of sound info
*/
typedef struct __SOUND_INFO {
- SF_INFO sfinfo;
- SNDFILE *infile;
- short *pcm_buf;
- int pcm_size;
- char *filename;
-
+ /* PCM */
MMSoundPcmHandle_t handle;
+ mm_sound_device_out active_out_backup;
- int thread_run;
- pthread_t thread;
+ /* mutex and cond */
pthread_mutex_t play_mutex;
pthread_cond_t play_cond;
pthread_mutex_t open_mutex;
pthread_cond_t open_cond;
- system_audio_route_t route_policy_backup;
+
+ /* pulse audio */
+ pa_threaded_mainloop *pulse_mainloop;
+ pa_context *pulse_context;
+
+#ifdef _MMCAMCORDER_UPLOAD_SAMPLE
+ /* sound file */
+ SF_INFO sfinfo;
+ SNDFILE *infile;
+ char *filename;
+ pa_stream *sample_stream;
+ pa_sample_spec sample_spec;
+ size_t sample_length;
+ pa_channel_map channel_map;
+#endif
_MMCamcorderSoundState state;
} SOUND_INFO;
/*=======================================================================================
| GLOBAL FUNCTION PROTOTYPES |
========================================================================================*/
+#ifdef _MMCAMCORDER_UPLOAD_SAMPLE
gboolean _mmcamcorder_sound_init(MMHandleType handle, char *filename);
-gboolean _mmcamcorder_sound_prepare(MMHandleType handle);
+#else /* _MMCAMCORDER_UPLOAD_SAMPLE */
+gboolean _mmcamcorder_sound_init(MMHandleType handle);
+#endif /* _MMCAMCORDER_UPLOAD_SAMPLE */
gboolean _mmcamcorder_sound_play(MMHandleType handle);
gboolean _mmcamcorder_sound_finalize(MMHandleType handle);
+gboolean _mmcamcorder_sound_capture_play_cb(gpointer data);
void _mmcamcorder_sound_solo_play(MMHandleType handle, const char *filepath, gboolean sync);
#ifdef __cplusplus
#define _MMCAMCORDER_CAPTURE_STOP_CHECK_INTERVAL 5000
#define _MMCAMCORDER_CAPTURE_STOP_CHECK_COUNT 600
#define _MNOTE_VALUE_NONE 0
+#define _SOUND_STATUS_INIT -1
/*=======================================================================================
| ENUM DEFINITIONS |
========================================================================================*/
+/**
+ * Enumeration for flip of fimcconvert
+ */
+enum {
+ FIMCCONVERT_FLIP_NONE = 0,
+ FIMCCONVERT_FLIP_VERTICAL,
+ FIMCCONVERT_FLIP_HORIZONTAL
+};
/*=======================================================================================
| STRUCTURE DEFINITIONS |
int width; /**< Width of capture image */
int height; /**< Height of capture image */
int interval; /**< Capture interval */
+ int preview_format; /**< Preview format */
+ int hdr_capture_mode; /**< HDR Capture mode */
+ gboolean sound_status; /**< sound status of system */
+ unsigned int volume_level; /**< media volume level of system */
+ gboolean played_capture_sound; /**< whether play capture sound when capture starts */
} _MMCamcorderImageInfo;
/*=======================================================================================
int _mmcamcorder_remove_stillshot_pipeline(MMHandleType handle);
/**
+ * This function connects capture signal.
+ *
+ * @param[in] handle Handle of camcorder context.
+ * @return This function returns MM_ERROR_NONE on success, or the other values on error.
+ * @remarks
+ */
+int _mmcamcorder_connect_capture_signal(MMHandleType handle);
+
+/**
* This function destroy image pipeline.
*
* @param[in] handle Handle of camcorder context.
* @see _mmcamcorder_destroy_pipeline()
*
*/
-void _mmcamcorder_destroy_image_pipeline(MMHandleType handle);
-int _mmcamcorder_image_command(MMHandleType handle, int command);
+void _mmcamcorder_destroy_video_capture_pipeline(MMHandleType handle);
+int _mmcamcorder_video_capture_command(MMHandleType handle, int command);
int _mmcamcorder_set_resize_property(MMHandleType handle, int capture_width, int capture_height);
/* Function for capture */
-int __mmcamcorder_set_exif_basic_info(MMHandleType handle);
+int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int image_height);
void __mmcamcorder_init_stillshot_info(MMHandleType handle);
void __mmcamcorder_get_capture_data_from_buffer(MMCamcorderCaptureDataType *capture_data, int pixtype, GstBuffer *buffer);
void __mmcamcorder_release_jpeg_data(MMHandleType handle, MMCamcorderCaptureDataType *dest);
-gboolean __mmcamcorder_capture_save_exifinfo(MMHandleType handle, MMCamcorderCaptureDataType *original, MMCamcorderCaptureDataType *thumbnail);
-gboolean __mmcamcorder_capture_send_msg(MMHandleType handle, int type, int count);
-gboolean __mmcamcorder_set_jpeg_data(MMHandleType handle, MMCamcorderCaptureDataType *dest, MMCamcorderCaptureDataType *thumbnail);
+int __mmcamcorder_capture_save_exifinfo(MMHandleType handle, MMCamcorderCaptureDataType *original, MMCamcorderCaptureDataType *thumbnail);
+int __mmcamcorder_set_jpeg_data(MMHandleType handle, MMCamcorderCaptureDataType *dest, MMCamcorderCaptureDataType *thumbnail);
#ifdef __cplusplus
}
((gchar)(((fourcc)>>16)&0xff)), \
((gchar)(((fourcc)>>24)&0xff))
+#define MMCAM_SEND_MESSAGE(handle, msg_id, msg_code) \
+{\
+ _MMCamcorderMsgItem msg;\
+ msg.id = msg_id;\
+ msg.param.code = msg_code;\
+ _mmcam_dbg_log("msg id : %x, code : %x", msg_id, msg_code);\
+ _mmcamcroder_send_message((MMHandleType)handle, &msg);\
+}
+
+
/*=======================================================================================
| ENUM DEFINITIONS |
========================================================================================*/
MMMessageParamType param; /**< message parameter */
} _MMCamcorderMsgItem;
+/**
+ * Structure of zero copy image buffer
+ */
+#define SCMN_IMGB_MAX_PLANE (4)
+
+/* image buffer definition ***************************************************
+
+ +------------------------------------------+ ---
+ | | ^
+ | a[], p[] | |
+ | +---------------------------+ --- | |
+ | | | ^ | |
+ | |<---------- w[] ---------->| | | |
+ | | | | | |
+ | | | |
+ | | | h[] | e[]
+ | | | |
+ | | | | | |
+ | | | | | |
+ | | | v | |
+ | +---------------------------+ --- | |
+ | | v
+ +------------------------------------------+ ---
+
+ |<----------------- s[] ------------------>|
+*/
+
+typedef struct
+{
+ /* width of each image plane */
+ int w[SCMN_IMGB_MAX_PLANE];
+ /* height of each image plane */
+ int h[SCMN_IMGB_MAX_PLANE];
+ /* stride of each image plane */
+ int s[SCMN_IMGB_MAX_PLANE];
+ /* elevation of each image plane */
+ int e[SCMN_IMGB_MAX_PLANE];
+ /* user space address of each image plane */
+ void *a[SCMN_IMGB_MAX_PLANE];
+ /* physical address of each image plane, if needs */
+ void *p[SCMN_IMGB_MAX_PLANE];
+ /* color space type of image */
+ int cs;
+ /* left postion, if needs */
+ int x;
+ /* top position, if needs */
+ int y;
+ /* to align memory */
+ int __dummy2;
+ /* arbitrary data */
+ int data[16];
+} SCMN_IMGB;
+
/*=======================================================================================
| CONSTANT DEFINITIONS |
========================================================================================*/
gboolean _mmcamcorder_encode_jpeg(void *src_data, unsigned int src_width, unsigned int src_height,
int src_format, unsigned int src_length, unsigned int jpeg_quality,
void **result_data, unsigned int *result_length);
+/* resize */
+gboolean _mmcamcorder_resize_frame(unsigned char *src_data, int src_width, int src_height, int src_length, int src_format,
+ unsigned char **dst_data, int *dst_width, int *dst_height, int *dst_length);
/* Recording */
/* find top level tag only, do not use this function for finding sub level tags.
tag_fourcc is Four-character-code (FOURCC) */
-gint _mmcamcorder_find_tag(FILE *f, guint32 tag_fourcc);
+gint _mmcamcorder_find_tag(FILE *f, guint32 tag_fourcc, gboolean do_rewind);
gint32 _mmcamcorder_double_to_fix(gdouble d_number);
gboolean _mmcamcorder_update_size(FILE *f, gint64 prev_pos, gint64 curr_pos);
gboolean _mmcamcorder_write_loci(FILE *f, _MMCamcorderLocationInfo info);
gboolean _mmcamcorder_write_udta(FILE *f, _MMCamcorderLocationInfo info);
-gulong _mmcamcorder_get_container_size(const guchar *size);
+guint64 _mmcamcorder_get_container_size(const guchar *size);
+gboolean _mmcamcorder_update_composition_matrix(FILE *f, int orientation);
/* File system */
int _mmcamcorder_get_freespace(const gchar *path, guint64 *free_space);
typedef struct {
gboolean b_commiting; /**< Is it commiting now? */
char *filename; /**< recorded filename */
- gint multiple_fps; /**< fps for high speed recording(slow motion recording) */
+ double record_timestamp_ratio; /**< timestamp ratio of video recording for slow motion recording */
guint64 video_frame_count; /**< current video frame */
guint64 audio_frame_count; /**< current audio frame */
guint64 filesize; /**< current file size */
+ guint64 max_size; /**< max recording size */
guint64 max_time; /**< max recording time */
int fileformat; /**< recording file format */
/*
*/
int _mmcamcorder_video_handle_eos(MMHandleType handle);
+
#ifdef __cplusplus
}
#endif
#include <gst/interfaces/cameracontrol.h>
#include <gst/interfaces/xoverlay.h>
+/*-----------------------------------------------------------------------
+| MACRO DEFINITIONS: |
+-----------------------------------------------------------------------*/
+#define MMCAMCORDER_DEFAULT_CAMERA_WIDTH 640
+#define MMCAMCORDER_DEFAULT_CAMERA_HEIGHT 480
/*---------------------------------------------------------------------------------------
| GLOBAL VARIABLE DEFINITIONS for internal |
---------------------------------------------------------------------------------------*/
-int video_input_rotation[] = {MM_VIDEO_INPUT_ROTATION_NONE,
- MM_VIDEO_INPUT_ROTATION_90,
- MM_VIDEO_INPUT_ROTATION_180,
- MM_VIDEO_INPUT_ROTATION_270,
- MM_VIDEO_INPUT_ROTATION_FLIP_HORZ,
- MM_VIDEO_INPUT_ROTATION_FLIP_VERT};
-
int depth[] = {MM_CAMCORDER_AUDIO_FORMAT_PCM_U8,
MM_CAMCORDER_AUDIO_FORMAT_PCM_S16_LE};
-int rotation[] = {MM_DISPLAY_ROTATION_NONE,
- MM_DISPLAY_ROTATION_90,
- MM_DISPLAY_ROTATION_180,
- MM_DISPLAY_ROTATION_270,
- MM_DISPLAY_ROTATION_FLIP_HORZ,
- MM_DISPLAY_ROTATION_FLIP_VERT};
-
int visible_values[] = { 0, 1 }; /*0: off, 1:on*/
int strobe_mode[] = {MM_CAMCORDER_STROBE_MODE_OFF,
8, /*the 0th row is the visual left-hand side of the image, and the 0th column is the visual bottom.*/
};
+
/* basic attributes' info */
mm_cam_attr_construct_info cam_attrs_const_info[] ={
//0
"mode", /* Name */
MMF_VALUE_TYPE_INT, /* Type */
MM_ATTRS_FLAG_RW, /* Flag */
- (void*)MM_CAMCORDER_MODE_IMAGE, /* Default value */
+ {(void*)MM_CAMCORDER_MODE_VIDEO_CAPTURE}, /* Default value */
MM_ATTRS_VALID_TYPE_INT_RANGE, /* Validity type */
- MM_CAMCORDER_MODE_IMAGE, /* Validity val1 (min, *array,...) */
- MM_CAMCORDER_MODE_VIDEO, /* Validity val2 (max, count, ...) */
+ MM_CAMCORDER_MODE_VIDEO_CAPTURE, /* Validity val1 (min, *array,...) */
+ MM_CAMCORDER_MODE_AUDIO, /* Validity val2 (max, count, ...) */
NULL, /* Runtime setting function of the attribute */
},
// 1
"audio-device",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)MM_AUDIO_DEVICE_MIC,
+ {(void*)MM_AUDIO_DEVICE_MIC},
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
MM_AUDIO_DEVICE_NUM-1,
},
// 2
{
- MM_CAM_CAMERA_DEVICE,
- "camera-device",
+ MM_CAM_CAMERA_DEVICE_COUNT,
+ "camera-device-count",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)MM_VIDEO_DEVICE_NONE,
+ {(void*)MM_VIDEO_DEVICE_NUM},
MM_ATTRS_VALID_TYPE_INT_RANGE,
MM_VIDEO_DEVICE_NONE,
- MM_VIDEO_DEVICE_NUM-1,
+ MM_VIDEO_DEVICE_NUM,
NULL,
},
// 3
"audio-encoder",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)MM_AUDIO_CODEC_AMR,
+ {(void*)MM_AUDIO_CODEC_AMR},
MM_ATTRS_VALID_TYPE_INT_ARRAY,
(int)NULL,
0,
"video-encoder",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)MM_VIDEO_CODEC_MPEG4,
+ {(void*)MM_VIDEO_CODEC_MPEG4},
MM_ATTRS_VALID_TYPE_INT_ARRAY,
(int)NULL,
0,
"image-encoder",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)MM_IMAGE_CODEC_JPEG,
+ {(void*)MM_IMAGE_CODEC_JPEG},
MM_ATTRS_VALID_TYPE_INT_ARRAY,
(int)NULL,
0,
"file-format",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)MM_FILE_FORMAT_MP4,
+ {(void*)MM_FILE_FORMAT_MP4},
MM_ATTRS_VALID_TYPE_INT_ARRAY,
(int)NULL,
0,
"camera-device-name",
MMF_VALUE_TYPE_STRING,
MM_ATTRS_FLAG_RW,
- (void*)NULL,
+ {(void*)NULL},
MM_ATTRS_VALID_TYPE_NONE,
0,
0,
"audio-samplerate",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)8000,
+ {(void*)8000},
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
_MMCAMCORDER_MAX_INT,
"audio-format",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)MM_CAMCORDER_AUDIO_FORMAT_PCM_S16_LE,
+ {(void*)MM_CAMCORDER_AUDIO_FORMAT_PCM_S16_LE},
MM_ATTRS_VALID_TYPE_INT_ARRAY,
(int)depth,
ARRAY_SIZE(depth),
"audio-channel",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)2,
+ {(void*)2},
MM_ATTRS_VALID_TYPE_INT_RANGE,
1,
2,
"audio-volume",
MMF_VALUE_TYPE_DOUBLE,
MM_ATTRS_FLAG_RW,
- (void*)1,
+ {(void*)1},
MM_ATTRS_VALID_TYPE_DOUBLE_RANGE,
0,
10.0,
"audio-input-route",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)MM_AUDIOROUTE_USE_EXTERNAL_SETTING,
+ {(void*)MM_AUDIOROUTE_USE_EXTERNAL_SETTING},
MM_ATTRS_VALID_TYPE_INT_RANGE,
MM_AUDIOROUTE_USE_EXTERNAL_SETTING,
MM_AUDIOROUTE_CAPTURE_STEREOMIC_ONLY,
"filter-scene-mode",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)0,
+ {(void*)0},
MM_ATTRS_VALID_TYPE_INT_ARRAY,
0,
0,
"filter-brightness",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)1,
+ {(void*)1},
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
-1,
"filter-contrast",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)0,
+ {(void*)0},
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
-1,
"filter-wb",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)0,
+ {(void*)0},
MM_ATTRS_VALID_TYPE_INT_ARRAY,
0,
0,
"filter-color-tone",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)0,
+ {(void*)0},
MM_ATTRS_VALID_TYPE_INT_ARRAY,
0,
0,
"filter-saturation",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)0,
+ {(void*)0},
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
-1,
"filter-hue",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)0,
+ {(void*)0},
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
-1,
"filter-sharpness",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)0,
+ {(void*)0},
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
-1,
"camera-format",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)MM_PIXEL_FORMAT_YUYV,
+ {(void*)MM_PIXEL_FORMAT_YUYV},
MM_ATTRS_VALID_TYPE_INT_ARRAY,
0,
0,
},
//22
{
- MM_CAM_CAMERA_SLOW_MOTION_FPS,
- "camera-slow-motion-fps",
- MMF_VALUE_TYPE_INT,
+ MM_CAM_CAMERA_RECORDING_MOTION_RATE,
+ "camera-recording-motion-rate",
+ MMF_VALUE_TYPE_DOUBLE,
MM_ATTRS_FLAG_RW,
- (void*)0,
- MM_ATTRS_VALID_TYPE_INT_RANGE,
+ {(void*)1},
+ MM_ATTRS_VALID_TYPE_DOUBLE_RANGE,
0,
_MMCAMCORDER_MAX_INT,
- NULL,
+ _mmcamcorder_commit_camera_recording_motion_rate,
},
//23
{
"camera-fps",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)30,
+ {(void*)30},
MM_ATTRS_VALID_TYPE_INT_ARRAY,
0,
0,
"camera-width",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)320,
+ {(void*)MMCAMCORDER_DEFAULT_CAMERA_WIDTH},
MM_ATTRS_VALID_TYPE_INT_ARRAY,
0,
0,
"camera-height",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)240,
+ {(void*)MMCAMCORDER_DEFAULT_CAMERA_HEIGHT},
MM_ATTRS_VALID_TYPE_INT_ARRAY,
0,
0,
"camera-digital-zoom",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)10,
+ {(void*)10},
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
-1,
"camera-optical-zoom",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)0,
+ {(void*)0},
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
-1,
"camera-focus-mode",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)MM_CAMCORDER_FOCUS_MODE_NONE,
+ {(void*)MM_CAMCORDER_FOCUS_MODE_NONE},
MM_ATTRS_VALID_TYPE_INT_ARRAY,
0,
0,
"camera-af-scan-range",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)0,
+ {(void*)0},
MM_ATTRS_VALID_TYPE_INT_ARRAY,
0,
0,
"camera-exposure-mode",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)0,
+ {(void*)0},
MM_ATTRS_VALID_TYPE_INT_ARRAY,
0,
0,
"camera-exposure-value",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)0,
+ {(void*)0},
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
-1,
"camera-f-number",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)0,
+ {(void*)0},
MM_ATTRS_VALID_TYPE_INT_ARRAY,
0,
0,
"camera-shutter-speed",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)0,
+ {(void*)0},
MM_ATTRS_VALID_TYPE_INT_ARRAY,
0,
0,
"camera-iso",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)0,
+ {(void*)0},
MM_ATTRS_VALID_TYPE_INT_ARRAY,
0,
0,
"camera-wdr",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)0,
+ {(void*)0},
MM_ATTRS_VALID_TYPE_INT_ARRAY,
0,
0,
"camera-anti-handshake",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)0,
+ {(void*)0},
MM_ATTRS_VALID_TYPE_INT_ARRAY,
0,
0,
"camera-fps-auto",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)FALSE,
+ {(void*)FALSE},
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
1,
"camera-hold-af-after-capturing",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)0,
+ {(void*)0},
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
1,
"camera-delay-attr-setting",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)FALSE,
+ {(void*)FALSE},
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
1,
"audio-encoder-bitrate",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)0,
+ {(void*)0},
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
_MMCAMCORDER_MAX_INT,
"video-encoder-bitrate",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)0,
+ {(void*)0},
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
_MMCAMCORDER_MAX_INT,
"image-encoder-quality",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)95,
+ {(void*)95},
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
-1,
"capture-format",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)MM_PIXEL_FORMAT_ENCODED,
+ {(void*)MM_PIXEL_FORMAT_ENCODED},
MM_ATTRS_VALID_TYPE_INT_ARRAY,
0,
0,
"capture-width",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)1600,
+ {(void*)1600},
MM_ATTRS_VALID_TYPE_INT_ARRAY,
0,
0,
"capture-height",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)1200,
+ {(void*)1200},
MM_ATTRS_VALID_TYPE_INT_ARRAY,
0,
0,
"capture-count",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)1,
+ {(void*)1},
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
-1,
"capture-interval",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)0,
+ {(void*)0},
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
_MMCAMCORDER_MAX_INT,
"capture-break-cont-shot",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)FALSE,
+ {(void*)FALSE},
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
1,
"display-handle",
MMF_VALUE_TYPE_DATA,
MM_ATTRS_FLAG_RW,
- (void*)NULL,
+ {(void*)NULL},
MM_ATTRS_VALID_TYPE_NONE,
0,
0,
"display-device",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)MM_DISPLAY_DEVICE_MAINLCD,
+ {(void*)MM_DISPLAY_DEVICE_MAINLCD},
MM_ATTRS_VALID_TYPE_INT_ARRAY,
0,
0,
"display-surface",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)MM_DISPLAY_SURFACE_X,
+ {(void*)MM_DISPLAY_SURFACE_X},
MM_ATTRS_VALID_TYPE_INT_ARRAY,
0,
0,
"display-rect-x",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)0,
+ {(void*)0},
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
_MMCAMCORDER_MAX_INT,
"display-rect-y",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)0,
+ {(void*)0},
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
_MMCAMCORDER_MAX_INT,
"display-rect-width",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)0,
+ {(void*)0},
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
_MMCAMCORDER_MAX_INT,
"display-rect-height",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)0,
+ {(void*)0},
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
_MMCAMCORDER_MAX_INT,
"display-src-x",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)0,
+ {(void*)0},
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
_MMCAMCORDER_MAX_INT,
"display-src-y",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)0,
+ {(void*)0},
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
_MMCAMCORDER_MAX_INT,
"display-src-width",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)0,
+ {(void*)0},
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
_MMCAMCORDER_MAX_INT,
"display-src-height",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)0,
+ {(void*)0},
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
_MMCAMCORDER_MAX_INT,
"display-rotation",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)MM_DISPLAY_ROTATION_NONE,
- MM_ATTRS_VALID_TYPE_INT_ARRAY,
- (int)rotation,
- ARRAY_SIZE(rotation),
+ {(void*)MM_DISPLAY_ROTATION_NONE},
+ MM_ATTRS_VALID_TYPE_INT_RANGE,
+ MM_DISPLAY_ROTATION_NONE,
+ MM_DISPLAY_ROTATION_270,
_mmcamcorder_commit_display_rotation,
},
//61
"display-visible",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)1,
+ {(void*)1},
MM_ATTRS_VALID_TYPE_INT_ARRAY,
(int)visible_values,
ARRAY_SIZE(visible_values),
"display-scale",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)0,
+ {(void*)0},
MM_ATTRS_VALID_TYPE_INT_RANGE,
MM_DISPLAY_SCALE_DEFAULT,
MM_DISPLAY_SCALE_TRIPLE_LENGTH,
"display-geometry-method",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)0,
+ {(void*)0},
MM_ATTRS_VALID_TYPE_INT_RANGE,
MM_DISPLAY_METHOD_LETTER_BOX,
MM_DISPLAY_METHOD_CUSTOM_ROI,
"target-filename",
MMF_VALUE_TYPE_STRING,
MM_ATTRS_FLAG_RW,
- (void*)"/tmp/CAM-NONAME",
+ {(void*)"/tmp/CAM-NONAME"},
MM_ATTRS_VALID_TYPE_NONE,
0,
0,
"target-max-size",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)0,
+ {(void*)0},
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
_MMCAMCORDER_MAX_INT,
"target-time-limit",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)0,
+ {(void*)0},
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
_MMCAMCORDER_MAX_INT,
"tag-enable",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
-// (void*)tag_enable_values[0],
- (void*)0,
+ {(void*)0},
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
1,
"tag-image-description",
MMF_VALUE_TYPE_STRING,
MM_ATTRS_FLAG_RW,
- (void*)NULL,
+ {(void*)NULL},
MM_ATTRS_VALID_TYPE_NONE,
0,
0,
"tag-orientation",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
-// (void*)tag_orientation_values[0],
- (void*)1,
+ {(void*)1},
MM_ATTRS_VALID_TYPE_INT_ARRAY,
(int)tag_orientation_values,
ARRAY_SIZE(tag_orientation_values),
"tag-software",
MMF_VALUE_TYPE_STRING,
MM_ATTRS_FLAG_RW,
- (void*)NULL,
+ {(void*)NULL},
MM_ATTRS_VALID_TYPE_NONE,
0,
0,
"tag-latitude",
MMF_VALUE_TYPE_DOUBLE,
MM_ATTRS_FLAG_RW,
- (void*)0,
+ {(void*)0},
MM_ATTRS_VALID_TYPE_DOUBLE_RANGE,
-360,
360,
"tag-longitude",
MMF_VALUE_TYPE_DOUBLE,
MM_ATTRS_FLAG_RW,
- (void*)0,
+ {(void*)0},
MM_ATTRS_VALID_TYPE_DOUBLE_RANGE,
-360,
360,
"tag-altitude",
MMF_VALUE_TYPE_DOUBLE,
MM_ATTRS_FLAG_RW,
- (void*)0,
+ {(void*)0},
MM_ATTRS_VALID_TYPE_DOUBLE_RANGE,
-999999,
999999,
"strobe-control",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)0,
+ {(void*)0},
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
-1,
"strobe-capabilities",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)0,
+ {(void*)0},
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
-1,
"strobe-mode",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)0,
+ {(void*)0},
MM_ATTRS_VALID_TYPE_INT_ARRAY,
- (int)strobe_mode,
- ARRAY_SIZE(strobe_mode),
+ 0,
+ 0,
_mmcamcorder_commit_strobe,
},
//77
"detect-mode",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)0,
+ {(void*)0},
MM_ATTRS_VALID_TYPE_INT_ARRAY,
0,
0,
"detect-number",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)0,
+ {(void*)0},
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
-1,
"detect-focus-select",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)0,
+ {(void*)0},
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
-1,
"detect-select-number",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)0,
+ {(void*)0},
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
-1,
"detect-status",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)0,
+ {(void*)0},
MM_ATTRS_VALID_TYPE_INT_ARRAY,
0,
0,
"capture-zero-systemlag",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)FALSE,
+ {(void*)FALSE},
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
1,
"camera-af-touch-x",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)0,
+ {(void*)0},
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
_MMCAMCORDER_MAX_INT,
"camera-af-touch-y",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)0,
+ {(void*)0},
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
_MMCAMCORDER_MAX_INT,
"camera-af-touch-width",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)0,
+ {(void*)0},
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
_MMCAMCORDER_MAX_INT,
"camera-af-touch-height",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)0,
+ {(void*)0},
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
_MMCAMCORDER_MAX_INT,
"camera-focal-length",
MMF_VALUE_TYPE_DOUBLE,
MM_ATTRS_FLAG_RW,
- (void*)0,
+ {(void*)0},
MM_ATTRS_VALID_TYPE_DOUBLE_RANGE,
0,
1000,
"recommend-preview-format-for-capture",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)MM_PIXEL_FORMAT_YUYV,
+ {(void*)MM_PIXEL_FORMAT_YUYV},
MM_ATTRS_VALID_TYPE_INT_RANGE,
MM_PIXEL_FORMAT_NV12,
- MM_PIXEL_FORMAT_ENCODED,
+ MM_PIXEL_FORMAT_ITLV_JPEG_UYVY,
NULL,
},
//89
"recommend-preview-format-for-recording",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)MM_PIXEL_FORMAT_NV12,
+ {(void*)MM_PIXEL_FORMAT_NV12},
MM_ATTRS_VALID_TYPE_INT_RANGE,
MM_PIXEL_FORMAT_NV12,
- MM_PIXEL_FORMAT_ENCODED,
+ MM_PIXEL_FORMAT_ITLV_JPEG_UYVY,
NULL,
},
//90
"capture-thumbnail",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)TRUE,
+ {(void*)TRUE},
MM_ATTRS_VALID_TYPE_NONE,
0,
0,
"tag-gps-enable",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)TRUE,
+ {(void*)TRUE},
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
1,
"tag-gps-time-stamp",
MMF_VALUE_TYPE_DOUBLE,
MM_ATTRS_FLAG_RW,
- (void*)0,
+ {(void*)0},
MM_ATTRS_VALID_TYPE_NONE,
0,
0,
"tag-gps-date-stamp",
MMF_VALUE_TYPE_STRING,
MM_ATTRS_FLAG_RW,
- NULL,
+ {(void*)NULL},
MM_ATTRS_VALID_TYPE_NONE,
0,
0,
"tag-gps-processing-method",
MMF_VALUE_TYPE_STRING,
MM_ATTRS_FLAG_RW,
- NULL,
+ {(void*)NULL},
MM_ATTRS_VALID_TYPE_NONE,
0,
0,
"camera-rotation",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)MM_VIDEO_INPUT_ROTATION_NONE,
- MM_ATTRS_VALID_TYPE_INT_ARRAY,
- (int)video_input_rotation,
- ARRAY_SIZE(video_input_rotation),
+ {(void*)MM_VIDEO_INPUT_ROTATION_NONE},
+ MM_ATTRS_VALID_TYPE_INT_RANGE,
+ MM_VIDEO_INPUT_ROTATION_NONE,
+ MM_VIDEO_INPUT_ROTATION_270,
_mmcamcorder_commit_camera_rotate,
},
//96
"enable-converted-stream-callback",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)0,
+ {(void*)0},
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
1,
MM_CAM_CAPTURED_SCREENNAIL,
"captured-screennail",
MMF_VALUE_TYPE_DATA,
- MM_ATTRS_FLAG_RW,
- (void*)NULL,
+ MM_ATTRS_FLAG_READABLE,
+ {(void*)NULL},
MM_ATTRS_VALID_TYPE_NONE,
0,
0,
"capture-sound-enable",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)FALSE,
+ {(void*)TRUE},
MM_ATTRS_VALID_TYPE_INT_RANGE,
0,
1,
- NULL,
+ _mmcamcorder_commit_capture_sound_enable,
},
//99
{
"recommend-display-rotation",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)MM_DISPLAY_ROTATION_270,
+ {(void*)MM_DISPLAY_ROTATION_270},
MM_ATTRS_VALID_TYPE_INT_RANGE,
MM_DISPLAY_ROTATION_NONE,
- MM_DISPLAY_ROTATION_FLIP_VERT,
+ MM_DISPLAY_ROTATION_270,
NULL,
},
//100
{
- MM_CAM_CAMCORDER_ROTATION,
- "camcorder-rotation",
+ MM_CAM_CAMERA_FLIP,
+ "camera-flip",
MMF_VALUE_TYPE_INT,
MM_ATTRS_FLAG_RW,
- (void*)MM_VIDEO_INPUT_ROTATION_NONE,
+ {(void*)MM_FLIP_NONE},
MM_ATTRS_VALID_TYPE_INT_RANGE,
- MM_VIDEO_INPUT_ROTATION_NONE,
- MM_VIDEO_INPUT_ROTATION_270,
- _mmcamcorder_commit_camcorder_rotate,
+ MM_FLIP_NONE,
+ MM_FLIP_BOTH,
+ _mmcamcorder_commit_camera_flip,
+ },
+ //101
+ {
+ MM_CAM_CAMERA_HDR_CAPTURE,
+ "camera-hdr-capture",
+ MMF_VALUE_TYPE_INT,
+ MM_ATTRS_FLAG_RW,
+ {(void*)FALSE},
+ MM_ATTRS_VALID_TYPE_INT_ARRAY,
+ 0,
+ 0,
+ _mmcamcorder_commit_camera_hdr_capture,
+ },
+ //102
+ {
+ MM_CAM_DISPLAY_MODE,
+ "display-mode",
+ MMF_VALUE_TYPE_INT,
+ MM_ATTRS_FLAG_RW,
+ {(void*)MM_DISPLAY_MODE_DEFAULT},
+ MM_ATTRS_VALID_TYPE_INT_ARRAY,
+ 0,
+ 0,
+ _mmcamcorder_commit_display_mode,
+ },
+ //103
+ {
+ MM_CAM_CAMERA_FACE_ZOOM_X,
+ "camera-face-zoom-x",
+ MMF_VALUE_TYPE_INT,
+ MM_ATTRS_FLAG_RW,
+ {(void*)0},
+ MM_ATTRS_VALID_TYPE_INT_RANGE,
+ 0,
+ _MMCAMCORDER_MAX_INT,
+ _mmcamcorder_commit_camera_face_zoom,
+ },
+ //104
+ {
+ MM_CAM_CAMERA_FACE_ZOOM_Y,
+ "camera-face-zoom-y",
+ MMF_VALUE_TYPE_INT,
+ MM_ATTRS_FLAG_RW,
+ {(void*)0},
+ MM_ATTRS_VALID_TYPE_INT_RANGE,
+ 0,
+ _MMCAMCORDER_MAX_INT,
+ _mmcamcorder_commit_camera_face_zoom,
+ },
+ //105
+ {
+ MM_CAM_CAMERA_FACE_ZOOM_LEVEL,
+ "camera-face-zoom-level",
+ MMF_VALUE_TYPE_INT,
+ MM_ATTRS_FLAG_RW,
+ {(void*)0},
+ MM_ATTRS_VALID_TYPE_INT_RANGE,
+ 0,
+ -1,
+ NULL,
+ },
+ //106
+ {
+ MM_CAM_CAMERA_FACE_ZOOM_MODE,
+ "camera-face-zoom-mode",
+ MMF_VALUE_TYPE_INT,
+ MM_ATTRS_FLAG_RW,
+ {(void*)FALSE},
+ MM_ATTRS_VALID_TYPE_INT_ARRAY,
+ 0,
+ 0,
+ _mmcamcorder_commit_camera_face_zoom,
+ },
+ //107
+ {
+ MM_CAM_AUDIO_DISABLE,
+ "audio-disable",
+ MMF_VALUE_TYPE_INT,
+ MM_ATTRS_FLAG_RW,
+ {(void*)FALSE},
+ MM_ATTRS_VALID_TYPE_INT_RANGE,
+ FALSE,
+ TRUE,
+ _mmcamcorder_commit_audio_disable,
+ },
+ //108
+ {
+ MM_CAM_RECOMMEND_CAMERA_WIDTH,
+ "recommend-camera-width",
+ MMF_VALUE_TYPE_INT,
+ MM_ATTRS_FLAG_RW,
+ {(void*)MMCAMCORDER_DEFAULT_CAMERA_WIDTH},
+ MM_ATTRS_VALID_TYPE_INT_ARRAY,
+ 0,
+ 0,
+ NULL,
+ },
+ //109
+ {
+ MM_CAM_RECOMMEND_CAMERA_HEIGHT,
+ "recommend-camera-height",
+ MMF_VALUE_TYPE_INT,
+ MM_ATTRS_FLAG_RW,
+ {(void*)MMCAMCORDER_DEFAULT_CAMERA_HEIGHT},
+ MM_ATTRS_VALID_TYPE_INT_ARRAY,
+ 0,
+ 0,
+ NULL,
+ },
+ //110
+ {
+ MM_CAM_CAPTURED_EXIF_RAW_DATA,
+ "captured-exif-raw-data",
+ MMF_VALUE_TYPE_DATA,
+ MM_ATTRS_FLAG_READABLE,
+ {(void*)NULL},
+ MM_ATTRS_VALID_TYPE_NONE,
+ 0,
+ 0,
+ NULL,
+ },
+ //111
+ {
+ MM_CAM_DISPLAY_EVAS_SURFACE_SINK,
+ "display-evas-surface-sink",
+ MMF_VALUE_TYPE_STRING,
+ MM_ATTRS_FLAG_READABLE,
+ {(void*)NULL},
+ MM_ATTRS_VALID_TYPE_NONE,
+ 0,
+ 0,
+ NULL,
+ },
+ //112
+ {
+ MM_CAM_DISPLAY_EVAS_DO_SCALING,
+ "display-evas-do-scaling",
+ MMF_VALUE_TYPE_INT,
+ MM_ATTRS_FLAG_RW,
+ {(void*)TRUE},
+ MM_ATTRS_VALID_TYPE_INT_RANGE,
+ FALSE,
+ TRUE,
+ _mmcamcorder_commit_display_evas_do_scaling,
+ },
+ //113
+ {
+ MM_CAM_CAMERA_FACING_DIRECTION,
+ "camera-facing-direction",
+ MMF_VALUE_TYPE_INT,
+ MM_ATTRS_FLAG_RW,
+ {(void*)MM_CAMCORDER_CAMERA_FACING_DIRECTION_REAR},
+ MM_ATTRS_VALID_TYPE_INT_RANGE,
+ MM_CAMCORDER_CAMERA_FACING_DIRECTION_REAR,
+ MM_CAMCORDER_CAMERA_FACING_DIRECTION_FRONT,
+ NULL,
},
+ //114
+ {
+ MM_CAM_DISPLAY_FLIP,
+ "display-flip",
+ MMF_VALUE_TYPE_INT,
+ MM_ATTRS_FLAG_RW,
+ {(void*)MM_FLIP_NONE},
+ MM_ATTRS_VALID_TYPE_INT_RANGE,
+ MM_FLIP_NONE,
+ MM_FLIP_BOTH,
+ _mmcamcorder_commit_display_flip,
+ },
+ //115
+ {
+ MM_CAM_CAMERA_VIDEO_STABILIZATION,
+ "camera-video-stabilization",
+ MMF_VALUE_TYPE_INT,
+ MM_ATTRS_FLAG_RW,
+ {(void*)MM_CAMCORDER_VIDEO_STABILIZATION_OFF},
+ MM_ATTRS_VALID_TYPE_INT_ARRAY,
+ 0,
+ 0,
+ _mmcamcorder_commit_camera_video_stabilization,
+ }
};
-/*---------------------------------------------------------------------------
-| LOCAL VARIABLE DEFINITIONS for internal |
----------------------------------------------------------------------------*/
+/*-----------------------------------------------------------------------
+| LOCAL VARIABLE DEFINITIONS for internal |
+-----------------------------------------------------------------------*/
/* Readonly attributes list.
* If you want to make some attributes read only, write down here.
* It will make them read only after composing whole attributes.
*/
-static int readonly_attributes[] = {
- MM_CAM_CAMERA_DEVICE,
+static int readonly_attributes[] = {
+ MM_CAM_CAMERA_DEVICE_COUNT,
MM_CAM_CAMERA_DEVICE_NAME,
+ MM_CAM_CAMERA_FACING_DIRECTION,
MM_CAM_CAMERA_SHUTTER_SPEED,
MM_CAM_RECOMMEND_PREVIEW_FORMAT_FOR_CAPTURE,
MM_CAM_RECOMMEND_PREVIEW_FORMAT_FOR_RECORDING,
MM_CAM_RECOMMEND_DISPLAY_ROTATION,
};
-/*---------------------------------------------------------------------------
-| LOCAL FUNCTION PROTOTYPES: |
----------------------------------------------------------------------------*/
+/*-----------------------------------------------------------------------
+| LOCAL FUNCTION PROTOTYPES: |
+-----------------------------------------------------------------------*/
/* STATIC INTERNAL FUNCTION */
static bool __mmcamcorder_set_capture_resolution(MMHandleType handle, int width, int height);
static bool __mmcamcorder_set_camera_resolution(MMHandleType handle, int width, int height);
static int __mmcamcorder_set_conf_to_valid_info(MMHandleType handle);
+static int __mmcamcorder_release_conf_valid_info(MMHandleType handle);
static bool __mmcamcorder_attrs_is_supported(MMHandleType handle, int idx);
static int __mmcamcorder_check_valid_pair(MMHandleType handle, char **err_attr_name, const char *attribute_name, va_list var_args);
-/*===========================================================================================
-| |
-| FUNCTION DEFINITIONS |
-| |
-========================================================================================== */
-/*---------------------------------------------------------------------------
-| GLOBAL FUNCTION DEFINITIONS: |
----------------------------------------------------------------------------*/
+/*=======================================================================
+| FUNCTION DEFINITIONS |
+=======================================================================*/
+/*-----------------------------------------------------------------------
+| GLOBAL FUNCTION DEFINITIONS: |
+-----------------------------------------------------------------------*/
MMHandleType
_mmcamcorder_alloc_attribute( MMHandleType handle, MMCamPreset *info )
{
_mmcam_dbg_log( "" );
MMHandleType attrs = 0;
- mmf_attrs_construct_info_t * attrs_const_info = NULL;
+ mmf_attrs_construct_info_t *attrs_const_info = NULL;
int attr_count = 0;
int idx;
-
+
/* Create attribute constructor */
- _mmcam_dbg_log( "start" );
- //set runtime values to 'cam_attrs_const_info'
- {
- cam_attrs_const_info[MM_CAM_CAMERA_DEVICE].default_value = (void*)info->videodev_type;
- }
+ _mmcam_dbg_log("start");
- //alloc 'mmf_attrs_construct_info_t'
- attr_count = ARRAY_SIZE( cam_attrs_const_info );
+ /* alloc 'mmf_attrs_construct_info_t' */
+ attr_count = ARRAY_SIZE(cam_attrs_const_info);
attrs_const_info = malloc(attr_count * sizeof(mmf_attrs_construct_info_t));
- if (!attrs_const_info)
- {
- _mmcam_dbg_err( "Fail to alloc constructor." );
+ if (!attrs_const_info) {
+ _mmcam_dbg_err("Fail to alloc constructor.");
return 0;
}
- for (idx = 0; idx < attr_count; idx++)
- {
- //attribute order check.
- if (idx != cam_attrs_const_info[idx].attrid) //This should be same.
- {
- _mmcam_dbg_err( "Please check attributes order. Is the idx same with enum val?" );
+ for (idx = 0 ; idx < attr_count ; idx++) {
+ /* attribute order check. This should be same. */
+ if (idx != cam_attrs_const_info[idx].attrid) {
+ _mmcam_dbg_err("Please check attributes order. Is the idx same with enum val?");
return 0;
}
attrs_const_info[idx].name = cam_attrs_const_info[idx].name;
attrs_const_info[idx].value_type = cam_attrs_const_info[idx].value_type;
attrs_const_info[idx].flags = cam_attrs_const_info[idx].flags;
- attrs_const_info[idx].default_value = cam_attrs_const_info[idx].default_value;
+ attrs_const_info[idx].default_value = cam_attrs_const_info[idx].default_value.value_void;
}
/* Camcorder Attributes */
- _mmcam_dbg_log( "Create Camcorder Attributes[%p, %d]", attrs_const_info, attr_count);
+ _mmcam_dbg_log("Create Camcorder Attributes[%p, %d]", attrs_const_info, attr_count);
- attrs = mmf_attrs_new_from_data( "Camcorder_Attributes",
- attrs_const_info,
- attr_count,
- _mmcamcorder_commit_camcorder_attrs,
- (void*)handle );
+ attrs = mmf_attrs_new_from_data("Camcorder_Attributes",
+ attrs_const_info,
+ attr_count,
+ _mmcamcorder_commit_camcorder_attrs,
+ (void *)handle);
free(attrs_const_info);
attrs_const_info = NULL;
- if( attrs == 0 )
- {
- _mmcam_dbg_err( "Fail to alloc attribute handle" );
+ if (attrs == 0) {
+ _mmcam_dbg_err("Fail to alloc attribute handle");
return 0;
}
switch (cam_attrs_const_info[idx].validity_type)
{
case MM_ATTRS_VALID_TYPE_INT_ARRAY:
- if ((cam_attrs_const_info[idx].validity_value1) &&(cam_attrs_const_info[idx].validity_value2 > 0))
- mmf_attrs_set_valid_array (attrs, idx, (const int*)(cam_attrs_const_info[idx].validity_value1), cam_attrs_const_info[idx].validity_value2);
+ if (cam_attrs_const_info[idx].validity_value1 &&
+ cam_attrs_const_info[idx].validity_value2 > 0) {
+ mmf_attrs_set_valid_array(attrs, idx,
+ (const int *)(cam_attrs_const_info[idx].validity_value1),
+ cam_attrs_const_info[idx].validity_value2,
+ (int)(cam_attrs_const_info[idx].default_value.value_int));
+ }
break;
case MM_ATTRS_VALID_TYPE_INT_RANGE:
- mmf_attrs_set_valid_range (attrs, idx, cam_attrs_const_info[idx].validity_value1, cam_attrs_const_info[idx].validity_value2);
+ mmf_attrs_set_valid_range(attrs, idx,
+ cam_attrs_const_info[idx].validity_value1,
+ cam_attrs_const_info[idx].validity_value2,
+ (int)(cam_attrs_const_info[idx].default_value.value_int));
break;
case MM_ATTRS_VALID_TYPE_DOUBLE_ARRAY:
- if ((cam_attrs_const_info[idx].validity_value1) &&(cam_attrs_const_info[idx].validity_value2 > 0))
- mmf_attrs_set_valid_double_array (attrs, idx, (const double*)(cam_attrs_const_info[idx].validity_value1), cam_attrs_const_info[idx].validity_value2);
+ if (cam_attrs_const_info[idx].validity_value1 &&
+ cam_attrs_const_info[idx].validity_value2 > 0) {
+ mmf_attrs_set_valid_double_array(attrs, idx,
+ (const double *)(cam_attrs_const_info[idx].validity_value1),
+ cam_attrs_const_info[idx].validity_value2,
+ (double)(cam_attrs_const_info[idx].default_value.value_double));
+ }
break;
case MM_ATTRS_VALID_TYPE_DOUBLE_RANGE:
- mmf_attrs_set_valid_double_range (attrs, idx, (double)cam_attrs_const_info[idx].validity_value1, (double)cam_attrs_const_info[idx].validity_value2);
+ mmf_attrs_set_valid_double_range(attrs, idx,
+ (double)(cam_attrs_const_info[idx].validity_value1),
+ (double)(cam_attrs_const_info[idx].validity_value2),
+ (double)(cam_attrs_const_info[idx].default_value.value_double));
break;
case MM_ATTRS_VALID_TYPE_NONE:
break;
}
}
+ __mmcamcorder_release_conf_valid_info(handle);
+
return attrs;
}
attrs = MMF_CAMCORDER_ATTRS(handle);
mmf_return_val_if_fail( attrs, MM_ERROR_CAMCORDER_NOT_INITIALIZED );
- ret = mm_attrs_get_valist (attrs, err_attr_name, attribute_name, var_args);
+ ret = mm_attrs_get_valist(attrs, err_attr_name, attribute_name, var_args);
return ret;
}
ret = __mmcamcorder_check_valid_pair( handle, err_attr_name, attribute_name, var_args );
);
- if( ret == MM_ERROR_NONE )
- {
- ret = mm_attrs_set_valist (attrs, err_attr_name, attribute_name, var_args);
+ if (ret == MM_ERROR_NONE) {
+ ret = mm_attrs_set_valist(attrs, err_attr_name, attribute_name, var_args);
}
return ret;
mmf_return_val_if_fail( attr_name, MM_ERROR_CAMCORDER_INVALID_ARGUMENT );
mmf_return_val_if_fail( info, MM_ERROR_CAMCORDER_INVALID_ARGUMENT );
- attrs = MMF_CAMCORDER_ATTRS(handle);
+ attrs = MMF_CAMCORDER_ATTRS(handle);
mmf_return_val_if_fail( attrs, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
ret = mm_attrs_get_info_by_name(attrs, attr_name, (MMAttrsInfo*)&attrinfo);
case MM_ATTRS_VALID_TYPE_INT_ARRAY:
info->int_array.array = attrinfo.int_array.array;
info->int_array.count = attrinfo.int_array.count;
- info->int_array.def = 0;
+ info->int_array.def = attrinfo.int_array.dval;
break;
case MM_ATTRS_VALID_TYPE_INT_RANGE:
info->int_range.min = attrinfo.int_range.min;
info->int_range.max = attrinfo.int_range.max;
- info->int_range.def = 0;
+ info->int_range.def = attrinfo.int_range.dval;
break;
case MM_ATTRS_VALID_TYPE_DOUBLE_ARRAY:
info->double_array.array = attrinfo.double_array.array;
info->double_array.count = attrinfo.double_array.count;
- info->double_array.def = 0;
+ info->double_array.def = attrinfo.double_array.dval;
break;
case MM_ATTRS_VALID_TYPE_DOUBLE_RANGE:
info->double_range.min = attrinfo.double_range.min;
info->double_range.max = attrinfo.double_range.max;
- info->double_range.def = 0;
+ info->double_range.def = attrinfo.double_range.dval;
break;
case MM_ATTRS_VALID_TYPE_NONE:
break;
}
-int
-__mmcamcorder_set_conf_to_valid_info(MMHandleType handle)
+int __mmcamcorder_set_conf_to_valid_info(MMHandleType handle)
{
- //mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle);
int *format = NULL;
int total_count = 0;
}
+int __mmcamcorder_release_conf_valid_info(MMHandleType handle)
+{
+ int *allocated_memory = NULL;
+
+ _mmcam_dbg_log("START");
+
+ /* Audio encoder info */
+ allocated_memory = (int*)(cam_attrs_const_info[MM_CAM_AUDIO_ENCODER].validity_value1);
+ if (allocated_memory) {
+ free(allocated_memory);
+ cam_attrs_const_info[MM_CAM_AUDIO_ENCODER].validity_value1 = (int)NULL;
+ cam_attrs_const_info[MM_CAM_AUDIO_ENCODER].validity_value2 = (int)0;
+ }
+
+ /* Video encoder info */
+ allocated_memory = (int*)(cam_attrs_const_info[MM_CAM_VIDEO_ENCODER].validity_value1);
+ if (allocated_memory) {
+ free(allocated_memory);
+ cam_attrs_const_info[MM_CAM_VIDEO_ENCODER].validity_value1 = (int)NULL;
+ cam_attrs_const_info[MM_CAM_VIDEO_ENCODER].validity_value2 = (int)0;
+ }
+
+ /* Image encoder info */
+ allocated_memory = (int*)(cam_attrs_const_info[MM_CAM_IMAGE_ENCODER].validity_value1);
+ if (allocated_memory) {
+ free(allocated_memory);
+ cam_attrs_const_info[MM_CAM_IMAGE_ENCODER].validity_value1 = (int)NULL;
+ cam_attrs_const_info[MM_CAM_IMAGE_ENCODER].validity_value2 = (int)0;
+ }
+
+ /* File format info */
+ allocated_memory = (int*)(cam_attrs_const_info[MM_CAM_FILE_FORMAT].validity_value1);
+ if (allocated_memory) {
+ free(allocated_memory);
+ cam_attrs_const_info[MM_CAM_FILE_FORMAT].validity_value1 = (int)NULL;
+ cam_attrs_const_info[MM_CAM_FILE_FORMAT].validity_value2 = (int)0;
+ }
+
+ _mmcam_dbg_log("DONE");
+
+ return MM_ERROR_NONE;
+}
+
+
bool _mmcamcorder_commit_capture_width (MMHandleType handle, int attr_idx, const mmf_value_t *value)
{
MMHandleType attr = 0;
_mmcam_dbg_log("(%d)", attr_idx);
- current_state = _mmcamcorder_get_state( handle);
-
- if( !_mmcamcorder_is_state_changing(handle)
- && ( current_state == MM_CAMCORDER_STATE_NULL
- || current_state == MM_CAMCORDER_STATE_READY
- || current_state == MM_CAMCORDER_STATE_PREPARE ) )
- {
+ current_state = _mmcamcorder_get_state(handle);
+ if (current_state <= MM_CAMCORDER_STATE_PREPARE) {
int flags = MM_ATTRS_FLAG_NONE;
int capture_width, capture_height;
MMCamAttrsInfo info;
mm_camcorder_get_attribute_info(handle, MMCAM_CAPTURE_HEIGHT, &info);
flags = info.flag;
- if (!(flags & MM_ATTRS_FLAG_MODIFIED))
- {
+ if (!(flags & MM_ATTRS_FLAG_MODIFIED)) {
mm_camcorder_get_attributes(handle, NULL, MMCAM_CAPTURE_HEIGHT, &capture_height, NULL);
capture_width = value->value.i_val;
}
return TRUE;
- }
- else
- {
+ } else {
_mmcam_dbg_log("Capture resolution can't be set.(state=%d)", current_state);
return FALSE;
}
{
int current_state = MM_CAMCORDER_STATE_NONE;
- current_state = _mmcamcorder_get_state( handle);
+ current_state = _mmcamcorder_get_state(handle);
- if( current_state == MM_CAMCORDER_STATE_NULL
- || current_state == MM_CAMCORDER_STATE_READY
- || current_state == MM_CAMCORDER_STATE_PREPARE )
- {
+ if (current_state <= MM_CAMCORDER_STATE_PREPARE) {
int capture_width, capture_height;
mm_camcorder_get_attributes(handle, NULL, MMCAM_CAPTURE_WIDTH, &capture_width, NULL);
capture_height = value->value.i_val;
return __mmcamcorder_set_capture_resolution(handle, capture_width, capture_height);
- }
- else
- {
+ } else {
_mmcam_dbg_log("Capture resolution can't be set.(state=%d)", current_state);
+
return FALSE;
}
}
char* videosrc_name = NULL;
- _mmcamcorder_conf_get_element( hcamcorder->conf_main,
- CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
- "VideosrcElement",
- &VideosrcElement );
- _mmcamcorder_conf_get_value_element_name( VideosrcElement, &videosrc_name );
+ _mmcamcorder_conf_get_element(hcamcorder->conf_main,
+ CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
+ "VideosrcElement",
+ &VideosrcElement );
+ _mmcamcorder_conf_get_value_element_name(VideosrcElement, &videosrc_name);
sc = MMF_CAMCORDER_SUBCONTEXT(handle);
if (!sc)
}
-bool _mmcamcorder_commit_capture_count (MMHandleType handle, int attr_idx, const mmf_value_t *value)
+bool _mmcamcorder_commit_capture_count(MMHandleType handle, int attr_idx, const mmf_value_t *value)
{
- int ret = FALSE;
- int cap_count = 0;
- int mode = MM_CAMCORDER_MODE_IMAGE;
+ int mode = MM_CAMCORDER_MODE_VIDEO_CAPTURE;
+ int current_state = MM_CAMCORDER_STATE_NONE;
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
mmf_return_val_if_fail(hcamcorder, FALSE);
- cap_count = value->value.i_val;
-
+ current_state = _mmcamcorder_get_state(handle);
mm_camcorder_get_attributes(handle, NULL, MMCAM_MODE, &mode, NULL);
- if (mode == MM_CAMCORDER_MODE_IMAGE) {
- if (cap_count > 1) {
- __ta__("_mmcamcorder_sound_init",
- ret = _mmcamcorder_sound_init(handle, _MMCAMCORDER_FILEPATH_CAPTURE2_SND);
- );
- if (ret == TRUE) {
- __ta__("_mmcamcorder_sound_prepare",
- ret = _mmcamcorder_sound_prepare(handle);
- );
- _mmcam_dbg_log("sound prepare [%d]", ret);
- }
- } else if (cap_count == 1) {
- __ta__("_mmcamcorder_sound_finalize",
- ret = _mmcamcorder_sound_finalize(handle);
- );
- _mmcam_dbg_log("sound finalize [%d]", ret);
- }
+
+ _mmcam_dbg_log("current state %d, mode %d, set count %d",
+ current_state, mode, value->value.i_val);
+
+ if (mode != MM_CAMCORDER_MODE_AUDIO &&
+ current_state != MM_CAMCORDER_STATE_CAPTURING) {
+ return TRUE;
+ } else {
+ _mmcam_dbg_err("Invalid mode[%d] or state[%d]", mode, current_state);
+ return FALSE;
}
+}
- _mmcam_dbg_log("Capture Count(%d)", cap_count);
- return TRUE;
+bool _mmcamcorder_commit_capture_sound_enable(MMHandleType handle, int attr_idx, const mmf_value_t *value)
+{
+ mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
+
+ mmf_return_val_if_fail(hcamcorder, FALSE);
+
+ _mmcam_dbg_log("shutter sound policy: %d", hcamcorder->shutter_sound_policy);
+
+ /* return error when disable shutter sound if policy is TRUE */
+ if (!value->value.i_val &&
+ hcamcorder->shutter_sound_policy == VCONFKEY_CAMERA_SHUTTER_SOUND_POLICY_ON) {
+ _mmcam_dbg_err("not permitted DISABLE SHUTTER SOUND");
+ return FALSE;
+ } else {
+ _mmcam_dbg_log("set value [%d] success", value->value.i_val);
+ return TRUE;
+ }
}
MMCAMCORDER_G_OBJECT_SET( sc->element[_MMCAMCORDER_AUDIOSRC_VOL].gst, "volume", mslNewVal);
}
}
-
+
_mmcam_dbg_log("Commit : volume(%f)", mslNewVal);
bret = TRUE;
}
_mmcam_dbg_log("Commit : nothing to commit. status(%d)", current_state);
bret = TRUE;
}
- return bret;
+ return bret;
}
}
+bool _mmcamcorder_commit_camera_recording_motion_rate(MMHandleType handle, int attr_idx, const mmf_value_t *value)
+{
+ int current_state = MM_CAMCORDER_STATE_NONE;
+ _MMCamcorderSubContext *sc = NULL;
+
+ mmf_return_val_if_fail(handle, TRUE);
+
+ current_state = _mmcamcorder_get_state(handle);
+
+ if (current_state > MM_CAMCORDER_STATE_PREPARE) {
+ _mmcam_dbg_warn("invalid state %d", current_state);
+ return FALSE;
+ }
+
+ /* Verify recording motion rate */
+ if (value->value.d_val > 0.0) {
+ sc = MMF_CAMCORDER_SUBCONTEXT(handle);
+ mmf_return_val_if_fail(sc, TRUE);
+
+ /* set is_slow flag */
+ if (value->value.d_val != _MMCAMCORDER_DEFAULT_RECORDING_MOTION_RATE) {
+ sc->is_modified_rate = TRUE;
+ } else {
+ sc->is_modified_rate = FALSE;
+ }
+
+ _mmcam_dbg_log("Set slow motion rate %lf", value->value.d_val);
+ return TRUE;
+ } else {
+ _mmcam_dbg_warn("Failed to set recording motion rate %lf", value->value.d_val);
+ return FALSE;
+ }
+}
+
+
bool _mmcamcorder_commit_camera_width (MMHandleType handle, int attr_idx, const mmf_value_t *value)
{
MMHandleType attr = 0;
_mmcam_dbg_log("Width(%d)", value->value.i_val);
- current_state = _mmcamcorder_get_state( handle);
+ current_state = _mmcamcorder_get_state(handle);
- if ((current_state > MM_CAMCORDER_STATE_READY) || _mmcamcorder_is_state_changing( handle ) ) {
+ if (current_state > MM_CAMCORDER_STATE_READY) {
_mmcam_dbg_log("Resolution can't be changed.(state=%d)", current_state);
return FALSE;
} else {
_mmcam_dbg_log("Height(%d)", value->value.i_val);
current_state = _mmcamcorder_get_state( handle);
- if ( (current_state > MM_CAMCORDER_STATE_READY) || _mmcamcorder_is_state_changing( handle )) {
+ if (current_state > MM_CAMCORDER_STATE_READY) {
_mmcam_dbg_log("Resolution can't be changed.(state=%d)", current_state);
return FALSE;
} else {
_mmcam_dbg_log("Focus mode(%d)", value->value.i_val);
- current_state = _mmcamcorder_get_state( handle);
+ /* check whether set or not */
+ if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
+ _mmcam_dbg_log("skip set value %d", value->value.i_val);
+ return TRUE;
+ }
- if (current_state < MM_CAMCORDER_STATE_READY) {
+ current_state = _mmcamcorder_get_state(handle);
+ if (current_state < MM_CAMCORDER_STATE_NULL) {
_mmcam_dbg_log("Focus mode will be changed later.(state=%d)", current_state);
return TRUE;
}
if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst))
{
_mmcam_dbg_log("Can't cast Video source into camera control.");
- return TRUE;
+ return TRUE;
}
-
+
control = GST_CAMERA_CONTROL (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
mslVal = value->value.i_val;
- mode = _mmcamcorder_convert_msl_to_sensor( attr_idx, mslVal );
+ mode = _mmcamcorder_convert_msl_to_sensor( handle, attr_idx, mslVal );
mm_camcorder_get_attribute_info(handle, MMCAM_CAMERA_AF_SCAN_RANGE, &info);
flags = info.flag;
if( gst_camera_control_set_focus( control, mode, cur_focus_range ) )
{
MMTA_ACUM_ITEM_END(" gst_camera_control_set_focus", 0);
- //_mmcam_dbg_log( "Succeed in setting AF mode[%d]", mslVal );
+ _mmcam_dbg_log( "Succeed in setting AF mode[%d]", mslVal );
return TRUE;
}
else
}
else
{
- //_mmcam_dbg_log( "No need to set AF mode. Current[%d]", mslVal );
+ _mmcam_dbg_log( "No need to set AF mode. Current[%d]", mslVal );
return TRUE;
}
}
_mmcam_dbg_log("(%d)", attr_idx);
- current_state = _mmcamcorder_get_state( handle);
+ /* check whether set or not */
+ if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
+ _mmcam_dbg_log("skip set value %d", value->value.i_val);
+ return TRUE;
+ }
mslVal = value->value.i_val;
- newVal = _mmcamcorder_convert_msl_to_sensor( attr_idx, mslVal );
+ newVal = _mmcamcorder_convert_msl_to_sensor(handle, attr_idx, mslVal);
- if( current_state < MM_CAMCORDER_STATE_PREPARE )
- {
+ current_state = _mmcamcorder_get_state(handle);
+ if (current_state < MM_CAMCORDER_STATE_PREPARE) {
_mmcam_dbg_log("It doesn't need to change dynamically.(state=%d)", current_state);
return TRUE;
}
if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst))
{
_mmcam_dbg_log("Can't cast Video source into camera control.");
- return TRUE;
+ return TRUE;
}
-
+
control = GST_CAMERA_CONTROL (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
mm_camcorder_get_attributes(handle, NULL, MMCAM_CAMERA_FOCUS_MODE, &msl_mode, NULL);
- converted_mode = _mmcamcorder_convert_msl_to_sensor( MM_CAM_CAMERA_FOCUS_MODE, msl_mode );
+ converted_mode = _mmcamcorder_convert_msl_to_sensor( handle, MM_CAM_CAMERA_FOCUS_MODE, msl_mode );
if( gst_camera_control_get_focus( control, &cur_focus_mode, &cur_focus_range ) )
{
int ivalue = value->value.i_val;
int mslVal1 = 0, mslVal2 = 0;
int newVal1 = 0, newVal2 = 0;
- int cur_value1 = 0, cur_value2 = 0;
int exposure_type = 0;
int current_state = MM_CAMCORDER_STATE_NONE;
_MMCamcorderSubContext *sc = NULL;
if (!sc)
return TRUE;
- current_state = _mmcamcorder_get_state( handle);
+ /* check whether set or not */
+ if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
+ _mmcam_dbg_log("skip set value %d", value->value.i_val);
+ return TRUE;
+ }
+ current_state = _mmcamcorder_get_state( handle);
if (current_state < MM_CAMCORDER_STATE_READY) {
return TRUE;
}
} else if (attr_idx == MM_CAM_CAMERA_ISO) {
exposure_type = GST_CAMERA_CONTROL_ISO;
mslVal1 = ivalue;
- newVal1 = _mmcamcorder_convert_msl_to_sensor(attr_idx, mslVal1);
+ newVal1 = _mmcamcorder_convert_msl_to_sensor(handle, attr_idx, mslVal1);
check_scene_mode = TRUE;
} else if (attr_idx == MM_CAM_CAMERA_EXPOSURE_MODE) {
exposure_type = GST_CAMERA_CONTROL_EXPOSURE_MODE;
mslVal1 = ivalue;
- newVal1 = _mmcamcorder_convert_msl_to_sensor(attr_idx, mslVal1);
+ newVal1 = _mmcamcorder_convert_msl_to_sensor(handle, attr_idx, mslVal1);
+ check_scene_mode = TRUE;
} else if (attr_idx == MM_CAM_CAMERA_EXPOSURE_VALUE) {
exposure_type = GST_CAMERA_CONTROL_EXPOSURE_VALUE;
mslVal1 = newVal1 = MM_CAMCORDER_GET_NUMERATOR( ivalue );
- mslVal2 = newVal2 = MM_CAMCORDER_GET_DENOMINATOR( ivalue );
+ mslVal2 = newVal2 = MM_CAMCORDER_GET_DENOMINATOR( ivalue );
}
if (check_scene_mode) {
}
if (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst) {
+ int ret = 0;
+
if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
_mmcam_dbg_log("Can't cast Video source into camera control.");
- return TRUE;
+ return TRUE;
}
control = GST_CAMERA_CONTROL (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
- if (gst_camera_control_get_exposure(control, exposure_type, &cur_value1, &cur_value2)) {
- if (newVal1 != cur_value1 || newVal2 != cur_value2) {
- int ret = 0;
- __ta__(" gst_camera_control_set_exposure",
- ret = gst_camera_control_set_exposure(control, exposure_type, newVal1, newVal2);
- );
- if (ret) {
- //_mmcam_dbg_log( "Succeed in setting exposure. Type[%d],value1[%d],value2[%d]", exposure_type, mslVal1, mslVal2 );
- return TRUE;
- } else {
- _mmcam_dbg_warn( "Failed to set exposure. Type[%d],value1[%d],value2[%d]", exposure_type, mslVal1, mslVal2 );
- }
- } else {
- //_mmcam_dbg_log( "No need to set exposure. Type[%d],value1[%d],value2[%d]", exposure_type, mslVal1, mslVal2 );
- return TRUE;
- }
+ __ta__(" gst_camera_control_set_exposure",
+ ret = gst_camera_control_set_exposure(control, exposure_type, newVal1, newVal2);
+ );
+ if (ret) {
+ _mmcam_dbg_log("Succeed in setting exposure. Type[%d],value1[%d],value2[%d]", exposure_type, mslVal1, mslVal2 );
+ return TRUE;
} else {
- _mmcam_dbg_warn( "Failed to get exposure. Type[%d]", exposure_type );
+ _mmcam_dbg_warn("Failed to set exposure. Type[%d],value1[%d],value2[%d]", exposure_type, mslVal1, mslVal2 );
}
} else {
_mmcam_dbg_log("pointer of video src is null");
bool _mmcamcorder_commit_camera_wdr (MMHandleType handle, int attr_idx, const mmf_value_t *value)
{
GstCameraControl *control = NULL;
- int mslVal = value->value.i_val;
- int newVal = _mmcamcorder_convert_msl_to_sensor( MM_CAM_CAMERA_WDR, mslVal);
+ int mslVal = 0;
+ int newVal = 0;
int cur_value = 0;
_MMCamcorderSubContext *sc = NULL;
int current_state = MM_CAMCORDER_STATE_NONE;
- sc = MMF_CAMCORDER_SUBCONTEXT(handle);
- if (!sc)
+ mmf_return_val_if_fail(handle && value, FALSE);
+
+ /* check whether set or not */
+ if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
+ _mmcam_dbg_log("skip set value %d", value->value.i_val);
return TRUE;
+ }
+
+ sc = MMF_CAMCORDER_SUBCONTEXT(handle);
+ mmf_return_val_if_fail(sc, TRUE);
+ /* check current state */
current_state = _mmcamcorder_get_state( handle);
-
if (current_state < MM_CAMCORDER_STATE_PREPARE) {
_mmcam_dbg_log("It doesn't need to change dynamically.(state=%d)", current_state);
return TRUE;
- }
+ }
- if( sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst )
- {
- if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst))
- {
+ if (current_state == MM_CAMCORDER_STATE_CAPTURING) {
+ _mmcam_dbg_warn("Can not set WDR while CAPTURING");
+ return FALSE;
+ }
+
+ mslVal = value->value.i_val;
+ newVal = _mmcamcorder_convert_msl_to_sensor(handle, MM_CAM_CAMERA_WDR, mslVal);
+
+ if (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst) {
+ if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
_mmcam_dbg_log("Can't cast Video source into camera control.");
return TRUE;
}
-
- control = GST_CAMERA_CONTROL( sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst );
- if( gst_camera_control_get_wdr( control, &cur_value ) )
- {
- if( newVal != cur_value )
- {
- if( gst_camera_control_set_wdr( control, newVal ) )
- {
- //_mmcam_dbg_log( "Success - set wdr[%d]", mslVal );
+ control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
+ if (gst_camera_control_get_wdr(control, &cur_value)) {
+ if (newVal != cur_value) {
+ if (gst_camera_control_set_wdr(control, newVal)) {
+ _mmcam_dbg_log( "Success - set wdr[%d]", mslVal );
return TRUE;
+ } else {
+ _mmcam_dbg_warn("Failed to set WDR. NewVal[%d],CurVal[%d]", newVal, cur_value);
}
- else
- {
- _mmcam_dbg_warn( "Failed to set WDR. NewVal[%d],CurVal[%d]", newVal, cur_value );
- }
- }
- else
- {
- //_mmcam_dbg_log( "No need to set new WDR. Current[%d]", mslVal );
+ } else {
+ _mmcam_dbg_log( "No need to set new WDR. Current[%d]", mslVal );
return TRUE;
}
- }
- else
- {
+ } else {
_mmcam_dbg_warn( "Failed to get WDR." );
}
- }
- else
- {
+ } else {
_mmcam_dbg_log("pointer of video src is null");
}
}
-bool _mmcamcorder_commit_camera_anti_handshake (MMHandleType handle, int attr_idx, const mmf_value_t *value)
+bool _mmcamcorder_commit_camera_anti_handshake(MMHandleType handle, int attr_idx, const mmf_value_t *value)
{
- GstCameraControl *control = NULL;
- int mslVal = value->value.i_val;
- int newVal = _mmcamcorder_convert_msl_to_sensor(MM_CAM_CAMERA_ANTI_HANDSHAKE, mslVal);
- int cur_value = 0;
- _MMCamcorderSubContext *sc = NULL;
int current_state = MM_CAMCORDER_STATE_NONE;
- sc = MMF_CAMCORDER_SUBCONTEXT(handle);
- if (!sc)
+ /* check whether set or not */
+ if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
+ _mmcam_dbg_log("skip set value %d", value->value.i_val);
return TRUE;
+ }
- current_state = _mmcamcorder_get_state( handle);
-
+ current_state = _mmcamcorder_get_state(handle);
if (current_state < MM_CAMCORDER_STATE_READY) {
_mmcam_dbg_log("It doesn't need to change dynamically.(state=%d)", current_state);
return TRUE;
- }
+ } else if (current_state > MM_CAMCORDER_STATE_PREPARE) {
+ _mmcam_dbg_err("Invaild state (state %d)", current_state);
+ return FALSE;
+ }
- if (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)
- {
- if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst))
- {
- _mmcam_dbg_log("Can't cast Video source into camera control.");
- return TRUE;
- }
-
- control = GST_CAMERA_CONTROL (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
+ return _mmcamcorder_set_videosrc_anti_shake(handle, value->value.i_val);
+}
- if( gst_camera_control_get_ahs( control, &cur_value ) )
- {
- if( newVal != cur_value )
- {
- if (gst_camera_control_set_ahs(control, newVal))
- {
- //_mmcam_dbg_log("Succeed in operating anti-handshake.");
- return TRUE;
- }
- else
- {
- _mmcam_dbg_warn("Failed to operate anti-handshake. value[%d]", newVal);
- }
- }
- else
- {
- //_mmcam_dbg_log( "No need to set new Anti-Handshake. Current[%d]", mslVal );
- return TRUE;
- }
- }
- else
- {
- _mmcam_dbg_warn( "Failed to get Anti-Handshake." );
- }
- }
- else
- {
- _mmcam_dbg_warn("pointer of video src is null");
+
+bool _mmcamcorder_commit_camera_video_stabilization(MMHandleType handle, int attr_idx, const mmf_value_t *value)
+{
+ int current_state = MM_CAMCORDER_STATE_NONE;
+
+ current_state = _mmcamcorder_get_state(handle);
+ if (current_state < MM_CAMCORDER_STATE_READY) {
+ _mmcam_dbg_log("It doesn't need to change dynamically.(state=%d)", current_state);
+ return TRUE;
+ } else if (current_state > MM_CAMCORDER_STATE_PREPARE) {
+ _mmcam_dbg_err("Invaild state (state %d)", current_state);
+ return FALSE;
}
- return FALSE;
+ return _mmcamcorder_set_videosrc_stabilization(handle, value->value.i_val);
}
if (!sc)
return TRUE;
- current_state = _mmcamcorder_get_state( handle);
+ current_state = _mmcamcorder_get_state(handle);
if( current_state < MM_CAMCORDER_STATE_READY )
{
}
-bool _mmcamcorder_commit_camera_rotate (MMHandleType handle, int attr_idx, const mmf_value_t *value)
+bool _mmcamcorder_commit_camera_rotate(MMHandleType handle, int attr_idx, const mmf_value_t *value)
{
int current_state = MM_CAMCORDER_STATE_NONE;
- gboolean bstate_changing = FALSE;
_mmcam_dbg_log("rotate(%d)", value->value.i_val);
- current_state = _mmcamcorder_get_state( handle);
- bstate_changing = _mmcamcorder_is_state_changing( handle);
+ current_state = _mmcamcorder_get_state(handle);
- if ((current_state > MM_CAMCORDER_STATE_READY) || bstate_changing ) {
- _mmcam_dbg_err("camera rotation setting failed.(state=%d, is_state_changing(%d))", current_state, bstate_changing);
+ if (current_state > MM_CAMCORDER_STATE_READY) {
+ _mmcam_dbg_err("camera rotation setting failed.(state=%d)", current_state);
return FALSE;
} else {
- return _mmcamcorder_set_videosrc_rotation( handle, value->value.i_val );
+ return _mmcamcorder_set_videosrc_rotation(handle, value->value.i_val);
}
}
-bool _mmcamcorder_commit_image_encoder_quality (MMHandleType handle, int attr_idx, const mmf_value_t *value)
+bool _mmcamcorder_commit_image_encoder_quality(MMHandleType handle, int attr_idx, const mmf_value_t *value)
{
+ int current_state = MM_CAMCORDER_STATE_NONE;
+
+ mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
+ _MMCamcorderSubContext *sc = NULL;
+
+ mmf_return_val_if_fail(handle, FALSE);
+
+ /* check type */
+ if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
+ _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
+ return FALSE;
+ }
+
+ /* check current state */
+ current_state = _mmcamcorder_get_state(handle);
+ if (current_state < MM_CAMCORDER_STATE_READY) {
+ _mmcam_dbg_log("NOT initialized. this will be applied later");
+ return TRUE;
+ }
+
+ sc = MMF_CAMCORDER_SUBCONTEXT(handle);
+
_mmcam_dbg_log("Image encoder quality(%d)", value->value.i_val);
- return TRUE;
+
+ if (current_state == MM_CAMCORDER_STATE_PREPARE) {
+ MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "capture-jpg-quality", value->value.i_val);
+ return TRUE;
+ } else {
+ _mmcam_dbg_err("invalid state %d", current_state);
+ return FALSE;
+ }
}
-bool _mmcamcorder_commit_target_filename (MMHandleType handle, int attr_idx, const mmf_value_t *value)
+bool _mmcamcorder_commit_target_filename(MMHandleType handle, int attr_idx, const mmf_value_t *value)
{
- mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
_MMCamcorderSubContext *sc = NULL;
char * filename = NULL;
int size = 0;
if (!sc)
return TRUE;
- //Set basic infomation
- if (value->type != MM_ATTRS_TYPE_STRING)
- {
- _mmcam_dbg_log("Mismatched value type (%d)", value->type);
- return FALSE;
- }
- else
- {
- filename = (char*)mmf_value_get_string(value, &size);
- }
+ /* get string */
+ filename = (char *)mmf_value_get_string(value, &size);
- if (sc->element != NULL)
- {
- if ((hcamcorder->type == MM_CAMCORDER_MODE_VIDEO) || (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO))
- {
- if (sc->element[_MMCAMCORDER_ENCSINK_BIN].gst != NULL)
- {
- if (sc->element[_MMCAMCORDER_ENCSINK_SINK].gst != NULL)
- {
- MMCAMCORDER_G_OBJECT_SET( sc->element[_MMCAMCORDER_ENCSINK_SINK].gst, "location", filename);
- _mmcam_dbg_log("new file location set.(%s)", filename);
- }
- else
- {
- _mmcam_dbg_warn("filesink is not created.");
- }
- }
- else
- {
- _mmcam_dbg_warn("filesink is not created.");
- }
- }
- else
- {
- _mmcam_dbg_log("new file location set.(%s)", filename);
- }
- }
- else
- {
- _mmcam_dbg_warn("gstreamer pipeline is not created.");
+ if (sc->element && sc->element[_MMCAMCORDER_ENCSINK_SINK].gst) {
+ MMCAMCORDER_G_OBJECT_SET( sc->element[_MMCAMCORDER_ENCSINK_SINK].gst, "location", filename);
+ _mmcam_dbg_log("new file location set.(%s)", filename);
+ } else {
+ _mmcam_dbg_log("element is not created yet. [%s] will be set later...", filename);
}
- return TRUE;
+
+ return TRUE;
}
const GList *item = NULL;
int newVal = 0;
int mslNewVal = 0;
- int cur_value = 0;
int current_state = MM_CAMCORDER_STATE_NONE;
gchar * control_label = NULL;
_MMCamcorderSubContext *sc = NULL;
if (!sc)
return TRUE;
- current_state = _mmcamcorder_get_state(handle);
+ /* check whether set or not */
+ if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
+ _mmcam_dbg_log("skip set value %d", value->value.i_val);
+ return TRUE;
+ }
- //status check
+ current_state = _mmcamcorder_get_state(handle);
if (current_state < MM_CAMCORDER_STATE_PREPARE) {
- //_mmcam_dbg_log("It doesn't need to change dynamically.(state=%d)", current_state);
+ _mmcam_dbg_log("It doesn't need to change dynamically.(state=%d)", current_state);
return TRUE;
}
mslNewVal = value->value.i_val;
}
- switch (attr_idx)
- {
- case MM_CAM_FILTER_BRIGHTNESS:
- control_label = "brightness";
- check_scene_mode = TRUE;
- break;
+ switch (attr_idx) {
+ case MM_CAM_FILTER_BRIGHTNESS:
+ control_label = "brightness";
+ check_scene_mode = TRUE;
+ break;
- case MM_CAM_FILTER_CONTRAST:
- control_label = "contrast";
- break;
+ case MM_CAM_FILTER_CONTRAST:
+ control_label = "contrast";
+ break;
- case MM_CAM_FILTER_WB:
- control_label = "white balance";
- check_scene_mode = TRUE;
- break;
+ case MM_CAM_FILTER_WB:
+ control_label = "white balance";
+ check_scene_mode = TRUE;
+ break;
- case MM_CAM_FILTER_COLOR_TONE:
- control_label = "color tone";
- break;
+ case MM_CAM_FILTER_COLOR_TONE:
+ control_label = "color tone";
+ break;
- case MM_CAM_FILTER_SATURATION:
- control_label = "saturation";
- check_scene_mode = TRUE;
- break;
+ case MM_CAM_FILTER_SATURATION:
+ control_label = "saturation";
+ check_scene_mode = TRUE;
+ break;
- case MM_CAM_FILTER_HUE:
- control_label = "hue";
- break;
+ case MM_CAM_FILTER_HUE:
+ control_label = "hue";
+ break;
- case MM_CAM_FILTER_SHARPNESS:
- control_label = "sharpness";
- check_scene_mode = TRUE;
- break;
+ case MM_CAM_FILTER_SHARPNESS:
+ control_label = "sharpness";
+ check_scene_mode = TRUE;
+ break;
}
if (check_scene_mode) {
}
}
- newVal = _mmcamcorder_convert_msl_to_sensor(attr_idx, mslNewVal);
+ newVal = _mmcamcorder_convert_msl_to_sensor(handle, attr_idx, mslNewVal);
if (newVal == _MMCAMCORDER_SENSOR_ENUM_NONE)
return FALSE;
_mmcam_dbg_log("label(%s): MSL(%d)->Sensor(%d)", control_label, mslNewVal, newVal);
- if (!GST_IS_COLOR_BALANCE(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst))
- {
+ if (!GST_IS_COLOR_BALANCE(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
_mmcam_dbg_log("Can't cast Video source into color balance.");
return TRUE;
}
balance = GST_COLOR_BALANCE (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
controls = gst_color_balance_list_channels (balance);
- //_mmcam_dbg_log("controls(%x)", controls);
if (controls == NULL) {
_mmcam_dbg_log("There is no list of colorbalance controls");
return FALSE;
}
- for (item = controls;item != NULL;item = item->next)
- {
- if (item)
- {
- if (item->data)
- {
+ for (item = controls ; item != NULL ; item = item->next) {
+ if (item) {
+ if (item->data) {
Colorchannel = item->data;
- //_mmcam_dbg_log("Getting name of CID=(%s), input CID=(%s)", Colorchannel->label, control_label);
+ /*_mmcam_dbg_log("Getting name of CID=(%s), input CID=(%s)", Colorchannel->label, control_label);*/
- if (strcmp(Colorchannel->label, control_label) == 0)
- {
+ if (!strcmp(Colorchannel->label, control_label)) {
break;
- }
- else
+ } else {
Colorchannel = NULL;
+ }
}
}
}
return FALSE;
}
- //_mmcam_dbg_log("Colorchannel(%x, %s)", Colorchannel, Colorchannel->label);
-
- cur_value = gst_color_balance_get_value( balance, Colorchannel );
- _mmcam_dbg_log( "device[cur:%d,new%d]", cur_value, newVal );
+ __ta__(" gst_color_balance_set_value",
+ gst_color_balance_set_value (balance, Colorchannel, newVal);
+ );
- if( newVal != cur_value )
- {
- __ta__(" gst_color_balance_set_value",
- gst_color_balance_set_value (balance, Colorchannel, newVal);
- );
- //_mmcam_dbg_log( "Set complete - %s[%d]", Colorchannel->label, mslNewVal );
- }
- else
- {
- _mmcam_dbg_log( "No need to set %s. Current[%d]", Colorchannel->label, mslNewVal);
- }
+ _mmcam_dbg_log( "Set complete - %s[msl:%d,real:%d]", Colorchannel->label, mslNewVal, newVal);
return TRUE;
}
{
GstCameraControl *control = NULL;
int mslVal = value->value.i_val;
- int newVal = _mmcamcorder_convert_msl_to_sensor( MM_CAM_FILTER_SCENE_MODE, mslVal );
- int cur_program_mode = MM_CAMCORDER_SCENE_MODE_NORMAL;
+ int newVal = _mmcamcorder_convert_msl_to_sensor( handle, MM_CAM_FILTER_SCENE_MODE, mslVal );
_MMCamcorderSubContext *sc = NULL;
int current_state = MM_CAMCORDER_STATE_NONE;
if (!sc)
return TRUE;
- current_state = _mmcamcorder_get_state( handle);
-
+ /* check whether set or not */
+ if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
+ _mmcam_dbg_log("skip set value %d", value->value.i_val);
+ return TRUE;
+ }
+
+ current_state = _mmcamcorder_get_state(handle);
if (current_state < MM_CAMCORDER_STATE_PREPARE) {
_mmcam_dbg_log("It doesn't need to change dynamically.(state=%d)", current_state);
return TRUE;
}
if (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst) {
+ int ret = 0;
+
if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
_mmcam_dbg_log("Can't cast Video source into camera control.");
return TRUE;
}
control = GST_CAMERA_CONTROL (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
- if( gst_camera_control_get_exposure( control, GST_CAMERA_CONTROL_PROGRAM_MODE, &cur_program_mode, NULL ) )
- {
- if( newVal != cur_program_mode )
- {
- int ret = 0;
- __ta__(" gst_camera_control_set_exposure:GST_CAMERA_CONTROL_PROGRAM_MODE",
- ret = gst_camera_control_set_exposure(control, GST_CAMERA_CONTROL_PROGRAM_MODE, newVal, 0);
- );
- if (ret) {
- _mmcam_dbg_log("Succeed in setting program mode[%d].", mslVal);
-
- if (mslVal == MM_CAMCORDER_SCENE_MODE_NORMAL) {
- int i = 0;
- int attr_idxs[] = {
- MM_CAM_CAMERA_ISO
- , MM_CAM_FILTER_BRIGHTNESS
- , MM_CAM_FILTER_WB
- , MM_CAM_FILTER_SATURATION
- , MM_CAM_FILTER_SHARPNESS
- };
- mmf_attrs_t *attr = (mmf_attrs_t *)MMF_CAMCORDER_ATTRS(handle);
-
- for (i = 0 ; i < ARRAY_SIZE(attr_idxs) ; i++) {
- if (__mmcamcorder_attrs_is_supported((MMHandleType)attr, attr_idxs[i])) {
- mmf_attribute_set_modified(&(attr->items[attr_idxs[i]]));
- }
- }
+ __ta__(" gst_camera_control_set_exposure:GST_CAMERA_CONTROL_PROGRAM_MODE",
+ ret = gst_camera_control_set_exposure(control, GST_CAMERA_CONTROL_PROGRAM_MODE, newVal, 0);
+ );
+ if (ret) {
+ _mmcam_dbg_log("Succeed in setting program mode[%d].", mslVal);
+
+ if (mslVal == MM_CAMCORDER_SCENE_MODE_NORMAL) {
+ int i = 0;
+ int attr_idxs[] = {
+ MM_CAM_CAMERA_ISO
+ , MM_CAM_FILTER_BRIGHTNESS
+ , MM_CAM_FILTER_WB
+ , MM_CAM_FILTER_SATURATION
+ , MM_CAM_FILTER_SHARPNESS
+ , MM_CAM_FILTER_COLOR_TONE
+ , MM_CAM_CAMERA_EXPOSURE_MODE
+ };
+ mmf_attrs_t *attr = (mmf_attrs_t *)MMF_CAMCORDER_ATTRS(handle);
+
+ for (i = 0 ; i < ARRAY_SIZE(attr_idxs) ; i++) {
+ if (__mmcamcorder_attrs_is_supported((MMHandleType)attr, attr_idxs[i])) {
+ mmf_attribute_set_modified(&(attr->items[attr_idxs[i]]));
}
-
- return TRUE;
- } else {
- _mmcam_dbg_log( "Failed to set program mode[%d].", mslVal );
}
- } else {
- _mmcam_dbg_log( "No need to set program mode. Current[%d]", mslVal );
- return TRUE;
}
+
+ return TRUE;
} else {
- _mmcam_dbg_warn( "Failed to get program mode, so do not set new program mode[%d]", mslVal );
+ _mmcam_dbg_log( "Failed to set program mode[%d].", mslVal );
}
} else {
_mmcam_dbg_warn("pointer of video src is null");
}
-bool _mmcamcorder_commit_camcorder_rotate(MMHandleType handle, int attr_idx, const mmf_value_t *value)
+bool _mmcamcorder_commit_camera_face_zoom(MMHandleType handle, int attr_idx, const mmf_value_t *value)
{
+ int ret = 0;
int current_state = MM_CAMCORDER_STATE_NONE;
- gboolean bstate_changing = FALSE;
- _mmcam_dbg_log("camcorder-rotation(%d)", value->value.i_val);
- current_state = _mmcamcorder_get_state( handle);
- bstate_changing = _mmcamcorder_is_state_changing( handle);
+ mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
+ GstCameraControl *control = NULL;
+ _MMCamcorderSubContext *sc = NULL;
- if ((current_state > MM_CAMCORDER_STATE_PREPARE) || bstate_changing ) {
- _mmcam_dbg_err("camcorder-rotation setting failed.(state=%d, is_state_changing(%d))", current_state, bstate_changing);
- return FALSE;
+ mmf_return_val_if_fail(hcamcorder, FALSE);
+
+ sc = MMF_CAMCORDER_SUBCONTEXT(handle);
+ mmf_return_val_if_fail(sc, TRUE);
+
+ /* these are only available after camera preview is started */
+ current_state = _mmcamcorder_get_state(handle);
+ if (current_state >= MM_CAMCORDER_STATE_PREPARE &&
+ hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
+ int x = 0;
+ int y = 0;
+ int zoom_level = 0;
+ int preview_width = 0;
+ int preview_height = 0;
+
+ switch (attr_idx) {
+ case MM_CAM_CAMERA_FACE_ZOOM_X:
+ /* check x coordinate of face zoom */
+ mm_camcorder_get_attributes(handle, NULL,
+ MMCAM_CAMERA_WIDTH, &preview_width,
+ NULL);
+ /* x coordinate should be smaller than width of preview */
+ if (value->value.i_val < preview_width) {
+ _mmcam_dbg_log("set face zoom x %d done", value->value.i_val);
+ ret = TRUE;
+ } else {
+ _mmcam_dbg_err("invalid face zoom x %d", value->value.i_val);
+ ret = FALSE;
+ }
+ break;
+ case MM_CAM_CAMERA_FACE_ZOOM_Y:
+ /* check y coordinate of face zoom */
+ mm_camcorder_get_attributes(handle, NULL,
+ MMCAM_CAMERA_WIDTH, &preview_height,
+ NULL);
+ /* y coordinate should be smaller than height of preview */
+ if (value->value.i_val < preview_height) {
+ _mmcam_dbg_log("set face zoom y %d done", value->value.i_val);
+ ret = TRUE;
+ } else {
+ _mmcam_dbg_err("invalid face zoom y %d", value->value.i_val);
+ ret = FALSE;
+ }
+ break;
+ case MM_CAM_CAMERA_FACE_ZOOM_MODE:
+ if (value->value.i_val == MM_CAMCORDER_FACE_ZOOM_MODE_ON) {
+ int face_detect_mode = MM_CAMCORDER_DETECT_MODE_OFF;
+
+ /* start face zoom */
+ /* get x,y coordinate and zoom level */
+ mm_camcorder_get_attributes(handle, NULL,
+ MMCAM_CAMERA_FACE_ZOOM_X, &x,
+ MMCAM_CAMERA_FACE_ZOOM_Y, &y,
+ MMCAM_CAMERA_FACE_ZOOM_LEVEL, &zoom_level,
+ MMCAM_DETECT_MODE, &face_detect_mode,
+ NULL);
+
+ if (face_detect_mode == MM_CAMCORDER_DETECT_MODE_ON) {
+ control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst );
+ __ta__(" gst_camera_control_start_face_zoom",
+ ret = gst_camera_control_start_face_zoom(control, x, y, zoom_level);
+ );
+ } else {
+ _mmcam_dbg_err("face detect is OFF... could not start face zoom");
+ ret = FALSE;
+ }
+ } else if (value->value.i_val == MM_CAMCORDER_FACE_ZOOM_MODE_OFF) {
+ /* stop face zoom */
+ control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst );
+ __ta__(" gst_camera_control_stop_face_zoom",
+ ret = gst_camera_control_stop_face_zoom(control);
+ );
+ } else {
+ /* should not be reached here */
+ _mmcam_dbg_err("unknown command [%d]", value->value.i_val);
+ ret = FALSE;
+ }
+
+ if (!ret) {
+ _mmcam_dbg_err("face zoom[%d] failed", value->value.i_val);
+ ret = FALSE;
+ } else {
+ _mmcam_dbg_log("");
+ ret = TRUE;
+ }
+ break;
+ default:
+ _mmcam_dbg_warn("should not be reached here. attr_idx %d", attr_idx);
+ break;
+ }
} else {
- return TRUE;
+ _mmcam_dbg_err("invalid state[%d] or mode[%d]", current_state, hcamcorder->type);
+ ret = FALSE;
}
+
+ return ret;
}
}
-bool _mmcamcorder_commit_display_handle (MMHandleType handle, int attr_idx, const mmf_value_t *value)
+bool _mmcamcorder_commit_audio_disable(MMHandleType handle, int attr_idx, const mmf_value_t *value)
{
- _MMCamcorderSubContext *sc = NULL;
-
- char* videosink_name = NULL;
+ int current_state = MM_CAMCORDER_STATE_NONE;
- sc = MMF_CAMCORDER_SUBCONTEXT(handle);
- if (!sc)
+ current_state = _mmcamcorder_get_state(handle);
+ if (current_state > MM_CAMCORDER_STATE_PREPARE) {
+ _mmcam_dbg_warn("Can NOT Disable AUDIO. invalid state %d", current_state);
+ return FALSE;
+ } else {
+ _mmcam_dbg_log("Disable AUDIO when Recording");
return TRUE;
-
- if( sc )
- {
- _mmcamcorder_conf_get_value_element_name( sc->VideosinkElement, &videosink_name );
- _mmcam_dbg_log( "Commit : videosinkname[%s]", videosink_name );
-
- if( !strcmp( videosink_name, "xvimagesink" ) || !strcmp( videosink_name, "xvimagesink" ) )
- {
- if( sc->element )
- {
- if( sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst )
- {
- _mmcam_dbg_log( "Commit : Set XID[%x]", *(int*)(value->value.p_val) );
- gst_x_overlay_set_xwindow_id( GST_X_OVERLAY(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst), *(int*)(value->value.p_val) );
- }
- }
- }
- else
- {
- _mmcam_dbg_log( "Commit : Nothing to commit with this element[%s]", videosink_name );
- }
}
- else
- {
- _mmcam_dbg_log( "Commit : Nothing to commit with this attribute(MM_CAMCORDER_DISPLAY_HANDLE)" );
- }
-
- return TRUE;
-
}
-bool _mmcamcorder_commit_display_rotation (MMHandleType handle, int attr_idx, const mmf_value_t *value)
+bool _mmcamcorder_commit_display_handle(MMHandleType handle, int attr_idx, const mmf_value_t *value)
{
- mmf_camcorder_t *hcamcorder = NULL;
- _MMCamcorderSubContext *sc = NULL;
int current_state = MM_CAMCORDER_STATE_NONE;
+ char *videosink_name = NULL;
+ void *p_handle = NULL;
- hcamcorder = MMF_CAMCORDER(handle);
- if(!hcamcorder)
- return TRUE;
- sc = MMF_CAMCORDER_SUBCONTEXT(handle);
- if (!sc)
+ mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
+ _MMCamcorderSubContext *sc = NULL;
+
+ mmf_return_val_if_fail(handle, FALSE);
+
+ /* check type */
+ if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
+ _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
+ return FALSE;
+ }
+
+ /* check current state */
+ current_state = _mmcamcorder_get_state(handle);
+ if (current_state < MM_CAMCORDER_STATE_READY) {
+ _mmcam_dbg_log("NOT initialized. this will be applied later");
return TRUE;
+ }
- current_state = _mmcamcorder_get_state( handle);
+ sc = MMF_CAMCORDER_SUBCONTEXT(handle);
- if( current_state > MM_CAMCORDER_STATE_NULL ) {
- if( hcamcorder->type != MM_CAMCORDER_MODE_AUDIO ) {
- return _mmcamcorder_set_display_rotation( handle, value->value.i_val );
+ p_handle = value->value.p_val;
+ if (p_handle) {
+ /* get videosink name */
+ _mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name);
+ _mmcam_dbg_log("Commit : videosinkname[%s]", videosink_name);
+
+ if (!strcmp(videosink_name, "xvimagesink") || !strcmp(videosink_name, "ximagesink")) {
+ _mmcam_dbg_log("Commit : Set XID[%x]", *(int*)(p_handle));
+ gst_x_overlay_set_xwindow_id(GST_X_OVERLAY(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst), *(int*)(p_handle));
+ } else if (!strcmp(videosink_name, "evasimagesink") ||
+ !strcmp(videosink_name, "evaspixmapsink")) {
+ _mmcam_dbg_log("Commit : Set evas object [%p]", p_handle);
+ MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "evas-object", p_handle);
} else {
- _mmcam_dbg_warn( "Current Mode is AUDIO only mode." );
+ _mmcam_dbg_warn("Commit : Nothing to commit with this element[%s]", videosink_name);
return FALSE;
}
} else {
- _mmcam_dbg_err("display rotation change failed.(state=%d)", current_state);
+ _mmcam_dbg_warn("Display handle is NULL");
return FALSE;
}
+
+ return TRUE;
}
-bool _mmcamcorder_commit_display_visible (MMHandleType handle, int attr_idx, const mmf_value_t *value)
+bool _mmcamcorder_commit_display_mode(MMHandleType handle, int attr_idx, const mmf_value_t *value)
{
- mmf_camcorder_t *hcamcorder= MMF_CAMCORDER( handle);
+ int current_state = MM_CAMCORDER_STATE_NONE;
+ char *videosink_name = NULL;
+
+ mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
_MMCamcorderSubContext *sc = NULL;
- int is_visible = 0;
- int current_state = MM_CAMCORDER_STATE_NONE;
- int bret = 0;
+ mmf_return_val_if_fail(handle, FALSE);
+
+ /* check type */
+ if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
+ _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
+ return FALSE;
+ }
+
+ /* check current state */
+ current_state = _mmcamcorder_get_state(handle);
+ if (current_state < MM_CAMCORDER_STATE_READY) {
+ _mmcam_dbg_log("NOT initialized. this will be applied later");
+ return TRUE;
+ }
- char *videosink_name = NULL;
-
sc = MMF_CAMCORDER_SUBCONTEXT(handle);
- if (!sc)
+
+ _mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name);
+ _mmcam_dbg_log("Commit : videosinkname[%s]", videosink_name);
+
+ if (!strcmp(videosink_name, "xvimagesink")) {
+ _mmcam_dbg_log("Commit : display mode [%d]", value->value.i_val);
+ MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "display-mode", value->value.i_val);
return TRUE;
- current_state = _mmcamcorder_get_state( handle);
+ } else {
+ _mmcam_dbg_warn("Commit : This element [%s] does not support display mode", videosink_name);
+ return FALSE;
+ }
+}
- if( current_state > MM_CAMCORDER_STATE_NULL )
- {
- if( hcamcorder->type != MM_CAMCORDER_MODE_AUDIO )
- {
- if( sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst )
- {
- // Get videosink name
- _mmcamcorder_conf_get_value_element_name( sc->VideosinkElement, &videosink_name );
- is_visible = value->value.i_val;
+bool _mmcamcorder_commit_display_rotation(MMHandleType handle, int attr_idx, const mmf_value_t *value)
+{
+ int current_state = MM_CAMCORDER_STATE_NONE;
- if( !strcmp( videosink_name, "xvimagesink" )
- || !strcmp( videosink_name, "avsysvideosink" ) )
- {
- MMCAMCORDER_G_OBJECT_SET( sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst,
- "visible", is_visible);
+ mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
- _mmcam_dbg_log( "Set visible [%d] done.", is_visible );
- bret = TRUE;
- }
- else
- {
- _mmcam_dbg_warn( "videosink[%s] does not support VISIBLE.", videosink_name );
- bret = FALSE;
- }
- }
- else
- {
- _mmcam_dbg_warn( "Videosink element is null, but current state is [%d]", current_state );
- bret = FALSE;
- }
- }
- else
- {
- _mmcam_dbg_warn( "Current Mode is AUDIO only mode." );
- bret = FALSE;
- }
+ mmf_return_val_if_fail(handle, FALSE);
+
+ /* check type */
+ if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
+ _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
+ return FALSE;
}
- else
- {
- _mmcam_dbg_log("It doesn't need to change dynamically.(state=%d)", current_state);
- bret = TRUE;
+
+ /* check current state */
+ current_state = _mmcamcorder_get_state(handle);
+ if (current_state < MM_CAMCORDER_STATE_READY) {
+ _mmcam_dbg_log("NOT initialized. this will be applied later");
+ return TRUE;
}
- return bret;
+
+ return _mmcamcorder_set_display_rotation(handle, value->value.i_val);
}
-bool _mmcamcorder_commit_display_geometry_method (MMHandleType handle, int attr_idx, const mmf_value_t *value)
+bool _mmcamcorder_commit_display_flip(MMHandleType handle, int attr_idx, const mmf_value_t *value)
{
- mmf_camcorder_t *hcamcorder= MMF_CAMCORDER( handle);
- _MMCamcorderSubContext *sc = NULL;
+ int current_state = MM_CAMCORDER_STATE_NONE;
- int newattrs = 0;
+ mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
+
+ mmf_return_val_if_fail(handle, FALSE);
+
+ /* check type */
+ if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
+ _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
+ return FALSE;
+ }
+
+ /* check current state */
+ current_state = _mmcamcorder_get_state(handle);
+ if (current_state < MM_CAMCORDER_STATE_READY) {
+ _mmcam_dbg_log("NOT initialized. this will be applied later");
+ return TRUE;
+ }
+
+ return _mmcamcorder_set_display_flip(handle, value->value.i_val);
+}
+
+
+bool _mmcamcorder_commit_display_visible(MMHandleType handle, int attr_idx, const mmf_value_t *value)
+{
int current_state = MM_CAMCORDER_STATE_NONE;
- int bret = 0;
-
char *videosink_name = NULL;
-
- sc = MMF_CAMCORDER_SUBCONTEXT(handle);
- if (!sc)
- return TRUE;
- current_state = _mmcamcorder_get_state( handle);
- if (current_state > MM_CAMCORDER_STATE_NULL)
- {
- if (sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst)
- {
- // Get videosink name
- _mmcamcorder_conf_get_value_element_name( sc->VideosinkElement, &videosink_name );
+ mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
+ _MMCamcorderSubContext *sc = NULL;
- if(strcmp(videosink_name, "xvimagesink") == 0) //only for xvimagesink
- {
- if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO)
- {
- newattrs = value->value.i_val;
- MMCAMCORDER_G_OBJECT_SET( sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "display-geometry-method", newattrs);
- }
- }
- bret = TRUE;
- }
- else
- {
- _mmcam_dbg_log("Videosink element is null");
- bret = FALSE;
- }
+ mmf_return_val_if_fail(handle, FALSE);
+
+ /* check type */
+ if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
+ _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
+ return FALSE;
}
- else
- {
- _mmcam_dbg_log("It doesn't need to change dynamically.(state=%d)", current_state);
- bret = TRUE;
+
+ /* check current state */
+ current_state = _mmcamcorder_get_state(handle);
+ if (current_state < MM_CAMCORDER_STATE_READY) {
+ _mmcam_dbg_log("NOT initialized. this will be applied later");
+ return TRUE;
+ }
+
+ sc = MMF_CAMCORDER_SUBCONTEXT(handle);
+
+ /* Get videosink name */
+ _mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name);
+ if (!strcmp(videosink_name, "xvimagesink") ||
+ !strcmp(videosink_name, "evaspixmapsink")) {
+ MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "visible", value->value.i_val);
+ _mmcam_dbg_log("Set visible [%d] done.", value->value.i_val);
+ return TRUE;
+ } else {
+ _mmcam_dbg_warn("videosink[%s] does not support VISIBLE.", videosink_name);
+ return FALSE;
}
-
- return bret;
}
-bool _mmcamcorder_commit_display_rect (MMHandleType handle, int attr_idx, const mmf_value_t *value)
+bool _mmcamcorder_commit_display_geometry_method (MMHandleType handle, int attr_idx, const mmf_value_t *value)
{
- mmf_camcorder_t *hcamcorder= MMF_CAMCORDER( handle);
+ int method = 0;
+ int current_state = MM_CAMCORDER_STATE_NONE;
+ char *videosink_name = NULL;
+
+ mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
_MMCamcorderSubContext *sc = NULL;
+ mmf_return_val_if_fail(handle, FALSE);
+
+ /* check type */
+ if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
+ _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
+ return FALSE;
+ }
+
+ /* check current state */
+ current_state = _mmcamcorder_get_state(handle);
+ if (current_state < MM_CAMCORDER_STATE_READY) {
+ _mmcam_dbg_log("NOT initialized. this will be applied later");
+ return TRUE;
+ }
+
+ sc = MMF_CAMCORDER_SUBCONTEXT(handle);
+
+ /* Get videosink name */
+ _mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name);
+ if (!strcmp(videosink_name, "xvimagesink") ||
+ !strcmp(videosink_name, "evaspixmapsink")) {
+ method = value->value.i_val;
+ MMCAMCORDER_G_OBJECT_SET( sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "display-geometry-method", method);
+ return TRUE;
+ } else {
+ _mmcam_dbg_warn("videosink[%s] does not support geometry method.", videosink_name);
+ return FALSE;
+ }
+}
+
+
+bool _mmcamcorder_commit_display_rect(MMHandleType handle, int attr_idx, const mmf_value_t *value)
+{
int current_state = MM_CAMCORDER_STATE_NONE;
- int bret = 0;
-
+ int method = 0;
char *videosink_name = NULL;
-
- sc = MMF_CAMCORDER_SUBCONTEXT(handle);
- if (!sc)
+
+ mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
+ _MMCamcorderSubContext *sc = NULL;
+
+ mmf_return_val_if_fail(handle, FALSE);
+
+ /* check type */
+ if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
+ _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
+ return FALSE;
+ }
+
+ /* check current state */
+ current_state = _mmcamcorder_get_state(handle);
+ if (current_state < MM_CAMCORDER_STATE_READY) {
+ _mmcam_dbg_log("NOT initialized. this will be applied later");
return TRUE;
- current_state = _mmcamcorder_get_state( handle);
+ }
- if (current_state > MM_CAMCORDER_STATE_NULL)
- {
- if (sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst)
- {
- // Get videosink name
- _mmcamcorder_conf_get_value_element_name( sc->VideosinkElement, &videosink_name );
-
- if(strcmp(videosink_name, "xvimagesink") == 0) //only for xvimagesink
- {
- if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO)
- {
- int err = 0;
- int rectx, recty, rectw, recth;
- int display_geometry_method = 0;
-
- err = mm_camcorder_get_attributes(handle, NULL,
- MMCAM_DISPLAY_RECT_X, &rectx,
- MMCAM_DISPLAY_RECT_Y, &recty,
- MMCAM_DISPLAY_RECT_WIDTH, &rectw,
- MMCAM_DISPLAY_RECT_HEIGHT, &recth,
- MMCAM_DISPLAY_GEOMETRY_METHOD, &display_geometry_method,
- NULL);
- if (err < 0)
- {
- _mmcam_dbg_warn("Get display-geometry-method attrs fail. (%x)", err);
- return FALSE;
- }
+ sc = MMF_CAMCORDER_SUBCONTEXT(handle);
- if (display_geometry_method == MM_DISPLAY_METHOD_CUSTOM_ROI)
- {
- int flags = MM_ATTRS_FLAG_NONE;
- MMCamAttrsInfo info;
- _mmcam_dbg_log("FRECT(x,y,w,h) = (%d,%d,%d,%d)", rectx, recty, rectw, recth);
- switch(attr_idx)
- {
- case MM_CAM_DISPLAY_RECT_X:
- mm_camcorder_get_attribute_info(handle, MMCAM_DISPLAY_RECT_Y, &info);
- flags |= info.flag;
- memset(&info, 0x00, sizeof(info));
- mm_camcorder_get_attribute_info(handle, MMCAM_DISPLAY_RECT_WIDTH, &info);
- flags |= info.flag;
- memset(&info, 0x00, sizeof(info));
- mm_camcorder_get_attribute_info(handle, MMCAM_DISPLAY_RECT_HEIGHT, &info);
- flags |= info.flag;
-
- rectx = value->value.i_val;
- break;
- case MM_CAM_DISPLAY_RECT_Y:
- mm_camcorder_get_attribute_info(handle, MMCAM_DISPLAY_RECT_WIDTH, &info);
- flags |= info.flag;
- memset(&info, 0x00, sizeof(info));
- mm_camcorder_get_attribute_info(handle, MMCAM_DISPLAY_RECT_HEIGHT, &info);
- flags |= info.flag;
-
- recty = value->value.i_val;
- break;
- case MM_CAM_DISPLAY_RECT_WIDTH:
- mm_camcorder_get_attribute_info(handle, MMCAM_DISPLAY_RECT_HEIGHT, &info);
- flags |= info.flag;
+ /* check current method */
+ mm_camcorder_get_attributes(handle, NULL,
+ MMCAM_DISPLAY_GEOMETRY_METHOD, &method,
+ NULL);
+ if (method != MM_DISPLAY_METHOD_CUSTOM_ROI) {
+ _mmcam_dbg_log("current method[%d] is not supported rect", method);
+ return FALSE;
+ }
- rectw = value->value.i_val;
- break;
- case MM_CAM_DISPLAY_RECT_HEIGHT:
- recth = value->value.i_val;
- break;
- default:
- _mmcam_dbg_err("Wrong attr_idx!");
- return FALSE;
- }
+ /* Get videosink name */
+ _mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name);
+ if (!strcmp(videosink_name, "xvimagesink") ||
+ !strcmp(videosink_name, "evaspixmapsink")) {
+ int rect_x = 0;
+ int rect_y = 0;
+ int rect_width = 0;
+ int rect_height = 0;
+ int flags = MM_ATTRS_FLAG_NONE;
+ MMCamAttrsInfo info;
- if (!(flags & MM_ATTRS_FLAG_MODIFIED))
- {
- _mmcam_dbg_log("RECT(x,y,w,h) = (%d,%d,%d,%d)", rectx, recty, rectw, recth);
-
- //Do we need to check all?
- if(g_object_class_find_property(G_OBJECT_GET_CLASS(G_OBJECT(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst)), "dst-roi-x"))
- {
- g_object_set (sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst,
- "dst-roi-x", rectx,
- "dst-roi-y", recty,
- "dst-roi-w", rectw,
- "dst-roi-h", recth,
- NULL);
- }
- }
- }
- }
- }
- bret = TRUE;
+ mm_camcorder_get_attributes(handle, NULL,
+ MMCAM_DISPLAY_RECT_X, &rect_x,
+ MMCAM_DISPLAY_RECT_Y, &rect_y,
+ MMCAM_DISPLAY_RECT_WIDTH, &rect_width,
+ MMCAM_DISPLAY_RECT_HEIGHT, &rect_height,
+ NULL);
+ switch (attr_idx) {
+ case MM_CAM_DISPLAY_RECT_X:
+ mm_camcorder_get_attribute_info(handle, MMCAM_DISPLAY_RECT_Y, &info);
+ flags |= info.flag;
+ memset(&info, 0x00, sizeof(info));
+ mm_camcorder_get_attribute_info(handle, MMCAM_DISPLAY_RECT_WIDTH, &info);
+ flags |= info.flag;
+ memset(&info, 0x00, sizeof(info));
+ mm_camcorder_get_attribute_info(handle, MMCAM_DISPLAY_RECT_HEIGHT, &info);
+ flags |= info.flag;
+
+ rect_x = value->value.i_val;
+ break;
+ case MM_CAM_DISPLAY_RECT_Y:
+ mm_camcorder_get_attribute_info(handle, MMCAM_DISPLAY_RECT_WIDTH, &info);
+ flags |= info.flag;
+ memset(&info, 0x00, sizeof(info));
+ mm_camcorder_get_attribute_info(handle, MMCAM_DISPLAY_RECT_HEIGHT, &info);
+ flags |= info.flag;
+
+ rect_y = value->value.i_val;
+ break;
+ case MM_CAM_DISPLAY_RECT_WIDTH:
+ mm_camcorder_get_attribute_info(handle, MMCAM_DISPLAY_RECT_HEIGHT, &info);
+ flags |= info.flag;
+
+ rect_width = value->value.i_val;
+ break;
+ case MM_CAM_DISPLAY_RECT_HEIGHT:
+ rect_height = value->value.i_val;
+ break;
+ default:
+ _mmcam_dbg_err("Wrong attr_idx!");
+ return FALSE;
}
- else
- {
- _mmcam_dbg_log("Videosink element is null");
- bret = FALSE;
+
+ if (!(flags & MM_ATTRS_FLAG_MODIFIED)) {
+ _mmcam_dbg_log("RECT(x,y,w,h) = (%d,%d,%d,%d)",
+ rect_x, rect_y, rect_width, rect_height);
+ g_object_set(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst,
+ "dst-roi-x", rect_x,
+ "dst-roi-y", rect_y,
+ "dst-roi-w", rect_width,
+ "dst-roi-h", rect_height,
+ NULL);
}
+
+ return TRUE;
+ } else {
+ _mmcam_dbg_warn("videosink[%s] does not support display rect.", videosink_name);
+ return FALSE;
}
- else
- {
- _mmcam_dbg_log("It doesn't need to change dynamically.(state=%d)", current_state);
- bret = TRUE;
- }
-
- return bret;
}
-bool _mmcamcorder_commit_display_scale (MMHandleType handle, int attr_idx, const mmf_value_t *value)
+bool _mmcamcorder_commit_display_scale(MMHandleType handle, int attr_idx, const mmf_value_t *value)
{
- mmf_camcorder_t *hcamcorder= MMF_CAMCORDER( handle);
- _MMCamcorderSubContext *sc = NULL;
-
int zoom = 0;
int current_state = MM_CAMCORDER_STATE_NONE;
- int bret = 0;
-
char *videosink_name = NULL;
+ GstElement *vs_element = NULL;
+
+ mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
+ _MMCamcorderSubContext *sc = NULL;
+
+ mmf_return_val_if_fail(handle, FALSE);
+
+ /* check type */
+ if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
+ _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
+ return FALSE;
+ }
+
+ /* check current state */
+ current_state = _mmcamcorder_get_state(handle);
+ if (current_state < MM_CAMCORDER_STATE_READY) {
+ _mmcam_dbg_log("NOT initialized. this will be applied later");
+ return TRUE;
+ }
sc = MMF_CAMCORDER_SUBCONTEXT(handle);
- if (!sc)
+
+ /* Get videosink name */
+ _mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name);
+ zoom = value->value.i_val;
+ if (!strcmp(videosink_name, "xvimagesink")) {
+ vs_element = sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst;
+
+ MMCAMCORDER_G_OBJECT_SET(vs_element, "zoom", zoom + 1);
+ _mmcam_dbg_log("Set display zoom to %d", zoom + 1);
+
return TRUE;
- current_state = _mmcamcorder_get_state( handle);
+ } else {
+ _mmcam_dbg_warn("videosink[%s] does not support scale", videosink_name);
+ return FALSE;
+ }
+}
- if( current_state > MM_CAMCORDER_STATE_NULL )
- {
- if( hcamcorder->type != MM_CAMCORDER_MODE_AUDIO )
- {
- if( sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst )
- {
- // Get videosink name
- _mmcamcorder_conf_get_value_element_name( sc->VideosinkElement, &videosink_name );
-
- zoom = value->value.i_val;
- if( !strcmp( videosink_name, "xvimagesink" ))
- {
- //xvimagesink
- switch (zoom)
- {
- case MM_DISPLAY_SCALE_DEFAULT:
- {
- MMCAMCORDER_G_OBJECT_SET( sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "zoom", 1);
+bool _mmcamcorder_commit_display_evas_do_scaling(MMHandleType handle, int attr_idx, const mmf_value_t *value)
+{
+ int current_state = MM_CAMCORDER_STATE_NONE;
+ int do_scaling = 0;
+ char *videosink_name = NULL;
- _mmcam_dbg_log( "Set display zoom to default.");
- break;
- }
- case MM_DISPLAY_SCALE_DOUBLE_LENGTH:
- {
- MMCAMCORDER_G_OBJECT_SET( sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "zoom", 2);
+ mmf_camcorder_t *hcamcorder= MMF_CAMCORDER( handle);
+ _MMCamcorderSubContext *sc = NULL;
- _mmcam_dbg_log( "Set display zoom to double.");
- break;
- }
- case MM_DISPLAY_SCALE_TRIPLE_LENGTH:
- {
- MMCAMCORDER_G_OBJECT_SET( sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "zoom", 3);
+ mmf_return_val_if_fail(handle, FALSE);
- _mmcam_dbg_log( "Set display zoom to triple.");
- break;
- }
- default:
- {
- _mmcam_dbg_warn( "Unsupported value.");
- }
- }
-
- bret = TRUE;
- }
- else if (!strcmp( videosink_name, "avsysvideosink" ) )
- {
- //avsysvideosink
- bret = TRUE;
- }
- else
- {
- _mmcam_dbg_warn( "videosink[%s] does not support 'zoom'.", videosink_name );
- bret = FALSE;
- }
- }
- else
- {
- _mmcam_dbg_warn( "Videosink element is null, but current state is [%d]", current_state );
- bret = FALSE;
- }
- }
- else
- {
- _mmcam_dbg_warn( "Current Mode is AUDIO only mode." );
- bret = FALSE;
- }
+ /* check type */
+ if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
+ _mmcam_dbg_err("invalid mode %d", hcamcorder->type);
+ return FALSE;
}
- else
- {
- _mmcam_dbg_log("It doesn't need to change dynamically.(state=%d)", current_state);
- bret = TRUE;
+
+ /* check current state */
+ current_state = _mmcamcorder_get_state(handle);
+ if (current_state < MM_CAMCORDER_STATE_READY) {
+ _mmcam_dbg_log("NOT initialized. this will be applied later");
+ return TRUE;
}
- return bret;
+ sc = MMF_CAMCORDER_SUBCONTEXT(handle);
+
+ do_scaling = value->value.i_val;
+
+ /* Get videosink name */
+ _mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name);
+ if (!strcmp(videosink_name, "evaspixmapsink")) {
+ MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "origin-size", !do_scaling);
+ _mmcam_dbg_log("Set origin-size to %d", !(value->value.i_val));
+ return TRUE;
+ } else {
+ _mmcam_dbg_warn("videosink[%s] does not support scale", videosink_name);
+ return FALSE;
+ }
}
bool _mmcamcorder_commit_strobe (MMHandleType handle, int attr_idx, const mmf_value_t *value)
{
- bool bret = FALSE;
- _MMCamcorderSubContext* sc = NULL;
- int strobe_type, mslVal, newVal, cur_value;
- int current_state = MM_CAMCORDER_STATE_NONE;
+ bool bret = FALSE;
+ _MMCamcorderSubContext *sc = NULL;
+ int strobe_type, mslVal, newVal, cur_value;
+ int current_state = MM_CAMCORDER_STATE_NONE;
- sc = MMF_CAMCORDER_SUBCONTEXT( handle );
+ sc = MMF_CAMCORDER_SUBCONTEXT(handle);
if (!sc)
return TRUE;
mslVal = value->value.i_val;
- switch( attr_idx )
- {
- case MM_CAM_STROBE_CONTROL:
- strobe_type = GST_CAMERA_CONTROL_STROBE_CONTROL;
- newVal = _mmcamcorder_convert_msl_to_sensor( MM_CAM_STROBE_CONTROL, mslVal);
- break;
- case MM_CAM_STROBE_CAPABILITIES:
- strobe_type = GST_CAMERA_CONTROL_STROBE_CAPABILITIES;
- newVal = mslVal;
- break;
- case MM_CAM_STROBE_MODE:
- strobe_type = GST_CAMERA_CONTROL_STROBE_MODE;
- newVal = _mmcamcorder_convert_msl_to_sensor( MM_CAM_STROBE_MODE, mslVal);
- break;
- default:
- {
- _mmcam_dbg_err("Commit : strobe attribute(attr_idx(%d) is out of range)", attr_idx);
- return FALSE;
+ switch (attr_idx) {
+ case MM_CAM_STROBE_CONTROL:
+ strobe_type = GST_CAMERA_CONTROL_STROBE_CONTROL;
+ newVal = _mmcamcorder_convert_msl_to_sensor(handle, MM_CAM_STROBE_CONTROL, mslVal);
+ break;
+ case MM_CAM_STROBE_CAPABILITIES:
+ strobe_type = GST_CAMERA_CONTROL_STROBE_CAPABILITIES;
+ newVal = mslVal;
+ break;
+ case MM_CAM_STROBE_MODE:
+ /* check whether set or not */
+ if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
+ _mmcam_dbg_log("skip set value %d", mslVal);
+ return TRUE;
}
+
+ strobe_type = GST_CAMERA_CONTROL_STROBE_MODE;
+ newVal = _mmcamcorder_convert_msl_to_sensor(handle, MM_CAM_STROBE_MODE, mslVal);
+ break;
+ default:
+ _mmcam_dbg_err("Commit : strobe attribute(attr_idx(%d) is out of range)", attr_idx);
+ return FALSE;
}
GstCameraControl *control = NULL;
- if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst))
- {
+ if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
_mmcam_dbg_err("Can't cast Video source into camera control.");
- bret = FALSE;
- }
- else
- {
- control = GST_CAMERA_CONTROL( sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst );
+ bret = FALSE;
+ } else {
+ control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
- if( gst_camera_control_get_strobe( control, strobe_type, &cur_value ) )
- {
- if( newVal != cur_value )
- {
- if( gst_camera_control_set_strobe( control, strobe_type, newVal ) )
- {
- _mmcam_dbg_log( "Succeed in setting strobe. Type[%d],value[%d]", strobe_type, mslVal );
+ if (gst_camera_control_get_strobe(control, strobe_type, &cur_value)) {
+ if (newVal != cur_value) {
+ if (gst_camera_control_set_strobe(control, strobe_type, newVal)) {
+ _mmcam_dbg_log("Succeed in setting strobe. Type[%d],value[%d]", strobe_type, mslVal);
bret = TRUE;
- }
- else
- {
- _mmcam_dbg_warn( "Set strobe failed. Type[%d],value[%d]", strobe_type, mslVal );
+ } else {
+ _mmcam_dbg_warn("Set strobe failed. Type[%d],value[%d]", strobe_type, mslVal);
bret = FALSE;
}
- }
- else
- {
- _mmcam_dbg_log( "No need to set strobe. Type[%d],value[%d]", strobe_type, mslVal );
+ } else {
+ _mmcam_dbg_log("No need to set strobe. Type[%d],value[%d]", strobe_type, mslVal);
bret = TRUE;
}
- }
- else
- {
- _mmcam_dbg_warn( "Failed to get strobe. Type[%d]", strobe_type );
+ } else {
+ _mmcam_dbg_warn("Failed to get strobe. Type[%d]", strobe_type);
bret = FALSE;
}
}
}
-bool _mmcamcorder_commit_detect (MMHandleType handle, int attr_idx, const mmf_value_t *value)
+bool _mmcamcorder_commit_camera_flip(MMHandleType handle, int attr_idx, const mmf_value_t *value)
+{
+ int ret = 0;
+ int current_state = MM_CAMCORDER_STATE_NONE;
+
+ if ((void *)handle == NULL) {
+ _mmcam_dbg_warn("handle is NULL");
+ return FALSE;
+ }
+
+ _mmcam_dbg_log("Commit : flip %d", value->value.i_val);
+
+ /* state check */
+ current_state = _mmcamcorder_get_state(handle);
+ if (current_state > MM_CAMCORDER_STATE_READY) {
+ _mmcam_dbg_err("Can not set camera FLIP horizontal at state %d", current_state);
+ return FALSE;
+ } else if (current_state < MM_CAMCORDER_STATE_READY) {
+ _mmcam_dbg_log("Pipeline is not created yet. This will be set when create pipeline.");
+ return TRUE;
+ }
+
+ ret = _mmcamcorder_set_videosrc_flip(handle, value->value.i_val);
+
+ _mmcam_dbg_log("ret %d", ret);
+
+ return ret;
+}
+
+
+bool _mmcamcorder_commit_camera_hdr_capture(MMHandleType handle, int attr_idx, const mmf_value_t *value)
+{
+ int current_state = MM_CAMCORDER_STATE_NONE;
+
+ if ((void *)handle == NULL) {
+ _mmcam_dbg_warn("handle is NULL");
+ return FALSE;
+ }
+
+ _mmcam_dbg_log("Commit : HDR Capture %d", value->value.i_val);
+
+ /* check whether set or not */
+ if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
+ _mmcam_dbg_log("skip set value %d", value->value.i_val);
+ return TRUE;
+ }
+
+ /* state check */
+ current_state = _mmcamcorder_get_state(handle);
+ if (current_state > MM_CAMCORDER_STATE_PREPARE) {
+ _mmcam_dbg_err("can NOT set HDR capture at state %d", current_state);
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+
+bool _mmcamcorder_commit_detect(MMHandleType handle, int attr_idx, const mmf_value_t *value)
{
- bool bret = FALSE;
- _MMCamcorderSubContext* sc = NULL;
- int detect_type, mslVal, newVal, curVal;
+ bool bret = FALSE;
+ _MMCamcorderSubContext *sc = NULL;
+ int detect_type = GST_CAMERA_CONTROL_FACE_DETECT_MODE;
+ int set_value = 0;
+ int current_value = 0;
+ int current_state = MM_CAMCORDER_STATE_NONE;
GstCameraControl *control = NULL;
- int current_state = MM_CAMCORDER_STATE_NONE;
- sc = MMF_CAMCORDER_SUBCONTEXT( handle );
- if (!sc)
+ if ((void *)handle == NULL) {
+ _mmcam_dbg_warn("handle is NULL");
+ return FALSE;
+ }
+
+ sc = MMF_CAMCORDER_SUBCONTEXT(handle);
+ if (!sc) {
return TRUE;
+ }
- _mmcam_dbg_log( "Commit : detect attribute(%d)", attr_idx);
+ _mmcam_dbg_log("Commit : detect attribute(%d)", attr_idx);
- //status check
+ /* state check */
current_state = _mmcamcorder_get_state( handle);
-
if (current_state < MM_CAMCORDER_STATE_READY) {
//_mmcam_dbg_log("It doesn't need to change dynamically.(state=%d)", current_state);
return TRUE;
}
-
- switch( attr_idx )
- {
- case MM_CAM_DETECT_MODE:
- detect_type = GST_CAMERA_CONTROL_FACE_DETECT_MODE;
- break;
- case MM_CAM_DETECT_NUMBER:
- detect_type = GST_CAMERA_CONTROL_FACE_DETECT_NUMBER;
- break;
- case MM_CAM_DETECT_FOCUS_SELECT:
- detect_type = GST_CAMERA_CONTROL_FACE_FOCUS_SELECT;
- break;
- case MM_CAM_DETECT_SELECT_NUMBER:
- detect_type = GST_CAMERA_CONTROL_FACE_SELECT_NUMBER;
- break;
- case MM_CAM_DETECT_STATUS:
- detect_type = GST_CAMERA_CONTROL_FACE_DETECT_STATUS;
- break;
- default:
- {
- _mmcam_dbg_err("Commit : strobe attribute(attr_idx(%d) is out of range)", attr_idx);
- bret = FALSE;
- return bret;
+
+ set_value = value->value.i_val;
+
+ switch (attr_idx) {
+ case MM_CAM_DETECT_MODE:
+ /* check whether set or not */
+ if (!_mmcamcorder_check_supported_attribute(handle, attr_idx)) {
+ _mmcam_dbg_log("skip set value %d", set_value);
+ return TRUE;
}
- }
- mslVal = value->value.i_val;
- newVal = _mmcamcorder_convert_msl_to_sensor( attr_idx, mslVal );
-
+ detect_type = GST_CAMERA_CONTROL_FACE_DETECT_MODE;
+ break;
+ case MM_CAM_DETECT_NUMBER:
+ detect_type = GST_CAMERA_CONTROL_FACE_DETECT_NUMBER;
+ break;
+ case MM_CAM_DETECT_FOCUS_SELECT:
+ detect_type = GST_CAMERA_CONTROL_FACE_FOCUS_SELECT;
+ break;
+ case MM_CAM_DETECT_SELECT_NUMBER:
+ detect_type = GST_CAMERA_CONTROL_FACE_SELECT_NUMBER;
+ break;
+ case MM_CAM_DETECT_STATUS:
+ detect_type = GST_CAMERA_CONTROL_FACE_DETECT_STATUS;
+ break;
+ default:
+ _mmcam_dbg_err("Commit : strobe attribute(attr_idx(%d) is out of range)", attr_idx);
+ return FALSE;
+ }
- if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst))
- {
+ if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
_mmcam_dbg_err("Can't cast Video source into camera control.");
bret = FALSE;
- }
- else
- {
- control = GST_CAMERA_CONTROL( sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst );
+ } else {
+ control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
- if( gst_camera_control_get_detect( control, detect_type, &curVal ) )
- {
- if( curVal == newVal )
- {
- _mmcam_dbg_log( "No need to set detect. Type[%d],value[%d]", detect_type, mslVal );
+ if (gst_camera_control_get_detect(control, detect_type, ¤t_value)) {
+ if (current_value == set_value) {
+ _mmcam_dbg_log("No need to set detect(same). Type[%d],value[%d]", detect_type, set_value);
bret = TRUE;
- }
- else
- {
- if( !gst_camera_control_set_detect( control, detect_type, newVal ) )
- {
- _mmcam_dbg_warn( "Set detect failed. Type[%d],value[%d]", detect_type, mslVal );
+ } else {
+ if (!gst_camera_control_set_detect(control, detect_type, set_value)) {
+ _mmcam_dbg_warn("Set detect failed. Type[%d],value[%d]",
+ detect_type, set_value);
bret = FALSE;
- }
- else
- {
- _mmcam_dbg_log( "Set detect success. Type[%d],value[%d]", detect_type, mslVal );
+ } else {
+ _mmcam_dbg_log("Set detect success. Type[%d],value[%d]",
+ detect_type, set_value);
bret = TRUE;
}
}
- }
- else
- {
- _mmcam_dbg_warn( "Get detect failed. Type[%d]", detect_type );
+ } else {
+ _mmcam_dbg_warn("Get detect failed. Type[%d]", detect_type);
bret = FALSE;
}
}
int attr_idxs_default[] = {
MM_CAM_CAMERA_DIGITAL_ZOOM
, MM_CAM_CAMERA_OPTICAL_ZOOM
- , MM_CAM_CAMERA_FOCUS_MODE
- , MM_CAM_CAMERA_AF_SCAN_RANGE
- , MM_CAM_CAMERA_EXPOSURE_MODE
- , MM_CAM_CAMERA_EXPOSURE_VALUE
- , MM_CAM_CAMERA_F_NUMBER
- , MM_CAM_CAMERA_SHUTTER_SPEED
, MM_CAM_CAMERA_WDR
- , MM_CAM_CAMERA_ANTI_HANDSHAKE
- , MM_CAM_CAMERA_FPS_AUTO
, MM_CAM_CAMERA_HOLD_AF_AFTER_CAPTURING
, MM_CAM_FILTER_CONTRAST
- , MM_CAM_FILTER_COLOR_TONE
, MM_CAM_FILTER_HUE
- , MM_CAM_STROBE_CONTROL
, MM_CAM_STROBE_MODE
, MM_CAM_DETECT_MODE
- , MM_CAM_DETECT_NUMBER
- , MM_CAM_DETECT_FOCUS_SELECT
- , MM_CAM_DETECT_SELECT_NUMBER
- , MM_CAM_CAMERA_AF_TOUCH_X
- , MM_CAM_CAMERA_AF_TOUCH_Y
- , MM_CAM_CAMERA_AF_TOUCH_WIDTH
- , MM_CAM_CAMERA_AF_TOUCH_HEIGHT
};
int attr_idxs_extra[] = {
, MM_CAM_FILTER_WB
, MM_CAM_FILTER_SATURATION
, MM_CAM_FILTER_SHARPNESS
+ , MM_CAM_FILTER_COLOR_TONE
+ , MM_CAM_CAMERA_EXPOSURE_MODE
};
mmf_return_val_if_fail(hcamcorder, FALSE);
_mmcam_dbg_log("");
/* add gst_param */
- _mmcamcorder_conf_get_value_string_array( hcamcorder->conf_main,
- CONFIGURE_CATEGORY_MAIN_GENERAL,
- "DisabledAttributes",
- &disabled_attr );
+ _mmcamcorder_conf_get_value_string_array(hcamcorder->conf_main,
+ CONFIGURE_CATEGORY_MAIN_GENERAL,
+ "DisabledAttributes",
+ &disabled_attr);
if (disabled_attr != NULL && disabled_attr->value) {
cnt_str = disabled_attr->count;
for (i = 0; i < cnt_str; i++) {
mmf_return_val_if_fail(hcamcorder, FALSE);
sc = MMF_CAMCORDER_SUBCONTEXT(handle);
- mmf_return_val_if_fail(sc && sc->info, TRUE);
+ mmf_return_val_if_fail(sc, TRUE);
current_state = _mmcamcorder_get_state(handle);
static bool __mmcamcorder_set_camera_resolution(MMHandleType handle, int width, int height)
{
- mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle);
- int fps, slow_fps;
+ int fps = 0;
+ double motion_rate = _MMCAMCORDER_DEFAULT_RECORDING_MOTION_RATE;
+
+ mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
_MMCamcorderSubContext *sc = NULL;
GstCaps *caps = NULL;
- int set_width, set_height;
-
+
+ mmf_return_val_if_fail(hcamcorder, FALSE);
+
sc = MMF_CAMCORDER_SUBCONTEXT(handle);
- if (!sc)
- return TRUE;
+ mmf_return_val_if_fail(sc, TRUE);
- mm_camcorder_get_attributes(handle, NULL,
- MMCAM_CAMERA_FPS, &fps,
- "camera-slow-motion-fps", &slow_fps,
- NULL);
+ mm_camcorder_get_attributes(handle, NULL,
+ MMCAM_CAMERA_FPS, &fps,
+ MMCAM_CAMERA_RECORDING_MOTION_RATE, &motion_rate,
+ NULL);
- if (hcamcorder->type == MM_CAMCORDER_MODE_VIDEO) {
- if(slow_fps > 0) {
- sc->is_slow = TRUE;
+ if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
+ if(motion_rate != _MMCAMCORDER_DEFAULT_RECORDING_MOTION_RATE) {
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "high-speed-fps", fps);
} else {
- sc->is_slow = FALSE;
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "high-speed-fps", 0);
}
- } else {
- sc->is_slow = FALSE;
}
- set_width = width;
- set_height = height;
-
- caps = gst_caps_new_simple( "video/x-raw-yuv",
- "format", GST_TYPE_FOURCC, sc->fourcc,
- "width", G_TYPE_INT, set_width,
- "height", G_TYPE_INT, set_height,
- "framerate", GST_TYPE_FRACTION, (sc->is_slow ? slow_fps : fps), 1,
- NULL
- );
- MMCAMCORDER_G_OBJECT_SET( sc->element[_MMCAMCORDER_VIDEOSRC_FILT].gst, "caps", caps);
+ caps = gst_caps_new_simple("video/x-raw-yuv",
+ "format", GST_TYPE_FOURCC, sc->fourcc,
+ "width", G_TYPE_INT, width,
+ "height", G_TYPE_INT, height,
+ "framerate", GST_TYPE_FRACTION, fps, 1,
+ NULL);
+ MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_FILT].gst, "caps", caps);
gst_caps_unref(caps);
return TRUE;
va_arg ((var_args), void*); /* data */
va_arg ((var_args), int); /* size */
break;
- case MM_ATTRS_TYPE_ARRAY:
- va_arg ((var_args), void*); /* array */
- va_arg ((var_args), int); /* length */
- break;
- case MM_ATTRS_TYPE_RANGE:
- va_arg ((var_args), int); /* min */
- va_arg ((var_args), int); /* max */
- break;
case MM_ATTRS_TYPE_INVALID:
default:
_mmcam_dbg_err( "Not supported attribute type(%d, name:%s)", attr_type, name);
return MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
}
+
+ if (err_name) {
+ free(err_name);
+ err_name = NULL;
+ }
}
}
return MM_ERROR_NONE;
}
+
+
+bool _mmcamcorder_check_supported_attribute(MMHandleType handle, int attr_index)
+{
+ MMAttrsInfo info;
+
+ if ((void *)handle == NULL) {
+ _mmcam_dbg_warn("handle %p is NULL", handle);
+ return FALSE;
+ }
+
+ memset(&info, 0x0, sizeof(MMAttrsInfo));
+
+ mm_attrs_get_info(MMF_CAMCORDER_ATTRS(handle), attr_index, &info);
+
+ switch (info.validity_type) {
+ case MM_ATTRS_VALID_TYPE_INT_ARRAY:
+ _mmcam_dbg_log("int array count %d", info.int_array.count)
+ if (info.int_array.count <= 1) {
+ return FALSE;
+ }
+ break;
+ case MM_ATTRS_VALID_TYPE_INT_RANGE:
+ _mmcam_dbg_log("int range min %d, max %d",info.int_range.min, info.int_range.max);
+ if (info.int_range.min >= info.int_range.max) {
+ return FALSE;
+ }
+ break;
+ case MM_ATTRS_VALID_TYPE_DOUBLE_ARRAY:
+ _mmcam_dbg_log("double array count %d", info.double_array.count)
+ if (info.double_array.count <= 1) {
+ return FALSE;
+ }
+ break;
+ case MM_ATTRS_VALID_TYPE_DOUBLE_RANGE:
+ _mmcam_dbg_log("double range min %lf, max %lf",info.int_range.min, info.int_range.max);
+ if (info.double_range.min >= info.double_range.max) {
+ return FALSE;
+ }
+ break;
+ default:
+ _mmcam_dbg_warn("invalid type %d", info.validity_type);
+ return FALSE;
+ }
+
+ return TRUE;
+}
| GLOBAL FUNCTION DEFINITIONS: |
---------------------------------------------------------------------------------------*/
-
static int __mmcamcorder_create_audiop_with_encodebin(MMHandleType handle)
{
int err = MM_ERROR_NONE;
mmf_return_val_if_fail(sc, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
mmf_return_val_if_fail(sc->element, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
- mmf_return_val_if_fail(sc->info, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
+ mmf_return_val_if_fail(sc->info_audio, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
- info = (_MMCamcorderAudioInfo *)sc->info;
+ info = (_MMCamcorderAudioInfo *)sc->info_audio;
_mmcam_dbg_log("");
if (info->bMuxing) {
/* Muxing. can use encodebin. */
__ta__(" _mmcamcorder_create_encodesink_bin",
- err = _mmcamcorder_create_encodesink_bin((MMHandleType)hcamcorder);
+ err = _mmcamcorder_create_encodesink_bin((MMHandleType)hcamcorder, MM_CAMCORDER_ENCBIN_PROFILE_AUDIO);
);
if (err != MM_ERROR_NONE ) {
return err;
void
_mmcamcorder_destroy_audio_pipeline(MMHandleType handle)
{
- mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle);
+ mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
_MMCamcorderSubContext *sc = NULL;
- _MMCamcorderAudioInfo* info = NULL;
+ _MMCamcorderAudioInfo *info = NULL;
mmf_return_if_fail(hcamcorder);
sc = MMF_CAMCORDER_SUBCONTEXT(handle);
- mmf_return_if_fail(sc);
+ mmf_return_if_fail(sc && sc->info_audio);
mmf_return_if_fail(sc->element);
- info = sc->info;
+ info = sc->info_audio;
_mmcam_dbg_log("");
_mmcamcorder_audio_command(MMHandleType handle, int command)
{
int cmd = command;
- GstElement *pipeline = NULL;
- GstElement *audioSrc = NULL;
int ret = MM_ERROR_NONE;
int err = 0;
- char *dir_name = NULL;
int size=0;
guint64 free_space = 0;
- mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle);
- _MMCamcorderSubContext *sc = NULL;
- _MMCamcorderAudioInfo *info = NULL;
+ char *dir_name = NULL;
char *err_attr_name = NULL;
-
+
+ GstElement *pipeline = NULL;
+ GstElement *audioSrc = NULL;
+
+ mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
+ _MMCamcorderSubContext *sc = NULL;
+ _MMCamcorderAudioInfo *info = NULL;
+
mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
sc = MMF_CAMCORDER_SUBCONTEXT(handle);
mmf_return_val_if_fail(sc, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
mmf_return_val_if_fail(sc->element, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
- mmf_return_val_if_fail(sc->info, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
+ mmf_return_val_if_fail(sc->info_audio, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
pipeline = sc->element[_MMCAMCORDER_MAIN_PIPE].gst;
- info = sc->info;
-
+ info = sc->info_audio;
+
_mmcam_dbg_log("");
pipeline = sc->element[_MMCAMCORDER_MAIN_PIPE].gst;
//check status for resume case
if (_mmcamcorder_get_state((MMHandleType)hcamcorder) != MM_CAMCORDER_STATE_PAUSED)
{
+ guint imax_size = 0;
guint imax_time = 0;
char *temp_filename = NULL;
sc->pipeline_time = RESET_PAUSE_TIME;
ret = mm_camcorder_get_attributes(handle, &err_attr_name,
+ MMCAM_TARGET_MAX_SIZE, &imax_size,
MMCAM_TARGET_TIME_LIMIT, &imax_time,
MMCAM_FILE_FORMAT, &(info->fileformat),
MMCAM_TARGET_FILENAME, &temp_filename, &size,
sc->bget_eos = FALSE;
info->filesize =0;
+ /* set max size */
+ if (imax_size <= 0) {
+ info->max_size = 0; /* do not check */
+ } else {
+ info->max_size = ((guint64)imax_size) << 10; /* to byte */
+ }
+
/* set max time */
if (imax_time <= 0) {
info->max_time = 0; /* do not check */
sc = MMF_CAMCORDER_SUBCONTEXT(handle);
mmf_return_val_if_fail(sc, FALSE);
- mmf_return_val_if_fail(sc->info, FALSE);
+ mmf_return_val_if_fail(sc->info_audio, FALSE);
_mmcam_dbg_err("");
- info = sc->info;
+ info = sc->info_audio;
//changing pipeline for display
pipeline = sc->element[_MMCAMCORDER_MAIN_PIPE].gst;
// )
//Send message
- //Send recording report to application
- msg.id = MM_MESSAGE_CAMCORDER_CAPTURED;
+ //Send recording report to application
+ msg.id = MM_MESSAGE_CAMCORDER_AUDIO_CAPTURED;
report = (MMCamRecordingReport*) malloc(sizeof(MMCamRecordingReport)); //who free this?
if (!report)
guint64 buffer_size = 0;
guint64 trailer_size = 0;
char *filename = NULL;
+ unsigned long long remained_time = 0;
_MMCamcorderSubContext *sc = NULL;
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(u_data);
mmf_return_val_if_fail(buffer, FALSE);
sc = MMF_CAMCORDER_SUBCONTEXT(hcamcorder);
- mmf_return_val_if_fail(sc && sc->info, FALSE);
- info = sc->info;
+ mmf_return_val_if_fail(sc && sc->info_audio, FALSE);
+ info = sc->info_audio;
if (sc->isMaxtimePausing || sc->isMaxsizePausing) {
_mmcam_dbg_warn("isMaxtimePausing[%d],isMaxsizePausing[%d]",
}
/* get trailer size */
- if (info->fileformat == MM_FILE_FORMAT_3GP || info->fileformat == MM_FILE_FORMAT_MP4) {
+ if (info->fileformat == MM_FILE_FORMAT_3GP ||
+ info->fileformat == MM_FILE_FORMAT_MP4 ||
+ info->fileformat == MM_FILE_FORMAT_AAC) {
MMCAMCORDER_G_OBJECT_GET(sc->element[_MMCAMCORDER_ENCSINK_MUX].gst, "expected-trailer-size", &trailer_size);
/*_mmcam_dbg_log("trailer_size %d", trailer_size);*/
} else {
rec_pipe_time = GST_TIME_AS_MSECONDS(GST_BUFFER_TIMESTAMP(buffer));
+ /* calculate remained time can be recorded */
+ if (info->max_time > 0 && info->max_time < (remained_time + rec_pipe_time)) {
+ remained_time = info->max_time - rec_pipe_time;
+ } else if (info->max_size > 0) {
+ long double max_size = (long double)info->max_size;
+ long double current_size = (long double)(info->filesize + buffer_size + trailer_size);
+
+ remained_time = (unsigned long long)((long double)rec_pipe_time * (max_size/current_size)) - rec_pipe_time;
+ }
+
+ /*_mmcam_dbg_log("remained time : %u", remained_time);*/
+
+ /* check max size of recorded file */
+ if (info->max_size > 0 &&
+ info->max_size < info->filesize + buffer_size + trailer_size + _MMCAMCORDER_MMS_MARGIN_SPACE) {
+ _mmcam_dbg_warn("Max size!!! Recording is paused.");
+ _mmcam_dbg_warn("Max [%" G_GUINT64_FORMAT "], file [%" G_GUINT64_FORMAT "], trailer : [%" G_GUINT64_FORMAT "]", \
+ info->max_size, info->filesize, trailer_size);
+
+ /* just same as pause status. After blocking two queue, this function will not call again. */
+ if (info->bMuxing) {
+ MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "block", TRUE);
+ } else {
+ MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_ENCSINK_AQUE].gst, "empty-buffers", TRUE);
+ }
+
+ msg.id = MM_MESSAGE_CAMCORDER_RECORDING_STATUS;
+ msg.param.recording_status.elapsed = (unsigned long long)rec_pipe_time;
+ msg.param.recording_status.filesize = (unsigned long long)((info->filesize + trailer_size) >> 10);
+ msg.param.recording_status.remained_time = 0;
+ _mmcamcroder_send_message((MMHandleType)hcamcorder, &msg);
+
+ _mmcam_dbg_log("Last filesize sent by message : %d", info->filesize + trailer_size);
+
+ sc->isMaxsizePausing = TRUE;
+ msg.id = MM_MESSAGE_CAMCORDER_MAX_SIZE;
+ _mmcamcroder_send_message((MMHandleType)hcamcorder, &msg);
+
+ /* skip this buffer */
+ return FALSE;
+ }
+
/* check recording time limit and send recording status message */
if (info->max_time > 0 && rec_pipe_time > info->max_time) {
_mmcam_dbg_warn("Current time : [%" G_GUINT64_FORMAT "], Maximum time : [%" G_GUINT64_FORMAT "]", \
info->filesize += buffer_size;
msg.id = MM_MESSAGE_CAMCORDER_RECORDING_STATUS;
- msg.param.recording_status.elapsed = (unsigned int)rec_pipe_time;
- msg.param.recording_status.filesize = (unsigned int)((info->filesize + trailer_size) >> 10);
+ msg.param.recording_status.elapsed = (unsigned long long)rec_pipe_time;
+ msg.param.recording_status.filesize = (unsigned long long)((info->filesize + trailer_size) >> 10);
+ msg.param.recording_status.remained_time = remained_time;
_mmcamcroder_send_message((MMHandleType)hcamcorder, &msg);
return TRUE;
*
*/
-/*===========================================================================================
-| |
-| INCLUDE FILES |
-| |
-========================================================================================== */
+/*=======================================================================================
+| INCLUDE FILES |
+=======================================================================================*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "mm_camcorder_internal.h"
#include "mm_camcorder_configure.h"
-/*---------------------------------------------------------------------------
-| MACRO DEFINITIONS: |
----------------------------------------------------------------------------*/
-#define CONFIGURE_PATH "/opt/etc"
-#define CONFIGURE_PATH_RETRY "/usr/etc"
+/*-----------------------------------------------------------------------
+| MACRO DEFINITIONS: |
+-----------------------------------------------------------------------*/
+#define CONFIGURE_PATH "/usr/etc"
+#define CONFIGURE_PATH_RETRY "/opt/etc"
-/*---------------------------------------------------------------------------
-| GLOBAL VARIABLE DEFINITIONS |
----------------------------------------------------------------------------*/
+/*-----------------------------------------------------------------------
+| GLOBAL VARIABLE DEFINITIONS |
+-----------------------------------------------------------------------*/
-/*---------------------------------------------------------------------------
-| LOCAL VARIABLE DEFINITIONS |
----------------------------------------------------------------------------*/
+/*-----------------------------------------------------------------------
+| LOCAL VARIABLE DEFINITIONS |
+-----------------------------------------------------------------------*/
static int conf_main_category_size[CONFIGURE_CATEGORY_MAIN_NUM] = { 0, };
static int conf_ctrl_category_size[CONFIGURE_CATEGORY_CTRL_NUM] = { 0, };
*/
static conf_info_table conf_main_general_table[] = {
{ "SyncStateChange", CONFIGURE_VALUE_INT, {1} },
- { "GSTInitOption", CONFIGURE_VALUE_STRING_ARRAY, {NULL} },
- { "ModelName", CONFIGURE_VALUE_STRING, {(char*)"Samsung Camera"} },
- { "DisabledAttributes", CONFIGURE_VALUE_STRING_ARRAY, {NULL} },
+ { "GSTInitOption", CONFIGURE_VALUE_STRING_ARRAY, {(int)NULL} },
+ { "ModelName", CONFIGURE_VALUE_STRING, {(int)"Samsung Camera"} },
+ { "DisabledAttributes", CONFIGURE_VALUE_STRING_ARRAY, {(int)NULL} },
};
/*
*/
static conf_info_table conf_main_video_input_table[] = {
{ "UseConfCtrl", CONFIGURE_VALUE_INT, {1} },
- { "ConfCtrlFile0", CONFIGURE_VALUE_STRING, {(char*)"mmfw_camcorder_dev_video_pri.ini"} },
- { "ConfCtrlFile1", CONFIGURE_VALUE_STRING, {(char*)"mmfw_camcorder_dev_video_sec.ini"} },
- { "VideosrcElement", CONFIGURE_VALUE_ELEMENT, {(type_element*)&_videosrc_element_default} },
+ { "ConfCtrlFile0", CONFIGURE_VALUE_STRING, {(int)"mmfw_camcorder_dev_video_pri.ini"} },
+ { "ConfCtrlFile1", CONFIGURE_VALUE_STRING, {(int)"mmfw_camcorder_dev_video_sec.ini"} },
+ { "VideosrcElement", CONFIGURE_VALUE_ELEMENT, {(int)&_videosrc_element_default} },
{ "UseVideoscale", CONFIGURE_VALUE_INT, {0} },
- { "VideoscaleElement", CONFIGURE_VALUE_ELEMENT, {(type_element*)&_videoscale_element_default} },
+ { "VideoscaleElement", CONFIGURE_VALUE_ELEMENT, {(int)&_videoscale_element_default} },
{ "UseZeroCopyFormat", CONFIGURE_VALUE_INT, {0} },
+ { "DeviceCount", CONFIGURE_VALUE_INT, {MM_VIDEO_DEVICE_NUM} },
};
/*
* [AudioInput] matching table
*/
static conf_info_table conf_main_audio_input_table[] = {
- { "AudiosrcElement", CONFIGURE_VALUE_ELEMENT, {(type_element*)&_audiosrc_element_default} },
- { "AudiomodemsrcElement", CONFIGURE_VALUE_ELEMENT, {(type_element*)&_audiomodemsrc_element_default} },
+ { "AudiosrcElement", CONFIGURE_VALUE_ELEMENT, {(int)&_audiosrc_element_default} },
+ { "AudiomodemsrcElement", CONFIGURE_VALUE_ELEMENT, {(int)&_audiomodemsrc_element_default} },
};
/*
* [VideoOutput] matching table
*/
static conf_info_table conf_main_video_output_table[] = {
- { "DisplayDevice", CONFIGURE_VALUE_INT_ARRAY, {NULL} },
- { "Videosink", CONFIGURE_VALUE_INT_ARRAY, {NULL} },
- { "VideosinkElementX", CONFIGURE_VALUE_ELEMENT, {(type_element*)&_videosink_element_x_default} },
- { "VideosinkElementEvas", CONFIGURE_VALUE_ELEMENT, {(type_element*)&_videosink_element_evas_default} },
- { "VideosinkElementGL", CONFIGURE_VALUE_ELEMENT, {(type_element*)&_videosink_element_gl_default} },
- { "VideosinkElementNull", CONFIGURE_VALUE_ELEMENT, {(type_element*)&_videosink_element_null_default} },
+ { "DisplayDevice", CONFIGURE_VALUE_INT_ARRAY, {(int)NULL} },
+ { "DisplayMode", CONFIGURE_VALUE_INT_ARRAY, {(int)NULL} },
+ { "Videosink", CONFIGURE_VALUE_INT_ARRAY, {(int)NULL} },
+ { "VideosinkElementX", CONFIGURE_VALUE_ELEMENT, {(int)&_videosink_element_x_default} },
+ { "VideosinkElementEvas", CONFIGURE_VALUE_ELEMENT, {(int)&_videosink_element_evas_default} },
+ { "VideosinkElementGL", CONFIGURE_VALUE_ELEMENT, {(int)&_videosink_element_gl_default} },
+ { "VideosinkElementNull", CONFIGURE_VALUE_ELEMENT, {(int)&_videosink_element_null_default} },
{ "UseVideoscale", CONFIGURE_VALUE_INT, {0} },
- { "VideoscaleElement", CONFIGURE_VALUE_ELEMENT, {(type_element*)&_videoscale_element_default} },
+ { "VideoscaleElement", CONFIGURE_VALUE_ELEMENT, {(int)&_videoscale_element_default} },
};
/*
static conf_info_table conf_main_capture_table[] = {
{ "UseEncodebin", CONFIGURE_VALUE_INT, {0} },
{ "UseCaptureMode", CONFIGURE_VALUE_INT, {0} },
- { "VideoscaleElement", CONFIGURE_VALUE_ELEMENT, {(type_element*)&_videoscale_element_default} },
+ { "VideoscaleElement", CONFIGURE_VALUE_ELEMENT, {(int)&_videoscale_element_default} },
+ { "PlayCaptureSound", CONFIGURE_VALUE_INT, {1} },
};
/*
* [Record] matching table
*/
static conf_info_table conf_main_record_table[] = {
- { "UseAudioEncoderQueue", CONFIGURE_VALUE_INT, {1} },
- { "UseVideoEncoderQueue", CONFIGURE_VALUE_INT, {1} },
+ { "UseAudioEncoderQueue", CONFIGURE_VALUE_INT, {1} },
+ { "UseVideoEncoderQueue", CONFIGURE_VALUE_INT, {1} },
{ "VideoProfile", CONFIGURE_VALUE_INT, {0} },
{ "VideoAutoAudioConvert", CONFIGURE_VALUE_INT, {0} },
{ "VideoAutoAudioResample", CONFIGURE_VALUE_INT, {0} },
{ "ImageAutoAudioConvert", CONFIGURE_VALUE_INT, {0} },
{ "ImageAutoAudioResample", CONFIGURE_VALUE_INT, {0} },
{ "ImageAutoColorSpace", CONFIGURE_VALUE_INT, {0} },
- { "RecordsinkElement", CONFIGURE_VALUE_ELEMENT, {(type_element*)&_recordsink_element_default} },
+ { "RecordsinkElement", CONFIGURE_VALUE_ELEMENT, {(int)&_recordsink_element_default} },
{ "UseNoiseSuppressor", CONFIGURE_VALUE_INT, {0} },
{ "DropVideoFrame", CONFIGURE_VALUE_INT, {0} },
{ "PassFirstVideoFrame", CONFIGURE_VALUE_INT, {0} },
* [VideoEncoder] matching table
*/
static conf_info_table conf_main_video_encoder_table[] = {
- { "H263", CONFIGURE_VALUE_ELEMENT, {(type_element*)&_h263_element_default} },
- { "H264", CONFIGURE_VALUE_ELEMENT, {(type_element*)&_h264_element_default} },
- { "H26L", CONFIGURE_VALUE_ELEMENT, {(type_element*)&_h26l_element_default} },
- { "MPEG4", CONFIGURE_VALUE_ELEMENT, {(type_element*)&_mpeg4_element_default} },
- { "MPEG1", CONFIGURE_VALUE_ELEMENT, {(type_element*)&_mpeg1_element_default} },
- { "THEORA", CONFIGURE_VALUE_ELEMENT, {(type_element*)&_theora_element_default} },
+ { "H263", CONFIGURE_VALUE_ELEMENT, {(int)&_h263_element_default} },
+ { "H264", CONFIGURE_VALUE_ELEMENT, {(int)&_h264_element_default} },
+ { "H26L", CONFIGURE_VALUE_ELEMENT, {(int)&_h26l_element_default} },
+ { "MPEG4", CONFIGURE_VALUE_ELEMENT, {(int)&_mpeg4_element_default} },
+ { "MPEG1", CONFIGURE_VALUE_ELEMENT, {(int)&_mpeg1_element_default} },
+ { "THEORA", CONFIGURE_VALUE_ELEMENT, {(int)&_theora_element_default} },
};
/*
* [AudioEncoder] matching table
*/
static conf_info_table conf_main_audio_encoder_table[] = {
- { "AMR", CONFIGURE_VALUE_ELEMENT, {(type_element*)&_amr_element_default} },
- { "G723_1", CONFIGURE_VALUE_ELEMENT, {(type_element*)&_g723_1_element_default} },
- { "MP3", CONFIGURE_VALUE_ELEMENT, {(type_element*)&_mp3_element_default} },
- { "AAC", CONFIGURE_VALUE_ELEMENT, {(type_element*)&_aac_element_default} },
- { "MMF", CONFIGURE_VALUE_ELEMENT, {(type_element*)&_mmf_element_default} },
- { "ADPCM", CONFIGURE_VALUE_ELEMENT, {(type_element*)&_adpcm_element_default} },
- { "WAVE", CONFIGURE_VALUE_ELEMENT, {(type_element*)&_wave_element_default} },
- { "MIDI", CONFIGURE_VALUE_ELEMENT, {(type_element*)&_midi_element_default} },
- { "IMELODY", CONFIGURE_VALUE_ELEMENT, {(type_element*)&_imelody_element_default} },
- { "VORBIS", CONFIGURE_VALUE_ELEMENT, {(type_element*)&_vorbis_element_default} },
+ { "AMR", CONFIGURE_VALUE_ELEMENT, {(int)&_amr_element_default} },
+ { "G723_1", CONFIGURE_VALUE_ELEMENT, {(int)&_g723_1_element_default} },
+ { "MP3", CONFIGURE_VALUE_ELEMENT, {(int)&_mp3_element_default} },
+ { "AAC", CONFIGURE_VALUE_ELEMENT, {(int)&_aac_element_default} },
+ { "MMF", CONFIGURE_VALUE_ELEMENT, {(int)&_mmf_element_default} },
+ { "ADPCM", CONFIGURE_VALUE_ELEMENT, {(int)&_adpcm_element_default} },
+ { "WAVE", CONFIGURE_VALUE_ELEMENT, {(int)&_wave_element_default} },
+ { "MIDI", CONFIGURE_VALUE_ELEMENT, {(int)&_midi_element_default} },
+ { "IMELODY", CONFIGURE_VALUE_ELEMENT, {(int)&_imelody_element_default} },
+ { "VORBIS", CONFIGURE_VALUE_ELEMENT, {(int)&_vorbis_element_default} },
};
/*
* [ImageEncoder] matching table
*/
static conf_info_table conf_main_image_encoder_table[] = {
- { "JPEG", CONFIGURE_VALUE_ELEMENT, {(type_element*)&_jpeg_element_default} },
- { "PNG", CONFIGURE_VALUE_ELEMENT, {(type_element*)&_png_element_default} },
- { "BMP", CONFIGURE_VALUE_ELEMENT, {(type_element*)&_bmp_element_default} },
- { "WBMP", CONFIGURE_VALUE_ELEMENT, {(type_element*)&_wbmp_element_default} },
- { "TIFF", CONFIGURE_VALUE_ELEMENT, {(type_element*)&_tiff_element_default} },
- { "PCX", CONFIGURE_VALUE_ELEMENT, {(type_element*)&_pcx_element_default} },
- { "GIF", CONFIGURE_VALUE_ELEMENT, {(type_element*)&_gif_element_default} },
- { "ICO", CONFIGURE_VALUE_ELEMENT, {(type_element*)&_ico_element_default} },
- { "RAS", CONFIGURE_VALUE_ELEMENT, {(type_element*)&_ras_element_default} },
- { "TGA", CONFIGURE_VALUE_ELEMENT, {(type_element*)&_tga_element_default} },
- { "XBM", CONFIGURE_VALUE_ELEMENT, {(type_element*)&_xbm_element_default} },
- { "XPM", CONFIGURE_VALUE_ELEMENT, {(type_element*)&_xpm_element_default} },
+ { "JPEG", CONFIGURE_VALUE_ELEMENT, {(int)&_jpeg_element_default} },
+ { "PNG", CONFIGURE_VALUE_ELEMENT, {(int)&_png_element_default} },
+ { "BMP", CONFIGURE_VALUE_ELEMENT, {(int)&_bmp_element_default} },
+ { "WBMP", CONFIGURE_VALUE_ELEMENT, {(int)&_wbmp_element_default} },
+ { "TIFF", CONFIGURE_VALUE_ELEMENT, {(int)&_tiff_element_default} },
+ { "PCX", CONFIGURE_VALUE_ELEMENT, {(int)&_pcx_element_default} },
+ { "GIF", CONFIGURE_VALUE_ELEMENT, {(int)&_gif_element_default} },
+ { "ICO", CONFIGURE_VALUE_ELEMENT, {(int)&_ico_element_default} },
+ { "RAS", CONFIGURE_VALUE_ELEMENT, {(int)&_ras_element_default} },
+ { "TGA", CONFIGURE_VALUE_ELEMENT, {(int)&_tga_element_default} },
+ { "XBM", CONFIGURE_VALUE_ELEMENT, {(int)&_xbm_element_default} },
+ { "XPM", CONFIGURE_VALUE_ELEMENT, {(int)&_xpm_element_default} },
};
/*
* [Mux] matching table
*/
static conf_info_table conf_main_mux_table[] = {
- { "3GP", CONFIGURE_VALUE_ELEMENT, {(type_element*)&_3gp_element_default} },
- { "AMR", CONFIGURE_VALUE_ELEMENT, {(type_element*)&_amrmux_element_default} },
- { "MP4", CONFIGURE_VALUE_ELEMENT, {(type_element*)&_mp4_element_default} },
- { "AAC", CONFIGURE_VALUE_ELEMENT, {(type_element*)&_aacmux_element_default} },
- { "MP3", CONFIGURE_VALUE_ELEMENT, {(type_element*)&_mp3mux_element_default} },
- { "OGG", CONFIGURE_VALUE_ELEMENT, {(type_element*)&_ogg_element_default} },
- { "WAV", CONFIGURE_VALUE_ELEMENT, {(type_element*)&_wav_element_default} },
- { "AVI", CONFIGURE_VALUE_ELEMENT, {(type_element*)&_avi_element_default} },
- { "WMA", CONFIGURE_VALUE_ELEMENT, {(type_element*)&_wma_element_default} },
- { "WMV", CONFIGURE_VALUE_ELEMENT, {(type_element*)&_wmv_element_default} },
- { "MID", CONFIGURE_VALUE_ELEMENT, {(type_element*)&_mid_element_default} },
- { "MMF", CONFIGURE_VALUE_ELEMENT, {(type_element*)&_mmfmux_element_default} },
- { "MATROSKA", CONFIGURE_VALUE_ELEMENT, {(type_element*)&_matroska_element_default} },
+ { "3GP", CONFIGURE_VALUE_ELEMENT, {(int)&_3gp_element_default} },
+ { "AMR", CONFIGURE_VALUE_ELEMENT, {(int)&_amrmux_element_default} },
+ { "MP4", CONFIGURE_VALUE_ELEMENT, {(int)&_mp4_element_default} },
+ { "AAC", CONFIGURE_VALUE_ELEMENT, {(int)&_aacmux_element_default} },
+ { "MP3", CONFIGURE_VALUE_ELEMENT, {(int)&_mp3mux_element_default} },
+ { "OGG", CONFIGURE_VALUE_ELEMENT, {(int)&_ogg_element_default} },
+ { "WAV", CONFIGURE_VALUE_ELEMENT, {(int)&_wav_element_default} },
+ { "AVI", CONFIGURE_VALUE_ELEMENT, {(int)&_avi_element_default} },
+ { "WMA", CONFIGURE_VALUE_ELEMENT, {(int)&_wma_element_default} },
+ { "WMV", CONFIGURE_VALUE_ELEMENT, {(int)&_wmv_element_default} },
+ { "MID", CONFIGURE_VALUE_ELEMENT, {(int)&_mid_element_default} },
+ { "MMF", CONFIGURE_VALUE_ELEMENT, {(int)&_mmfmux_element_default} },
+ { "MATROSKA", CONFIGURE_VALUE_ELEMENT, {(int)&_matroska_element_default} },
};
* [Camera] matching table
*/
static conf_info_table conf_ctrl_camera_table[] = {
- { "InputIndex", CONFIGURE_VALUE_INT_ARRAY, {NULL} },
- { "DeviceName", CONFIGURE_VALUE_STRING, {NULL} },
- { "PreviewResolution", CONFIGURE_VALUE_INT_PAIR_ARRAY, {NULL} },
- { "CaptureResolution", CONFIGURE_VALUE_INT_PAIR_ARRAY, {NULL} },
- { "FPS", CONFIGURE_VALUE_INT_ARRAY, {NULL} },
- { "PictureFormat", CONFIGURE_VALUE_INT_ARRAY, {NULL} },
- { "Overlay", CONFIGURE_VALUE_INT_RANGE, {NULL} },
+ { "InputIndex", CONFIGURE_VALUE_INT_ARRAY, {(int)NULL} },
+ { "DeviceName", CONFIGURE_VALUE_STRING, {(int)NULL} },
+ { "PreviewResolution", CONFIGURE_VALUE_INT_PAIR_ARRAY, {(int)NULL} },
+ { "CaptureResolution", CONFIGURE_VALUE_INT_PAIR_ARRAY, {(int)NULL} },
+ { "FPS", CONFIGURE_VALUE_INT_ARRAY, {(int)NULL} },
+ { "PictureFormat", CONFIGURE_VALUE_INT_ARRAY, {(int)NULL} },
+ { "Overlay", CONFIGURE_VALUE_INT_RANGE, {(int)NULL} },
{ "RecommendDisplayRotation", CONFIGURE_VALUE_INT, {3} },
{ "RecommendPreviewFormatCapture", CONFIGURE_VALUE_INT, {MM_PIXEL_FORMAT_YUYV} },
{ "RecommendPreviewFormatRecord", CONFIGURE_VALUE_INT, {MM_PIXEL_FORMAT_NV12} },
+ { "RecommendPreviewResolution", CONFIGURE_VALUE_INT_PAIR_ARRAY, {(int)NULL} },
+ { "FacingDirection", CONFIGURE_VALUE_INT, {MM_CAMCORDER_CAMERA_FACING_DIRECTION_REAR} },
};
/*
* [Strobe] matching table
*/
static conf_info_table conf_ctrl_strobe_table[] = {
- { "StrobeControl", CONFIGURE_VALUE_INT_ARRAY, {NULL} },
- { "StrobeMode", CONFIGURE_VALUE_INT_ARRAY, {NULL} },
- { "StrobeEV", CONFIGURE_VALUE_INT_RANGE, {NULL} },
+ { "StrobeControl", CONFIGURE_VALUE_INT_ARRAY, {(int)NULL} },
+ { "StrobeMode", CONFIGURE_VALUE_INT_ARRAY, {(int)NULL} },
+ { "StrobeEV", CONFIGURE_VALUE_INT_RANGE, {(int)NULL} },
};
/*
* [Effect] matching table
*/
static conf_info_table conf_ctrl_effect_table[] = {
- { "Brightness", CONFIGURE_VALUE_INT_RANGE, {NULL} },
- { "Contrast", CONFIGURE_VALUE_INT_RANGE, {NULL} },
- { "Saturation", CONFIGURE_VALUE_INT_RANGE, {NULL} },
- { "Sharpness", CONFIGURE_VALUE_INT_RANGE, {NULL} },
- { "WhiteBalance", CONFIGURE_VALUE_INT_ARRAY, {NULL} },
- { "ColorTone", CONFIGURE_VALUE_INT_ARRAY, {NULL} },
- { "Flip", CONFIGURE_VALUE_INT_ARRAY, {NULL} },
- { "WDR", CONFIGURE_VALUE_INT_ARRAY, {NULL} },
- { "PartColorMode", CONFIGURE_VALUE_INT_ARRAY, {NULL} },
- { "PartColor", CONFIGURE_VALUE_INT_ARRAY, {NULL} },
+ { "Brightness", CONFIGURE_VALUE_INT_RANGE, {(int)NULL} },
+ { "Contrast", CONFIGURE_VALUE_INT_RANGE, {(int)NULL} },
+ { "Saturation", CONFIGURE_VALUE_INT_RANGE, {(int)NULL} },
+ { "Sharpness", CONFIGURE_VALUE_INT_RANGE, {(int)NULL} },
+ { "WhiteBalance", CONFIGURE_VALUE_INT_ARRAY, {(int)NULL} },
+ { "ColorTone", CONFIGURE_VALUE_INT_ARRAY, {(int)NULL} },
+ { "Flip", CONFIGURE_VALUE_INT_ARRAY, {(int)NULL} },
+ { "WDR", CONFIGURE_VALUE_INT_ARRAY, {(int)NULL} },
+ { "PartColorMode", CONFIGURE_VALUE_INT_ARRAY, {(int)NULL} },
+ { "PartColor", CONFIGURE_VALUE_INT_ARRAY, {(int)NULL} },
};
/*
* [Photograph] matching table
*/
static conf_info_table conf_ctrl_photograph_table[] = {
- { "LensInit", CONFIGURE_VALUE_INT_ARRAY, {NULL} },
- { "DigitalZoom", CONFIGURE_VALUE_INT_RANGE, {NULL} },
- { "OpticalZoom", CONFIGURE_VALUE_INT_RANGE, {NULL} },
- { "FocusMode", CONFIGURE_VALUE_INT_ARRAY, {NULL} },
- { "AFType", CONFIGURE_VALUE_INT_ARRAY, {NULL} },
- { "AEType", CONFIGURE_VALUE_INT_ARRAY, {NULL} },
- { "ExposureValue", CONFIGURE_VALUE_INT_RANGE, {NULL} },
- { "FNumber", CONFIGURE_VALUE_INT_ARRAY, {NULL} },
- { "ShutterSpeed", CONFIGURE_VALUE_INT_ARRAY, {NULL} },
- { "ISO", CONFIGURE_VALUE_INT_ARRAY, {NULL} },
- { "ProgramMode", CONFIGURE_VALUE_INT_ARRAY, {NULL} },
- { "AntiHandshake", CONFIGURE_VALUE_INT_ARRAY, {NULL} },
+ { "LensInit", CONFIGURE_VALUE_INT_ARRAY, {(int)NULL} },
+ { "DigitalZoom", CONFIGURE_VALUE_INT_RANGE, {(int)NULL} },
+ { "OpticalZoom", CONFIGURE_VALUE_INT_RANGE, {(int)NULL} },
+ { "FocusMode", CONFIGURE_VALUE_INT_ARRAY, {(int)NULL} },
+ { "AFType", CONFIGURE_VALUE_INT_ARRAY, {(int)NULL} },
+ { "AEType", CONFIGURE_VALUE_INT_ARRAY, {(int)NULL} },
+ { "ExposureValue", CONFIGURE_VALUE_INT_RANGE, {(int)NULL} },
+ { "FNumber", CONFIGURE_VALUE_INT_ARRAY, {(int)NULL} },
+ { "ShutterSpeed", CONFIGURE_VALUE_INT_ARRAY, {(int)NULL} },
+ { "ISO", CONFIGURE_VALUE_INT_ARRAY, {(int)NULL} },
+ { "ProgramMode", CONFIGURE_VALUE_INT_ARRAY, {(int)NULL} },
+ { "AntiHandshake", CONFIGURE_VALUE_INT_ARRAY, {(int)NULL} },
+ { "VideoStabilization", CONFIGURE_VALUE_INT_ARRAY, {(int)NULL} },
+ { "FaceZoomMode", CONFIGURE_VALUE_INT_ARRAY, {(int)NULL} },
+ { "FaceZoomLevel", CONFIGURE_VALUE_INT_RANGE, {(int)NULL} },
};
/*
* [Capture] matching table
*/
static conf_info_table conf_ctrl_capture_table[] = {
- { "OutputMode", CONFIGURE_VALUE_INT_ARRAY, {NULL} },
- { "JpegQuality", CONFIGURE_VALUE_INT_RANGE, {NULL} },
- { "MultishotNumber", CONFIGURE_VALUE_INT_RANGE, {NULL} },
+ { "OutputMode", CONFIGURE_VALUE_INT_ARRAY, {(int)NULL} },
+ { "JpegQuality", CONFIGURE_VALUE_INT_RANGE, {(int)NULL} },
+ { "MultishotNumber", CONFIGURE_VALUE_INT_RANGE, {(int)NULL} },
{ "SensorEncodedCapture", CONFIGURE_VALUE_INT, {1} },
+ { "SupportHDR", CONFIGURE_VALUE_INT_ARRAY, {(int)NULL} },
};
/*
* [Detect] matching table
*/
static conf_info_table conf_ctrl_detect_table[] = {
- { "DetectMode", CONFIGURE_VALUE_INT_ARRAY, {NULL} },
- { "DetectNumber", CONFIGURE_VALUE_INT_RANGE, {NULL} },
- { "DetectSelect", CONFIGURE_VALUE_INT_RANGE, {NULL} },
- { "DetectSelectNumber", CONFIGURE_VALUE_INT_RANGE, {NULL} },
+ { "DetectMode", CONFIGURE_VALUE_INT_ARRAY, {(int)NULL} },
+ { "DetectNumber", CONFIGURE_VALUE_INT_RANGE, {(int)NULL} },
+ { "DetectSelect", CONFIGURE_VALUE_INT_RANGE, {(int)NULL} },
+ { "DetectSelectNumber", CONFIGURE_VALUE_INT_RANGE, {(int)NULL} },
};
return strdup(src_string);
}
-void
-_mmcamcorder_conf_init( int type, camera_conf** configure_info )
+void _mmcamcorder_conf_init(int type, camera_conf** configure_info)
{
int i = 0;
- int info_table_size = sizeof( conf_info_table );
-
- _mmcam_dbg_log( "Entered..." );
+ int info_table_size = sizeof(conf_info_table);
- if( type == CONFIGURE_TYPE_MAIN )
- {
+ _mmcam_dbg_log("Entered...");
+
+ if (type == CONFIGURE_TYPE_MAIN) {
conf_main_info_table[CONFIGURE_CATEGORY_MAIN_GENERAL] = conf_main_general_table;
conf_main_info_table[CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT] = conf_main_video_input_table;
conf_main_info_table[CONFIGURE_CATEGORY_MAIN_AUDIO_INPUT] = conf_main_audio_input_table;
(*configure_info)->info = (conf_info**)g_malloc0( sizeof( conf_info* ) * CONFIGURE_CATEGORY_MAIN_NUM );
- for( i = 0 ; i < CONFIGURE_CATEGORY_MAIN_NUM ; i++ )
- {
+ for (i = 0 ; i < CONFIGURE_CATEGORY_MAIN_NUM ; i++) {
(*configure_info)->info[i] = NULL;
}
- }
- else
- {
+ } else {
conf_ctrl_info_table[CONFIGURE_CATEGORY_CTRL_CAMERA] = conf_ctrl_camera_table;
conf_ctrl_info_table[CONFIGURE_CATEGORY_CTRL_STROBE] = conf_ctrl_strobe_table;
conf_ctrl_info_table[CONFIGURE_CATEGORY_CTRL_EFFECT] = conf_ctrl_effect_table;
(*configure_info)->info = (conf_info**)g_malloc0( sizeof( conf_info* ) * CONFIGURE_CATEGORY_CTRL_NUM );
- for( i = 0 ; i < CONFIGURE_CATEGORY_CTRL_NUM ; i++ )
- {
- (*configure_info)->info[i] = NULL;
+ for (i = 0 ; i < CONFIGURE_CATEGORY_CTRL_NUM ; i++) {
+ (*configure_info)->info[i] = NULL;
}
}
-
- _mmcam_dbg_log( "Done." );
+ _mmcam_dbg_log("Done.");
+
+ return;
}
if( count_details == 0 )
{
_mmcam_dbg_warn( "category %s has no detail value... skip this category...", category_name );
+ SAFE_FREE(category_name);
continue;
}
}
}
- if( category_name )
- {
- SAFE_FREE( category_name );
- }
+ SAFE_FREE(category_name);
}
//(*configure_info) = new_conf;
}
-int
-_mmcamcorder_get_audio_codec_format(MMHandleType handle, char * name)
+int _mmcamcorder_get_audio_codec_format(MMHandleType handle, char *name)
{
- int i = 0;
- char* audio_fmt_type[] = {
- "AMR", /**< AMR codec*/
- "G723_1", /**< G723.1 codec*/
- "MP3", /**< MP3 codec*/
- "OGG", /**< OGG codec*/
- "AAC", /**< AAC codec*/
- "WMA", /**< WMA codec*/
- "MMF", /**< MMF codec*/
- "ADPCM", /**< ADPCM codec */
- "WAVE", /**< WAVE codec */
- "WAVE_NEW", /**< WAVE codec */
- "MIDI", /**< MIDI codec */
- "IMELODY", /**< IMELODY codec */
- "MXMF",
- "MPA", /**< MPEG1-Layer1 codec */
- "MP2", /**< MPEG1-Layer2 codec */
- "G711", /**< G711 codec */
- "G722", /**< G722 wideband speech codec */
- "G722_1", /**< G722.1 codec */
- "G722_2", /**< G722.2 (AMR-WB) codec */
- "G723", /**< G723 wideband speech codec */
- "G726", /**< G726 (ADPCM) codec */
- "G728", /**< G728 speech codec */
- "G729", /**< G729 codec */
- "G729A", /**< G729a codec */
- "G729_1", /**< G729.1 codec */
- "REAL", /**< Real audio */
- "AAC_LC", /**< AAC-Low complexity codec */
- "AAC_MAIN", /**< AAC-Main profile codec */
- "AAC_SRS", /**< AAC-Scalable sample rate codec */
- "AAC_LTP", /**< AAC-Long term prediction codec */
- "AAC_HE_V1", /**< AAC-High Efficiency v1 codec */
- "AAC_HE_V2", /**< AAC-High efficiency v2 codec */
- "AC3", /**< DolbyDigital codec */
- "ALAC", /**< Apple Lossless audio codec */
- "ATRAC", /**< Sony audio codec */
- "SPEEX", /**< SPEEX audio codec */
- "VORBIS", /**< Vor*/
- "AIFF", /**< AIFF codec*/
- "AU", /**< AU codec*/
- "NONE", /**< None (will be deprecated) */
- "PCM", /**< PCM codec */
- "ALAW", /**< ALAW codec */
- "MULAW", /**< MULAW codec */
- "MS_ADPCM" /**< MS ADPCM codec */
- };
-
- for (i = 0; i < MM_AUDIO_CODEC_NUM; i++)
- {
- if (!strcmp(name, audio_fmt_type[i]))
- {
-// _mmcam_dbg_log( "Audio codec[%d]", i);
- return i;
- }
+ int codec_index = MM_AUDIO_CODEC_INVALID;
+
+ if (!name) {
+ _mmcam_dbg_err("name is NULL");
+ return MM_AUDIO_CODEC_INVALID;
+ }
+
+ if (!strcmp(name, "AMR")) {
+ codec_index = MM_AUDIO_CODEC_AMR;
+ } else if (!strcmp(name, "G723_1")) {
+ codec_index = MM_AUDIO_CODEC_G723_1;
+ } else if (!strcmp(name, "MP3")) {
+ codec_index = MM_AUDIO_CODEC_MP3;
+ } else if (!strcmp(name, "AAC")) {
+ codec_index = MM_AUDIO_CODEC_AAC;
+ } else if (!strcmp(name, "MMF")) {
+ codec_index = MM_AUDIO_CODEC_MMF;
+ } else if (!strcmp(name, "ADPCM")) {
+ codec_index = MM_AUDIO_CODEC_ADPCM;
+ } else if (!strcmp(name, "WAVE")) {
+ codec_index = MM_AUDIO_CODEC_WAVE;
+ } else if (!strcmp(name, "MIDI")) {
+ codec_index = MM_AUDIO_CODEC_MIDI;
+ } else if (!strcmp(name, "IMELODY")) {
+ codec_index = MM_AUDIO_CODEC_IMELODY;
+ } else if (!strcmp(name, "VORBIS")) {
+ codec_index = MM_AUDIO_CODEC_VORBIS;
}
- _mmcam_dbg_err( "Not supported audio codec[%s]", name);
- return -1;
+ _mmcam_dbg_log("audio codec index %d", codec_index);
+ return codec_index;
}
-int
-_mmcamcorder_get_video_codec_format(MMHandleType handle, char * name)
+int _mmcamcorder_get_video_codec_format(MMHandleType handle, char *name)
{
- int i = 0;
- char* video_fmt_type[] = {
- "NONE", /**< None (will be deprecated) */
- "H263", /**< H263 codec*/
- "H264", /**< H264 codec*/
- "H26L", /**< H26L codec*/
- "MPEG4", /**< MPEG4 codec*/
- "MPEG1", /**< MPEG1 codec*/
- "WMV", /**< WMV codec*/
- "DIVX", /**< DIVX codec*/
- "XVID", /**< XVID codec*/
- "H261", /**< H261 codec*/
- "H262", /**< H262/MPEG2-part2 codec*/
- "H263V2", /**< H263v2 codec*/
- "H263V3", /**< H263v3 codec*/
- "MJPEG", /**< Motion JPEG Video codec*/
- "MPEG2", /**< MPEG2 codec*/
- "MPEG4_SIMPLE", /**< MPEG4 part-2 Simple profile codec*/
- "MPEG4_ADV_SIMPLE",/**< MPEG4 part-2 Advanced Simple profile codec*/
- "MPEG4_MAIN", /**< MPEG4 part-2 Main profile codec*/
- "MPEG4_CORE", /**< MPEG4 part-2 Core profile codec*/
- "MPEG4_ACE", /**< MPEG4 part-2 Adv Coding Eff profile codec*/
- "MPEG4_ARTS", /**< MPEG4 part-2 Adv RealTime Simple profile codec*/
- "MPEG4_AVC", /**< MPEG4 part-10 (h.264) codec*/
- "REAL", /**< Real video*/
- "VC1", /**< VC-1 video*/
- "AVS", /**< AVS video*/
- "CINEPAK", /**< Cinepak videocodec */
- "INDEO", /**< Indeo videocodec */
- "THEORA" /**< Theora videocodec */
- };
-
- for (i = 0; i < MM_VIDEO_CODEC_NUM; i++)
- {
- if (!strcmp(name, video_fmt_type[i]))
- {
-// _mmcam_dbg_log( "Video codec[%d]", i);
- return i;
- }
+ int codec_index = MM_VIDEO_CODEC_INVALID;
+
+ if (!name) {
+ _mmcam_dbg_err("name is NULL");
+ return MM_VIDEO_CODEC_INVALID;
+ }
+
+ if (!strcmp(name, "H263")) {
+ codec_index = MM_VIDEO_CODEC_H263;
+ } else if (!strcmp(name, "H264")) {
+ codec_index = MM_VIDEO_CODEC_H264;
+ } else if (!strcmp(name, "H26L")) {
+ codec_index = MM_VIDEO_CODEC_H26L;
+ } else if (!strcmp(name, "MPEG4")) {
+ codec_index = MM_VIDEO_CODEC_MPEG4;
+ } else if (!strcmp(name, "MPEG1")) {
+ codec_index = MM_VIDEO_CODEC_MPEG1;
+ } else if (!strcmp(name, "THEORA")) {
+ codec_index = MM_VIDEO_CODEC_THEORA;
}
- _mmcam_dbg_err( "Not supported Video codec[%s]", name);
- return -1;
+ _mmcam_dbg_log("video codec index %d", codec_index);
+ return codec_index;
}
-int
-_mmcamcorder_get_image_codec_format(MMHandleType handle, char * name)
+int _mmcamcorder_get_image_codec_format(MMHandleType handle, char *name)
{
- int i = 0;
- char* image_fmt_type[] = {
- "JPEG", /**< JPEG codec */
- "PNG", /**< PNG codec */
- "BMP", /**< BMP codec */
- "WBMP", /**< WBMP codec */
- "TIFF", /**< TIFF codec */
- "PCX", /**< PCX codec */
- "GIF", /**< GIF codec */
- "ICO", /**< ICO codec */
- "RAS", /**< RAS codec */
- "TGA", /**< TGA codec */
- "XBM", /**< XBM codec */
- "XPM" /**< XPM codec */
- "SRW" /**< SRW (Samsung standard RAW) */
- "JPEG_SRW" /**< JPEG + SRW */
- };
-
- for (i = 0; i < MM_IMAGE_CODEC_NUM; i++)
- {
- if (!strcmp(name, image_fmt_type[i]))
- {
-// _mmcam_dbg_log( "Image codec[%d]", i);
- return i;
- }
+ int codec_index = MM_IMAGE_CODEC_INVALID;
+
+ if (!name) {
+ _mmcam_dbg_err("name is NULL");
+ return MM_IMAGE_CODEC_INVALID;
+ }
+
+ if (!strcmp(name, "JPEG")) {
+ codec_index = MM_IMAGE_CODEC_JPEG;
+ } else if (!strcmp(name, "PNG")) {
+ codec_index = MM_IMAGE_CODEC_PNG;
+ } else if (!strcmp(name, "BMP")) {
+ codec_index = MM_IMAGE_CODEC_BMP;
+ } else if (!strcmp(name, "WBMP")) {
+ codec_index = MM_IMAGE_CODEC_WBMP;
+ } else if (!strcmp(name, "TIFF")) {
+ codec_index = MM_IMAGE_CODEC_TIFF;
+ } else if (!strcmp(name, "PCX")) {
+ codec_index = MM_IMAGE_CODEC_PCX;
+ } else if (!strcmp(name, "GIF")) {
+ codec_index = MM_IMAGE_CODEC_GIF;
+ } else if (!strcmp(name, "ICO")) {
+ codec_index = MM_IMAGE_CODEC_ICO;
+ } else if (!strcmp(name, "RAS")) {
+ codec_index = MM_IMAGE_CODEC_RAS;
+ } else if (!strcmp(name, "TGA")) {
+ codec_index = MM_IMAGE_CODEC_TGA;
+ } else if (!strcmp(name, "XBM")) {
+ codec_index = MM_IMAGE_CODEC_XBM;
+ } else if (!strcmp(name, "XPM")) {
+ codec_index = MM_IMAGE_CODEC_XPM;
}
- _mmcam_dbg_err( "Not supported Image codec[%s]", name);
- return -1;
+ _mmcam_dbg_log("image codec index %d", codec_index);
+ return codec_index;
}
-int
-_mmcamcorder_get_mux_format(MMHandleType handle, char * name)
+int _mmcamcorder_get_mux_format(MMHandleType handle, char *name)
{
- int i = 0;
- char* mux_fmt_type[] = {
- "3GP", /**< 3GP file format */
- "ASF", /**< Advanced Systems File file format */
- "AVI", /**< Audio Video Interleaved file format */
- "MATROSKA", /**< MATROSAK file format */
- "MP4", /**< MP4 file format */
- "OGG", /**< OGG file format */
- "NUT", /**< NUT file format */
- "QT", /**< MOV file format */
- "REAL", /**< RealMedia file format */
- "AMR", /**< AMR file format */
- "AAC", /**< AAC file format */
- "MP3", /**< MP3 file format */
- "AIFF", /**< AIFF file format */
- "AU", /**< Audio file format */
- "WAV", /**< WAV file format */
- "MID", /**< MID file format */
- "MMF", /**< MMF file format */
- "DIVX", /**< DivX file format */
- "FLV", /**< Flash video file format */
- "VOB", /**< DVD-Video Object file format */
- "IMELODY", /**< IMelody file format */
- "WMA", /**< WMA file format */
- "WMV", /**< WMV file format */
- "JPG" /**< JPEG file format */
- };
-
- for (i = 0; i < MM_FILE_FORMAT_NUM; i++)
- {
- if (!strcmp(name, mux_fmt_type[i]))
- {
-// _mmcam_dbg_log( "Mux[%d]", i);
- return i;
- }
+ int mux_index = MM_FILE_FORMAT_INVALID;
+
+ if (!name) {
+ _mmcam_dbg_err("name is NULL");
+ return MM_FILE_FORMAT_INVALID;
+ }
+
+ if (!strcmp(name, "3GP")) {
+ mux_index = MM_FILE_FORMAT_3GP;
+ } else if (!strcmp(name, "AMR")) {
+ mux_index = MM_FILE_FORMAT_AMR;
+ } else if (!strcmp(name, "MP4")) {
+ mux_index = MM_FILE_FORMAT_MP4;
+ } else if (!strcmp(name, "AAC")) {
+ mux_index = MM_FILE_FORMAT_AAC;
+ } else if (!strcmp(name, "MP3")) {
+ mux_index = MM_FILE_FORMAT_MP3;
+ } else if (!strcmp(name, "OGG")) {
+ mux_index = MM_FILE_FORMAT_OGG;
+ } else if (!strcmp(name, "WAV")) {
+ mux_index = MM_FILE_FORMAT_WAV;
+ } else if (!strcmp(name, "AVI")) {
+ mux_index = MM_FILE_FORMAT_AVI;
+ } else if (!strcmp(name, "WMA")) {
+ mux_index = MM_FILE_FORMAT_WMA;
+ } else if (!strcmp(name, "WMV")) {
+ mux_index = MM_FILE_FORMAT_WMV;
+ } else if (!strcmp(name, "MID")) {
+ mux_index = MM_FILE_FORMAT_MID;
+ } else if (!strcmp(name, "MMF")) {
+ mux_index = MM_FILE_FORMAT_MMF;
+ } else if (!strcmp(name, "MATROSKA")) {
+ mux_index = MM_FILE_FORMAT_MATROSKA;
}
- _mmcam_dbg_err( "Not supported Mux[%s]", name);
- return -1;
+ _mmcam_dbg_log("mux index %d", mux_index);
+ return mux_index;
}
configure_info = hcamcorder->conf_main;
- if( configure_info->info[conf_category] )
- {
- int count = configure_info->info[conf_category]->count;
- conf_info* info = configure_info->info[conf_category];
+ if (configure_info->info[conf_category]) {
int i = 0;
int fmt = 0;
- char* name = NULL;
+ char *name = NULL;
+ int count = configure_info->info[conf_category]->count;
+ conf_info *info = configure_info->info[conf_category];
_mmcam_dbg_log("count[%d], info[%p]", count, info);
- if ((count <= 0) || (!info))
- {
+ if (count <= 0 || !info) {
return total_count;
}
arr = (int*) g_malloc0(count * sizeof(int));
- for( i = 0 ; i < count ; i++ )
- {
- if( info->detail_info[i] == NULL )
- {
+ for (i = 0 ; i < count ; i++) {
+ if (info->detail_info[i] == NULL) {
continue;
}
-
+
name = ((type_element*)(info->detail_info[i]))->name;
-
- if ((fmt = _mmcamcorder_get_format(handle, conf_category, name)) >= 0)
- {
+ fmt = _mmcamcorder_get_format(handle, conf_category, name);
+ if (fmt >= 0) {
arr[total_count++] = fmt;
}
+
_mmcam_dbg_log("name:%s, fmt:%d", name, fmt);
}
}
-
+
*format = arr;
return total_count;
}
-
#include <mm_error.h>
#include <glib.h>
-#define MM_EXIFINFO_USE_BINARY_EXIFDATA 1
-#define JPEG_MAX_SIZE 20000000
-#define JPEG_THUMBNAIL_MAX_SIZE (128*1024)
+#define MM_EXIFINFO_USE_BINARY_EXIFDATA 1
+#define JPEG_MAX_SIZE 20000000
+#define JPEG_THUMBNAIL_MAX_SIZE (128*1024)
+#define JPEG_DATA_OFFSET 2
+#define EXIF_MARKER_SOI_LENGTH 2
+#define EXIF_MARKER_APP1_LENGTH 2
+#define EXIF_APP1_LENGTH 2
+
#if MM_EXIFINFO_USE_BINARY_EXIFDATA
/**
* Exif Binary Data.
}
+#ifdef _MMCAMCORDER_EXIF_GET_JPEG_MARKER_OFFSET
static unsigned long
_exif_get_jpeg_marker_offset (void *jpeg, int jpeg_size, unsigned short marker)
{
mmf_debug (MMF_DEBUG_ERROR,"[%05d][%s]Marker not found.\n", __LINE__, __func__);
return 0UL;
}
+#endif /* _MMCAMCORDER_EXIF_GET_JPEG_MARKER_OFFSET */
ExifData*
int
mm_exif_set_add_entry (ExifData *exif, ExifIfd ifd, ExifTag tag,ExifFormat format,unsigned long components,unsigned char* data)
{
-// mmf_debug (MMF_DEBUG_LOG, "%s()\n", __func__);
- ExifData *ed = (ExifData *)exif;
- ExifEntry *e = NULL;
+ /*mmf_debug (MMF_DEBUG_LOG, "%s()\n", __func__);*/
+ ExifData *ed = (ExifData *)exif;
+ ExifEntry *e = NULL;
- if(exif==NULL || format<=0 || components<=0 || data==NULL)
- {
- mmf_debug (MMF_DEBUG_ERROR,"[%05d][%s] invalid argument exif=%p format=%d, components=%lu data=%p!\n", __LINE__, __func__,exif,format,components,data);
+ if (exif == NULL || format <= 0 || components <= 0 || data == NULL) {
+ mmf_debug(MMF_DEBUG_ERROR,"[%05d][%s] invalid argument exif=%p format=%d, components=%lu data=%p!\n",
+ __LINE__, __func__,exif,format,components,data);
return MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
}
+
/*remove same tag in EXIF*/
- exif_content_remove_entry (ed->ifd[ifd], exif_content_get_entry(ed->ifd[ifd], tag));
+ exif_content_remove_entry(ed->ifd[ifd], exif_content_get_entry(ed->ifd[ifd], tag));
+
/*create new tag*/
- e = exif_entry_new ();
- if(e==NULL)
- {
- mmf_debug (MMF_DEBUG_ERROR,"[%05d][%s] entry create error!\n", __LINE__, __func__);
+ e = exif_entry_new();
+ if (e == NULL) {
+ mmf_debug(MMF_DEBUG_ERROR,"[%05d][%s] entry create error!\n", __LINE__, __func__);
return MM_ERROR_CAMCORDER_LOW_MEMORY;
}
- exif_entry_initialize (e, tag);
- e->tag = tag;
- e->format = format;
- e->components = components;
+ exif_entry_initialize(e, tag);
- if(e->size==0)
- {
- e->data=NULL;
- e->data=malloc(exif_format_get_size(format)*e->components);
- if(!e->data)
- {
+ e->tag = tag;
+ e->format = format;
+ e->components = components;
+
+ if (e->size == 0) {
+ e->data = NULL;
+ e->data = malloc(exif_format_get_size(format) * e->components);
+ if (!e->data) {
exif_entry_unref(e);
return MM_ERROR_CAMCORDER_LOW_MEMORY;
}
- if(format==EXIF_FORMAT_ASCII)
- memset (e->data, '\0', exif_format_get_size(format)*e->components);
+
+ if (format == EXIF_FORMAT_ASCII) {
+ memset(e->data, '\0', exif_format_get_size(format) * e->components);
+ }
}
- e->size = exif_format_get_size(format)*e->components;
+
+ e->size = exif_format_get_size(format) * e->components;
memcpy(e->data,data,e->size);
- exif_content_add_entry (ed->ifd[ifd], e);
+ exif_content_add_entry(ed->ifd[ifd], e);
exif_entry_unref(e);
return MM_ERROR_NONE;
int
mm_exif_create_exif_info (mm_exif_info_t **info)
{
- mm_exif_info_t *x = NULL;
+ mm_exif_info_t *x = NULL;
#if (MM_EXIFINFO_USE_BINARY_EXIFDATA == 0)
- ExifData *ed = NULL;
- unsigned char *eb = NULL;
- unsigned int ebs;
+ ExifData *ed = NULL;
+ unsigned char *eb = NULL;
+ unsigned int ebs;
#endif
-
mmf_debug (MMF_DEBUG_LOG,"[%05d][%s]\n", __LINE__, __func__);
- x = malloc (sizeof (mm_exif_info_t));
- if(!x)
- {
- mmf_debug (MMF_DEBUG_ERROR,"[%05d][%s]malloc error\n", __LINE__, __func__);
+ if (!info) {
+ mmf_debug(MMF_DEBUG_ERROR,"[%05d][%s] NULL pointer\n", __LINE__, __func__);
+ return MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
+ }
+
+ x = malloc(sizeof(mm_exif_info_t));
+ if (!x) {
+ mmf_debug(MMF_DEBUG_ERROR,"[%05d][%s]malloc error\n", __LINE__, __func__);
return MM_ERROR_CAMCORDER_LOW_MEMORY;
- }
+ }
#if MM_EXIFINFO_USE_BINARY_EXIFDATA
- x->data=NULL;
- x->data = malloc (_EXIF_BIN_SIZE_);
- if(!x->data)
- {
- mmf_debug (MMF_DEBUG_ERROR,"[%05d][%s]malloc error\n", __LINE__, __func__);
+ x->data = NULL;
+ x->data = malloc(_EXIF_BIN_SIZE_);
+ if (!x->data) {
+ mmf_debug(MMF_DEBUG_ERROR,"[%05d][%s]malloc error\n", __LINE__, __func__);
free(x);
return MM_ERROR_CAMCORDER_LOW_MEMORY;
- }
- memcpy (x->data, g_exif_bin, _EXIF_BIN_SIZE_);
+ }
+ memcpy(x->data, g_exif_bin, _EXIF_BIN_SIZE_);
x->size = _EXIF_BIN_SIZE_;
#else
- ed = exif_data_new ();
- if(!ed )
- {
- mmf_debug (MMF_DEBUG_ERROR,"[%05d][%s]exif data new error\n", __LINE__, __func__);
+ ed = exif_data_new();
+ if (!ed) {
+ mmf_debug(MMF_DEBUG_ERROR,"[%05d][%s]exif data new error\n", __LINE__, __func__);
return MM_ERROR_CAMCORDER_LOW_MEMORY;
- }
-
- exif_data_set_byte_order (ed, EXIF_BYTE_ORDER_INTEL);
- exif_data_set_data_type (ed, EXIF_DATA_TYPE_COMPRESSED);
- exif_data_set_option (ed, EXIF_DATA_OPTION_FOLLOW_SPECIFICATION);
-
- exif_data_fix (ed);
-
- exif_data_save_data (ed, &eb, &ebs);
- if(eb==NULL)
- {
- mmf_debug (MMF_DEBUG_ERROR,"[%05d][%s]exif_data_save_data error\n", __LINE__, __func__);
+ }
+
+ exif_data_set_byte_order(ed, EXIF_BYTE_ORDER_INTEL);
+ exif_data_set_data_type(ed, EXIF_DATA_TYPE_COMPRESSED);
+ exif_data_set_option(ed, EXIF_DATA_OPTION_FOLLOW_SPECIFICATION);
+
+ exif_data_fix(ed);
+
+ exif_data_save_data(ed, &eb, &ebs);
+ if (eb == NULL) {
+ mmf_debug(MMF_DEBUG_ERROR,"[%05d][%s]exif_data_save_data error\n", __LINE__, __func__);
free(x->data);
free(x);
- exif_data_unref (ed);
+ exif_data_unref(ed);
return MM_ERROR_CAMCORDER_INTERNAL;
- }
- exif_data_unref (ed);
+ }
+ exif_data_unref(ed);
x->data = eb;
x->size = ebs;
#endif
-
*info = x;
- //mmf_debug (MMF_DEBUG_LOG, "%s() Data:%p Size:%d\n", __func__, x->data, x->size);
+ mmf_debug(MMF_DEBUG_LOG, "%s() Data:%p Size:%d\n", __func__, x->data, x->size);
return MM_ERROR_NONE;
}
/* get ExifData from info*/
ed = mm_exif_get_exif_from_info(info);
- ed->data=thumbnail;
+ ed->data = thumbnail;
ed->size = len;
/* set thumbnail data */
if (ret != MM_ERROR_NONE) {
goto exit;
}
-
+
ed->data = NULL;
ed->size = 0;
exif_data_unref (ed);
int
mm_exif_write_exif_jpeg_to_file (char *filename, mm_exif_info_t *info, void *jpeg, int jpeg_len)
{
- FILE *fp = NULL;
- unsigned long offset_jpeg_start;
- unsigned short head[2]={0,};
- unsigned short head_len=0;
- unsigned char *eb = NULL;
- unsigned int ebs;
+ FILE *fp = NULL;
+ unsigned short head[2] = {0,};
+ unsigned short head_len = 0;
+ unsigned char *eb = NULL;
+ unsigned int ebs;
mmf_debug (MMF_DEBUG_LOG,"[%05d][%s]\n", __LINE__, __func__);
eb = info->data;
ebs = info->size;
- /*get DQT*/
- offset_jpeg_start = _exif_get_jpeg_marker_offset (jpeg, jpeg_len, 0xffdb);
- if (offset_jpeg_start == 0) {
- return -1;
- }
-
/*create file*/
fp = fopen (filename, "wb");
if (!fp) {
_exif_set_uint16 (0, &head[1], 0xffe1);
/*set header length*/
_exif_set_uint16 (0, &head_len, (unsigned short)(ebs + 2));
-
+
if(head[0]==0 || head[1]==0 || head_len==0)
{
mmf_debug (MMF_DEBUG_ERROR,"[%05d][%s]setting error\n", __LINE__, __func__);
fclose (fp);
return -1;
}
-
- fwrite (&head[0], 1, 2, fp); /*SOI marker*/
- fwrite (&head[1], 1, 2, fp); /*APP1 marker*/
- fwrite (&head_len, 1, 2, fp); /*length of APP1*/
- fwrite (eb, 1, ebs, fp); /*EXIF*/
- fwrite (jpeg + offset_jpeg_start, 1, jpeg_len - offset_jpeg_start, fp); /*IMAGE*/
+
+ fwrite (&head[0], 1, EXIF_MARKER_SOI_LENGTH, fp); /*SOI marker*/
+ fwrite (&head[1], 1, EXIF_MARKER_APP1_LENGTH, fp); /*APP1 marker*/
+ fwrite (&head_len, 1, EXIF_APP1_LENGTH, fp); /*length of APP1*/
+ fwrite (eb, 1, ebs, fp); /*EXIF*/
+ fwrite (jpeg + JPEG_DATA_OFFSET, 1, jpeg_len - JPEG_DATA_OFFSET, fp); /*IMAGE*/
fclose (fp);
int
mm_exif_write_exif_jpeg_to_memory (void **mem, unsigned int *length, mm_exif_info_t *info, void *jpeg, unsigned int jpeg_len)
{
+ unsigned short head[2] = {0,};
+ unsigned short head_len = 0;
+ unsigned char *eb = NULL;
+ unsigned int ebs;
+
/*output*/
- unsigned char *m = NULL;
- int m_len = 0;
- /**/
- unsigned long offset_jpeg_start;
- unsigned short head[2]={0,};
- unsigned short head_len=0;
- unsigned char *eb = NULL;
- unsigned int ebs;
+ unsigned char *m = NULL;
+ int m_len = 0;
+
mmf_debug (MMF_DEBUG_LOG,"[%05d][%s]\n", __LINE__, __func__);
if(info==NULL || jpeg==NULL)
eb = info->data;
ebs = info->size;
- /*get DQT*/
- offset_jpeg_start = _exif_get_jpeg_marker_offset (jpeg, (int)jpeg_len, 0xffdb);
- if (offset_jpeg_start == 0) {
- return MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
- }
/*length of output image*/
/*SOI + APP1 + length of APP1 + length of EXIF + IMAGE*/
- m_len = 2 + 2 + 2 + ebs + (jpeg_len - offset_jpeg_start);
+ m_len = EXIF_MARKER_SOI_LENGTH + EXIF_MARKER_APP1_LENGTH + EXIF_APP1_LENGTH + ebs + (jpeg_len - JPEG_DATA_OFFSET);
/*alloc output image*/
m = malloc (m_len);
if (!m) {
_exif_set_uint16 (0, &head[1], 0xffe1);
/*set header length*/
_exif_set_uint16 (0, &head_len, (unsigned short)(ebs + 2));
- if(head[0]==0 || head[1]==0 || head_len==0)
- {
+ if (head[0] == 0 || head[1] == 0 || head_len == 0) {
mmf_debug (MMF_DEBUG_ERROR,"[%05d][%s]setting error\n", __LINE__, __func__);
free(m);
return MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
- }
- memcpy (m, &head[0], 2); /*SOI marker*/
- memcpy (m + 2, &head[1], 2); /*APP1 marker*/
- memcpy (m + 2 + 2, &head_len, 2); /*length of APP1*/
- memcpy (m + 2 + 2 + 2, eb, ebs); /*EXIF*/
- memcpy (m + 2 + 2 + 2 + ebs, jpeg + offset_jpeg_start, jpeg_len - offset_jpeg_start); /*IMAGE*/
+ }
+
+ /* Complete JPEG+EXIF */
+ /*SOI marker*/
+ memcpy(m, &head[0], EXIF_MARKER_SOI_LENGTH);
+ /*APP1 marker*/
+ memcpy(m + EXIF_MARKER_SOI_LENGTH,
+ &head[1], EXIF_MARKER_APP1_LENGTH);
+ /*length of APP1*/
+ memcpy(m + EXIF_MARKER_SOI_LENGTH + EXIF_MARKER_APP1_LENGTH,
+ &head_len, EXIF_APP1_LENGTH);
+ /*EXIF*/
+ memcpy(m + EXIF_MARKER_SOI_LENGTH + EXIF_MARKER_APP1_LENGTH + EXIF_APP1_LENGTH,
+ eb, ebs);
+ /*IMAGE*/
+ memcpy(m + EXIF_MARKER_SOI_LENGTH + EXIF_MARKER_APP1_LENGTH + EXIF_APP1_LENGTH + ebs,
+ jpeg + JPEG_DATA_OFFSET, jpeg_len - JPEG_DATA_OFFSET);
+
+ mmf_debug(MMF_DEBUG_LOG,"[%05d][%s] JPEG+EXIF Copy DONE(original:%d, copied:%d)\n",
+ __LINE__, __func__, jpeg_len, jpeg_len - JPEG_DATA_OFFSET);
/*set ouput param*/
*mem = m;
/*G723.1*/ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
/*MP3*/ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
/*OGG*/ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
-/*AAC*/ { 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
+/*AAC*/ { 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
/*WMA*/ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
/*MMF*/ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
/*ADPCM*/ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
-----------------------------------------------------------------------*/
#define USE_AUDIO_CLOCK_TUNE
#define _MMCAMCORDER_WAIT_EOS_TIME 5.0 //sec
-#define _DPRAM_RAW_PCM_LOCATION "/dev/rawPCM0"
/*-----------------------------------------------------------------------
| LOCAL FUNCTION PROTOTYPES: |
* @see __mmcamcorder_create_preview_pipeline()
*/
static gboolean __mmcamcorder_video_dataprobe_preview(GstPad *pad, GstBuffer *buffer, gpointer u_data);
-static gboolean __mmcamcorder_video_dataprobe_vsink(GstPad *pad, GstBuffer *buffer, gpointer u_data);
-static gboolean __mmcamcorder_video_dataprobe_vsink_drop_by_time(GstPad *pad, GstBuffer *buffer, gpointer u_data);
static int __mmcamcorder_get_amrnb_bitrate_mode(int bitrate);
{
int err = MM_ERROR_NONE;
int rotate = 0;
+ int flip = 0;
int fps = 0;
- int slow_fps = 0;
int hold_af = 0;
int UseVideoscale = 0;
- int PictureFormat = 0;
int codectype = 0;
int capture_width = 0;
int capture_height = 0;
+ int capture_jpg_quality = 100;
+ int video_stabilization = 0;
+ int anti_shake = 0;
char *videosrc_name = NULL;
char *err_name = NULL;
}
err = mm_camcorder_get_attributes(handle, &err_name,
- MMCAM_CAMERA_FORMAT, &PictureFormat,
+ MMCAM_CAMERA_FORMAT, &sc->info_image->preview_format,
MMCAM_CAMERA_FPS, &fps,
- "camera-slow-motion-fps", &slow_fps,
MMCAM_CAMERA_ROTATION, &rotate,
+ MMCAM_CAMERA_FLIP, &flip,
+ MMCAM_CAMERA_VIDEO_STABILIZATION, &video_stabilization,
+ MMCAM_CAMERA_ANTI_HANDSHAKE, &anti_shake,
MMCAM_CAPTURE_WIDTH, &capture_width,
MMCAM_CAPTURE_HEIGHT, &capture_height,
MMCAM_IMAGE_ENCODER, &codectype,
+ MMCAM_IMAGE_ENCODER_QUALITY, &capture_jpg_quality,
"camera-hold-af-after-capturing", &hold_af,
NULL);
if (err != MM_ERROR_NONE) {
}
/* Get fourcc from picture format */
- sc->fourcc = _mmcamcorder_get_fourcc(PictureFormat, codectype, hcamcorder->use_zero_copy_format);
+ sc->fourcc = _mmcamcorder_get_fourcc(sc->info_image->preview_format, codectype, hcamcorder->use_zero_copy_format);
/* Get videosrc element and its name from configure */
_mmcamcorder_conf_get_element(hcamcorder->conf_main,
__ta__(" videosrc_capsfilter",
_MMCAMCORDER_ELEMENT_MAKE(sc, _MMCAMCORDER_VIDEOSRC_FILT, "capsfilter", "videosrc_filter", element_list, err);
);
+ __ta__(" videosrc_queue",
+ _MMCAMCORDER_ELEMENT_MAKE(sc, _MMCAMCORDER_VIDEOSRC_QUE, "queue", "videosrc_queue", element_list, err);
+ );
- sc->is_slow = FALSE;
+ /* init high-speed-fps */
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "high-speed-fps", 0);
+
+ /* set capture size, quality and flip setting which were set before mm_camcorder_realize */
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "capture-width", capture_width);
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "capture-height", capture_height);
+ MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "capture-jpg-quality", capture_jpg_quality);
- if (hcamcorder->type == MM_CAMCORDER_MODE_VIDEO) {
- _mmcamcorder_conf_get_value_int(hcamcorder->conf_main,
- CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
- "UseVideoscale",
- &UseVideoscale);
- if (UseVideoscale) {
- int set_width = 0;
- int set_height = 0;
- int scale_width = 0;
- int scale_height = 0;
- int scale_method = 0;
- char *videoscale_name = NULL;
- type_element *VideoscaleElement = NULL;
-
- _mmcamcorder_conf_get_element(hcamcorder->conf_main,
- CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
- "VideoscaleElement",
- &VideoscaleElement);
- _mmcamcorder_conf_get_value_element_name(VideoscaleElement, &videoscale_name);
- __ta__(" videosrc_scale",
- _MMCAMCORDER_ELEMENT_MAKE(sc, _MMCAMCORDER_VIDEOSRC_SCALE, videoscale_name, "videosrc_scale", element_list, err);
- );
- __ta__(" videoscale_capsfilter",
- _MMCAMCORDER_ELEMENT_MAKE(sc, _MMCAMCORDER_VIDEOSRC_VSFLT, "capsfilter", "videosrc_scalefilter", element_list, err);
- );
+ /* set camera flip */
+ _mmcamcorder_set_videosrc_flip(handle, flip);
- _mmcamcorder_conf_get_value_element_int(VideoscaleElement, "width", &scale_width);
- _mmcamcorder_conf_get_value_element_int(VideoscaleElement, "height", &scale_height);
- _mmcamcorder_conf_get_value_element_int(VideoscaleElement, "method", &scale_method);
+ /* set flush cache as FALSE */
+ if (sc->info_image->preview_format == MM_PIXEL_FORMAT_ITLV_JPEG_UYVY) {
+ MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "flush-cache", FALSE);
+ }
- if (rotate == MM_VIDEO_INPUT_ROTATION_90 ||
- rotate == MM_VIDEO_INPUT_ROTATION_270) {
- set_width = scale_height;
- set_height = scale_width;
- } else {
- set_width = scale_width;
- set_height = scale_height;
- }
+ /* set video stabilization mode */
+ _mmcamcorder_set_videosrc_stabilization(handle, video_stabilization);
- _mmcam_dbg_log("VideoSRC Scale[%dx%d], Method[%d]", set_width, set_height, scale_method);
+ /* set anti handshake mode */
+ _mmcamcorder_set_videosrc_anti_shake(handle, anti_shake);
- caps = gst_caps_new_simple("video/x-raw-yuv",
- "format", GST_TYPE_FOURCC, sc->fourcc,
- "width", G_TYPE_INT, set_width,
- "height", G_TYPE_INT, set_height,
- NULL);
- MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_VSFLT].gst, "caps", caps);
- MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SCALE].gst, "method", scale_method);
+ _mmcamcorder_conf_get_value_int(hcamcorder->conf_main,
+ CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
+ "UseVideoscale",
+ &UseVideoscale);
+ if (UseVideoscale) {
+ int set_width = 0;
+ int set_height = 0;
+ int scale_width = 0;
+ int scale_height = 0;
+ int scale_method = 0;
+ char *videoscale_name = NULL;
+ type_element *VideoscaleElement = NULL;
- gst_caps_unref(caps);
- caps = NULL;
- }
+ _mmcamcorder_conf_get_element(hcamcorder->conf_main,
+ CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
+ "VideoscaleElement",
+ &VideoscaleElement);
+ _mmcamcorder_conf_get_value_element_name(VideoscaleElement, &videoscale_name);
+ __ta__(" videosrc_scale",
+ _MMCAMCORDER_ELEMENT_MAKE(sc, _MMCAMCORDER_VIDEOSRC_SCALE, videoscale_name, "videosrc_scale", element_list, err);
+ );
+ __ta__(" videoscale_capsfilter",
+ _MMCAMCORDER_ELEMENT_MAKE(sc, _MMCAMCORDER_VIDEOSRC_VSFLT, "capsfilter", "videosrc_scalefilter", element_list, err);
+ );
- if (slow_fps > 0) {
- sc->is_slow = TRUE;
- MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "high-speed-fps", fps);
+ _mmcamcorder_conf_get_value_element_int(VideoscaleElement, "width", &scale_width);
+ _mmcamcorder_conf_get_value_element_int(VideoscaleElement, "height", &scale_height);
+ _mmcamcorder_conf_get_value_element_int(VideoscaleElement, "method", &scale_method);
+
+ if (rotate == MM_VIDEO_INPUT_ROTATION_90 ||
+ rotate == MM_VIDEO_INPUT_ROTATION_270) {
+ set_width = scale_height;
+ set_height = scale_width;
+ } else {
+ set_width = scale_width;
+ set_height = scale_height;
}
+
+ _mmcam_dbg_log("VideoSRC Scale[%dx%d], Method[%d]", set_width, set_height, scale_method);
+
+ caps = gst_caps_new_simple("video/x-raw-yuv",
+ "format", GST_TYPE_FOURCC, sc->fourcc,
+ "width", G_TYPE_INT, set_width,
+ "height", G_TYPE_INT, set_height,
+ NULL);
+ MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_VSFLT].gst, "caps", caps);
+ MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SCALE].gst, "method", scale_method);
+
+ gst_caps_unref(caps);
+ caps = NULL;
+ }
+
+ if (sc->is_modified_rate) {
+ MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "high-speed-fps", fps);
}
__ta__(" tee",
int camera_width = 0;
int camera_height = 0;
int rotate = 0;
- int camera_format = MM_PIXEL_FORMAT_NV12;
+ int flip = 0;
int UseVideoscale = 0, EnableConvertedSC = 0;
int scale_method = 0;
char* videosink_name = NULL;
err = mm_camcorder_get_attributes(handle, &err_name,
MMCAM_CAMERA_WIDTH, &camera_width,
MMCAM_CAMERA_HEIGHT, &camera_height,
- MMCAM_CAMERA_FORMAT, &camera_format,
MMCAM_DISPLAY_RECT_WIDTH, &rect_width,
MMCAM_DISPLAY_RECT_HEIGHT, &rect_height,
MMCAM_DISPLAY_ROTATION, &rotate,
+ MMCAM_DISPLAY_FLIP, &flip,
"enable-converted-stream-callback", &EnableConvertedSC,
NULL);
if (err != MM_ERROR_NONE) {
if (EnableConvertedSC ||
!strcmp(videosink_name, "evasimagesink") ||
!strcmp(videosink_name, "ximagesink")) {
- if (camera_format == MM_PIXEL_FORMAT_NV12 ||
- camera_format == MM_PIXEL_FORMAT_NV12T) {
+ GstElementFactory *factory = gst_element_factory_find("fimcconvert");
+
+ if ((sc->fourcc == GST_MAKE_FOURCC('S','N','2','1') ||
+ sc->fourcc == GST_MAKE_FOURCC('S','N','1','2') ||
+ sc->fourcc == GST_MAKE_FOURCC('S','T','1','2') ||
+ sc->fourcc == GST_MAKE_FOURCC('S','4','2','0')) &&
+ factory) {
int set_rotate = 0;
+ int set_flip = 0;
+
+ gst_object_unref(factory);
+ factory = NULL;
__ta__(" videosink_fimcconvert",
_MMCAMCORDER_ELEMENT_MAKE(sc, _MMCAMCORDER_VIDEOSINK_CLS, "fimcconvert", NULL, element_list, err);
);
- if (rotate < MM_DISPLAY_ROTATION_FLIP_HORZ) {
+ /* set rotate */
+ if (rotate > MM_VIDEO_INPUT_ROTATION_NONE &&
+ rotate < MM_VIDEO_INPUT_ROTATION_NUM) {
set_rotate = rotate * 90;
} else {
set_rotate = 0;
}
}
- _mmcam_dbg_log("Fimcconvert set values - %dx%d, rotate: %d", rect_width, rect_height, set_rotate);
+ /* set flip */
+ switch (flip) {
+ case MM_FLIP_HORIZONTAL:
+ set_flip = FIMCCONVERT_FLIP_HORIZONTAL;
+ break;
+ case MM_FLIP_VERTICAL:
+ set_flip = FIMCCONVERT_FLIP_VERTICAL;
+ break;
+ case MM_FLIP_BOTH: /* both flip has same effect with 180 rotation */
+ set_rotate = (set_rotate + 180) % 360;
+ case MM_FLIP_NONE:
+ default:
+ set_flip = FIMCCONVERT_FLIP_NONE;
+ break;
+ }
+
+ _mmcam_dbg_log("Fimcconvert set values - %dx%d, rotate: %d, flip: %d",
+ rect_width, rect_height, set_rotate, set_flip);
+
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_CLS].gst, "src-width", rect_width);
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_CLS].gst, "src-height", rect_height);
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_CLS].gst, "rotate", set_rotate);
+ MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_CLS].gst, "flip", set_flip);
} else {
+ if (factory) {
+ gst_object_unref(factory);
+ factory = NULL;
+ }
+
__ta__(" videosink_ffmpegcolorspace",
_MMCAMCORDER_ELEMENT_MAKE(sc, _MMCAMCORDER_VIDEOSINK_CLS, "ffmpegcolorspace", NULL, element_list, err);
);
_MMCAMCORDER_ELEMENT_MAKE(sc, _MMCAMCORDER_VIDEOSINK_SINK, videosink_name, NULL, element_list, err);
);
- if (!strcmp(videosink_name, "xvimagesink") ||
- !strcmp(videosink_name, "ximagesink") ||
- !strcmp(videosink_name, "evasimagesink")) {
+ if (!strcmp(videosink_name, "xvimagesink") || !strcmp(videosink_name, "ximagesink") ||
+ !strcmp(videosink_name, "evasimagesink") || !strcmp(videosink_name, "evaspixmapsink")) {
if (_mmcamcorder_videosink_window_set(handle, sc->VideosinkElement) != MM_ERROR_NONE) {
_mmcam_dbg_err("_mmcamcorder_videosink_window_set error");
err = MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
}
-int _mmcamcorder_create_encodesink_bin(MMHandleType handle)
+int _mmcamcorder_create_encodesink_bin(MMHandleType handle, MMCamcorderEncodebinProfile profile)
{
int err = MM_ERROR_NONE;
int result = 0;
int channel = 0;
- int profile = 0;
int audio_enc = 0;
int v_bitrate = 0;
int a_bitrate = 0;
);
/* check element availability */
- err = mm_camcorder_get_attributes(handle, &err_name,
- MMCAM_MODE, &profile,
- MMCAM_AUDIO_ENCODER, &audio_enc,
- MMCAM_AUDIO_CHANNEL, &channel,
- MMCAM_VIDEO_ENCODER_BITRATE, &v_bitrate,
- MMCAM_AUDIO_ENCODER_BITRATE, &a_bitrate,
- NULL);
- if (err != MM_ERROR_NONE) {
- _mmcam_dbg_warn("Get attrs fail. (%s:%x)", err_name, err);
- SAFE_FREE (err_name);
- return err;
- }
+ mm_camcorder_get_attributes(handle, &err_name,
+ MMCAM_AUDIO_ENCODER, &audio_enc,
+ MMCAM_AUDIO_CHANNEL, &channel,
+ MMCAM_VIDEO_ENCODER_BITRATE, &v_bitrate,
+ MMCAM_AUDIO_ENCODER_BITRATE, &a_bitrate,
+ NULL);
_mmcam_dbg_log("Profile[%d]", profile);
/* Set information */
- if (profile == MM_CAMCORDER_MODE_VIDEO) {
+ if (profile == MM_CAMCORDER_ENCBIN_PROFILE_VIDEO) {
str_profile = "VideoProfile";
str_aac = "VideoAutoAudioConvert";
str_aar = "VideoAutoAudioResample";
str_acs = "VideoAutoColorSpace";
- } else if (profile == MM_CAMCORDER_MODE_AUDIO) {
+ } else if (profile == MM_CAMCORDER_ENCBIN_PROFILE_AUDIO) {
str_profile = "AudioProfile";
str_aac = "AudioAutoAudioConvert";
str_aar = "AudioAutoAudioResample";
str_acs = "AudioAutoColorSpace";
- } else if (profile == MM_CAMCORDER_MODE_IMAGE) {
+ } else if (profile == MM_CAMCORDER_ENCBIN_PROFILE_IMAGE) {
str_profile = "ImageProfile";
str_aac = "ImageAutoAudioConvert";
str_aar = "ImageAutoAudioResample";
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "use-video-toggle", FALSE);
/* Codec */
- if (profile == MM_CAMCORDER_MODE_VIDEO) {
+ if (profile == MM_CAMCORDER_ENCBIN_PROFILE_VIDEO) {
int use_venc_queue = 0;
VideoencElement = _mmcamcorder_get_type_element(handle, MM_CAM_VIDEO_ENCODER);
if (use_venc_queue) {
_MMCAMCORDER_ENCODEBIN_ELMGET(sc, _MMCAMCORDER_ENCSINK_VENC_QUE, "use-venc-queue", err);
}
-
- if (!strcmp(gst_element_venc_name, "ari_h263enc")) {
- MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "auto-colorspace", TRUE);
- }
}
- if (sc->is_slow == FALSE) {
- if (profile == MM_CAMCORDER_MODE_AUDIO || profile == MM_CAMCORDER_MODE_VIDEO) {
- int use_aenc_queue =0;
+ if (sc->audio_disable == FALSE &&
+ profile != MM_CAMCORDER_ENCBIN_PROFILE_IMAGE) {
+ int use_aenc_queue =0;
- AudioencElement = _mmcamcorder_get_type_element(handle, MM_CAM_AUDIO_ENCODER);
- if (!AudioencElement) {
- _mmcam_dbg_err("Fail to get type element");
- err = MM_ERROR_CAMCORDER_RESOURCE_CREATION;
- goto pipeline_creation_error;
- }
+ AudioencElement = _mmcamcorder_get_type_element(handle, MM_CAM_AUDIO_ENCODER);
+ if (!AudioencElement) {
+ _mmcam_dbg_err("Fail to get type element");
+ err = MM_ERROR_CAMCORDER_RESOURCE_CREATION;
+ goto pipeline_creation_error;
+ }
- _mmcamcorder_conf_get_value_element_name(AudioencElement, &gst_element_aenc_name);
+ _mmcamcorder_conf_get_value_element_name(AudioencElement, &gst_element_aenc_name);
- MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "aenc-name", gst_element_aenc_name);
- _MMCAMCORDER_ENCODEBIN_ELMGET(sc, _MMCAMCORDER_ENCSINK_AENC, "audio-encode", err);
+ MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "aenc-name", gst_element_aenc_name);
+ _MMCAMCORDER_ENCODEBIN_ELMGET(sc, _MMCAMCORDER_ENCSINK_AENC, "audio-encode", err);
- if (audio_enc == MM_AUDIO_CODEC_AMR && channel == 2) {
- caps = gst_caps_new_simple("audio/x-raw-int",
- "channels", G_TYPE_INT, 1,
- NULL);
- MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "auto-audio-convert", TRUE);
- MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "acaps", caps);
- gst_caps_unref (caps);
- caps = NULL;
- }
+ if (audio_enc == MM_AUDIO_CODEC_AMR && channel == 2) {
+ caps = gst_caps_new_simple("audio/x-raw-int",
+ "channels", G_TYPE_INT, 1,
+ NULL);
+ MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "auto-audio-convert", TRUE);
+ MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "acaps", caps);
+ gst_caps_unref (caps);
+ caps = NULL;
+ }
- if (audio_enc == MM_AUDIO_CODEC_OGG) {
- caps = gst_caps_new_simple("audio/x-raw-int",
- NULL);
- MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "auto-audio-convert", TRUE);
- MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "acaps", caps);
- gst_caps_unref (caps);
- caps = NULL;
- _mmcam_dbg_log("***** MM_AUDIO_CODEC_OGG : setting audio/x-raw-int ");
- }
+ if (audio_enc == MM_AUDIO_CODEC_OGG) {
+ caps = gst_caps_new_simple("audio/x-raw-int",
+ NULL);
+ MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "auto-audio-convert", TRUE);
+ MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "acaps", caps);
+ gst_caps_unref (caps);
+ caps = NULL;
+ _mmcam_dbg_log("***** MM_AUDIO_CODEC_OGG : setting audio/x-raw-int ");
+ }
- _mmcamcorder_conf_get_value_int(hcamcorder->conf_main,
- CONFIGURE_CATEGORY_MAIN_RECORD,
- "UseAudioEncoderQueue",
- &use_aenc_queue);
- if (use_aenc_queue) {
- _MMCAMCORDER_ENCODEBIN_ELMGET(sc, _MMCAMCORDER_ENCSINK_AENC_QUE, "use-aenc-queue", err);
- }
+ _mmcamcorder_conf_get_value_int(hcamcorder->conf_main,
+ CONFIGURE_CATEGORY_MAIN_RECORD,
+ "UseAudioEncoderQueue",
+ &use_aenc_queue);
+ if (use_aenc_queue) {
+ _MMCAMCORDER_ENCODEBIN_ELMGET(sc, _MMCAMCORDER_ENCSINK_AENC_QUE, "use-aenc-queue", err);
}
}
- if (profile == MM_CAMCORDER_MODE_IMAGE) {
+ if (profile == MM_CAMCORDER_ENCBIN_PROFILE_IMAGE) {
ImageencElement = _mmcamcorder_get_type_element(handle, MM_CAM_IMAGE_ENCODER);
if (!ImageencElement) {
_mmcam_dbg_err("Fail to get type element");
}
/* Mux */
- if (profile == MM_CAMCORDER_MODE_AUDIO || profile == MM_CAMCORDER_MODE_VIDEO) {
+ if (profile != MM_CAMCORDER_ENCBIN_PROFILE_IMAGE) {
MuxElement = _mmcamcorder_get_type_element(handle, MM_CAM_FILE_FORMAT);
if (!MuxElement) {
_mmcam_dbg_err("Fail to get type element");
}
/* Sink */
- if (profile == MM_CAMCORDER_MODE_AUDIO || profile == MM_CAMCORDER_MODE_VIDEO) {
+ if (profile != MM_CAMCORDER_ENCBIN_PROFILE_IMAGE) {
+ /* for recording */
_mmcamcorder_conf_get_element(hcamcorder->conf_main,
CONFIGURE_CATEGORY_MAIN_RECORD,
"RecordsinkElement",
);
}
- if (profile == MM_CAMCORDER_MODE_VIDEO) {
+ if (profile == MM_CAMCORDER_ENCBIN_PROFILE_VIDEO) {
/* video encoder attribute setting */
if (v_bitrate > 0) {
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_ENCSINK_VENC].gst, "bitrate", v_bitrate);
_mmcamcorder_conf_set_value_element_property(sc->element[_MMCAMCORDER_ENCSINK_VENC].gst, VideoencElement);
}
- if (sc->is_slow == FALSE) {
- if (profile == MM_CAMCORDER_MODE_AUDIO || profile == MM_CAMCORDER_MODE_VIDEO) {
- /* audio encoder attribute setting */
- if (a_bitrate > 0) {
- switch (audio_enc) {
- case MM_AUDIO_CODEC_AMR:
- result = __mmcamcorder_get_amrnb_bitrate_mode(a_bitrate);
-
- _mmcam_dbg_log("Set AMR encoder[%s] mode [%d]", gst_element_aenc_name, result);
-
- if(!strcmp(gst_element_aenc_name, "ari_amrnbenc")) {
- MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_ENCSINK_AENC].gst, "mode", result);
- } else {
- MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_ENCSINK_AENC].gst, "band-mode", result);
- }
- break;
- case MM_AUDIO_CODEC_AAC:
- _mmcam_dbg_log("Set AAC encoder[%s] bitrate [%d]", gst_element_aenc_name, a_bitrate);
- MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_ENCSINK_AENC].gst, "bitrate", a_bitrate);
- break;
- default:
- _mmcam_dbg_log("Audio codec is not AMR or AAC... you need to implement setting function for audio encoder bit-rate");
- break;
- }
- } else {
- _mmcam_dbg_warn("Setting bitrate is too small, so skip setting. Use DEFAULT value.");
+ if (sc->audio_disable == FALSE &&
+ profile != MM_CAMCORDER_ENCBIN_PROFILE_IMAGE) {
+ /* audio encoder attribute setting */
+ if (a_bitrate > 0) {
+ switch (audio_enc) {
+ case MM_AUDIO_CODEC_AMR:
+ result = __mmcamcorder_get_amrnb_bitrate_mode(a_bitrate);
+ _mmcam_dbg_log("Set AMR encoder[%s] mode [%d]", gst_element_aenc_name, result);
+ MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_ENCSINK_AENC].gst, "band-mode", result);
+ break;
+ case MM_AUDIO_CODEC_AAC:
+ _mmcam_dbg_log("Set AAC encoder[%s] bitrate [%d]", gst_element_aenc_name, a_bitrate);
+ MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_ENCSINK_AENC].gst, "bitrate", a_bitrate);
+ break;
+ default:
+ _mmcam_dbg_log("Audio codec is not AMR or AAC... you need to implement setting function for audio encoder bit-rate");
+ break;
}
- _mmcamcorder_conf_set_value_element_property( sc->element[_MMCAMCORDER_ENCSINK_AENC].gst, AudioencElement );
+ } else {
+ _mmcam_dbg_warn("Setting bitrate is too small, so skip setting. Use DEFAULT value.");
}
+
+ _mmcamcorder_conf_set_value_element_property(sc->element[_MMCAMCORDER_ENCSINK_AENC].gst, AudioencElement);
}
_mmcam_dbg_log("Element creation complete");
_mmcam_dbg_log("Element add complete");
- if (profile == MM_CAMCORDER_MODE_VIDEO) {
+ if (profile == MM_CAMCORDER_ENCBIN_PROFILE_VIDEO) {
pad = gst_element_get_request_pad(sc->element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "video");
if (gst_element_add_pad(sc->element[_MMCAMCORDER_ENCSINK_BIN].gst, gst_ghost_pad_new("video_sink0", pad)) < 0) {
gst_object_unref(pad);
gst_object_unref(pad);
pad = NULL;
- if (sc->is_slow == FALSE) {
+ if (sc->audio_disable == FALSE) {
pad = gst_element_get_request_pad(sc->element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "audio");
if (gst_element_add_pad(sc->element[_MMCAMCORDER_ENCSINK_BIN].gst, gst_ghost_pad_new("audio_sink0", pad)) < 0) {
gst_object_unref(pad);
gst_object_unref(pad);
pad = NULL;
}
- } else if (profile == MM_CAMCORDER_MODE_AUDIO) {
+ } else if (profile == MM_CAMCORDER_ENCBIN_PROFILE_AUDIO) {
pad = gst_element_get_request_pad(sc->element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "audio");
if (gst_element_add_pad(sc->element[_MMCAMCORDER_ENCSINK_BIN].gst, gst_ghost_pad_new("audio_sink0", pad)) < 0) {
gst_object_unref(pad);
_MM_GST_PAD_LINK_UNREF(srcpad, sinkpad, err, pipeline_creation_error);
/* Set data probe function */
- srcpad = gst_element_get_static_pad(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "src");
+ srcpad = gst_element_get_static_pad(sc->element[_MMCAMCORDER_VIDEOSRC_QUE].gst, "src");
MMCAMCORDER_ADD_BUFFER_PROBE(srcpad, _MMCAMCORDER_HANDLER_PREVIEW,
__mmcamcorder_video_dataprobe_preview, hcamcorder);
gst_object_unref(srcpad);
srcpad = NULL;
- if (hcamcorder->type == MM_CAMCORDER_MODE_IMAGE) {
- sinkpad = gst_element_get_static_pad(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "sink");
- MMCAMCORDER_ADD_BUFFER_PROBE(sinkpad, _MMCAMCORDER_HANDLER_PREVIEW,
- __mmcamcorder_video_dataprobe_vsink, hcamcorder);
- } else if (hcamcorder->type == MM_CAMCORDER_MODE_VIDEO) {
- sinkpad = gst_element_get_static_pad(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "sink");
- MMCAMCORDER_ADD_BUFFER_PROBE(sinkpad, _MMCAMCORDER_HANDLER_PREVIEW,
- __mmcamcorder_video_dataprobe_vsink_drop_by_time, hcamcorder);
- }
- gst_object_unref(sinkpad);
- sinkpad = NULL;
+ bus = gst_pipeline_get_bus(GST_PIPELINE(sc->element[_MMCAMCORDER_MAIN_PIPE].gst));
/* Register message callback */
- bus = gst_pipeline_get_bus(GST_PIPELINE(sc->element[_MMCAMCORDER_MAIN_PIPE].gst));
- hcamcorder->pipeline_cb_event_id = gst_bus_add_watch(bus, _mmcamcorder_pipeline_cb_message, hcamcorder);
+ hcamcorder->pipeline_cb_event_id = gst_bus_add_watch(bus, _mmcamcorder_pipeline_cb_message, (gpointer)hcamcorder);
+
+ /* set sync handler */
+ gst_bus_set_sync_handler(bus, _mmcamcorder_pipeline_bus_sync_callback, (gpointer)hcamcorder);
+
gst_object_unref(bus);
bus = NULL;
sc->cam_stability_count = _MMCAMCORDER_CAMSTABLE_COUNT;
}
- if (hcamcorder->type == MM_CAMCORDER_MODE_IMAGE) {
+ if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
_MMCamcorderImageInfo *info = NULL;
- info = sc->info;
+ info = sc->info_image;
if (info->resolution_change == TRUE) {
_mmcam_dbg_log("open toggle of stillshot sink.");
MMCAMCORDER_G_OBJECT_SET( sc->element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "block", FALSE);
int visible = 0;
int rotation = MM_DISPLAY_ROTATION_NONE;
int rotation_degree = 0;
- int display_device = MM_DISPLAY_DEVICE_MAINLCD;
- int display_mode = 0;
+ int flip = MM_FLIP_NONE;
+ int display_mode = MM_DISPLAY_MODE_DEFAULT;
int display_geometry_method = MM_DISPLAY_METHOD_LETTER_BOX;
int origin_size = 0;
int zoom_attr = 0;
int zoom_level = 0;
+ int do_scaling = FALSE;
int *overlay = NULL;
gulong xid;
char *err_name = NULL;
MMCAM_DISPLAY_RECT_WIDTH, &retwidth,
MMCAM_DISPLAY_RECT_HEIGHT, &retheight,
MMCAM_DISPLAY_ROTATION, &rotation,
+ MMCAM_DISPLAY_FLIP, &flip,
MMCAM_DISPLAY_VISIBLE, &visible,
MMCAM_DISPLAY_HANDLE, (void**)&overlay, &size,
- MMCAM_DISPLAY_DEVICE, &display_device,
+ MMCAM_DISPLAY_MODE, &display_mode,
MMCAM_DISPLAY_GEOMETRY_METHOD, &display_geometry_method,
MMCAM_DISPLAY_SCALE, &zoom_attr,
+ MMCAM_DISPLAY_EVAS_DO_SCALING, &do_scaling,
NULL);
);
- if (err != MM_ERROR_NONE) {
- _mmcam_dbg_warn("Get display attrs fail. (%s:%x)", err_name, err);
- SAFE_FREE(err_name);
- return err;
- }
_mmcam_dbg_log("(overlay=%p, size=%d)", overlay, size);
_mmcamcorder_conf_get_value_element_name(VideosinkElement, &videosink_name);
- /* Set xid */
- if (!strcmp(videosink_name, "xvimagesink") || !strcmp(videosink_name, "ximagesink")) {
+ /* Set display handle */
+ if (!strcmp(videosink_name, "xvimagesink") ||
+ !strcmp(videosink_name, "ximagesink")) {
if (overlay) {
xid = *overlay;
_mmcam_dbg_log("xid = %lu )", xid);
gst_x_overlay_set_xwindow_id(GST_X_OVERLAY(vsink), xid);
} else {
- _mmcam_dbg_warn( "Set xid as 0.. but, it's not recommended." );
+ _mmcam_dbg_warn("Handle is NULL. Set xid as 0.. but, it's not recommended.");
gst_x_overlay_set_xwindow_id(GST_X_OVERLAY(vsink), 0);
}
_mmcam_dbg_log("%s set: display_geometry_method[%d],origin-size[%d],visible[%d],rotate[enum:%d]",
videosink_name, display_geometry_method, origin_size, visible, rotation);
- } else if (!strcmp(videosink_name, "evasimagesink")) {
+ } else if (!strcmp(videosink_name, "evasimagesink") ||
+ !strcmp(videosink_name, "evaspixmapsink")) {
+ _mmcam_dbg_log("videosink : %s, handle : %p", videosink_name, overlay);
if (overlay) {
- MMCAMCORDER_G_OBJECT_SET( vsink, "evas-object", overlay );
+ MMCAMCORDER_G_OBJECT_SET(vsink, "evas-object", overlay);
+ MMCAMCORDER_G_OBJECT_SET(vsink, "origin-size", !do_scaling);
} else {
- _mmcam_dbg_err("Evas Object pointer is NULL");
+ _mmcam_dbg_err("display handle(eavs object) is NULL");
return MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
}
} else {
}
/* Set attribute */
- if (!strcmp(videosink_name, "xvimagesink")) {
- switch (rotation) {
- case MM_DISPLAY_ROTATION_NONE :
- rotation_degree = 0;
- break;
- case MM_DISPLAY_ROTATION_90 :
- rotation_degree = 1;
- break;
- case MM_DISPLAY_ROTATION_180 :
- rotation_degree = 2;
- break;
- case MM_DISPLAY_ROTATION_270 :
- rotation_degree = 3;
- break;
- default:
- _mmcam_dbg_warn("Unsupported rotation value. set as default(0).");
- rotation_degree = 0;
- break;
+ if (!strcmp(videosink_name, "xvimagesink") ||
+ !strcmp(videosink_name, "evaspixmapsink")) {
+
+ if (!strcmp(videosink_name, "xvimagesink")) {
+ /* set rotation */
+ switch (rotation) {
+ case MM_DISPLAY_ROTATION_NONE :
+ rotation_degree = 0;
+ break;
+ case MM_DISPLAY_ROTATION_90 :
+ rotation_degree = 1;
+ break;
+ case MM_DISPLAY_ROTATION_180 :
+ rotation_degree = 2;
+ break;
+ case MM_DISPLAY_ROTATION_270 :
+ rotation_degree = 3;
+ break;
+ default:
+ _mmcam_dbg_warn("Unsupported rotation value. set as default(0).");
+ rotation_degree = 0;
+ break;
+ }
+ MMCAMCORDER_G_OBJECT_SET(vsink, "rotate", rotation_degree);
+
+ /* set flip */
+ MMCAMCORDER_G_OBJECT_SET(vsink, "flip", flip);
+
+ _mmcam_dbg_log("set videosink[%s] rotate %d, flip %d",
+ videosink_name, rotation_degree, flip);
}
switch (zoom_attr) {
break;
}
- switch (display_device) {
- case MM_DISPLAY_DEVICE_TVOUT:
- display_mode = 2;
- break;
- case MM_DISPLAY_DEVICE_MAINLCD_AND_TVOUT:
- display_mode = 1;
- break;
- case MM_DISPLAY_DEVICE_MAINLCD:
- case MM_DISPLAY_DEVICE_SUBLCD:
- case MM_DISPLAY_DEVICE_MAINLCD_AND_SUBLCD:
- default:
- display_mode = 3;
- break;
- }
-
MMCAMCORDER_G_OBJECT_SET(vsink, "display-geometry-method", display_geometry_method);
MMCAMCORDER_G_OBJECT_SET(vsink, "display-mode", display_mode);
MMCAMCORDER_G_OBJECT_SET(vsink, "visible", visible);
- MMCAMCORDER_G_OBJECT_SET(vsink, "rotate", rotation_degree);
MMCAMCORDER_G_OBJECT_SET(vsink, "zoom", zoom_level);
if (display_geometry_method == MM_DISPLAY_METHOD_CUSTOM_ROI) {
_MMCamcorderSubContext *sc = NULL;
_MMCamcorderKPIMeasure *kpi = NULL;
+ mmf_return_val_if_fail(buffer, FALSE);
+ mmf_return_val_if_fail(GST_BUFFER_DATA(buffer), FALSE);
mmf_return_val_if_fail(hcamcorder, TRUE);
sc = MMF_CAMCORDER_SUBCONTEXT(u_data);
}
}
- return TRUE;
-}
-
-
-static gboolean __mmcamcorder_video_dataprobe_vsink(GstPad *pad, GstBuffer *buffer, gpointer u_data)
-{
- mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(u_data);
-
- mmf_return_val_if_fail(hcamcorder, FALSE);
-
- if (buffer == NULL || GST_BUFFER_DATA(buffer) == NULL) {
- _mmcam_dbg_err("Null buffer!!");
- return FALSE;
- }
-
+ /* video stream callback */
if (hcamcorder->vstream_cb && buffer) {
GstCaps *caps = NULL;
GstStructure *structure = NULL;
return TRUE;
}
+ /* clear stream data structure */
+ memset(&stream, 0x0, sizeof(MMCamcorderVideoStreamDataType));
+
structure = gst_caps_get_structure( caps, 0 );
gst_structure_get_int(structure, "width", &(stream.width));
gst_structure_get_int(structure, "height", &(stream.height));
return TRUE;
}
- stream.data = (void *)GST_BUFFER_DATA(buffer);
- stream.length = GST_BUFFER_SIZE(buffer);
+ /* set size and timestamp */
+ stream.length_total = GST_BUFFER_SIZE(buffer);
stream.timestamp = (unsigned int)(GST_BUFFER_TIMESTAMP(buffer)/1000000); /* nano sec -> mili sec */
+ /* set data pointers */
+ if (stream.format == MM_PIXEL_FORMAT_NV12 || stream.format == MM_PIXEL_FORMAT_I420) {
+ if (hcamcorder->use_zero_copy_format && GST_BUFFER_MALLOCDATA(buffer)) {
+ SCMN_IMGB *scmn_imgb = (SCMN_IMGB *)GST_BUFFER_MALLOCDATA(buffer);
+
+ if (stream.format == MM_PIXEL_FORMAT_NV12) {
+ stream.data_type = MM_CAM_STREAM_DATA_YUV420SP;
+ stream.num_planes = 2;
+ stream.data.yuv420sp.y = scmn_imgb->a[0];
+ stream.data.yuv420sp.length_y = stream.width * stream.height;
+ stream.data.yuv420sp.uv = scmn_imgb->a[1];
+ stream.data.yuv420sp.length_uv = stream.data.yuv420sp.length_y >> 1;
+
+ _mmcam_dbg_log("SN12[num_planes:%d] [Y]p:0x%x,size:%d [UV]p:0x%x,size:%d",
+ stream.num_planes,
+ stream.data.yuv420sp.y, stream.data.yuv420sp.length_y,
+ stream.data.yuv420sp.uv, stream.data.yuv420sp.length_uv);
+ } else {
+ stream.data_type = MM_CAM_STREAM_DATA_YUV420P;
+ stream.num_planes = 3;
+ stream.data.yuv420p.y = scmn_imgb->a[0];
+ stream.data.yuv420p.length_y = stream.width * stream.height;
+ stream.data.yuv420p.u = scmn_imgb->a[1];
+ stream.data.yuv420p.length_u = stream.data.yuv420p.length_y >> 2;
+ stream.data.yuv420p.v = scmn_imgb->a[2];
+ stream.data.yuv420p.length_v = stream.data.yuv420p.length_u;
+
+ _mmcam_dbg_log("S420[num_planes:%d] [Y]p:0x%x,size:%d [U]p:0x%x,size:%d [V]p:0x%x,size:%d",
+ stream.num_planes,
+ stream.data.yuv420p.y, stream.data.yuv420p.length_y,
+ stream.data.yuv420p.u, stream.data.yuv420p.length_u,
+ stream.data.yuv420p.v, stream.data.yuv420p.length_v);
+ }
+ } else {
+ if (stream.format == MM_PIXEL_FORMAT_NV12) {
+ stream.data_type = MM_CAM_STREAM_DATA_YUV420SP;
+ stream.num_planes = 2;
+ stream.data.yuv420sp.y = GST_BUFFER_DATA(buffer);
+ stream.data.yuv420sp.length_y = stream.width * stream.height;
+ stream.data.yuv420sp.uv = stream.data.yuv420sp.y + stream.data.yuv420sp.length_y;
+ stream.data.yuv420sp.length_uv = stream.data.yuv420sp.length_y >> 1;
+
+ _mmcam_dbg_log("NV12[num_planes:%d] [Y]p:0x%x,size:%d [UV]p:0x%x,size:%d",
+ stream.num_planes,
+ stream.data.yuv420sp.y, stream.data.yuv420sp.length_y,
+ stream.data.yuv420sp.uv, stream.data.yuv420sp.length_uv);
+ } else {
+ stream.data_type = MM_CAM_STREAM_DATA_YUV420P;
+ stream.num_planes = 3;
+ stream.data.yuv420p.y = GST_BUFFER_DATA(buffer);
+ stream.data.yuv420p.length_y = stream.width * stream.height;
+ stream.data.yuv420p.u = stream.data.yuv420p.y + stream.data.yuv420p.length_y;
+ stream.data.yuv420p.length_u = stream.data.yuv420p.length_y >> 2;
+ stream.data.yuv420p.v = stream.data.yuv420p.u + stream.data.yuv420p.length_u;
+ stream.data.yuv420p.length_v = stream.data.yuv420p.length_u;
+
+ _mmcam_dbg_log("I420[num_planes:%d] [Y]p:0x%x,size:%d [U]p:0x%x,size:%d [V]p:0x%x,size:%d",
+ stream.num_planes,
+ stream.data.yuv420p.y, stream.data.yuv420p.length_y,
+ stream.data.yuv420p.u, stream.data.yuv420p.length_u,
+ stream.data.yuv420p.v, stream.data.yuv420p.length_v);
+ }
+ }
+ } else {
+ if (stream.format == MM_PIXEL_FORMAT_YUYV ||
+ stream.format == MM_PIXEL_FORMAT_UYVY ||
+ stream.format == MM_PIXEL_FORMAT_422P ||
+ stream.format == MM_PIXEL_FORMAT_ITLV_JPEG_UYVY) {
+ stream.data_type = MM_CAM_STREAM_DATA_YUV422;
+ stream.data.yuv422.yuv = GST_BUFFER_DATA(buffer);
+ stream.data.yuv422.length_yuv = stream.length_total;
+ } else {
+ stream.data_type = MM_CAM_STREAM_DATA_YUV420;
+ stream.data.yuv420.yuv = GST_BUFFER_DATA(buffer);
+ stream.data.yuv420.length_yuv = stream.length_total;
+ }
+
+ stream.num_planes = 1;
+
+ _mmcam_dbg_log("%c%c%c%c[num_planes:%d] [0]p:0x%x,size:%d",
+ fourcc, fourcc>>8, fourcc>>16, fourcc>>24,
+ stream.num_planes, stream.data.yuv420.yuv, stream.data.yuv420.length_yuv);
+ }
+
+ /* call application callback */
_MMCAMCORDER_LOCK_VSTREAM_CALLBACK(hcamcorder);
if (hcamcorder->vstream_cb) {
hcamcorder->vstream_cb(&stream, hcamcorder->vstream_cb_param);
_MMCAMCORDER_UNLOCK_VSTREAM_CALLBACK(hcamcorder);
}
- return TRUE;
-}
-
-
-static gboolean __mmcamcorder_video_dataprobe_vsink_drop_by_time(GstPad *pad, GstBuffer *buffer, gpointer u_data)
-{
- static GstClockTime next_time = 0;
- static GstClockTime current_time = 0;
- GstClockTime interval = 30 * GST_MSECOND; //30ms(about 33 fps)
-
- mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(u_data);
- _MMCamcorderSubContext *sc = NULL;
-
- mmf_return_val_if_fail(hcamcorder, TRUE);
-
- sc = MMF_CAMCORDER_SUBCONTEXT(u_data);
- mmf_return_val_if_fail(sc, TRUE);
-
-/*
- _mmcam_dbg_log("VIDEO SRC time stamp : [%" GST_TIME_FORMAT "]", GST_TIME_ARGS(GST_BUFFER_TIMESTAMP(buffer)));
-*/
-
- /* Call video stream callback */
- if (__mmcamcorder_video_dataprobe_vsink(pad, buffer, u_data) == FALSE) {
- _mmcam_dbg_warn( "__mmcamcorder_video_dataprobe_vsink failed." );
- return FALSE;
+ /* Do force flush cache */
+ if (sc->info_image->preview_format == MM_PIXEL_FORMAT_ITLV_JPEG_UYVY) {
+ MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "force-flush-cache", FALSE);
}
- if (sc->is_slow) {
- if (GST_BUFFER_TIMESTAMP(buffer) < current_time) {
- next_time = 0;
- }
- current_time = GST_BUFFER_TIMESTAMP(buffer);
-
- if (current_time >= next_time) {
- next_time = current_time + interval;
- return TRUE;
- } else {
- return FALSE;
- }
- } else {
- return TRUE;
- }
+ return TRUE;
}
/* Get videosink name */
_mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name);
if (!strcmp(videosink_name, "xvimagesink")) {
- if (display_rotate < MM_DISPLAY_ROTATION_NONE ||
- display_rotate > MM_DISPLAY_ROTATION_270) {
- display_rotate = 0;
- _mmcam_dbg_log( "Rotate: Out of range. set as default(0)...");
- }
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst,
"rotate", display_rotate);
_mmcam_dbg_log("Set display-rotate [%d] done.", display_rotate);
}
+bool _mmcamcorder_set_display_flip(MMHandleType handle, int display_flip)
+{
+ char* videosink_name = NULL;
+
+ mmf_camcorder_t *hcamcorder = NULL;
+ _MMCamcorderSubContext *sc = NULL;
+
+ hcamcorder = MMF_CAMCORDER(handle);
+ mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
+
+ sc = MMF_CAMCORDER_SUBCONTEXT(handle);
+ mmf_return_val_if_fail(sc, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
+ mmf_return_val_if_fail(sc->element, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
+
+ if (sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst) {
+ /* Get videosink name */
+ _mmcamcorder_conf_get_value_element_name(sc->VideosinkElement, &videosink_name);
+ if (!strcmp(videosink_name, "xvimagesink")) {
+ MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst,
+ "flip", display_flip);
+ _mmcam_dbg_log("Set display flip [%d] done.", display_flip);
+ return TRUE;
+ } else {
+ _mmcam_dbg_warn("videosink[%s] does not support DISPLAY_FLIP", videosink_name);
+ return FALSE;
+ }
+ } else {
+ _mmcam_dbg_err("Videosink element is null");
+ return FALSE;
+ }
+}
+
+
bool _mmcamcorder_set_videosrc_rotation(MMHandleType handle, int videosrc_rotate)
{
int width = 0;
int set_height = 0;
int set_rotate = 0;
int fps = 0;
- int slow_fps = 0;
- int set_fps = 0;
gboolean do_set_caps = FALSE;
GstCaps *caps = NULL;
MMCAM_CAMERA_WIDTH, &width,
MMCAM_CAMERA_HEIGHT, &height,
MMCAM_CAMERA_FPS, &fps,
- "camera-slow-motion-fps", &slow_fps,
NULL);
_mmcamcorder_conf_get_value_int_array(hcamcorder->conf_ctrl,
return FALSE;
}
- /* Define width, height, rotate and flip in caps */
- if (input_index->default_value == MM_VIDEO_DEVICE_CAMERA1) {
- MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "vflip", 1);
- } else {
- MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "vflip", 0);
- }
- MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "hflip", 0);
+ /* Interleaved format does not support rotation */
+ if (sc->info_image->preview_format != MM_PIXEL_FORMAT_ITLV_JPEG_UYVY) {
+ /* store videosrc rotation */
+ sc->videosrc_rotate = videosrc_rotate;
- /* This will be applied when rotate is 0, 90, 180, 270 if rear camera.
- This will be applied when rotate is 0, 180 if front camera. */
- set_rotate = videosrc_rotate * 90;
+ /* Define width, height and rotate in caps */
- if (videosrc_rotate == MM_VIDEO_INPUT_ROTATION_90 ||
- videosrc_rotate == MM_VIDEO_INPUT_ROTATION_270) {
- set_width = height;
- set_height = width;
+ /* This will be applied when rotate is 0, 90, 180, 270 if rear camera.
+ This will be applied when rotate is 0, 180 if front camera. */
+ set_rotate = videosrc_rotate * 90;
- if (input_index->default_value == MM_VIDEO_DEVICE_CAMERA1) {
- if (videosrc_rotate == MM_VIDEO_INPUT_ROTATION_90) {
- set_rotate = 270;
- } else {
- set_rotate = 90;
+ if (videosrc_rotate == MM_VIDEO_INPUT_ROTATION_90 ||
+ videosrc_rotate == MM_VIDEO_INPUT_ROTATION_270) {
+ set_width = height;
+ set_height = width;
+ if (input_index->default_value == MM_VIDEO_DEVICE_CAMERA1) {
+ if (videosrc_rotate == MM_VIDEO_INPUT_ROTATION_90) {
+ set_rotate = 270;
+ } else {
+ set_rotate = 90;
+ }
}
+ } else {
+ set_width = width;
+ set_height = height;
}
} else {
+ sc->videosrc_rotate = MM_VIDEO_INPUT_ROTATION_NONE;
+ set_rotate = 0;
set_width = width;
set_height = height;
- if (videosrc_rotate == MM_VIDEO_INPUT_ROTATION_FLIP_HORZ) {
- set_rotate = 0;
- MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "hflip", 1);
- } else if (videosrc_rotate == MM_VIDEO_INPUT_ROTATION_FLIP_VERT) {
- set_rotate = 0;
- if (input_index->default_value == MM_VIDEO_DEVICE_CAMERA1) {
- MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "vflip", 0);
- } else {
- MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "vflip", 1);
- }
- }
+ _mmcam_dbg_warn("ITLV format doe snot support INPUT ROTATE. Ignore ROTATE[%d]",
+ videosrc_rotate);
}
- set_fps = sc->is_slow ? slow_fps : fps;
+ /* correct size because ITLV does not support QCIF */
+ if (input_index->default_value == MM_VIDEO_DEVICE_CAMERA0 &&
+ sc->fourcc == GST_MAKE_FOURCC('I','T','L','V')) {
+ if ((set_width == 176 && set_height == 144) ||
+ (set_width == 144 && set_height == 176)) {
+ set_width = set_width << 1;
+ set_height = set_height << 1;
+ _mmcam_dbg_log("ITLV format is not supported QCIF, so we set CIF(%dx%d)",
+ set_width, set_height);
+ }
+ }
MMCAMCORDER_G_OBJECT_GET(sc->element[_MMCAMCORDER_VIDEOSRC_FILT].gst, "caps", &caps);
if (caps) {
gst_structure_get_int(structure, "fps", &caps_fps);
gst_structure_get_int(structure, "rotate", &caps_rotate);
if (set_width == caps_width && set_height == caps_height &&
- set_rotate == caps_rotate && set_fps == caps_fps) {
+ set_rotate == caps_rotate && fps == caps_fps) {
_mmcam_dbg_log("No need to replace caps.");
} else {
_mmcam_dbg_log("something is different. set new one...");
"format", GST_TYPE_FOURCC, sc->fourcc,
"width", G_TYPE_INT, set_width,
"height", G_TYPE_INT, set_height,
- "framerate", GST_TYPE_FRACTION, set_fps, 1,
+ "framerate", GST_TYPE_FRACTION, fps, 1,
"rotate", G_TYPE_INT, set_rotate,
NULL);
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_FILT].gst, "caps", caps);
caps = NULL;
_mmcam_dbg_log("vidoesrc new caps set. format[%c%c%c%c],width[%d],height[%d],fps[%d],rotate[%d]",
(sc->fourcc), (sc->fourcc)>>8, (sc->fourcc)>>16, (sc->fourcc)>>24,
- set_width, set_height, set_fps, set_rotate);
+ set_width, set_height, fps, set_rotate);
}
return TRUE;
}
+
+
+bool _mmcamcorder_set_videosrc_flip(MMHandleType handle, int videosrc_flip)
+{
+ mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
+ _MMCamcorderSubContext *sc = NULL;
+ type_int_array *input_index = NULL;
+
+ mmf_return_val_if_fail(hcamcorder, FALSE);
+
+ sc = MMF_CAMCORDER_SUBCONTEXT(handle);
+ mmf_return_val_if_fail(sc, TRUE);
+
+ _mmcam_dbg_log("Set FLIP %d", videosrc_flip);
+
+ if (sc->element && sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst) {
+ int hflip = 0;
+ int vflip = 0;
+
+ /* Interleaved format does not support FLIP */
+ if (sc->info_image->preview_format != MM_PIXEL_FORMAT_ITLV_JPEG_UYVY) {
+ _mmcamcorder_conf_get_value_int_array(hcamcorder->conf_ctrl,
+ CONFIGURE_CATEGORY_CTRL_CAMERA,
+ "InputIndex",
+ &input_index );
+
+ hflip = (videosrc_flip & MM_FLIP_HORIZONTAL) == MM_FLIP_HORIZONTAL;
+ vflip = (videosrc_flip & MM_FLIP_VERTICAL) == MM_FLIP_VERTICAL;
+
+ _mmcam_dbg_log("videosrc flip H:%d, V:%d", hflip, vflip);
+
+ MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "hflip", hflip);
+ MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "vflip", vflip);
+ } else {
+ _mmcam_dbg_warn("ITLV format does not support FLIP. Ignore FLIP[%d]",
+ videosrc_flip);
+ }
+ } else {
+ _mmcam_dbg_warn("element is NULL");
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+
+bool _mmcamcorder_set_videosrc_anti_shake(MMHandleType handle, int anti_shake)
+{
+ GstCameraControl *control = NULL;
+ _MMCamcorderSubContext *sc = NULL;
+ GstElement *v_src = NULL;
+
+ int set_value = 0;
+
+ mmf_return_val_if_fail(handle, FALSE);
+
+ sc = MMF_CAMCORDER_SUBCONTEXT(handle);
+ mmf_return_val_if_fail(sc, TRUE);
+
+ v_src = sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst;
+
+ if (!v_src) {
+ _mmcam_dbg_warn("videosrc element is NULL");
+ return FALSE;
+ }
+
+ set_value = _mmcamcorder_convert_msl_to_sensor(handle, MM_CAM_CAMERA_ANTI_HANDSHAKE, anti_shake);
+
+ /* set anti-shake with camera control */
+ if (!GST_IS_CAMERA_CONTROL(v_src)) {
+ _mmcam_dbg_warn("Can't cast Video source into camera control.");
+ return FALSE;
+ }
+
+ control = GST_CAMERA_CONTROL(v_src);
+ if (gst_camera_control_set_ahs(control, set_value)) {
+ _mmcam_dbg_log("Succeed in operating anti-handshake. value[%d]", set_value);
+ return TRUE;
+ } else {
+ _mmcam_dbg_warn("Failed to operate anti-handshake. value[%d]", set_value);
+ }
+
+ return FALSE;
+}
+
+
+bool _mmcamcorder_set_videosrc_stabilization(MMHandleType handle, int stabilization)
+{
+ _MMCamcorderSubContext *sc = NULL;
+ GstElement *v_src = NULL;
+
+ mmf_return_val_if_fail(handle, FALSE);
+
+ sc = MMF_CAMCORDER_SUBCONTEXT(handle);
+ mmf_return_val_if_fail(sc, TRUE);
+
+ v_src = sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst;
+
+ if (!v_src) {
+ _mmcam_dbg_warn("videosrc element is NULL");
+ return FALSE;
+ }
+
+ /* check property of videosrc element - support VDIS */
+ if(g_object_class_find_property(G_OBJECT_GET_CLASS(G_OBJECT(v_src)), "enable-vdis-mode")) {
+ int camera_format =MM_PIXEL_FORMAT_INVALID;
+ int camera_width = 0;
+ int camera_height = 0;
+
+ if (stabilization == MM_CAMCORDER_VIDEO_STABILIZATION_ON) {
+ _mmcam_dbg_log("ENABLE video stabilization");
+
+ /* VDIS mode only supports NV12 and [720p or 1080p] */
+ mm_camcorder_get_attributes(handle, NULL,
+ MMCAM_CAMERA_FORMAT, &camera_format,
+ MMCAM_CAMERA_WIDTH, &camera_width,
+ MMCAM_CAMERA_HEIGHT, &camera_height,
+ NULL);
+ if (camera_format == MM_PIXEL_FORMAT_NV12 &&
+ camera_width >= 1280 &&
+ camera_height >= 720) {
+ _mmcam_dbg_log("preview format %d, size %dx%d, ENABLE video stabilization",
+ camera_format, camera_width, camera_height, stabilization);
+ /* set vdis mode */
+ g_object_set(G_OBJECT(v_src),
+ "enable-vdis-mode", TRUE,
+ NULL);
+ } else {
+ _mmcam_dbg_warn("invalid preview format %d or size %dx%d",
+ camera_format, camera_width, camera_height);
+ return FALSE;
+ }
+ } else {
+ /* set vdis mode */
+ g_object_set(G_OBJECT(v_src),
+ "enable-vdis-mode", FALSE,
+ NULL);
+
+ _mmcam_dbg_log("DISABLE video stabilization");
+ }
+ } else if (stabilization == MM_CAMCORDER_VIDEO_STABILIZATION_ON) {
+ _mmcam_dbg_err("no property for video stabilization, so can not set ON");
+ return FALSE;
+ } else {
+ _mmcam_dbg_warn("no property for video stabilization");
+ }
+
+ return TRUE;
+}
+
/*---------------------------------------------------------------------------------------
| LOCAL VARIABLE DEFINITIONS for internal |
---------------------------------------------------------------------------------------*/
-
-//#define _MMCAM_USING_CAPTUREMODE
-#define __MMCAMCORDER_CMD_ITERATE_MAX 3
+#define __MMCAMCORDER_CMD_ITERATE_MAX 3
+#define __MMCAMCORDER_SECURITY_HANDLE_DEFAULT -1
+#define __MMCAMCORDER_SET_GST_STATE_TIMEOUT 5
/*---------------------------------------------------------------------------------------
| LOCAL FUNCTION PROTOTYPES: |
static int __mmcamcorder_asm_get_event_type(int sessionType);
static void __mmcamcorder_force_stop(mmf_camcorder_t *hcamcorder);
static void __mmcamcorder_force_resume(mmf_camcorder_t *hcamcorder);
-ASM_cb_result_t _mmcamcorder_asm_callback(int handle, ASM_event_sources_t event_src,
- ASM_sound_commands_t command,
- unsigned int sound_status, void *cb_data);
-
+ASM_cb_result_t _mmcamcorder_asm_callback_sh(int handle, ASM_event_sources_t event_src,
+ ASM_sound_commands_t command,
+ unsigned int sound_status, void *cb_data);
+ASM_cb_result_t _mmcamcorder_asm_callback_ex(int handle, ASM_event_sources_t event_src,
+ ASM_sound_commands_t command,
+ unsigned int sound_status, void *cb_data);
+
+#ifdef _MMCAMCORDER_USE_SET_ATTR_CB
static gboolean __mmcamcorder_set_attr_to_camsensor_cb(gpointer data);
-
+#endif /* _MMCAMCORDER_USE_SET_ATTR_CB */
/*=======================================================================================
| FUNCTION DEFINITIONS |
{
int ret = MM_ERROR_NONE;
int UseConfCtrl = 0;
- int sessionType = MM_SESSION_TYPE_EXCLUSIVE;
+ int sessionType = MM_SESSION_TYPE_SHARE;
int errorcode = MM_ERROR_NONE;
int rcmd_fmt_capture = MM_PIXEL_FORMAT_YUYV;
int rcmd_fmt_recording = MM_PIXEL_FORMAT_NV12;
int rcmd_dpy_rotation = MM_DISPLAY_ROTATION_270;
+ int play_capture_sound = TRUE;
+ int camera_device_count = MM_VIDEO_DEVICE_NUM;
+ int camera_facing_direction = MM_CAMCORDER_CAMERA_FACING_DIRECTION_REAR;
char *err_attr_name = NULL;
char *ConfCtrlFile = NULL;
mmf_camcorder_t *hcamcorder = NULL;
ASM_resource_t mm_resource = ASM_RESOURCE_NONE;
+ type_element *EvasSurfaceElement = NULL;
_mmcam_dbg_log("Entered");
- mmf_return_val_if_fail( handle, MM_ERROR_CAMCORDER_INVALID_ARGUMENT );
+ mmf_return_val_if_fail(handle, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
+ mmf_return_val_if_fail(info, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
/* Create mmf_camcorder_t handle and initialize every variable */
hcamcorder = (mmf_camcorder_t *)malloc(sizeof(mmf_camcorder_t));
memset(hcamcorder, 0x00, sizeof(mmf_camcorder_t));
/* init values */
- hcamcorder->type=0;
- hcamcorder->state=MM_CAMCORDER_STATE_NULL;
- hcamcorder->sub_context=NULL;
- hcamcorder->target_state=MM_CAMCORDER_STATE_NULL;
+ hcamcorder->type = 0;
+ hcamcorder->state = MM_CAMCORDER_STATE_NONE;
+ hcamcorder->sub_context = NULL;
+ hcamcorder->target_state = MM_CAMCORDER_STATE_NULL;
/* thread - for g_mutex_new() */
if (!g_thread_supported()) {
/* Check and register ASM */
if (MM_ERROR_NONE != _mm_session_util_read_type(-1, &sessionType)) {
- _mmcam_dbg_warn("Read _mm_session_util_read_type failed. use default \"exclusive\" type");
- sessionType = MM_SESSION_TYPE_EXCLUSIVE;
- if (MM_ERROR_NONE != mm_session_init(sessionType)) {
- _mmcam_dbg_err("mm_session_init() failed");
- ret = MM_ERROR_POLICY_INTERNAL;
- goto _ERR_DEFAULT_VALUE_INIT;
- }
+ _mmcam_dbg_log("_mm_session_util_read_type Fail. but keep going...");
+ sessionType = MM_SESSION_TYPE_SHARE;
}
+
+ /* Call will not be interrupted. so does not need callback function */
if ((sessionType != MM_SESSION_TYPE_CALL) && (sessionType != MM_SESSION_TYPE_VIDEOCALL)) {
- int asm_session_type = ASM_EVENT_NONE;
- int asm_handle;
int pid = -1; /* process id of itself */
- asm_session_type = __mmcamcorder_asm_get_event_type( sessionType );
- /* Call will not be interrupted. so does not need callback function */
- if (!ASM_register_sound(pid, &asm_handle, asm_session_type, ASM_STATE_NONE,
- (ASM_sound_cb_t)_mmcamcorder_asm_callback,
+ /* set SHARE session */
+ if (!ASM_register_sound(pid, &(hcamcorder->asm_handle_sh), ASM_EVENT_SHARE_MMCAMCORDER, ASM_STATE_NONE,
+ (ASM_sound_cb_t)_mmcamcorder_asm_callback_sh,
(void*)hcamcorder, mm_resource, &errorcode)) {
- _mmcam_dbg_err("ASM_register_sound() failed[%x]", errorcode);
+ _mmcam_dbg_err("SHARE ASM_register_sound() failed[%x]", errorcode);
ret = MM_ERROR_POLICY_INTERNAL;
goto _ERR_DEFAULT_VALUE_INIT;
}
- hcamcorder->asm_handle = asm_handle;
+
+ /* set EXCLUSIVE session */
+ if (!ASM_register_sound(pid, &(hcamcorder->asm_handle_ex), ASM_EVENT_EXCLUSIVE_MMCAMCORDER, ASM_STATE_NONE,
+ (ASM_sound_cb_t)_mmcamcorder_asm_callback_ex,
+ (void*)hcamcorder, mm_resource, &errorcode)) {
+ _mmcam_dbg_err("EXCLUSIVE ASM_register_sound() failed[%x]", errorcode);
+ ret = MM_ERROR_POLICY_INTERNAL;
+ goto _ERR_DEFAULT_VALUE_INIT;
+ }
+
+ _mmcam_dbg_log("ASM handle - SHARE %d, EXCLUSIVE %d",
+ hcamcorder->asm_handle_sh, hcamcorder->asm_handle_ex);
}
/* Get Camera Configure information from Camcorder INI file */
goto _ERR_AUDIO_BLOCKED;
}
- __ta__(" _mmcamcorder_alloc_attribute",
- hcamcorder->attributes= _mmcamcorder_alloc_attribute((MMHandleType)hcamcorder, info);
+ __ta__(" _mmcamcorder_alloc_attribute",
+ hcamcorder->attributes = _mmcamcorder_alloc_attribute((MMHandleType)hcamcorder, info);
);
if (!(hcamcorder->attributes)) {
_mmcam_dbg_err("_mmcamcorder_create::alloc attribute error.");
if (ret != MM_ERROR_NONE) {
_mmcam_dbg_warn("converting table initialize error!!");
}
+
+ /* Get device info, recommend preview fmt and display rotation from INI */
+ _mmcamcorder_conf_get_value_int(hcamcorder->conf_ctrl,
+ CONFIGURE_CATEGORY_CTRL_CAMERA,
+ "RecommendPreviewFormatCapture",
+ &rcmd_fmt_capture);
+
+ _mmcamcorder_conf_get_value_int(hcamcorder->conf_ctrl,
+ CONFIGURE_CATEGORY_CTRL_CAMERA,
+ "RecommendPreviewFormatRecord",
+ &rcmd_fmt_recording);
+
+ _mmcamcorder_conf_get_value_int(hcamcorder->conf_ctrl,
+ CONFIGURE_CATEGORY_CTRL_CAMERA,
+ "RecommendDisplayRotation",
+ &rcmd_dpy_rotation);
+
+ _mmcamcorder_conf_get_value_int(hcamcorder->conf_main,
+ CONFIGURE_CATEGORY_MAIN_CAPTURE,
+ "PlayCaptureSound",
+ &play_capture_sound);
+
+ _mmcamcorder_conf_get_value_int(hcamcorder->conf_main,
+ CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
+ "DeviceCount",
+ &camera_device_count);
+
+ _mmcamcorder_conf_get_value_int(hcamcorder->conf_ctrl,
+ CONFIGURE_CATEGORY_CTRL_CAMERA,
+ "FacingDirection",
+ &camera_facing_direction);
+
+ _mmcam_dbg_log("Recommend fmt[cap:%d,rec:%d], dpy rot[%d], cap snd[%d], dev cnt[%d], cam facing dir[%d]",
+ rcmd_fmt_capture, rcmd_fmt_recording, rcmd_dpy_rotation,
+ play_capture_sound, camera_device_count, camera_facing_direction);
+
+ mm_camcorder_set_attributes((MMHandleType)hcamcorder, &err_attr_name,
+ MMCAM_CAMERA_DEVICE_COUNT, camera_device_count,
+ MMCAM_CAMERA_FACING_DIRECTION, camera_facing_direction,
+ MMCAM_RECOMMEND_PREVIEW_FORMAT_FOR_CAPTURE, rcmd_fmt_capture,
+ MMCAM_RECOMMEND_PREVIEW_FORMAT_FOR_RECORDING, rcmd_fmt_recording,
+ MMCAM_RECOMMEND_DISPLAY_ROTATION, rcmd_dpy_rotation,
+ "capture-sound-enable", play_capture_sound,
+ NULL);
+ if (err_attr_name) {
+ _mmcam_dbg_err("Set %s FAILED.", err_attr_name);
+ free(err_attr_name);
+ err_attr_name = NULL;
+ }
+
+ /* Get UseZeroCopyFormat value from INI */
+ _mmcamcorder_conf_get_value_int(hcamcorder->conf_main,
+ CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
+ "UseZeroCopyFormat",
+ &(hcamcorder->use_zero_copy_format));
+ _mmcam_dbg_log("UseZeroCopyFormat : %d", hcamcorder->use_zero_copy_format);
}
else
{
goto _ERR_ALLOC_ATTRIBUTE;
}
- /* Get recommend preview format and display rotation from INI */
- rcmd_fmt_capture = MM_PIXEL_FORMAT_YUYV;
- rcmd_fmt_recording = MM_PIXEL_FORMAT_NV12;
- rcmd_dpy_rotation = MM_DISPLAY_ROTATION_270;
- err_attr_name = NULL;
-
- _mmcamcorder_conf_get_value_int(hcamcorder->conf_ctrl,
- CONFIGURE_CATEGORY_CTRL_CAMERA,
- "RecommendPreviewFormatCapture",
- &rcmd_fmt_capture);
-
- _mmcamcorder_conf_get_value_int(hcamcorder->conf_ctrl,
- CONFIGURE_CATEGORY_CTRL_CAMERA,
- "RecommendPreviewFormatRecord",
- &rcmd_fmt_recording);
-
- _mmcamcorder_conf_get_value_int(hcamcorder->conf_ctrl,
- CONFIGURE_CATEGORY_CTRL_CAMERA,
- "RecommendDisplayRotation",
- &rcmd_dpy_rotation);
-
- _mmcam_dbg_log("Recommend prv[capture:%d,recording:%d], rot[%d]",
- rcmd_fmt_capture, rcmd_fmt_recording, rcmd_dpy_rotation);
-
- ret = mm_camcorder_set_attributes((MMHandleType)hcamcorder, &err_attr_name,
- MMCAM_RECOMMEND_PREVIEW_FORMAT_FOR_CAPTURE, rcmd_fmt_capture,
- MMCAM_RECOMMEND_PREVIEW_FORMAT_FOR_RECORDING, rcmd_fmt_recording,
- MMCAM_RECOMMEND_DISPLAY_ROTATION, rcmd_dpy_rotation,
- NULL);
- if (ret != MM_ERROR_NONE) {
- _mmcam_dbg_err( "Set %s FAILED.", err_attr_name );
- if (err_attr_name != NULL) {
- free( err_attr_name );
- err_attr_name = NULL;
- }
-
- goto _ERR_ALLOC_ATTRIBUTE;
- }
-
- /* Get UseZeroCopyFormat value from INI */
- _mmcamcorder_conf_get_value_int(hcamcorder->conf_main,
- CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
- "UseZeroCopyFormat",
- &(hcamcorder->use_zero_copy_format));
- _mmcam_dbg_log("UseZeroCopyFormat : %d", hcamcorder->use_zero_copy_format);
-
-
/* Make some attributes as read-only type */
__ta__( " _mmcamcorder_lock_readonly_attributes",
_mmcamcorder_lock_readonly_attributes((MMHandleType)hcamcorder);
_mmcamcorder_create_command_loop((MMHandleType)hcamcorder);
}
+ /* Get videosink name for evas surface */
+ _mmcamcorder_conf_get_element(hcamcorder->conf_main,
+ CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT,
+ "VideosinkElementEvas",
+ &EvasSurfaceElement);
+ if (EvasSurfaceElement) {
+ int attr_index = 0;
+ char *evassink_name = NULL;
+ mmf_attribute_t *item_evassink_name = NULL;
+ mmf_attrs_t *attrs = (mmf_attrs_t *)MMF_CAMCORDER_ATTRS(hcamcorder);
+
+ _mmcamcorder_conf_get_value_element_name(EvasSurfaceElement, &evassink_name);
+ mm_attrs_get_index((MMHandleType)attrs, MMCAM_DISPLAY_EVAS_SURFACE_SINK, &attr_index);
+ item_evassink_name = &attrs->items[attr_index];
+ mmf_attribute_set_string(item_evassink_name, evassink_name, strlen(evassink_name));
+ mmf_attribute_commit(item_evassink_name);
+
+ _mmcam_dbg_log("Evassink name : %s", evassink_name);
+ }
+
+ /* get shutter sound policy */
+ vconf_get_int(VCONFKEY_CAMERA_SHUTTER_SOUND_POLICY, &hcamcorder->shutter_sound_policy);
+ _mmcam_dbg_log("current shutter sound policy : %d", hcamcorder->shutter_sound_policy);
+
/* Set initial state */
_mmcamcorder_set_state((MMHandleType)hcamcorder, MM_CAMCORDER_STATE_NULL);
_mmcam_dbg_log("_mmcamcorder_set_state");
_ERR_AUDIO_BLOCKED:
/* unregister audio session manager */
{
- sessionType = MM_SESSION_TYPE_EXCLUSIVE;
errorcode = MM_ERROR_NONE;
if (MM_ERROR_NONE != _mm_session_util_read_type(-1, &sessionType)) {
- sessionType = MM_SESSION_TYPE_EXCLUSIVE;
+ _mmcam_dbg_log("_mm_session_util_read_type Fail. but keep going...");
+ sessionType = MM_SESSION_TYPE_SHARE;
}
if((sessionType != MM_SESSION_TYPE_CALL) && (sessionType != MM_SESSION_TYPE_VIDEOCALL)) {
- int asm_session_type = __mmcamcorder_asm_get_event_type( sessionType );
- if (!ASM_unregister_sound(hcamcorder->asm_handle, asm_session_type, &errorcode)) {
- _mmcam_dbg_err("ASM_unregister_sound() failed(hdl:%p, stype:%d, err:%x)",
- (void*)hcamcorder->asm_handle, sessionType, errorcode);
+ /* unregister SHARE session */
+ if (!ASM_unregister_sound(hcamcorder->asm_handle_sh, ASM_EVENT_SHARE_MMCAMCORDER, &errorcode)) {
+ _mmcam_dbg_err("ASM_unregister_sound() SHARE failed(hdl:%p, stype:%d, err:%x)",
+ (void*)hcamcorder->asm_handle_sh, sessionType, errorcode);
+ }
+ /* unregister EXCLUSIVE session */
+ if (!ASM_unregister_sound(hcamcorder->asm_handle_ex, ASM_EVENT_EXCLUSIVE_MMCAMCORDER, &errorcode)) {
+ _mmcam_dbg_err("ASM_unregister_sound() EXCLUSIVE failed(hdl:%p, stype:%d, err:%x)",
+ (void*)hcamcorder->asm_handle_ex, sessionType, errorcode);
}
}
}
int state = MM_CAMCORDER_STATE_NONE;
int state_FROM = MM_CAMCORDER_STATE_NULL;
int state_TO = MM_CAMCORDER_STATE_NONE;
- int asm_session_type = ASM_EVENT_EXCLUSIVE_MMCAMCORDER;
int sessionType = MM_SESSION_TYPE_SHARE;
int errorcode = MM_ERROR_NONE;
+
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
- _MMCamcorderMsgItem msg;
_mmcam_dbg_log("");
goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
}
- /* Release sound handle */
- __ta__("_mmcamcorder_sound_finalize",
- ret = _mmcamcorder_sound_finalize(handle);
- );
- _mmcam_dbg_log("sound finalize [%d]", ret);
-
/* Release SubContext and pipeline */
if (hcamcorder->sub_context) {
if (hcamcorder->sub_context->element) {
/* Unregister ASM */
if (MM_ERROR_NONE != _mm_session_util_read_type(-1, &sessionType)) {
- _mmcam_dbg_err("_mm_session_util_read_type Fail");
+ _mmcam_dbg_log("_mm_session_util_read_type Fail. but keep going...");
+ sessionType = MM_SESSION_TYPE_SHARE;
}
if ((sessionType != MM_SESSION_TYPE_CALL) && (sessionType != MM_SESSION_TYPE_VIDEOCALL)) {
- asm_session_type = __mmcamcorder_asm_get_event_type(sessionType);
- if (!ASM_unregister_sound(hcamcorder->asm_handle, asm_session_type, &errorcode)) {
- _mmcam_dbg_err("ASM_unregister_sound() failed(hdl:%p, stype:%d, err:%x)",
- (void*)hcamcorder->asm_handle, sessionType, errorcode);
+ /* unregister SHARE session */
+ if (!ASM_unregister_sound(hcamcorder->asm_handle_sh, ASM_EVENT_SHARE_MMCAMCORDER, &errorcode)) {
+ _mmcam_dbg_err("SHARE ASM_unregister_sound() failed(hdl:%p, err:%x)",
+ (void*)hcamcorder->asm_handle_sh, errorcode);
+ }
+
+ /* unregister EXCLUSIVE session */
+ if (!ASM_unregister_sound(hcamcorder->asm_handle_ex, ASM_EVENT_EXCLUSIVE_MMCAMCORDER, &errorcode)) {
+ _mmcam_dbg_err("EXCLUSIVE ASM_unregister_sound() failed(hdl:%p, err:%x)",
+ (void*)hcamcorder->asm_handle_ex, errorcode);
}
}
_MMCAMCORDER_UNLOCK_CMD(hcamcorder);
_ERR_CAMCORDER_CMD_PRECON:
- /*send message*/
if (hcamcorder) {
- _mmcam_dbg_err("Destroy fail (%d, %d)", hcamcorder->type, state);
- msg.id = MM_MESSAGE_CAMCORDER_STATE_CHANGED;
- msg.param.state.previous = state;
- msg.param.state.current = state;
- msg.param.state.code = ret;
- _mmcamcroder_send_message(handle, &msg);
- } else {
- _mmcam_dbg_err("Destroy fail (%d)", state);
+ _mmcam_dbg_err("Destroy fail (type %d, state %d)", hcamcorder->type, state);
}
+ _mmcam_dbg_err("Destroy fail (ret %x)", ret);
+
return ret;
}
int state = MM_CAMCORDER_STATE_NONE;
int state_FROM = MM_CAMCORDER_STATE_NULL;
int state_TO = MM_CAMCORDER_STATE_READY;
- int sessionType = MM_SESSION_TYPE_EXCLUSIVE;
+ int sessionType = MM_SESSION_TYPE_SHARE;
int errorcode = MM_ERROR_NONE;
int display_surface_type = MM_DISPLAY_SURFACE_X;
+ double motion_rate = _MMCAMCORDER_DEFAULT_RECORDING_MOTION_RATE;
char *videosink_element_type = NULL;
char *videosink_name = NULL;
- _MMCamcorderMsgItem msg;
+
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
_mmcam_dbg_log("");
goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
}
+ /* set camera state to vconf key */
+ if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
+ int vconf_camera_state = 0;
+
+ /* get current camera state of vconf key */
+ vconf_get_int(VCONFKEY_CAMERA_STATE, &vconf_camera_state);
+ vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_OPEN);
+
+ _mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d",
+ vconf_camera_state, VCONFKEY_CAMERA_STATE_OPEN);
+ }
+
/* Set async state */
ret = _mmcamcorder_set_async_state(handle, state_TO);
if (ret < 0) {
goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
}
+ mm_camcorder_get_attributes(handle, NULL,
+ MMCAM_MODE, &hcamcorder->type,
+ MMCAM_DISPLAY_SURFACE, &display_surface_type,
+ MMCAM_CAMERA_RECORDING_MOTION_RATE, &motion_rate,
+ NULL);
+
/* Get profile mode */
- mm_camcorder_get_attributes(handle, NULL, MMCAM_MODE, &hcamcorder->type, NULL);
_mmcam_dbg_log("Profile mode set is (%d)", hcamcorder->type);
- /* Check and register ASM */
+ /* Check and make SHARE session as PLAYING */
if (MM_ERROR_NONE != _mm_session_util_read_type(-1, &sessionType)) {
- _mmcam_dbg_warn("Read _mm_session_util_read_type failed. use default \"exclusive\" type");
- sessionType = MM_SESSION_TYPE_EXCLUSIVE;
+ _mmcam_dbg_log("_mm_session_util_read_type Fail. but keep going...");
+ sessionType = MM_SESSION_TYPE_SHARE;
}
if ((sessionType != MM_SESSION_TYPE_CALL) && (sessionType != MM_SESSION_TYPE_VIDEOCALL)) {
- int asm_session_type = ASM_EVENT_NONE;
ASM_resource_t mm_resource = ASM_RESOURCE_NONE;
- asm_session_type = __mmcamcorder_asm_get_event_type(sessionType);
switch (hcamcorder->type) {
- case MM_CAMCORDER_MODE_VIDEO:
- mm_resource = ASM_RESOURCE_CAMERA | ASM_RESOURCE_VIDEO_OVERLAY | ASM_RESOURCE_HW_ENCODER;
- break;
case MM_CAMCORDER_MODE_AUDIO:
mm_resource = ASM_RESOURCE_NONE;
break;
- case MM_CAMCORDER_MODE_IMAGE:
+ case MM_CAMCORDER_MODE_VIDEO_CAPTURE:
default:
- mm_resource = ASM_RESOURCE_CAMERA | ASM_RESOURCE_VIDEO_OVERLAY;
+ mm_resource = ASM_RESOURCE_CAMERA | ASM_RESOURCE_VIDEO_OVERLAY | ASM_RESOURCE_HW_ENCODER;
break;
}
- if (!ASM_set_sound_state(hcamcorder->asm_handle, asm_session_type,
+ if (!ASM_set_sound_state(hcamcorder->asm_handle_sh, ASM_EVENT_SHARE_MMCAMCORDER,
ASM_STATE_PLAYING, mm_resource, &errorcode)) {
- debug_error("Set state to playing failed 0x%X\n", errorcode);
- ret = MM_ERROR_POLICY_BLOCKED;
+ _mmcam_dbg_err("Set state to playing failed 0x%x", errorcode);
+ ret = MM_ERROR_POLICY_BLOCKED;
goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
}
}
}
/* Set basic configure information */
- mm_camcorder_get_attributes(handle, NULL, MMCAM_DISPLAY_SURFACE, &display_surface_type, NULL);
+ if (motion_rate != _MMCAMCORDER_DEFAULT_RECORDING_MOTION_RATE) {
+ hcamcorder->sub_context->is_modified_rate = TRUE;
+ }
+
+ _mmcamcorder_conf_get_value_int(hcamcorder->conf_main,
+ CONFIGURE_CATEGORY_MAIN_CAPTURE,
+ "UseEncodebin",
+ &(hcamcorder->sub_context->bencbin_capture));
+
switch (display_surface_type) {
case MM_DISPLAY_SURFACE_X:
videosink_element_type = strdup("VideosinkElementX");
videosink_element_type = strdup("VideosinkElementX");
break;
}
- _mmcamcorder_conf_get_element(hcamcorder->conf_main,
- CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT,
- videosink_element_type,
- &hcamcorder->sub_context->VideosinkElement );
- _mmcamcorder_conf_get_value_element_name( hcamcorder->sub_context->VideosinkElement, &videosink_name );
- _mmcam_dbg_log( "Videosink name : %s", videosink_name );
+ /* check string of videosink element */
if (videosink_element_type) {
+ _mmcamcorder_conf_get_element(hcamcorder->conf_main,
+ CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT,
+ videosink_element_type,
+ &hcamcorder->sub_context->VideosinkElement);
free(videosink_element_type);
videosink_element_type = NULL;
+ } else {
+ _mmcam_dbg_warn("strdup failed(display_surface_type %d). Use default X type",
+ display_surface_type);
+
+ _mmcamcorder_conf_get_element(hcamcorder->conf_main,
+ CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT,
+ _MMCAMCORDER_DEFAULT_VIDEOSINK_TYPE,
+ &hcamcorder->sub_context->VideosinkElement );
}
+ _mmcamcorder_conf_get_value_element_name(hcamcorder->sub_context->VideosinkElement, &videosink_name);
+ _mmcam_dbg_log("Videosink name : %s", videosink_name);
+
_mmcamcorder_conf_get_value_int(hcamcorder->conf_ctrl,
CONFIGURE_CATEGORY_CTRL_CAPTURE,
"SensorEncodedCapture",
__ta__(" _mmcamcorder_create_pipeline",
ret = _mmcamcorder_create_pipeline(handle, hcamcorder->type);
);
- if(ret<0) {
+ if (ret != MM_ERROR_NONE) {
+ /* check internal error of gstreamer */
+ if (hcamcorder->sub_context->error_code != MM_ERROR_NONE) {
+ ret = hcamcorder->sub_context->error_code;
+ _mmcam_dbg_log("gstreamer error is occurred. return it %x", ret);
+ }
+
+ /* release sub context */
_mmcamcorder_dealloc_subcontext(hcamcorder->sub_context);
hcamcorder->sub_context = NULL;
goto _ERR_CAMCORDER_CMD;
/* set command function */
ret = _mmcamcorder_set_functions(handle, hcamcorder->type);
-
- if(ret<0) {
+ if (ret != MM_ERROR_NONE) {
_mmcamcorder_destroy_pipeline(handle, hcamcorder->type);
_mmcamcorder_dealloc_subcontext(hcamcorder->sub_context);
hcamcorder->sub_context = NULL;
}
_mmcamcorder_set_state(handle, state_TO);
+
_MMCAMCORDER_UNLOCK_CMD(hcamcorder);
return MM_ERROR_NONE;
_MMCAMCORDER_UNLOCK_CMD(hcamcorder);
_ERR_CAMCORDER_CMD_PRECON:
- /* send message */
- _mmcam_dbg_err("Realize fail (%d, %d, %x)", hcamcorder->type, state, ret);
+ _mmcam_dbg_err("Realize fail (type %d, state %d, ret %x)",
+ hcamcorder->type, state, ret);
- msg.id = MM_MESSAGE_CAMCORDER_STATE_CHANGED;
- msg.param.state.previous = state;
- msg.param.state.current = state;
- msg.param.state.code = ret;
- _mmcamcroder_send_message(handle, &msg);
+ /* rollback camera state to vconf key */
+ if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
+ int vconf_camera_state = 0;
+
+ /* get current camera state of vconf key */
+ vconf_get_int(VCONFKEY_CAMERA_STATE, &vconf_camera_state);
+ vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_NULL);
+
+ _mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d",
+ vconf_camera_state, VCONFKEY_CAMERA_STATE_NULL);
+ }
return ret;
}
int state_FROM = MM_CAMCORDER_STATE_READY;
int state_TO = MM_CAMCORDER_STATE_NULL;
int sessionType = MM_SESSION_TYPE_SHARE;
- int asm_session_type = ASM_EVENT_NONE;
ASM_resource_t mm_resource = ASM_RESOURCE_NONE;
- _MMCamcorderMsgItem msg;
+
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
_mmcam_dbg_log("");
goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
}
- /* Release sound handle */
- __ta__("_mmcamcorder_sound_finalize",
- ret = _mmcamcorder_sound_finalize(handle);
- );
- _mmcam_dbg_log("sound finalize [%d]", ret);
-
/* Release SubContext */
if (hcamcorder->sub_context) {
/* destroy pipeline */
hcamcorder->command = NULL;
- if (MM_ERROR_NONE != _mm_session_util_read_type(-1, &sessionType)) {
- _mmcam_dbg_err("_mm_session_util_read_type Fail\n");
- }
-
- if ((sessionType != MM_SESSION_TYPE_CALL) && (sessionType != MM_SESSION_TYPE_VIDEOCALL)) {
- asm_session_type = ASM_EVENT_NONE;
- mm_resource = ASM_RESOURCE_NONE;
- asm_session_type = __mmcamcorder_asm_get_event_type( sessionType );
-
- switch (hcamcorder->type) {
- case MM_CAMCORDER_MODE_VIDEO:
- mm_resource = ASM_RESOURCE_CAMERA | ASM_RESOURCE_VIDEO_OVERLAY | ASM_RESOURCE_HW_ENCODER;
- break;
- case MM_CAMCORDER_MODE_AUDIO:
- mm_resource = ASM_RESOURCE_NONE;
- break;
- case MM_CAMCORDER_MODE_IMAGE:
- default:
- mm_resource = ASM_RESOURCE_CAMERA | ASM_RESOURCE_VIDEO_OVERLAY;
- break;
+ /* check who calls unrealize. it's no need to set ASM state if caller is ASM */
+ if (hcamcorder->state_change_by_system != _MMCAMCORDER_STATE_CHANGE_BY_ASM) {
+ if (MM_ERROR_NONE != _mm_session_util_read_type(-1, &sessionType)) {
+ _mmcam_dbg_log("_mm_session_util_read_type Fail. but keep going...");
+ sessionType = MM_SESSION_TYPE_SHARE;
}
/* Call session is not ended here */
- if (!ASM_set_sound_state(hcamcorder->asm_handle, asm_session_type,
- ASM_STATE_STOP, mm_resource, &ret)) {
- _mmcam_dbg_err("Set state to playing failed 0x%X\n", ret);
+ if ((sessionType != MM_SESSION_TYPE_CALL) && (sessionType != MM_SESSION_TYPE_VIDEOCALL)) {
+ mm_resource = ASM_RESOURCE_NONE;
+
+ switch (hcamcorder->type) {
+ case MM_CAMCORDER_MODE_AUDIO:
+ mm_resource = ASM_RESOURCE_NONE;
+ break;
+ case MM_CAMCORDER_MODE_VIDEO_CAPTURE:
+ default:
+ mm_resource = ASM_RESOURCE_CAMERA | ASM_RESOURCE_VIDEO_OVERLAY | ASM_RESOURCE_HW_ENCODER;
+ break;
+ }
+
+ /* STOP SHARE session */
+ if (!ASM_set_sound_state(hcamcorder->asm_handle_sh, ASM_EVENT_SHARE_MMCAMCORDER,
+ ASM_STATE_STOP, mm_resource, &ret)) {
+ _mmcam_dbg_err("SHARE Set state to STOP failed 0x%x", ret);
+ }
}
}
_mmcamcorder_set_state(handle, state_TO);
+
+ /* set camera state to vconf key */
+ if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
+ int vconf_camera_state = 0;
+
+ /* get current camera state of vconf key */
+ vconf_get_int(VCONFKEY_CAMERA_STATE, &vconf_camera_state);
+ vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_NULL);
+
+ _mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d",
+ vconf_camera_state, VCONFKEY_CAMERA_STATE_NULL);
+ }
+
_MMCAMCORDER_UNLOCK_CMD(hcamcorder);
return MM_ERROR_NONE;
_ERR_CAMCORDER_CMD_PRECON:
/* send message */
- _mmcam_dbg_err("Unrealize fail (%d, %d)", hcamcorder->type, state);
-
- msg.id = MM_MESSAGE_CAMCORDER_STATE_CHANGED;
- msg.param.state.previous = state;
- msg.param.state.current = state;
- msg.param.state.code = ret;
- _mmcamcroder_send_message(handle, &msg);
+ _mmcam_dbg_err("Unrealize fail (type %d, state %d, ret %x)",
+ hcamcorder->type, state, ret);
return ret;
}
int state = MM_CAMCORDER_STATE_NONE;
int state_FROM = MM_CAMCORDER_STATE_READY;
int state_TO =MM_CAMCORDER_STATE_PREPARE;
- _MMCamcorderMsgItem msg;
+
_MMCamcorderSubContext *sc = NULL;
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
}
+ /* initialize error code */
+ hcamcorder->sub_context->error_code = MM_ERROR_NONE;
+
/* set async state */
ret = _mmcamcorder_set_async_state(handle, state_TO);
if (ret != MM_ERROR_NONE) {
_mmcamcorder_set_state(handle, state_TO);
if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
+ int vconf_camera_state = 0;
+
_mmcamcorder_set_attribute_to_camsensor(handle);
+
+ /* check camera state of vconf key */
+ vconf_get_int(VCONFKEY_CAMERA_STATE, &vconf_camera_state);
+
+ /* set camera state to vconf key */
+ vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_PREVIEW);
+
+ _mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d",
+ vconf_camera_state, VCONFKEY_CAMERA_STATE_PREVIEW);
}
_MMCAMCORDER_UNLOCK_CMD(hcamcorder);
_MMCAMCORDER_UNLOCK_CMD(hcamcorder);
_ERR_CAMCORDER_CMD_PRECON:
- /* send message */
- _mmcam_dbg_err("Start fail (%d, %d)", hcamcorder->type, state);
+ /* check internal error of gstreamer */
+ if (hcamcorder->sub_context->error_code != MM_ERROR_NONE) {
+ ret = hcamcorder->sub_context->error_code;
+ hcamcorder->sub_context->error_code = MM_ERROR_NONE;
- msg.id = MM_MESSAGE_CAMCORDER_STATE_CHANGED;
- msg.param.state.previous = state;
- msg.param.state.current = state;
- msg.param.state.code = ret;
- _mmcamcroder_send_message(handle, &msg);
+ _mmcam_dbg_log("gstreamer error is occurred. return it %x", ret);
+ }
+
+ _mmcam_dbg_err("Start fail (type %d, state %d, ret %x)",
+ hcamcorder->type, state, ret);
return ret;
}
int state_FROM = MM_CAMCORDER_STATE_PREPARE;
int state_TO = MM_CAMCORDER_STATE_READY;
int frame_rate = 0;
- _MMCamcorderMsgItem msg;
+
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
_mmcam_dbg_log("");
__ta__(__tafmt__("MM_CAM_006:: Frame per sec : %d", frame_rate), ;);
_mmcamcorder_set_state(handle, state_TO);
+
+ if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
+ int vconf_camera_state = 0;
+
+ /* check camera state of vconf key */
+ vconf_get_int(VCONFKEY_CAMERA_STATE, &vconf_camera_state);
+
+ /* set camera state to vconf key */
+ vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_OPEN);
+
+ _mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d",
+ vconf_camera_state, VCONFKEY_CAMERA_STATE_OPEN);
+ }
+
_MMCAMCORDER_UNLOCK_CMD(hcamcorder);
return MM_ERROR_NONE;
_ERR_CAMCORDER_CMD_PRECON:
/* send message */
- _mmcam_dbg_err("Stop fail (%d, %d)", hcamcorder->type, state);
-
- msg.id = MM_MESSAGE_CAMCORDER_STATE_CHANGED;
- msg.param.state.previous = state;
- msg.param.state.current = state;
- msg.param.state.code = ret;
- _mmcamcroder_send_message(handle, &msg);
+ _mmcam_dbg_err("Stop fail (type %d, state %d, ret %x)",
+ hcamcorder->type, state, ret);
return ret;
}
{
int ret = MM_ERROR_NONE;
int state = MM_CAMCORDER_STATE_NONE;
- int state_FROM = MM_CAMCORDER_STATE_PREPARE;
+ int state_FROM_0 = MM_CAMCORDER_STATE_PREPARE;
+ int state_FROM_1 = MM_CAMCORDER_STATE_RECORDING;
+ int state_FROM_2 = MM_CAMCORDER_STATE_PAUSED;
int state_TO = MM_CAMCORDER_STATE_CAPTURING;
char *err_name = NULL;
- _MMCamcorderMsgItem msg;
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
_mmcam_dbg_log("");
}
state = _mmcamcorder_get_state(handle);
- if (state != state_FROM) {
+ if (state != state_FROM_0 &&
+ state != state_FROM_1 &&
+ state != state_FROM_2) {
_mmcam_dbg_err("Wrong state(%d)", state);
ret = MM_ERROR_CAMCORDER_INVALID_STATE;
goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
goto _ERR_CAMCORDER_CMD;
}
- _mmcamcorder_set_state(handle, state_TO);
+ /* Do not change state when recording snapshot capture */
+ if (state == state_FROM_0) {
+ _mmcamcorder_set_state(handle, state_TO);
+ }
/* Init break continuous shot attr */
mm_camcorder_set_attributes(handle, &err_name, "capture-break-cont-shot", 0, NULL);
_ERR_CAMCORDER_CMD_PRECON:
/* send message */
- _mmcam_dbg_err("Capture start fail (%d, %d)", hcamcorder->type, state);
-
- msg.id = MM_MESSAGE_CAMCORDER_STATE_CHANGED;
- msg.param.state.previous = state;
- msg.param.state.current = state;
- msg.param.state.code = ret;
- _mmcamcroder_send_message(handle, &msg);
+ _mmcam_dbg_err("Capture start fail (type %d, state %d, ret %x)",
+ hcamcorder->type, state, ret);
return ret;
}
int state = MM_CAMCORDER_STATE_NONE;
int state_FROM = MM_CAMCORDER_STATE_CAPTURING;
int state_TO = MM_CAMCORDER_STATE_PREPARE;
- _MMCamcorderMsgItem msg;
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
_mmcam_dbg_log("");
_mmcamcorder_set_state(handle, state_TO);
- /* Set strobe mode - strobe mode can not be set to driver while captuing */
-{
- __ta__("Set strobe mode after capture",
- mmf_attrs_t *attr = (mmf_attrs_t *)MMF_CAMCORDER_ATTRS(handle);
- if (attr) {
- mmf_attribute_set_modified(&(attr->items[MM_CAM_STROBE_MODE]));
- if (mmf_attrs_commit((MMHandleType) attr) == -1) {
- _mmcam_dbg_warn("Failed to set strobe mode");
- }
- }
- );
-}
-
_MMCAMCORDER_UNLOCK_CMD(hcamcorder);
+ MMTA_ACUM_ITEM_END("Real First Capture Start", FALSE);
+
return MM_ERROR_NONE;
_ERR_CAMCORDER_CMD:
_ERR_CAMCORDER_CMD_PRECON:
/* send message */
- _mmcam_dbg_err("Capture stop fail (%d, %d)", hcamcorder->type, state);
-
- msg.id = MM_MESSAGE_CAMCORDER_STATE_CHANGED;
- msg.param.state.previous = state;
- msg.param.state.current = state;
- msg.param.state.code = ret;
- _mmcamcroder_send_message(handle, &msg);
+ _mmcam_dbg_err("Capture stop fail (type %d, state %d, ret %x)",
+ hcamcorder->type, state, ret);
return ret;
}
int state_FROM1 = MM_CAMCORDER_STATE_PREPARE;
int state_FROM2 = MM_CAMCORDER_STATE_PAUSED;
int state_TO = MM_CAMCORDER_STATE_RECORDING;
- _MMCamcorderMsgItem msg;
+ int sessionType = MM_SESSION_TYPE_SHARE;
+
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
_mmcam_dbg_log("");
goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
}
+ /* initialize error code */
+ hcamcorder->sub_context->error_code = MM_ERROR_NONE;
+
+ /* Check and register EXCLUSIVE ASM */
+ if (MM_ERROR_NONE != _mm_session_util_read_type(-1, &sessionType)) {
+ _mmcam_dbg_log("_mm_session_util_read_type Fail. but keep going...");
+ sessionType = MM_SESSION_TYPE_SHARE;
+ }
+ if ((sessionType != MM_SESSION_TYPE_CALL) && (sessionType != MM_SESSION_TYPE_VIDEOCALL)) {
+ int errorcode;
+ ASM_resource_t mm_resource = ASM_RESOURCE_NONE;
+
+ switch (hcamcorder->type) {
+ case MM_CAMCORDER_MODE_AUDIO:
+ mm_resource = ASM_RESOURCE_NONE;
+ break;
+ case MM_CAMCORDER_MODE_VIDEO_CAPTURE:
+ default:
+ mm_resource = ASM_RESOURCE_CAMERA | ASM_RESOURCE_VIDEO_OVERLAY | ASM_RESOURCE_HW_ENCODER;
+ break;
+ }
+
+ if (!ASM_set_sound_state(hcamcorder->asm_handle_ex, ASM_EVENT_EXCLUSIVE_MMCAMCORDER,
+ ASM_STATE_PLAYING, mm_resource, &errorcode)) {
+ _mmcam_dbg_err("Set state to playing failed 0x%x", errorcode);
+ ret = MM_ERROR_POLICY_BLOCKED;
+ goto _ERR_CAMCORDER_CMD_PRECON_AFTER_LOCK;
+ }
+ }
+
/* set async state */
ret = _mmcamcorder_set_async_state(handle, state_TO);
if (ret != MM_ERROR_NONE) {
}
_mmcamcorder_set_state(handle, state_TO);
+
+ /* set camera state to vconf key */
+ if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
+ int vconf_camera_state = 0;
+
+ /* get current camera state of vconf key */
+ vconf_get_int(VCONFKEY_CAMERA_STATE, &vconf_camera_state);
+ vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_RECORDING);
+
+ _mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d",
+ vconf_camera_state, VCONFKEY_CAMERA_STATE_RECORDING);
+ }
+
_MMCAMCORDER_UNLOCK_CMD(hcamcorder);
return MM_ERROR_NONE;
_MMCAMCORDER_UNLOCK_CMD(hcamcorder);
_ERR_CAMCORDER_CMD_PRECON:
- /* send message */
- _mmcam_dbg_err("Record fail (%d, %d)", hcamcorder->type, state);
+ /* check internal error of gstreamer */
+ if (hcamcorder->sub_context->error_code != MM_ERROR_NONE) {
+ ret = hcamcorder->sub_context->error_code;
+ hcamcorder->sub_context->error_code = MM_ERROR_NONE;
- msg.id = MM_MESSAGE_CAMCORDER_STATE_CHANGED;
- msg.param.state.previous = state;
- msg.param.state.current = state;
- msg.param.state.code = ret;
- _mmcamcroder_send_message(handle, &msg);
+ _mmcam_dbg_log("gstreamer error is occurred. return it %x", ret);
+ }
+
+ _mmcam_dbg_err("Record fail (type %d, state %d, ret %x)",
+ hcamcorder->type, state, ret);
return ret;
}
int state = MM_CAMCORDER_STATE_NONE;
int state_FROM = MM_CAMCORDER_STATE_RECORDING;
int state_TO = MM_CAMCORDER_STATE_PAUSED;
- _MMCamcorderMsgItem msg;
+
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
_mmcam_dbg_log("");
}
_mmcamcorder_set_state(handle, state_TO);
+
+ /* set camera state to vconf key */
+ if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
+ int vconf_camera_state = 0;
+
+ /* get current camera state of vconf key */
+ vconf_get_int(VCONFKEY_CAMERA_STATE, &vconf_camera_state);
+ vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_RECORDING_PAUSE);
+
+ _mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d",
+ vconf_camera_state, VCONFKEY_CAMERA_STATE_RECORDING_PAUSE);
+ }
+
_MMCAMCORDER_UNLOCK_CMD(hcamcorder);
return MM_ERROR_NONE;
_ERR_CAMCORDER_CMD_PRECON:
/* send message */
- _mmcam_dbg_err("Pause fail (%d, %d)", hcamcorder->type, state);
-
- msg.id = MM_MESSAGE_CAMCORDER_STATE_CHANGED;
- msg.param.state.previous = state;
- msg.param.state.current = state;
- msg.param.state.code = ret;
- _mmcamcroder_send_message(handle, &msg);
+ _mmcam_dbg_err("Pause fail (type %d, state %d, ret %x)",
+ hcamcorder->type, state, ret);
return ret;
}
int state_FROM1 = MM_CAMCORDER_STATE_RECORDING;
int state_FROM2 = MM_CAMCORDER_STATE_PAUSED;
int state_TO = MM_CAMCORDER_STATE_PREPARE;
- _MMCamcorderMsgItem msg;
+
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
_mmcam_dbg_log("");
}
_mmcamcorder_set_state(handle,state_TO);
+
+ /* set camera state to vconf key */
+ if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
+ int vconf_camera_state = 0;
+
+ /* get current camera state of vconf key */
+ vconf_get_int(VCONFKEY_CAMERA_STATE, &vconf_camera_state);
+ vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_PREVIEW);
+
+ _mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d",
+ vconf_camera_state, VCONFKEY_CAMERA_STATE_PREVIEW);
+ }
+
+ /* check who calls unrealize. it's no need to set ASM state if caller is ASM */
+ if (hcamcorder->state_change_by_system != _MMCAMCORDER_STATE_CHANGE_BY_ASM) {
+ int sessionType = MM_SESSION_TYPE_SHARE;
+ ASM_resource_t mm_resource = ASM_RESOURCE_NONE;
+
+ if (MM_ERROR_NONE != _mm_session_util_read_type(-1, &sessionType)) {
+ _mmcam_dbg_log("_mm_session_util_read_type Fail. but keep going...");
+ sessionType = MM_SESSION_TYPE_SHARE;
+ }
+
+ /* Call session is not ended here */
+ if ((sessionType != MM_SESSION_TYPE_CALL) && (sessionType != MM_SESSION_TYPE_VIDEOCALL)) {
+ switch (hcamcorder->type) {
+ case MM_CAMCORDER_MODE_AUDIO:
+ mm_resource = ASM_RESOURCE_NONE;
+ break;
+ case MM_CAMCORDER_MODE_VIDEO_CAPTURE:
+ default:
+ mm_resource = ASM_RESOURCE_CAMERA | ASM_RESOURCE_VIDEO_OVERLAY | ASM_RESOURCE_HW_ENCODER;
+ break;
+ }
+
+ /* STOP EXCLUSIVE session */
+ if (!ASM_set_sound_state(hcamcorder->asm_handle_ex, ASM_EVENT_EXCLUSIVE_MMCAMCORDER,
+ ASM_STATE_STOP, mm_resource, &ret)) {
+ _mmcam_dbg_err("EXCLUSIVE Set state to STOP failed 0x%x", ret);
+ }
+ }
+ }
+
_MMCAMCORDER_UNLOCK_CMD(hcamcorder);
return MM_ERROR_NONE;
_ERR_CAMCORDER_CMD_PRECON:
/* send message */
- _mmcam_dbg_err("Commit fail (%d, %d)", hcamcorder->type, state);
-
- msg.id = MM_MESSAGE_CAMCORDER_STATE_CHANGED;
- msg.param.state.previous = state;
- msg.param.state.current = state;
- msg.param.state.code = ret;
- _mmcamcroder_send_message(handle, &msg);
+ _mmcam_dbg_err("Commit fail (type %d, state %d, ret %x)",
+ hcamcorder->type, state, ret);
return ret;
}
int state_FROM1 = MM_CAMCORDER_STATE_RECORDING;
int state_FROM2 = MM_CAMCORDER_STATE_PAUSED;
int state_TO = MM_CAMCORDER_STATE_PREPARE;
- _MMCamcorderMsgItem msg;
+ int sessionType = MM_SESSION_TYPE_SHARE;
+
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
_mmcam_dbg_log("");
}
_mmcamcorder_set_state(handle, state_TO);
+
+ /* read session type */
+ if (MM_ERROR_NONE != _mm_session_util_read_type(-1, &sessionType)) {
+ _mmcam_dbg_log("_mm_session_util_read_type Fail. but keep going...");
+ sessionType = MM_SESSION_TYPE_SHARE;
+ }
+
+ /* Call session is not ended here */
+ if ((sessionType != MM_SESSION_TYPE_CALL) && (sessionType != MM_SESSION_TYPE_VIDEOCALL)) {
+ ASM_resource_t mm_resource = ASM_RESOURCE_NONE;
+
+ switch (hcamcorder->type) {
+ case MM_CAMCORDER_MODE_AUDIO:
+ mm_resource = ASM_RESOURCE_NONE;
+ break;
+ case MM_CAMCORDER_MODE_VIDEO_CAPTURE:
+ default:
+ mm_resource = ASM_RESOURCE_CAMERA | ASM_RESOURCE_VIDEO_OVERLAY | ASM_RESOURCE_HW_ENCODER;
+ break;
+ }
+
+ /* STOP EXCLUSIVE session */
+ if (!ASM_set_sound_state(hcamcorder->asm_handle_ex, ASM_EVENT_EXCLUSIVE_MMCAMCORDER,
+ ASM_STATE_STOP, mm_resource, &ret)) {
+ _mmcam_dbg_err("EXCLUSIVE Set state to STOP failed 0x%x", ret);
+ }
+ }
+
+ /* set camera state to vconf key */
+ if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
+ int vconf_camera_state = 0;
+
+ /* get current camera state of vconf key */
+ vconf_get_int(VCONFKEY_CAMERA_STATE, &vconf_camera_state);
+ vconf_set_int(VCONFKEY_CAMERA_STATE, VCONFKEY_CAMERA_STATE_PREVIEW);
+
+ _mmcam_dbg_log("VCONFKEY_CAMERA_STATE prev %d -> cur %d",
+ vconf_camera_state, VCONFKEY_CAMERA_STATE_PREVIEW);
+ }
+
_MMCAMCORDER_UNLOCK_CMD(hcamcorder);
return MM_ERROR_NONE;
_ERR_CAMCORDER_CMD_PRECON:
/* send message */
- _mmcam_dbg_err("Cancel fail (%d, %d)", hcamcorder->type, state);
-
- msg.id = MM_MESSAGE_CAMCORDER_STATE_CHANGED;
- msg.param.state.previous = state;
- msg.param.state.current = state;
- msg.param.state.code = ret;
- _mmcamcroder_send_message(handle, &msg);
+ _mmcam_dbg_err("Cancel fail (type %d, state %d, ret %x)",
+ hcamcorder->type, state, ret);
return ret;
}
int _mmcamcorder_init_focusing(MMHandleType handle)
{
- int ret = 0;
+ int ret = TRUE;
int state = MM_CAMCORDER_STATE_NONE;
int focus_mode = MM_CAMCORDER_FOCUS_MODE_NONE;
int af_range = MM_CAMCORDER_AUTO_FOCUS_NORMAL;
int sensor_focus_mode = 0;
int sensor_af_range = 0;
+ int current_focus_mode = 0;
+ int current_af_range = 0;
mmf_camcorder_t *hcamcorder = NULL;
_MMCamcorderSubContext *sc = NULL;
mmf_attrs_t *attr = NULL;
MMCAM_CAMERA_FOCUS_MODE, &focus_mode,
MMCAM_CAMERA_AF_SCAN_RANGE, &af_range,
NULL);
- sensor_af_range = _mmcamcorder_convert_msl_to_sensor(MM_CAM_CAMERA_AF_SCAN_RANGE, af_range);
- sensor_focus_mode = _mmcamcorder_convert_msl_to_sensor(MM_CAM_CAMERA_FOCUS_MODE, focus_mode);
+ sensor_af_range = _mmcamcorder_convert_msl_to_sensor(handle, MM_CAM_CAMERA_AF_SCAN_RANGE, af_range);
+ sensor_focus_mode = _mmcamcorder_convert_msl_to_sensor(handle, MM_CAM_CAMERA_FOCUS_MODE, focus_mode);
- ret = gst_camera_control_set_focus(control, sensor_focus_mode, sensor_af_range);
+ gst_camera_control_get_focus(control, ¤t_focus_mode, ¤t_af_range);
+
+ if (current_focus_mode != sensor_focus_mode ||
+ current_af_range != sensor_af_range) {
+ ret = gst_camera_control_set_focus(control, sensor_focus_mode, sensor_af_range);
+ } else {
+ _mmcam_dbg_log("No need to init FOCUS [mode:%d, range:%d]", focus_mode, af_range );
+ ret = TRUE;
+ }
_MMCAMCORDER_UNLOCK_CMD(hcamcorder);
int _mmcamcorder_adjust_auto_focus(MMHandleType handle)
{
- int af_mode = MM_CAMCORDER_FOCUS_MODE_AUTO;
gboolean ret;
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
GstCameraControl *control = NULL;
/* Start AF */
ret = gst_camera_control_start_auto_focus(control);
if (ret) {
- mm_camcorder_get_attributes(handle, NULL, MMCAM_CAMERA_FOCUS_MODE, &af_mode, NULL);
- if (af_mode == MM_CAMCORDER_FOCUS_MODE_CONTINUOUS) {
- sc->now_continuous_af = TRUE;
- _mmcam_dbg_log("Set now_continuous_af as TRUE");
- }
_mmcam_dbg_log("Auto focusing start success.");
return MM_ERROR_NONE;
} else {
control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
ret = gst_camera_control_stop_auto_focus(control);
- sc->now_continuous_af = FALSE;
- _mmcam_dbg_log("Set now_continuous_af as FALSE");
_MMCAMCORDER_UNLOCK_CMD(hcamcorder);
);
if (!ret) {
- _mmcam_dbg_err("Could not initialize GStreamer: %s\n",
+ _mmcam_dbg_err("Could not initialize GStreamer: %s ",
err ? err->message : "unknown error occurred");
if (err) {
g_error_free (err);
msg.id = MM_MESSAGE_CAMCORDER_STATE_CHANGED_BY_ASM;
msg.param.state.code = hcamcorder->asm_event_code;
break;
+ case _MMCAMCORDER_STATE_CHANGE_NORMAL:
default:
msg.id = MM_MESSAGE_CAMCORDER_STATE_CHANGED;
msg.param.state.code = MM_ERROR_NONE;
/* alloc info for each mode */
switch (type) {
- case MM_CAMCORDER_MODE_IMAGE:
- sc->info = malloc( sizeof(_MMCamcorderImageInfo));
- if(sc->info == NULL) {
+ case MM_CAMCORDER_MODE_AUDIO:
+ sc->info_audio = malloc( sizeof(_MMCamcorderAudioInfo));
+ if(sc->info_audio == NULL) {
_mmcam_dbg_err("Failed to alloc info structure");
free(sc);
return NULL;
}
- memset(sc->info, 0x00, sizeof(_MMCamcorderImageInfo));
+ memset(sc->info_audio, 0x00, sizeof(_MMCamcorderAudioInfo));
break;
- case MM_CAMCORDER_MODE_AUDIO:
- sc->info = malloc( sizeof(_MMCamcorderAudioInfo));
- if(sc->info == NULL) {
+ case MM_CAMCORDER_MODE_VIDEO_CAPTURE:
+ default:
+ sc->info_image = malloc( sizeof(_MMCamcorderImageInfo));
+ if(sc->info_image == NULL) {
_mmcam_dbg_err("Failed to alloc info structure");
free(sc);
return NULL;
}
- memset(sc->info, 0x00, sizeof(_MMCamcorderAudioInfo));
- break;
- case MM_CAMCORDER_MODE_VIDEO:
- sc->info = malloc( sizeof(_MMCamcorderVideoInfo));
- if(sc->info == NULL) {
+ memset(sc->info_image, 0x00, sizeof(_MMCamcorderImageInfo));
+
+ /* init sound status */
+ sc->info_image->sound_status = _SOUND_STATUS_INIT;
+
+ sc->info_video = malloc( sizeof(_MMCamcorderVideoInfo));
+ if(sc->info_video == NULL) {
_mmcam_dbg_err("Failed to alloc info structure");
+ free(sc->info_image);
free(sc);
return NULL;
}
- memset(sc->info, 0x00, sizeof(_MMCamcorderVideoInfo));
+ memset(sc->info_video, 0x00, sizeof(_MMCamcorderVideoInfo));
break;
- default:
- _mmcam_dbg_err("unknown type[%d]", type);
- free(sc);
- return NULL;
}
/* alloc element array */
sc->element = (_MMCamcorderGstElement *)malloc(sizeof(_MMCamcorderGstElement) * sc->element_num);
if(!sc->element) {
_mmcam_dbg_err("Failed to alloc element structure");
- free(sc->info);
+ if (type == MM_CAMCORDER_MODE_AUDIO) {
+ free(sc->info_audio);
+ } else {
+ free(sc->info_image);
+ free(sc->info_video);
+ }
free(sc);
return NULL;
}
}
sc->fourcc = 0x80000000;
-
sc->cam_stability_count = 0;
- sc->drop_vframe = 0;
- sc->pass_first_vframe = 0;
+ sc->drop_vframe = 0;
+ sc->pass_first_vframe = 0;
+ sc->is_modified_rate = FALSE;
return sc;
}
sc->element = NULL;
}
- if (sc->info) {
- free(sc->info);
- sc->info = NULL;
+ if (sc->info_image) {
+ _mmcam_dbg_log("release info_image");
+ free(sc->info_image);
+ sc->info_image = NULL;
+ }
+
+ if (sc->info_video) {
+ _mmcam_dbg_log("release info_video");
+ free(sc->info_video);
+ sc->info_video = NULL;
+ }
+
+ if (sc->info_audio) {
+ _mmcam_dbg_log("release info_audio");
+ free(sc->info_audio);
+ sc->info_audio = NULL;
}
free(sc);
_mmcam_dbg_log("");
switch (type) {
- case MM_CAMCORDER_MODE_VIDEO:
- hcamcorder->command = _mmcamcorder_video_command;
- break;
case MM_CAMCORDER_MODE_AUDIO:
hcamcorder->command = _mmcamcorder_audio_command;
break;
- case MM_CAMCORDER_MODE_IMAGE:
- hcamcorder->command = _mmcamcorder_image_command;
- break;
+ case MM_CAMCORDER_MODE_VIDEO_CAPTURE:
default:
- return MM_ERROR_CAMCORDER_INTERNAL;
+ hcamcorder->command = _mmcamcorder_video_capture_command;
break;
}
sc = MMF_CAMCORDER_SUBCONTEXT(hcamcorder);
mmf_return_val_if_fail(sc, TRUE);
- mmf_return_val_if_fail(sc->info, TRUE);
- if (hcamcorder->type == MM_CAMCORDER_MODE_VIDEO) {
- _MMCamcorderVideoInfo *info = sc->info;
- if (info->b_commiting) {
+ if (hcamcorder->type != MM_CAMCORDER_MODE_AUDIO) {
+ mmf_return_val_if_fail(sc->info_video, TRUE);
+ if (sc->info_video->b_commiting) {
_mmcamcorder_video_handle_eos((MMHandleType)hcamcorder);
}
- } else if (hcamcorder->type == MM_CAMCORDER_MODE_AUDIO) {
- _MMCamcorderAudioInfo *info = sc->info;
- if (info->b_commiting) {
+ } else {
+ mmf_return_val_if_fail(sc->info_audio, TRUE);
+ if (sc->info_audio->b_commiting) {
_mmcamcorder_audio_handle_eos((MMHandleType)hcamcorder);
}
}
msg.id = MM_MESSAGE_CAMCORDER_FOCUS_CHANGED;
msg.param.code = focus_state;
_mmcamcroder_send_message((MMHandleType)hcamcorder, &msg);
+ } else if (gst_structure_has_name(message->structure, "camerasrc-HDR")) {
+ int progress = 0;
+ int status = 0;
+
+ gst_structure_get_int(message->structure, "progress", &progress);
+ gst_structure_get_int(message->structure, "status", &status);
+ _mmcam_dbg_log("HDR progress %d percent, status %d", progress, status);
+
+ msg.id = MM_MESSAGE_CAMCORDER_HDR_PROGRESS;
+ msg.param.code = progress;
+ _mmcamcroder_send_message((MMHandleType)hcamcorder, &msg);
+ } else if (gst_structure_has_name(message->structure, "camerasrc-FD")) {
+ int i = 0;
+ const GValue *g_value = gst_structure_get_value(message->structure, "face-info");;
+ GstCameraControlFaceDetectInfo *fd_info = NULL;
+ MMCamFaceDetectInfo *cam_fd_info = NULL;
+
+ if (g_value) {
+ fd_info = (GstCameraControlFaceDetectInfo *)g_value_get_pointer(g_value);
+ }
+
+ if (fd_info == NULL) {
+ _mmcam_dbg_warn("fd_info is NULL");
+ return TRUE;
+ }
+
+ cam_fd_info = (MMCamFaceDetectInfo *)malloc(sizeof(MMCamFaceDetectInfo));
+ if (cam_fd_info == NULL) {
+ _mmcam_dbg_warn("cam_fd_info alloc failed");
+
+ free(fd_info);
+ fd_info = NULL;
+
+ return TRUE;
+ }
+
+ /* set total face count */
+ cam_fd_info->num_of_faces = fd_info->num_of_faces;
+
+ if (cam_fd_info->num_of_faces > 0) {
+ cam_fd_info->face_info = (MMCamFaceInfo *)malloc(sizeof(MMCamFaceInfo) * cam_fd_info->num_of_faces);
+ if (cam_fd_info->face_info) {
+ /* set information of each face */
+ for (i = 0 ; i < fd_info->num_of_faces ; i++) {
+ cam_fd_info->face_info[i].id = fd_info->face_info[i].id;
+ cam_fd_info->face_info[i].score = fd_info->face_info[i].score;
+ cam_fd_info->face_info[i].rect.x = fd_info->face_info[i].rect.x;
+ cam_fd_info->face_info[i].rect.y = fd_info->face_info[i].rect.y;
+ cam_fd_info->face_info[i].rect.width = fd_info->face_info[i].rect.width;
+ cam_fd_info->face_info[i].rect.height = fd_info->face_info[i].rect.height;
+ /*
+ _mmcam_dbg_log("id %d, score %d, [%d,%d,%dx%d]",
+ fd_info->face_info[i].id,
+ fd_info->face_info[i].score,
+ fd_info->face_info[i].rect.x,
+ fd_info->face_info[i].rect.y,
+ fd_info->face_info[i].rect.width,
+ fd_info->face_info[i].rect.height);
+ */
+ }
+ } else {
+ _mmcam_dbg_warn("MMCamFaceInfo alloc failed");
+
+ /* free allocated memory that is not sent */
+ free(cam_fd_info);
+ cam_fd_info = NULL;
+ }
+ } else {
+ cam_fd_info->face_info = NULL;
+ }
+
+ if (cam_fd_info) {
+ /* send message - cam_fd_info should be freed by application */
+ msg.id = MM_MESSAGE_CAMCORDER_FACE_DETECT_INFO;
+ msg.param.data = cam_fd_info;
+ msg.param.size = sizeof(MMCamFaceDetectInfo);
+ msg.param.code = 0;
+
+ _mmcamcroder_send_message((MMHandleType)hcamcorder, &msg);
+ }
+
+ /* free fd_info allocated by plugin */
+ free(fd_info);
+ fd_info = NULL;
}
break;
case GST_MESSAGE_SEGMENT_START:
}
+GstBusSyncReply _mmcamcorder_pipeline_bus_sync_callback(GstBus *bus, GstMessage *message, gpointer data)
+{
+ GstElement *element = NULL;
+ GError *err = NULL;
+ gchar *debug_info = NULL;
+
+ mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(data);
+ _MMCamcorderSubContext *sc = NULL;
+
+ mmf_return_val_if_fail(hcamcorder, GST_BUS_PASS);
+ mmf_return_val_if_fail(message, GST_BUS_PASS);
+
+ sc = MMF_CAMCORDER_SUBCONTEXT(hcamcorder);
+ mmf_return_val_if_fail(sc, GST_BUS_PASS);
+
+ sc->error_code = MM_ERROR_NONE;
+
+ if (GST_MESSAGE_TYPE(message) == GST_MESSAGE_ERROR) {
+ /* parse error message */
+ gst_message_parse_error(message, &err, &debug_info);
+
+ if (!err) {
+ _mmcam_dbg_warn("failed to parse error message");
+ return GST_BUS_PASS;
+ }
+
+ if (debug_info) {
+ _mmcam_dbg_err("GST ERROR : %s", debug_info);
+ g_free(debug_info);
+ debug_info = NULL;
+ }
+
+ /* set videosrc element to compare */
+ element = GST_ELEMENT_CAST(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
+
+ /* check domain[RESOURCE] and element[VIDEOSRC] */
+ if (err->domain == GST_RESOURCE_ERROR &&
+ GST_ELEMENT_CAST(message->src) == element) {
+ switch (err->code) {
+ case GST_RESOURCE_ERROR_BUSY:
+ _mmcam_dbg_err("Camera device [busy]");
+ sc->error_code = MM_ERROR_CAMCORDER_DEVICE_BUSY;
+ break;
+ case GST_RESOURCE_ERROR_OPEN_READ_WRITE:
+ case GST_RESOURCE_ERROR_OPEN_WRITE:
+ _mmcam_dbg_err("Camera device [open failed]");
+ sc->error_code = MM_ERROR_CAMCORDER_DEVICE_OPEN;
+ break;
+ case GST_RESOURCE_ERROR_OPEN_READ:
+ _mmcam_dbg_err("Camera device [register trouble]");
+ sc->error_code = MM_ERROR_CAMCORDER_DEVICE_REG_TROUBLE;
+ break;
+ case GST_RESOURCE_ERROR_NOT_FOUND:
+ _mmcam_dbg_err("Camera device [device not found]");
+ sc->error_code = MM_ERROR_CAMCORDER_DEVICE_NOT_FOUND;
+ break;
+ case GST_RESOURCE_ERROR_TOO_LAZY:
+ _mmcam_dbg_err("Camera device [timeout]");
+ sc->error_code = MM_ERROR_CAMCORDER_DEVICE_TIMEOUT;
+ break;
+ case GST_RESOURCE_ERROR_SETTINGS:
+ _mmcam_dbg_err("Camera device [not supported]");
+ sc->error_code = MM_ERROR_CAMCORDER_NOT_SUPPORTED;
+ break;
+ case GST_RESOURCE_ERROR_FAILED:
+ _mmcam_dbg_err("Camera device [working failed].");
+ sc->error_code = MM_ERROR_CAMCORDER_DEVICE_IO;
+ break;
+ default:
+ _mmcam_dbg_err("Camera device [General(%d)]", err->code);
+ sc->error_code = MM_ERROR_CAMCORDER_DEVICE;
+ break;
+ }
+
+ sc->error_occurs = TRUE;
+ }
+
+ g_error_free(err);
+
+ /* store error code and drop this message if cmd is running */
+ if (sc->error_code != MM_ERROR_NONE) {
+ if (!_MMCAMCORDER_TRYLOCK_CMD(hcamcorder)) {
+ _mmcam_dbg_err("cmd is running and will be returned with this error %x",
+ sc->error_code);
+ return GST_BUS_DROP;
+ }
+
+ _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
+ }
+ }
+
+ return GST_BUS_PASS;
+}
+
+
static int __mmcamcorder_asm_get_event_type(int sessionType)
{
switch (sessionType) {
}
}
-ASM_cb_result_t _mmcamcorder_asm_callback(int handle, ASM_event_sources_t event_src,
- ASM_sound_commands_t command,
- unsigned int sound_status, void* cb_data)
+ASM_cb_result_t _mmcamcorder_asm_callback_sh(int handle, ASM_event_sources_t event_src,
+ ASM_sound_commands_t command,
+ unsigned int sound_status, void* cb_data)
{
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(cb_data);
int current_state = MM_CAMCORDER_STATE_NONE;
/* set ASM event code for sending it to application */
hcamcorder->asm_event_code = event_src;
+ _mmcam_dbg_log("ASM SHARE callback : event code 0x%x, command 0x%x", event_src, command);
+
switch (command) {
case ASM_COMMAND_STOP:
case ASM_COMMAND_PAUSE:
if (current_state >= MM_CAMCORDER_STATE_PREPARE) {
_mmcam_dbg_log("Already start previewing");
- return ASM_CB_RES_PLAYING;
+ } else {
+ __mmcamcorder_force_resume(hcamcorder);
+ }
+
+ cb_res = ASM_CB_RES_PLAYING;
+
+ _mmcam_dbg_log("Finish opeartion. Preview is started.(%d)", cb_res);
+ break;
+ case ASM_COMMAND_RESUME:
+ {
+ _MMCamcorderMsgItem msg;
+
+ _mmcam_dbg_log("Got msg from asm to Resume(%d, %d)", command, current_state);
+
+ msg.id = MM_MESSAGE_READY_TO_RESUME;
+ _mmcamcroder_send_message((MMHandleType)hcamcorder, &msg);
+ cb_res = ASM_CB_RES_PLAYING;
+
+ _mmcam_dbg_log("Finish opeartion.(%d)", cb_res);
+ break;
+ }
+ default: /* should not be reached here */
+ cb_res = ASM_CB_RES_PLAYING;
+ _mmcam_dbg_err("Command err.");
+ break;
+ }
+
+ /* restore value */
+ hcamcorder->state_change_by_system = _MMCAMCORDER_STATE_CHANGE_NORMAL;
+
+ return cb_res;
+}
+
+
+ASM_cb_result_t _mmcamcorder_asm_callback_ex(int handle, ASM_event_sources_t event_src,
+ ASM_sound_commands_t command,
+ unsigned int sound_status, void* cb_data)
+{
+ mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(cb_data);
+ int current_state = MM_CAMCORDER_STATE_NONE;
+ ASM_cb_result_t cb_res = ASM_CB_RES_NONE;
+
+ mmf_return_val_if_fail((MMHandleType)hcamcorder, ASM_CB_RES_NONE);
+
+ current_state = _mmcamcorder_get_state((MMHandleType)hcamcorder);
+
+ _mmcam_dbg_log("ASM EXCLUSIVE callback : event code 0x%x, command 0x%x, current state %d",
+ event_src, command, current_state);
+
+ /* set value to inform a status is changed by asm */
+ hcamcorder->state_change_by_system = _MMCAMCORDER_STATE_CHANGE_BY_ASM;
+
+ /* set ASM event code for sending it to application */
+ hcamcorder->asm_event_code = event_src;
+
+ switch (command) {
+ case ASM_COMMAND_STOP:
+ case ASM_COMMAND_PAUSE:
+ _mmcam_dbg_log("Got msg from asm to Stop or Pause(%d, %d)", command, current_state);
+
+ __mmcamcorder_force_stop(hcamcorder);
+ cb_res = ASM_CB_RES_STOP;
+
+ _mmcam_dbg_log("Finish opeartion. Camera is released.(%d)", cb_res);
+ break;
+ case ASM_COMMAND_PLAY:
+ _mmcam_dbg_log("Got msg from asm to Play(%d, %d)", command, current_state);
+
+ if (current_state >= MM_CAMCORDER_STATE_PREPARE) {
+ _mmcam_dbg_log("Already start previewing");
+ } else {
+ __mmcamcorder_force_resume(hcamcorder);
}
- __mmcamcorder_force_resume(hcamcorder);
cb_res = ASM_CB_RES_PLAYING;
_mmcam_dbg_log("Finish opeartion. Preview is started.(%d)", cb_res);
mmf_return_val_if_fail(sc, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
switch (type) {
- case MM_CAMCORDER_MODE_IMAGE:
- __ta__(" _mmcamcorder_create_preview_pipeline",
- ret = _mmcamcorder_create_preview_pipeline(handle);
- );
- if (ret != MM_ERROR_NONE) {
- return ret;
- }
-
- __ta__(" _mmcamcorder_add_stillshot_pipeline",
- ret = _mmcamcorder_add_stillshot_pipeline(handle);
- );
- if (ret != MM_ERROR_NONE) {
- return ret;
- }
- break;
case MM_CAMCORDER_MODE_AUDIO:
__ta__(" _mmcamcorder_create_audio_pipeline",
ret = _mmcamcorder_create_audio_pipeline(handle);
return ret;
}
break;
- case MM_CAMCORDER_MODE_VIDEO:
+ case MM_CAMCORDER_MODE_VIDEO_CAPTURE:
+ default:
__ta__(" _mmcamcorder_create_preview_pipeline",
ret = _mmcamcorder_create_preview_pipeline(handle);
);
if (ret != MM_ERROR_NONE) {
return ret;
}
+
+ /* connect capture signal */
+ if (!sc->bencbin_capture) {
+ __ta__(" _mmcamcorder_connect_capture_signal",
+ ret = _mmcamcorder_connect_capture_signal(handle);
+ );
+ if (ret != MM_ERROR_NONE) {
+ return ret;
+ }
+ }
break;
- default:
- return MM_ERROR_CAMCORDER_INTERNAL;
}
pipeline = sc->element[_MMCAMCORDER_MAIN_PIPE].gst;
}
}
}
-
+#ifdef _MMCAMCORDER_GET_DEVICE_INFO
if (!_mmcamcorder_get_device_info(handle)) {
_mmcam_dbg_err("Getting device information error!!");
}
-
+#endif
_mmcam_dbg_log("ret[%x]", ret);
return ret;
}
/* Inside each pipeline destroy function, Set GST_STATE_NULL to Main pipeline */
switch (type) {
- case MM_CAMCORDER_MODE_IMAGE:
- _mmcamcorder_destroy_image_pipeline(handle);
+ case MM_CAMCORDER_MODE_VIDEO_CAPTURE:
+ _mmcamcorder_destroy_video_capture_pipeline(handle);
break;
case MM_CAMCORDER_MODE_AUDIO:
_mmcamcorder_destroy_audio_pipeline(handle);
break;
- case MM_CAMCORDER_MODE_VIDEO:
- _mmcamcorder_destroy_video_pipeline(handle);
- break;
default:
+ _mmcam_dbg_err("unknown type %d", type);
break;
}
}
+#ifdef _MMCAMCORDER_USE_SET_ATTR_CB
static gboolean __mmcamcorder_set_attr_to_camsensor_cb(gpointer data)
{
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(data);
/* once */
return FALSE;
}
+#endif /* _MMCAMCORDER_USE_SET_ATTR_CB */
int _mmcamcorder_gst_set_state (MMHandleType handle, GstElement *pipeline, GstState target_state)
GstState pipeline_state = GST_STATE_VOID_PENDING;
GstStateChangeReturn setChangeReturn = GST_STATE_CHANGE_FAILURE;
GstStateChangeReturn getChangeReturn = GST_STATE_CHANGE_FAILURE;
- GstClockTime get_timeout = 3 * GST_SECOND;
+ GstClockTime get_timeout = __MMCAMCORDER_SET_GST_STATE_TIMEOUT * GST_SECOND;
mmf_return_val_if_fail(handle, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
for (k = 0; k < _MMCAMCORDER_STATE_SET_COUNT; k++) {
setChangeReturn = gst_element_set_state(pipeline, target_state);
+ _mmcam_dbg_log("gst_element_set_state[%d] return %d",
+ target_state, setChangeReturn);
if (setChangeReturn != GST_STATE_CHANGE_FAILURE) {
getChangeReturn = gst_element_get_state(pipeline, &pipeline_state, NULL, get_timeout);
switch (getChangeReturn) {
case GST_STATE_CHANGE_ASYNC:
_mmcam_dbg_log("status=GST_STATE_CHANGE_ASYNC.");
break;
- default :
+ default:
_MMCAMCORDER_UNLOCK_GST_STATE(handle);
_mmcam_dbg_log("status=GST_STATE_CHANGE_FAILURE.");
return MM_ERROR_CAMCORDER_GST_STATECHANGE;
_MMCamcorderImageInfo *info = NULL;
mmf_return_if_fail(sc);
- mmf_return_if_fail((info = sc->info));
+ mmf_return_if_fail((info = sc->info_image));
_mmcam_dbg_log("Stop capturing.");
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
_MMCamcorderMsgItem msg;
gchar *msg_src_element;
- _MMCamcorderSubContext *sc = NULL;
+ _MMCamcorderSubContext *sc = NULL;
return_val_if_fail(hcamcorder, FALSE);
return_val_if_fail(error, FALSE);
} else if (error->domain == GST_STREAM_ERROR) {
msg.param.code = __mmcamcorder_gst_handle_stream_error(handle, error->code, message);
} else {
- debug_warning("This error domain is not defined.\n");
+ _mmcam_dbg_warn("This error domain is not defined.");
/* we treat system error as an internal error */
msg.param.code = MM_ERROR_CAMCORDER_INTERNAL;
if (message->src) {
msg_src_element = GST_ELEMENT_NAME(GST_ELEMENT_CAST(message->src));
- debug_error("-Msg src : [%s] Domain : [%s] Error : [%s] Code : [%d] is tranlated to error code : [0x%x]\n",
- msg_src_element, g_quark_to_string (error->domain), error->message, error->code, msg.param.code);
+ _mmcam_dbg_err("-Msg src : [%s] Domain : [%s] Error : [%s] Code : [%d] is tranlated to error code : [0x%x]",
+ msg_src_element, g_quark_to_string (error->domain), error->message, error->code, msg.param.code);
} else {
- debug_error("Domain : [%s] Error : [%s] Code : [%d] is tranlated to error code : [0x%x]\n",
- g_quark_to_string (error->domain), error->message, error->code, msg.param.code);
+ _mmcam_dbg_err("Domain : [%s] Error : [%s] Code : [%d] is tranlated to error code : [0x%x]",
+ g_quark_to_string (error->domain), error->message, error->code, msg.param.code);
}
+#ifdef _MMCAMCORDER_SKIP_GST_FLOW_ERROR
/* Check whether send this error to application */
if (msg.param.code == MM_ERROR_CAMCORDER_GST_FLOW_ERROR) {
_mmcam_dbg_log("We got the error. But skip it.");
return TRUE;
}
+#endif /* _MMCAMCORDER_SKIP_GST_FLOW_ERROR */
/* post error to application */
sc->error_occurs = TRUE;
{
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
_MMCamcorderSubContext *sc = NULL;
- GstElement *element =NULL;
+ GstElement *element = NULL;
mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
_mmcam_dbg_log("");
/* Specific plugin */
- /* video source */
- element = GST_ELEMENT_CAST(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
- if (GST_ELEMENT_CAST(message->src) == element) {
- switch (code) {
- case GST_RESOURCE_ERROR_BUSY:
- _mmcam_dbg_err("Video device [busy]");
- return MM_ERROR_CAMCORDER_DEVICE_BUSY;
- case GST_RESOURCE_ERROR_FAILED:
- _mmcam_dbg_err("Video device [working failed].");
- return MM_ERROR_CAMCORDER_DEVICE_IO;
- case GST_RESOURCE_ERROR_TOO_LAZY:
- _mmcam_dbg_err("Video device [timeout]");
- return MM_ERROR_CAMCORDER_DEVICE_TIMEOUT;
- case GST_RESOURCE_ERROR_OPEN_READ:
- _mmcam_dbg_err("Video device [open failed]");
- return MM_ERROR_CAMCORDER_DEVICE_OPEN;
- case GST_RESOURCE_ERROR_SETTINGS:
- _mmcam_dbg_err("Video device [Not supported]");
- return MM_ERROR_CAMCORDER_NOT_SUPPORTED;
- case GST_RESOURCE_ERROR_NOT_FOUND:
- _mmcam_dbg_err("Video device [Register trouble]");
- return MM_ERROR_CAMCORDER_DEVICE_REG_TROUBLE;
- default:
- _mmcam_dbg_err("Video device [General(%d)]", code);
- return MM_ERROR_CAMCORDER_DEVICE;
- }
- }
-
/* video sink */
element = GST_ELEMENT_CAST(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst);
if (GST_ELEMENT_CAST(message->src) == element) {
"AntiHandshake"
};
-static int __enum_conv_picture_format[MM_PIXEL_FORMAT_NUM];
-_MMCamcorderEnumConvert _mmcamcorder_enum_conv_picture_format =
+static int __enum_conv_video_stabilization[MM_CAMCORDER_VIDEO_STABILIZATION_NUM];
+
+_MMCamcorderEnumConvert _mmcamcorder_enum_conv_video_stabilization =
{
- MM_PIXEL_FORMAT_NUM,
- __enum_conv_picture_format,
- CONFIGURE_CATEGORY_CTRL_CAMERA,
- "PictureFormat"
+ MM_CAMCORDER_VIDEO_STABILIZATION_NUM,
+ __enum_conv_video_stabilization,
+ CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH,
+ "VideoStabilization"
};
-static int __enum_conv_vid_dev[MM_VIDEO_DEVICE_NUM] =
+
+static int __enum_conv_hdr_capture[MM_CAMCORDER_HDR_CAPTURE_NUM];
+
+_MMCamcorderEnumConvert _mmcamcorder_enum_conv_hdr_capture =
{
- //{Enum of (Plugin or Kernel) , Enum of MSL Camcorder}
- 2, //MM_VIDEO_DEVICE_CAMERA0
- 1, //MM_VIDEO_DEVICE_CAMERA1
+ MM_CAMCORDER_HDR_CAPTURE_NUM,
+ __enum_conv_hdr_capture,
+ CONFIGURE_CATEGORY_CTRL_CAPTURE,
+ "SupportHDR"
};
-_MMCamcorderEnumConvert _mmcamcorder_enum_conv_vid_dev =
+static int __enum_conv_detect_mode[MM_CAMCORDER_DETECT_MODE_NUM];
+
+_MMCamcorderEnumConvert _mmcamcorder_enum_conv_detect_mode =
{
- MM_VIDEO_DEVICE_NUM,
- __enum_conv_vid_dev,
- 0,
- NULL
+ MM_CAMCORDER_DETECT_MODE_NUM,
+ __enum_conv_detect_mode,
+ CONFIGURE_CATEGORY_CTRL_DETECT,
+ "DetectMode"
};
{
CONFIGURE_TYPE_MAIN,
CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT,
- MM_CAM_DISPLAY_SURFACE,
+ MM_CAM_DISPLAY_MODE,
MM_CAMCORDER_ATTR_NONE,
- "Videosink",
+ "DisplayMode",
MM_CAMCONVERT_TYPE_INT_ARRAY,
NULL,
},
-};
-
-static _MMCamcorderInfoConverting g_caminfo_convert[] = {
{
- CONFIGURE_TYPE_CTRL,
- CONFIGURE_CATEGORY_CTRL_CAMERA,
- MM_CAM_CAMERA_DEVICE,
+ CONFIGURE_TYPE_MAIN,
+ CONFIGURE_CATEGORY_MAIN_VIDEO_OUTPUT,
+ MM_CAM_DISPLAY_SURFACE,
MM_CAMCORDER_ATTR_NONE,
- "InputIndex",
+ "Videosink",
MM_CAMCONVERT_TYPE_INT_ARRAY,
- &_mmcamcorder_enum_conv_vid_dev,
+ NULL,
},
+};
+
+static _MMCamcorderInfoConverting g_caminfo_convert[CAMINFO_CONVERT_NUM] = {
{
CONFIGURE_TYPE_CTRL,
CONFIGURE_CATEGORY_CTRL_CAMERA,
MM_CAMCONVERT_TYPE_INT_ARRAY,
NULL,
},
- {
+ { /* 5 */
CONFIGURE_TYPE_CTRL,
CONFIGURE_CATEGORY_CTRL_CAMERA,
MM_CAM_CAMERA_FORMAT,
MM_CAMCONVERT_TYPE_INT_RANGE,
NULL,
},
- {
+ { /* 10 */
CONFIGURE_TYPE_CTRL,
CONFIGURE_CATEGORY_CTRL_EFFECT,
MM_CAM_FILTER_CONTRAST,
MM_CAMCONVERT_TYPE_INT_ARRAY,
&_mmcamcorder_enum_conv_whitebalance,
},
- {
+ { /* 15 */
CONFIGURE_TYPE_CTRL,
CONFIGURE_CATEGORY_CTRL_EFFECT,
MM_CAM_FILTER_COLOR_TONE,
MM_CAMCONVERT_TYPE_INT_ARRAY,
&_mmcamcorder_enum_conv_focus_mode,
},
- {
+ { /* 20 */
CONFIGURE_TYPE_CTRL,
CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH,
MM_CAM_CAMERA_AF_SCAN_RANGE,
MM_CAMCONVERT_TYPE_INT_ARRAY,
NULL,
},
- {
+ { /* 25 */
CONFIGURE_TYPE_CTRL,
CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH,
MM_CAM_CAMERA_ISO,
MM_CAMCONVERT_TYPE_INT_RANGE,
NULL,
},
- {
+ { /* 30 */
CONFIGURE_TYPE_CTRL,
CONFIGURE_CATEGORY_CTRL_CAPTURE,
MM_CAM_CAPTURE_COUNT,
},
{
CONFIGURE_TYPE_CTRL,
+ CONFIGURE_CATEGORY_CTRL_CAPTURE,
+ MM_CAM_CAMERA_HDR_CAPTURE,
+ MM_CAMCORDER_ATTR_NONE,
+ "SupportHDR",
+ MM_CAMCONVERT_TYPE_INT_ARRAY,
+ &_mmcamcorder_enum_conv_hdr_capture,
+ },
+ {
+ CONFIGURE_TYPE_CTRL,
CONFIGURE_CATEGORY_CTRL_DETECT,
MM_CAM_DETECT_MODE,
MM_CAMCORDER_ATTR_NONE,
"DetectMode",
MM_CAMCONVERT_TYPE_INT_ARRAY,
- NULL,
+ &_mmcamcorder_enum_conv_detect_mode,
},
{
CONFIGURE_TYPE_CTRL,
MM_CAMCONVERT_TYPE_INT_RANGE,
NULL,
},
- {
+ { /* 35 */
CONFIGURE_TYPE_CTRL,
CONFIGURE_CATEGORY_CTRL_DETECT,
MM_CAM_DETECT_SELECT_NUMBER,
MM_CAMCONVERT_TYPE_INT_ARRAY,
NULL,
},
+ {
+ CONFIGURE_TYPE_CTRL,
+ CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH,
+ MM_CAM_CAMERA_FACE_ZOOM_MODE,
+ MM_CAMCORDER_ATTR_NONE,
+ "FaceZoomMode",
+ MM_CAMCONVERT_TYPE_INT_ARRAY,
+ NULL,
+ },
+ {
+ CONFIGURE_TYPE_CTRL,
+ CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH,
+ MM_CAM_CAMERA_FACE_ZOOM_LEVEL,
+ MM_CAMCORDER_ATTR_NONE,
+ "FaceZoomLevel",
+ MM_CAMCONVERT_TYPE_INT_RANGE,
+ NULL,
+ },
+ {
+ CONFIGURE_TYPE_CTRL,
+ CONFIGURE_CATEGORY_CTRL_CAMERA,
+ MM_CAM_RECOMMEND_CAMERA_WIDTH,
+ MM_CAM_RECOMMEND_CAMERA_HEIGHT,
+ "RecommendPreviewResolution",
+ MM_CAMCONVERT_TYPE_INT_PAIR_ARRAY,
+ NULL,
+ },
+ { /* 40 */
+ CONFIGURE_TYPE_CTRL,
+ CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH,
+ MM_CAM_CAMERA_VIDEO_STABILIZATION,
+ MM_CAMCORDER_ATTR_NONE,
+ "VideoStabilization",
+ MM_CAMCONVERT_TYPE_INT_ARRAY,
+ &_mmcamcorder_enum_conv_video_stabilization,
+ }
};
/*---------------------------------------------------------------------------
| GLOBAL FUNCTION DEFINITIONS: |
---------------------------------------------------------------------------*/
//convert MSL value to sensor value
-int _mmcamcorder_convert_msl_to_sensor( int attr_idx, int mslval )
+int _mmcamcorder_convert_msl_to_sensor(MMHandleType handle, int attr_idx, int mslval)
{
+ mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
_MMCamcorderInfoConverting *info = NULL;
int i =0;
int size = sizeof(g_caminfo_convert) / sizeof(_MMCamcorderInfoConverting);
+ mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
+
//_mmcam_dbg_log("attr_idx(%d), mslval(%d)", attr_idx, mslval);
- info = g_caminfo_convert;
-
+ info = hcamcorder->caminfo_convert;
+
for (i = 0; i < size; i++)
{
if (info[i].attr_idx == attr_idx)
}
_mmcam_dbg_warn("There is no category to match. Just return the original value.");
+
return mslval;
}
//convert sensor value to MSL value
-int _mmcamcorder_convert_sensor_to_msl(int attr_idx, int sensval)
+int _mmcamcorder_convert_sensor_to_msl(MMHandleType handle, int attr_idx, int sensval)
{
+ mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
+ _MMCamcorderInfoConverting *info = NULL;
int i = 0, j = 0;
int size = sizeof(g_caminfo_convert) / sizeof(_MMCamcorderInfoConverting);
-
- _MMCamcorderInfoConverting *info = NULL;
- info = g_caminfo_convert;
+ mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
+
+ info = hcamcorder->caminfo_convert;
for( i = 0 ; i < size ; i++ )
{
int _mmcamcorder_init_attr_from_configure(MMHandleType handle)
{
- _MMCamcorderInfoConverting *info = NULL;
+ mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
+ _MMCamcorderInfoConverting *info = NULL;
int table_size = 0;
int ret = MM_ERROR_NONE;
+ mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
+
_mmcam_dbg_log("");
/* Initialize attribute related to camera control */
- info = g_caminfo_convert;
+ info = hcamcorder->caminfo_convert;
table_size = sizeof(g_caminfo_convert) / sizeof(_MMCamcorderInfoConverting);
ret = __mmcamcorder_set_info_to_attr( handle, info, table_size );
if( ret != MM_ERROR_NONE )
info[i].main_key, info[i].sub_key1, iarray, iarray_size, idefault);
*/
- mmf_attrs_set_valid_type (attrs, info[i].attr_idx, MM_ATTRS_VALID_TYPE_INT_ARRAY);
- mmf_attrs_set_valid_array (attrs, info[i].attr_idx, iarray, iarray_size);
+ mmf_attrs_set_valid_type(attrs, info[i].attr_idx, MM_ATTRS_VALID_TYPE_INT_ARRAY);
+ mmf_attrs_set_valid_array(attrs, info[i].attr_idx, iarray, iarray_size, idefault);
}
ret = mm_attrs_set_int(MMF_CAMCORDER_ATTRS(hcamcorder), info[i].attr_idx, idefault);
//_mmcam_dbg_log("INT Range. m:%d, s:%d, min=%d, max=%d", info[i].main_key, info[i].sub_key1, irange->min, irange->max);
mmf_attrs_set_valid_type (attrs, info[i].attr_idx, MM_ATTRS_VALID_TYPE_INT_RANGE);
- mmf_attrs_set_valid_range(attrs, info[i].attr_idx, irange->min, irange->max);
+ mmf_attrs_set_valid_range(attrs, info[i].attr_idx, irange->min, irange->max, irange->default_value);
ret = mm_attrs_set_int(MMF_CAMCORDER_ATTRS(hcamcorder), info[i].attr_idx, irange->default_value);
}
if( pair_array && pair_array->count > 0 )
{
- mmf_attrs_set_valid_type (attrs, info[i].attr_idx, MM_ATTRS_VALID_TYPE_INT_ARRAY);
- mmf_attrs_set_valid_array (attrs, info[i].attr_idx, pair_array->value[0], pair_array->count);
- mmf_attrs_set_valid_type (attrs, info[i].attr_idx_pair, MM_ATTRS_VALID_TYPE_INT_ARRAY);
- mmf_attrs_set_valid_array (attrs, info[i].attr_idx_pair, pair_array->value[1], pair_array->count);
+ mmf_attrs_set_valid_type(attrs, info[i].attr_idx, MM_ATTRS_VALID_TYPE_INT_ARRAY);
+ mmf_attrs_set_valid_array(attrs, info[i].attr_idx,
+ pair_array->value[0],
+ pair_array->count,
+ pair_array->default_value[0]);
+ mmf_attrs_set_valid_type(attrs, info[i].attr_idx_pair, MM_ATTRS_VALID_TYPE_INT_ARRAY);
+ mmf_attrs_set_valid_array(attrs, info[i].attr_idx_pair,
+ pair_array->value[1],
+ pair_array->count,
+ pair_array->default_value[1]);
mm_attrs_set_int(MMF_CAMCORDER_ATTRS(hcamcorder), info[i].attr_idx, pair_array->default_value[0]);
mm_attrs_set_int(MMF_CAMCORDER_ATTRS(hcamcorder), info[i].attr_idx_pair, pair_array->default_value[1]);
int _mmcamcorder_init_convert_table(MMHandleType handle)
{
- mmf_return_val_if_fail(handle, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
-
- _mmcamcorder_set_converted_value(handle, &_mmcamcorder_enum_conv_whitebalance);
- _mmcamcorder_set_converted_value(handle, &_mmcamcorder_enum_conv_colortone);
- _mmcamcorder_set_converted_value(handle, &_mmcamcorder_enum_conv_iso);
- _mmcamcorder_set_converted_value(handle, &_mmcamcorder_enum_conv_prgrm);
- _mmcamcorder_set_converted_value(handle, &_mmcamcorder_enum_conv_focus_mode);
- _mmcamcorder_set_converted_value(handle, &_mmcamcorder_enum_conv_focus_type);
- _mmcamcorder_set_converted_value(handle, &_mmcamcorder_enum_conv_ae_type);
-// _mmcamcorder_set_converted_value(handle, &_mmcamcorder_enum_conv_pcolor_mode);
-// _mmcamcorder_set_converted_value(handle, &_mmcamcorder_enum_conv_flip);
-// _mmcamcorder_set_converted_value(handle, &_mmcamcorder_enum_conv_pcolor);
- _mmcamcorder_set_converted_value(handle, &_mmcamcorder_enum_conv_strobe_mode);
- _mmcamcorder_set_converted_value(handle, &_mmcamcorder_enum_conv_wdr_ctrl);
- _mmcamcorder_set_converted_value(handle, &_mmcamcorder_enum_conv_ahs);
-// _mmcamcorder_set_converted_value(handle, &_mmcamcorder_enum_conv_picture_format);
+ mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
+ int enum_conv_size = sizeof(_MMCamcorderEnumConvert);
+ int caminfo_conv_size = sizeof(g_caminfo_convert);
+ int caminfo_conv_length = sizeof(g_caminfo_convert) / sizeof(_MMCamcorderInfoConverting);
+ int i = 0;
+
+ mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
+
+ /* copy default conv data into memory of handle */
+ memcpy(&(hcamcorder->caminfo_convert), &g_caminfo_convert, caminfo_conv_size);
+ memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_WHITE_BALANCE]), &_mmcamcorder_enum_conv_whitebalance, enum_conv_size);
+ memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_COLOR_TONE]), &_mmcamcorder_enum_conv_colortone, enum_conv_size);
+ memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_ISO]), &_mmcamcorder_enum_conv_iso, enum_conv_size);
+ memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_PROGRAM_MODE]), &_mmcamcorder_enum_conv_prgrm, enum_conv_size);
+ memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_FOCUS_MODE]), &_mmcamcorder_enum_conv_focus_mode, enum_conv_size);
+ memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_AF_RANGE]), &_mmcamcorder_enum_conv_focus_type, enum_conv_size);
+ memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_EXPOSURE_MODE]), &_mmcamcorder_enum_conv_ae_type, enum_conv_size);
+ memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_STROBE_MODE]), &_mmcamcorder_enum_conv_strobe_mode, enum_conv_size);
+ memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_WDR]), &_mmcamcorder_enum_conv_wdr_ctrl, enum_conv_size);
+ memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_ANTI_HAND_SHAKE]), &_mmcamcorder_enum_conv_ahs, enum_conv_size);
+ memcpy(&(hcamcorder->enum_conv[ENUM_CONVERT_VIDEO_STABILIZATION]), &_mmcamcorder_enum_conv_video_stabilization, enum_conv_size);
+
+ /* set ini info to conv data */
+ _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_WHITE_BALANCE]));
+ _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_COLOR_TONE]));
+ _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_ISO]));
+ _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_PROGRAM_MODE]));
+ _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_FOCUS_MODE]));
+ _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_AF_RANGE]));
+ _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_EXPOSURE_MODE]));
+ _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_STROBE_MODE]));
+ _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_WDR]));
+ _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_ANTI_HAND_SHAKE]));
+ _mmcamcorder_set_converted_value(handle, &(hcamcorder->enum_conv[ENUM_CONVERT_VIDEO_STABILIZATION]));
+
+ /* set modified conv data to handle */
+ for (i = 0 ; i < caminfo_conv_length ; i++) {
+ if (hcamcorder->caminfo_convert[i].type == CONFIGURE_TYPE_CTRL) {
+ switch (hcamcorder->caminfo_convert[i].category) {
+ case CONFIGURE_CATEGORY_CTRL_STROBE:
+ if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "StrobeMode")) {
+ hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_STROBE_MODE]);
+ }
+ break;
+ case CONFIGURE_CATEGORY_CTRL_EFFECT:
+ if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "WhiteBalance")) {
+ hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_WHITE_BALANCE]);
+ } else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "ColorTone")) {
+ hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_COLOR_TONE]);
+ } else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "WDR")) {
+ hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_WDR]);
+ }
+ break;
+ case CONFIGURE_CATEGORY_CTRL_PHOTOGRAPH:
+ if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "FocusMode")) {
+ hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_FOCUS_MODE]);
+ } else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "AFType")) {
+ hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_AF_RANGE]);
+ } else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "AEType")) {
+ hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_EXPOSURE_MODE]);
+ } else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "ISO")) {
+ hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_ISO]);
+ } else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "ProgramMode")) {
+ hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_PROGRAM_MODE]);
+ } else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "AntiHandshake")) {
+ hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_ANTI_HAND_SHAKE]);
+ } else if (!strcmp(hcamcorder->caminfo_convert[i].keyword, "VideoStabilization")) {
+ hcamcorder->caminfo_convert[i].enum_convert = &(hcamcorder->enum_conv[ENUM_CONVERT_VIDEO_STABILIZATION]);
+ }
+ break;
+ default:
+ break;
+ }
+ }
+ }
return MM_ERROR_NONE;
}
=======================================================================================*/
#include <mm_sound.h>
#include <mm_sound_private.h>
+#include <avsystem.h>
#include <audio-session-manager.h>
#include "mm_camcorder_internal.h"
#include "mm_camcorder_sound.h"
/*---------------------------------------------------------------------------------------
| LOCAL VARIABLE DEFINITIONS for internal |
---------------------------------------------------------------------------------------*/
-#define BLOCK_SIZE 2048
+#define SAMPLE_SOUND_NAME "camera-shutter"
+#define SAMPLE_SOUND_RATE 44100
+#define DEFAULT_ACTIVE_DEVICE -1
+
+enum {
+ SOUND_DEVICE_TYPE_SPEAKER, /* AVSYS_AUDIO_LVOL_DEV_TYPE_SPK */
+ SOUND_DEVICE_TYPE_HEADSET, /* AVSYS_AUDIO_LVOL_DEV_TYPE_HEADSET */
+ SOUND_DEVICE_TYPE_BTHEADSET, /* AVSYS_AUDIO_LVOL_DEV_TYPE_BTHEADSET */
+ SOUND_DEVICE_TYPE_NUM /* AVSYS_AUDIO_LVOL_DEV_TYPE_MAX */
+};
/*---------------------------------------------------------------------------------------
| LOCAL FUNCTION PROTOTYPES: |
---------------------------------------------------------------------------------------*/
-static gboolean __prepare_buffer(SOUND_INFO *info, char *filename);
-static gboolean __cleanup_buffer(SOUND_INFO *info);
-static void *__sound_open_thread_func(void *data);
-static void *__sound_write_thread_func(void *data);
static void __solo_sound_callback(void *data);
-static gboolean __prepare_buffer(SOUND_INFO *info, char *filename)
+
+static void __pulseaudio_context_state_cb(pa_context *pulse_context, void *user_data)
{
- mmf_return_val_if_fail(info, FALSE);
- mmf_return_val_if_fail(filename, FALSE);
+ int state = 0;
+ SOUND_INFO *info = NULL;
- info->infile = sf_open(filename, SFM_READ, &info->sfinfo);
- if (!(info->infile)) {
- _mmcam_dbg_err("failed to open file [%s]", filename);
- return FALSE;
- }
+ mmf_return_if_fail(user_data);
- _mmcam_dbg_log("SOUND: frame = %lld", info->sfinfo.frames);
- _mmcam_dbg_log("SOUND: sameplerate = %d", info->sfinfo.samplerate);
- _mmcam_dbg_log("SOUND: channel = %d", info->sfinfo.channels);
- _mmcam_dbg_log("SOUND: format = 0x%x", info->sfinfo.format);
-
- info->pcm_size = info->sfinfo.frames * info->sfinfo.channels * 2;
- info->pcm_buf = (short *)malloc(info->pcm_size);
- if (info->pcm_buf == NULL) {
- _mmcam_dbg_err("pcm_buf malloc failed");
- sf_close(info->infile);
- info->infile = NULL;
- return FALSE;
+ info = (SOUND_INFO *)user_data;
+
+ state = pa_context_get_state(pulse_context);
+ switch (state) {
+ case PA_CONTEXT_READY:
+ _mmcam_dbg_log("pulseaudio context READY");
+ if (info->pulse_context == pulse_context) {
+ /* Signal */
+ _mmcam_dbg_log("pulseaudio send signal");
+ pa_threaded_mainloop_signal(info->pulse_mainloop, 0);
+ }
+ break;
+ case PA_CONTEXT_TERMINATED:
+ if (info->pulse_context == pulse_context) {
+ /* Signal */
+ _mmcam_dbg_log("Context terminated : pulseaudio send signal");
+ pa_threaded_mainloop_signal(info->pulse_mainloop, 0);
+ }
+ break;
+ case PA_CONTEXT_UNCONNECTED:
+ case PA_CONTEXT_CONNECTING:
+ case PA_CONTEXT_AUTHORIZING:
+ case PA_CONTEXT_SETTING_NAME:
+ case PA_CONTEXT_FAILED:
+ default:
+ _mmcam_dbg_log("pulseaudio context %p, state %d",
+ pulse_context, state);
+ break;
}
- sf_read_short(info->infile, info->pcm_buf, info->pcm_size);
- return TRUE;
+ return;
}
-
-static gboolean __cleanup_buffer(SOUND_INFO *info)
+#ifdef _MMCAMCORDER_UPLOAD_SAMPLE
+static void __pulseaudio_stream_write_cb(pa_stream *stream, size_t length, void *user_data)
{
- mmf_return_val_if_fail(info, FALSE);
+ sf_count_t read_length;
+ short *data;
+ SOUND_INFO *info = NULL;
- if (info->infile) {
- sf_close(info->infile);
- info->infile = NULL;
- }
+ mmf_return_if_fail(user_data);
+
+ info = (SOUND_INFO *)user_data;
+
+ _mmcam_dbg_log("START");
- if (info->pcm_buf) {
- free(info->pcm_buf);
- info->pcm_buf = NULL;
+ data = pa_xmalloc(length);
+
+ read_length = (sf_count_t)(length/pa_frame_size(&(info->sample_spec)));
+
+ if ((sf_readf_short(info->infile, data, read_length)) != read_length) {
+ pa_xfree(data);
+ return;
}
- _mmcam_dbg_log("Done");
+ pa_stream_write(stream, data, length, pa_xfree, 0, PA_SEEK_RELATIVE);
- return TRUE;
+ info->sample_length -= length;
+
+ if (info->sample_length <= 0) {
+ pa_stream_set_write_callback(info->sample_stream, NULL, NULL);
+ pa_stream_finish_upload(info->sample_stream);
+
+ pa_threaded_mainloop_signal(info->pulse_mainloop, 0);
+ _mmcam_dbg_log("send signal DONE");
+ }
+
+ _mmcam_dbg_log("DONE read_length %d", read_length);
}
-static void *__sound_open_thread_func(void *data)
+static void __pulseaudio_remove_sample_finish_cb(pa_context *pulse_context, int success, void *user_data)
+{
+ SOUND_INFO *info = NULL;
+
+ mmf_return_if_fail(user_data);
+
+ info = (SOUND_INFO *)user_data;
+
+ _mmcam_dbg_log("START");
+
+ pa_threaded_mainloop_signal(info->pulse_mainloop, 0);
+
+ _mmcam_dbg_log("DONE");
+}
+#endif /* _MMCAMCORDER_UPLOAD_SAMPLE */
+
+#ifdef _MMCAMCORDER_UPLOAD_SAMPLE
+gboolean _mmcamcorder_sound_init(MMHandleType handle, char *filename)
+#else /* _MMCAMCORDER_UPLOAD_SAMPLE */
+gboolean _mmcamcorder_sound_init(MMHandleType handle)
+#endif /* _MMCAMCORDER_UPLOAD_SAMPLE */
{
int ret = 0;
- system_audio_route_t route = SYSTEM_AUDIO_ROUTE_POLICY_HANDSET_ONLY;
+ int sound_enable = TRUE;
+ mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
SOUND_INFO *info = NULL;
- mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(data);
+ mm_sound_device_in device_in;
+ mm_sound_device_out device_out;
+ pa_mainloop_api *api = NULL;
- mmf_return_val_if_fail(hcamcorder, NULL);
+ mmf_return_val_if_fail(hcamcorder, FALSE);
- MMTA_ACUM_ITEM_BEGIN(" __sound_open_thread_func", FALSE);
+ /* check sound play enable */
+ ret = mm_camcorder_get_attributes((MMHandleType)hcamcorder, NULL,
+ "capture-sound-enable", &sound_enable,
+ NULL);
+ _mmcam_dbg_log("Capture sound enable %d", sound_enable);
+ if (!sound_enable) {
+ return TRUE;
+ }
info = &(hcamcorder->snd_info);
- __ta__(" __prepare_buffer",
- ret = __prepare_buffer(info, info->filename);
- );
- if (ret == FALSE) {
- goto EXIT_FUNC;
+ pthread_mutex_lock(&(info->open_mutex));
+
+ if (info->state > _MMCAMCORDER_SOUND_STATE_NONE) {
+ _mmcam_dbg_warn("already initialized [%d]", info->state);
+ pthread_mutex_unlock(&(info->open_mutex));
+ return TRUE;
}
- __ta__(" mm_sound_pcm_play_open",
- ret = mm_sound_pcm_play_open_ex(&(info->handle), info->sfinfo.samplerate,
- (info->sfinfo.channels == 1) ? MMSOUND_PCM_MONO : MMSOUND_PCM_STEREO,
- MMSOUND_PCM_S16_LE, VOLUME_TYPE_FIXED, ASM_EVENT_EXCLUSIVE_MMSOUND);
- );
- if (ret < 0) {
- /* error */
- _mmcam_dbg_err("mm_sound_pcm_play_open failed [%x]", ret);
- __cleanup_buffer(info);
- goto EXIT_FUNC;
- } else {
- /* success */
- info->state = _MMCAMCORDER_SOUND_STATE_PREPARE;
- _mmcam_dbg_log("mm_sound_pcm_play_open succeeded. state [%d]", info->state);
+#ifdef _MMCAMCORDER_UPLOAD_SAMPLE
+ if (info->filename) {
+ free(info->filename);
+ info->filename = NULL;
}
- ret = mm_sound_route_get_system_policy(&route);
- if (ret != MM_ERROR_NONE) {
- _mmcam_dbg_err("mm_sound_route_get_system_policy failed [%x]", ret);
- goto POLICY_ERROR;
+ info->filename = strdup(filename);
+ if (info->filename == NULL) {
+ _mmcam_dbg_err("strdup failed");
+ return FALSE;
}
+#endif /* _MMCAMCORDER_UPLOAD_SAMPLE */
- _mmcam_dbg_log("current policy [%d]", route);
+ pthread_mutex_init(&(info->play_mutex), NULL);
+ pthread_cond_init(&(info->play_cond), NULL);
- if (route != SYSTEM_AUDIO_ROUTE_POLICY_HANDSET_ONLY) {
- ret = mm_sound_route_set_system_policy(SYSTEM_AUDIO_ROUTE_POLICY_HANDSET_ONLY);
- if (ret != MM_ERROR_NONE) {
- _mmcam_dbg_err("mm_sound_route_set_system_policy failed [%x]", ret);
- goto POLICY_ERROR;
+#ifdef _MMCAMCORDER_UPLOAD_SAMPLE
+ /* read sample */
+ memset (&(info->sfinfo), 0, sizeof(SF_INFO));
+ info->infile = sf_open(info->filename, SFM_READ, &(info->sfinfo));
+ if (!(info->infile)) {
+ _mmcam_dbg_err("Failed to open sound file");
+ goto SOUND_INIT_ERROR;
+ }
+#endif /* _MMCAMCORDER_UPLOAD_SAMPLE */
+
+ if (hcamcorder->shutter_sound_policy == VCONFKEY_CAMERA_SHUTTER_SOUND_POLICY_ON) {
+ int errorcode;
+ ASM_resource_t mm_resource = mm_resource = ASM_RESOURCE_CAMERA | ASM_RESOURCE_VIDEO_OVERLAY | ASM_RESOURCE_HW_ENCODER;
+
+ /* set EXCLUSIVE session as PLAYING to pause other session */
+ if (!ASM_set_sound_state(hcamcorder->asm_handle_ex, ASM_EVENT_EXCLUSIVE_MMCAMCORDER,
+ ASM_STATE_PLAYING, mm_resource, &errorcode)) {
+ _mmcam_dbg_err("Set state to playing failed 0x%x", errorcode);
+ ret = MM_ERROR_POLICY_BLOCKED;
+ goto SOUND_INIT_ERROR;
}
- info->route_policy_backup = route;
+ _mmcam_dbg_log("EXCLUSIVE session PLAYING done.");
+ } else {
+ _mmcam_dbg_log("do not register session to pause another playing session");
}
-EXIT_FUNC:
- pthread_cond_signal(&(info->open_cond));
- pthread_mutex_unlock(&(info->open_mutex));
+ /**
+ * Init Pulseaudio thread
+ */
+ /* create pulseaudio mainloop */
+ info->pulse_mainloop = pa_threaded_mainloop_new();
+ ret = pa_threaded_mainloop_start(info->pulse_mainloop);
+
+ /* lock pulseaudio thread */
+ pa_threaded_mainloop_lock(info->pulse_mainloop);
+ /* get pulseaudio api */
+ api = pa_threaded_mainloop_get_api(info->pulse_mainloop);
+ /* create pulseaudio context */
+ info->pulse_context = pa_context_new(api, NULL);
+ /* set pulseaudio context callback */
+ pa_context_set_state_callback(info->pulse_context, __pulseaudio_context_state_cb, info);
+
+ if (pa_context_connect(info->pulse_context, NULL, PA_CONTEXT_NOAUTOSPAWN, NULL) < 0) {
+ _mmcam_dbg_err("pa_context_connect error");
+ }
- _mmcam_dbg_log("Done");
+ /* wait READY state of pulse context */
+ while (TRUE) {
+ pa_context_state_t state = pa_context_get_state(info->pulse_context);
- MMTA_ACUM_ITEM_END(" __sound_open_thread_func", FALSE);
+ _mmcam_dbg_log("pa context state is now %d", state);
- return NULL;
+ if (!PA_CONTEXT_IS_GOOD (state)) {
+ _mmcam_dbg_log("connection failed");
+ break;
+ }
-POLICY_ERROR:
- pthread_mutex_unlock(&(info->open_mutex));
- _mmcamcorder_sound_finalize((MMHandleType)hcamcorder);
+ if (state == PA_CONTEXT_READY) {
+ _mmcam_dbg_log("pa context READY");
+ break;
+ }
- return NULL;
-}
+ /* Wait until the context is ready */
+ _mmcam_dbg_log("waiting..................");
+ pa_threaded_mainloop_wait(info->pulse_mainloop);
+ _mmcam_dbg_log("waiting DONE. check again...");
+ }
+ /* unlock pulseaudio thread */
+ pa_threaded_mainloop_unlock(info->pulse_mainloop);
-static void *__sound_write_thread_func(void *data)
-{
- int ret = 0;
- int bytes_to_write = 0;
- int remain_bytes = 0;
- system_audio_route_t route = SYSTEM_AUDIO_ROUTE_POLICY_HANDSET_ONLY;
- char *buffer_to_write = NULL;
- SOUND_INFO *info = NULL;
- mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(data);
+#ifdef _MMCAMCORDER_UPLOAD_SAMPLE
+ /**
+ * Upload sample
+ */
+ if (pa_sndfile_read_sample_spec(info->infile, &(info->sample_spec)) < 0) {
+ _mmcam_dbg_err("Failed to determine sample specification from file");
+ goto SOUND_INIT_ERROR;
+ }
- mmf_return_val_if_fail(hcamcorder, NULL);
+ info->sample_spec.format = PA_SAMPLE_S16LE;
- info = &(hcamcorder->snd_info);
+ if (pa_sndfile_read_channel_map(info->infile, &(info->channel_map)) < 0) {
+ pa_channel_map_init_extend(&(info->channel_map), info->sample_spec.channels, PA_CHANNEL_MAP_DEFAULT);
- _mmcam_dbg_log("RUN sound write thread");
+ if (info->sample_spec.channels > 2) {
+ _mmcam_dbg_warn("Failed to determine sample specification from file");
+ }
+ }
- pthread_mutex_lock(&(info->play_mutex));
+ info->sample_length = (size_t)info->sfinfo.frames * pa_frame_size(&(info->sample_spec));
- do {
- pthread_cond_wait(&(info->play_cond), &(info->play_mutex));
+ pa_threaded_mainloop_lock(info->pulse_mainloop);
- _mmcam_dbg_log("Signal received. Play sound.");
+ /* prepare uploading */
+ info->sample_stream = pa_stream_new(info->pulse_context, SAMPLE_SOUND_NAME, &(info->sample_spec), NULL);
+ /* set stream write callback */
+ pa_stream_set_write_callback(info->sample_stream, __pulseaudio_stream_write_cb, info);
+ /* upload sample (ASYNC) */
+ pa_stream_connect_upload(info->sample_stream, info->sample_length);
+ /* wait for upload completion */
+ pa_threaded_mainloop_wait(info->pulse_mainloop);
- if (info->thread_run == FALSE) {
- _mmcam_dbg_log("Exit thread command is detected");
- break;
- }
+ pa_threaded_mainloop_unlock (info->pulse_mainloop);
- ret = mm_sound_route_get_system_policy(&route);
- if (ret != MM_ERROR_NONE) {
- _mmcam_dbg_err("get_system_policy failed [%x]. skip sound play.", ret);
- break;
- }
-
- _mmcam_dbg_log("current policy [%d]", route);
+ /* close sndfile */
+ sf_close(info->infile);
+ info->infile = NULL;
+#endif /* _MMCAMCORDER_UPLOAD_SAMPLE */
- if (route != SYSTEM_AUDIO_ROUTE_POLICY_HANDSET_ONLY) {
- ret = mm_sound_route_set_system_policy(SYSTEM_AUDIO_ROUTE_POLICY_HANDSET_ONLY);
- if (ret != MM_ERROR_NONE) {
- _mmcam_dbg_err("set_system_policy failed. skip sound play.");
- break;
- }
+ if (hcamcorder->shutter_sound_policy == VCONFKEY_CAMERA_SHUTTER_SOUND_POLICY_ON) {
+ /* backup current route */
+ info->active_out_backup = DEFAULT_ACTIVE_DEVICE;
- info->route_policy_backup = route;
+ __ta__(" mm_sound_get_active_device",
+ ret = mm_sound_get_active_device(&device_in, &device_out);
+ );
+ if (ret != MM_ERROR_NONE) {
+ _mmcam_dbg_err("mm_sound_get_active_device failed [%x]. skip sound play.", ret);
+ goto SOUND_INIT_ERROR;
}
- buffer_to_write = (char *)info->pcm_buf;
- remain_bytes = info->pcm_size;
- bytes_to_write = 0;
+ _mmcam_dbg_log("current out [%x]", device_out);
- while (remain_bytes) {
- bytes_to_write = (remain_bytes >= BLOCK_SIZE) ? BLOCK_SIZE : remain_bytes;
- ret = mm_sound_pcm_play_write(info->handle, buffer_to_write, bytes_to_write);
- if (ret != bytes_to_write) {
- _mmcam_dbg_err("pcm write error [%x]", ret);
+ if (device_out != MM_SOUND_DEVICE_OUT_SPEAKER) {
+ ret = mm_sound_set_active_route (MM_SOUND_ROUTE_OUT_SPEAKER);
+ if (ret != MM_ERROR_NONE) {
+ _mmcam_dbg_err("mm_sound_set_active_route failed [%x]. skip sound play.", ret);
+ goto SOUND_INIT_ERROR;
}
- remain_bytes -= bytes_to_write;
- buffer_to_write += bytes_to_write;
+ info->active_out_backup = device_out;
}
- } while (TRUE);
-
- pthread_mutex_unlock(&(info->play_mutex));
-
- _mmcam_dbg_log("END sound write thread");
-
- return NULL;
-}
+ }
+ info->state = _MMCAMCORDER_SOUND_STATE_INIT;
-gboolean _mmcamcorder_sound_init(MMHandleType handle, char *filename)
-{
- int ret = 0;
- mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
- SOUND_INFO *info = NULL;
-
- mmf_return_val_if_fail(hcamcorder, FALSE);
+ _mmcam_dbg_log("init DONE");
- info = &(hcamcorder->snd_info);
+ pthread_mutex_unlock(&(info->open_mutex));
- pthread_mutex_lock(&(info->open_mutex));
+ return TRUE;
- if (info->state > _MMCAMCORDER_SOUND_STATE_NONE) {
- _mmcam_dbg_warn("already initialized [%d]", info->state);
- pthread_mutex_unlock(&(info->open_mutex));
- return FALSE;
- }
+SOUND_INIT_ERROR:
+#ifdef _MMCAMCORDER_UPLOAD_SAMPLE
+ /**
+ * Release allocated resources
+ */
if (info->filename) {
free(info->filename);
info->filename = NULL;
}
+#endif /* _MMCAMCORDER_UPLOAD_SAMPLE */
+
+ /* remove pulse mainloop */
+ if (info->pulse_mainloop) {
+ /* remove pulse context */
+ if (info->pulse_context) {
+#ifdef _MMCAMCORDER_UPLOAD_SAMPLE
+ /* remove uploaded sample */
+ if (info->sample_stream) {
+ pa_threaded_mainloop_lock(info->pulse_mainloop);
+
+ /* Remove sample (ASYNC) */
+ pa_operation_unref(pa_context_remove_sample(info->pulse_context, SAMPLE_SOUND_NAME, __pulseaudio_remove_sample_finish_cb, info));
+
+ /* Wait for async operation */
+ pa_threaded_mainloop_wait(info->pulse_mainloop);
+ }
+#endif /* _MMCAMCORDER_UPLOAD_SAMPLE */
- info->filename = strdup(filename);
- if (info->filename == NULL) {
- _mmcam_dbg_err("strdup failed");
- ret = FALSE;
- } else {
- pthread_mutex_init(&(info->play_mutex), NULL);
- pthread_cond_init(&(info->play_cond), NULL);
- if (pthread_create(&(info->thread), NULL, __sound_write_thread_func, (void *)handle) == 0) {
- info->thread_run = TRUE;
- info->state = _MMCAMCORDER_SOUND_STATE_INIT;
- info->route_policy_backup = -1;
- _mmcam_dbg_log("write thread created");
- ret = TRUE;
- } else {
- _mmcam_dbg_err("failed to create write thread");
- free(info->filename);
- info->filename = NULL;
- ret = FALSE;
+ /* Make sure we don't get any further callbacks */
+ pa_context_set_state_callback(info->pulse_context, NULL, NULL);
+
+ pa_context_disconnect(info->pulse_context);
+ pa_context_unref(info->pulse_context);
+ info->pulse_context = NULL;
}
+
+ pa_threaded_mainloop_stop(info->pulse_mainloop);
+ pa_threaded_mainloop_free(info->pulse_mainloop);
+ info->pulse_mainloop = NULL;
}
+ /* remove mutex and cond */
+ pthread_mutex_destroy(&(info->play_mutex));
+ pthread_cond_destroy(&(info->play_cond));
+
pthread_mutex_unlock(&(info->open_mutex));
- return ret;
+ return FALSE;
}
-gboolean _mmcamcorder_sound_prepare(MMHandleType handle)
+gboolean _mmcamcorder_sound_play(MMHandleType handle)
{
- int ret = FALSE;
- pthread_t open_thread;
+ int ret = 0;
+ int sound_enable = TRUE;
+ int volume_type = AVSYS_AUDIO_VOLUME_TYPE_FIXED;
+ int device_type = SOUND_DEVICE_TYPE_SPEAKER;
+ int left_volume = 0, right_volume = 0;
+ float left_gain = 1.0f, right_gain = 1.0f;
+ int set_volume = 0;
+ int max_level = 0;
+ unsigned int volume_level;
+
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
SOUND_INFO *info = NULL;
+ pa_operation *pulse_op = NULL;
mmf_return_val_if_fail(hcamcorder, FALSE);
+ /* check sound play enable */
+ ret = mm_camcorder_get_attributes((MMHandleType)hcamcorder, NULL,
+ "capture-sound-enable", &sound_enable,
+ NULL);
+ _mmcam_dbg_log("Capture sound enable %d", sound_enable);
+ if (!sound_enable) {
+ return TRUE;
+ }
+
info = &(hcamcorder->snd_info);
pthread_mutex_lock(&(info->open_mutex));
- if (info->state == _MMCAMCORDER_SOUND_STATE_INIT) {
- if (pthread_create(&open_thread, NULL, __sound_open_thread_func, (void *)handle) == 0) {
- _mmcam_dbg_log("open thread created");
- ret = TRUE;
- } else {
- _mmcam_dbg_err("failed to create open thread");
- ret = FALSE;
- pthread_mutex_unlock(&(info->open_mutex));
- }
- } else {
- _mmcam_dbg_warn("Wrong state [%d]", info->state);
- ret = FALSE;
+ if (info->state < _MMCAMCORDER_SOUND_STATE_INIT) {
+ _mmcam_dbg_log("not initialized state:[%d]", info->state);
pthread_mutex_unlock(&(info->open_mutex));
+ return FALSE;
}
- return ret;
-}
+ /* get volume level and set volume */
+ if (hcamcorder->shutter_sound_policy == VCONFKEY_CAMERA_SHUTTER_SOUND_POLICY_OFF) {
+ gboolean sound_status = hcamcorder->sub_context->info_image->sound_status;
+ mm_sound_device_in device_in = MM_SOUND_DEVICE_IN_NONE;
+ mm_sound_device_out device_out = MM_SOUND_DEVICE_OUT_NONE;
+ volume_type = AVSYS_AUDIO_VOLUME_TYPE_MEDIA;
+ avsys_audio_get_volume_max_ex(volume_type, &max_level);
-gboolean _mmcamcorder_sound_play(MMHandleType handle)
-{
- mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
- SOUND_INFO *info = NULL;
+ /* get sound path */
+ __ta__(" mm_sound_get_active_device",
+ mm_sound_get_active_device(&device_in, &device_out);
+ );
- mmf_return_val_if_fail(hcamcorder, FALSE);
+ _mmcam_dbg_log("sound status %d, device out %x", sound_status, device_out);
- info = &(hcamcorder->snd_info);
+ if (device_out == MM_SOUND_DEVICE_OUT_WIRED_ACCESSORY) {
+ device_type = SOUND_DEVICE_TYPE_HEADSET;
+ } else if (device_out == MM_SOUND_DEVICE_OUT_BT_A2DP) {
+ device_type = SOUND_DEVICE_TYPE_BTHEADSET;
+ }
- pthread_mutex_lock(&(info->open_mutex));
+ if (sound_status || device_out != MM_SOUND_DEVICE_OUT_SPEAKER) {
+ volume_level = hcamcorder->sub_context->info_image->volume_level;
+ _mmcam_dbg_log("current volume level %d", volume_level);
+ } else {
+ volume_level = 0;
+ _mmcam_dbg_log("current state is SILENT mode and SPEAKER output");
+ }
- if (info->state < _MMCAMCORDER_SOUND_STATE_PREPARE) {
- _mmcam_dbg_log("not initialized state:[%d]", info->state);
- pthread_mutex_unlock(&(info->open_mutex));
- return FALSE;
+ if (volume_level > (unsigned int)max_level) {
+ _mmcam_dbg_warn("invalid volume level. set max");
+ volume_level = (unsigned int)max_level;
+ }
+ } else {
+ avsys_audio_get_volume_max_ex(volume_type, &max_level);
+ volume_level = (unsigned int)max_level;
}
+ avsys_audio_get_volume_table(volume_type, device_type, (int)volume_level, &left_volume, &right_volume);
+ avsys_audio_get_volume_gain_table(
+ AVSYS_AUDIO_VOLUME_GAIN_IDX(AVSYS_AUDIO_VOLUME_GAIN_SHUTTER2),
+ device_type, &left_gain, &right_gain);
+ set_volume = left_volume * left_gain;
+ _mmcam_dbg_log("volume type %d, device type %d, volume level %d, left volume %d left gain %.2f set_volume %d",
+ volume_type, device_type, volume_level, left_volume, left_gain, set_volume);
+
+ _mmcam_dbg_log("shutter sound policy %d, volume %d",
+ hcamcorder->shutter_sound_policy, set_volume);
+
_mmcam_dbg_log("Play start");
- pthread_mutex_lock(&(info->play_mutex));
- pthread_cond_signal(&(info->play_cond));
- pthread_mutex_unlock(&(info->play_mutex));
+ __ta__(" pa_context_play_sample",
+ pulse_op = pa_context_play_sample(info->pulse_context,
+ SAMPLE_SOUND_NAME,
+ NULL,
+ set_volume,
+ NULL,
+ NULL);
+ );
+ if (pulse_op) {
+ pa_operation_unref(pulse_op);
+ pulse_op = NULL;
+ }
pthread_mutex_unlock(&(info->open_mutex));
{
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
SOUND_INFO *info = NULL;
+ mm_sound_device_in device_in;
+ mm_sound_device_out device_out;
+ int ret = 0;
mmf_return_val_if_fail(hcamcorder, FALSE);
info = &(hcamcorder->snd_info);
+ _mmcam_dbg_err("START");
+
pthread_mutex_lock(&(info->open_mutex));
if (info->state < _MMCAMCORDER_SOUND_STATE_INIT) {
_mmcam_dbg_warn("not initialized");
pthread_mutex_unlock(&(info->open_mutex));
- return FALSE;
+ return TRUE;
}
- info->thread_run = 0;
- pthread_cond_signal(&(info->play_cond));
+ if (hcamcorder->shutter_sound_policy == VCONFKEY_CAMERA_SHUTTER_SOUND_POLICY_ON) {
+ /**
+ * Restore route
+ */
+ _mmcam_dbg_log("restore route");
+ if (info->active_out_backup != DEFAULT_ACTIVE_DEVICE) {
+ ret = mm_sound_get_active_device(&device_in, &device_out);
+ if (ret != MM_ERROR_NONE) {
+ _mmcam_dbg_err("mm_sound_get_active_device failed [%x]. skip sound play.", ret);
+ }
+
+ _mmcam_dbg_log("current out [%x]", device_out);
- if (info->thread) {
- _mmcam_dbg_log("wait for sound write thread join");
- pthread_join(info->thread, NULL);
- _mmcam_dbg_log("join done");
+ if (device_out != info->active_out_backup) {
+ ret = mm_sound_set_active_route (info->active_out_backup);
+ if (ret != MM_ERROR_NONE) {
+ _mmcam_dbg_err("mm_sound_set_active_route failed [%x]. skip sound play.", ret);
+ }
+ }
+ }
}
- if (info->state == _MMCAMCORDER_SOUND_STATE_PREPARE) {
- _mmcam_dbg_log("restore route policy [%d]", info->route_policy_backup);
+#ifdef _MMCAMCORDER_UPLOAD_SAMPLE
+ /**
+ * Remove sample
+ */
+ _mmcam_dbg_log("remove sample");
- if (info->route_policy_backup != -1) {
- mm_sound_route_set_system_policy(info->route_policy_backup);
- }
+ pa_threaded_mainloop_lock(info->pulse_mainloop);
- mm_sound_pcm_play_close(info->handle);
- __cleanup_buffer(info);
- }
+ /* Remove sample (ASYNC) */
+ pa_operation_unref(pa_context_remove_sample(info->pulse_context, SAMPLE_SOUND_NAME, __pulseaudio_remove_sample_finish_cb, info));
+
+ /* Wait for async operation */
+ pa_threaded_mainloop_wait(info->pulse_mainloop);
+ pa_threaded_mainloop_unlock(info->pulse_mainloop);
+#endif /* _MMCAMCORDER_UPLOAD_SAMPLE */
+
+ /**
+ * Release pulseaudio thread
+ */
+ _mmcam_dbg_log("release pulseaudio thread");
+
+ pa_threaded_mainloop_lock(info->pulse_mainloop);
+
+ pa_context_disconnect(info->pulse_context);
+
+ /* Make sure we don't get any further callbacks */
+ pa_context_set_state_callback(info->pulse_context, NULL, NULL);
+
+ pa_context_unref(info->pulse_context);
+ info->pulse_context = NULL;
+
+ pa_threaded_mainloop_unlock(info->pulse_mainloop);
+
+ pa_threaded_mainloop_stop(info->pulse_mainloop);
+ pa_threaded_mainloop_free(info->pulse_mainloop);
+ info->pulse_mainloop = NULL;
+
+#ifdef _MMCAMCORDER_UPLOAD_SAMPLE
if (info->filename) {
free(info->filename);
info->filename = NULL;
}
+#endif /* _MMCAMCORDER_UPLOAD_SAMPLE */
info->state = _MMCAMCORDER_SOUND_STATE_NONE;
- info->route_policy_backup = -1;
+ info->active_out_backup = DEFAULT_ACTIVE_DEVICE;
+ /* release mutex and cond */
+ _mmcam_dbg_log("release play_mutex/cond");
pthread_mutex_destroy(&(info->play_mutex));
pthread_cond_destroy(&(info->play_cond));
+ if (hcamcorder->shutter_sound_policy == VCONFKEY_CAMERA_SHUTTER_SOUND_POLICY_ON) {
+ int errorcode = 0;
+ ASM_resource_t mm_resource = ASM_RESOURCE_CAMERA | ASM_RESOURCE_VIDEO_OVERLAY | ASM_RESOURCE_HW_ENCODER;
+
+ /* stop EXCLUSIVE session */
+ if (!ASM_set_sound_state(hcamcorder->asm_handle_ex, ASM_EVENT_EXCLUSIVE_MMCAMCORDER,
+ ASM_STATE_STOP, mm_resource, &errorcode)) {
+ _mmcam_dbg_err("EXCLUSIVE Set state to STOP failed 0x%x", errorcode);
+ } else {
+ _mmcam_dbg_log("EXCLUSIVE session STOP done.");
+ }
+ }
+
pthread_mutex_unlock(&(info->open_mutex));
- _mmcam_dbg_log("Done");
+ _mmcam_dbg_err("DONE");
return TRUE;
}
+gboolean _mmcamcorder_sound_capture_play_cb(gpointer data)
+{
+ mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(data);
+
+ mmf_return_val_if_fail(hcamcorder, FALSE);
+
+ _mmcam_dbg_log("Capture sound PLAY in idle callback");
+
+ _mmcamcorder_sound_solo_play((MMHandleType)hcamcorder, _MMCAMCORDER_FILEPATH_CAPTURE_SND, FALSE);
+
+ return FALSE;
+}
+
+
void _mmcamcorder_sound_solo_play(MMHandleType handle, const char* filepath, gboolean sync)
{
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
int sound_handle = 0;
- int ret = 0;
+ int ret = MM_ERROR_NONE;
int sound_enable = TRUE;
+ int gain_type = VOLUME_GAIN_SHUTTER1;
- mmf_return_if_fail( filepath );
+ mmf_return_if_fail(filepath && hcamcorder);
- _mmcam_dbg_log( "START" );
+ _mmcam_dbg_log("START : %s", filepath);
ret = mm_camcorder_get_attributes((MMHandleType)hcamcorder, NULL,
"capture-sound-enable", &sound_enable,
NULL);
- if (ret == MM_ERROR_NONE) {
- if (sound_enable == FALSE) {
- _mmcam_dbg_log("Capture sound DISABLED.");
- return;
- }
- } else {
- _mmcam_dbg_warn("capture-sound-enable get FAILED.[%x]", ret);
+ _mmcam_dbg_log("Capture sound enable %d", sound_enable);
+ if (!sound_enable) {
+ return;
}
ret = pthread_mutex_trylock(&(hcamcorder->sound_lock));
return;
}
- MMTA_ACUM_ITEM_BEGIN("CAPTURE SOUND:mm_sound_play_loud_solo_sound", FALSE);
+ /* check filename to set gain_type */
+ if (!strcmp(filepath, _MMCAMCORDER_FILEPATH_CAPTURE_SND)) {
+ gain_type = VOLUME_GAIN_SHUTTER1;
+ } else if (!strcmp(filepath, _MMCAMCORDER_FILEPATH_CAPTURE2_SND)) {
+ gain_type = VOLUME_GAIN_SHUTTER2;
+ } else if (!strcmp(filepath, _MMCAMCORDER_FILEPATH_REC_START_SND) ||
+ !strcmp(filepath, _MMCAMCORDER_FILEPATH_REC_STOP_SND)) {
+ gain_type = VOLUME_GAIN_CAMCORDING;
+ }
+
+ _mmcam_dbg_log("gain type 0x%x", gain_type);
+
+ if (hcamcorder->shutter_sound_policy == VCONFKEY_CAMERA_SHUTTER_SOUND_POLICY_ON) {
+ __ta__("CAPTURE SOUND:mm_sound_play_loud_solo_sound",
+ ret = mm_sound_play_loud_solo_sound(filepath, VOLUME_TYPE_FIXED | gain_type,
+ __solo_sound_callback, (void*)hcamcorder, &sound_handle);
+ );
+ } else {
+ gboolean sound_status = hcamcorder->sub_context->info_image->sound_status;
+ mm_sound_device_in device_in;
+ mm_sound_device_out device_out;
+
+ /* get sound path */
+ mm_sound_get_active_device(&device_in, &device_out);
- ret = mm_sound_play_loud_solo_sound(filepath, VOLUME_TYPE_FIXED, __solo_sound_callback,
- (void*)hcamcorder, &sound_handle);
+ _mmcam_dbg_log("sound status %d, device out %x", sound_status, device_out);
+
+ if (sound_status || device_out != MM_SOUND_DEVICE_OUT_SPEAKER) {
+ __ta__("CAPTURE SOUND:mm_sound_play_sound",
+ ret = mm_sound_play_sound(filepath, VOLUME_TYPE_MEDIA | gain_type,
+ __solo_sound_callback, (void*)hcamcorder, &sound_handle);
+ );
+ }
+ }
if (ret != MM_ERROR_NONE) {
_mmcam_dbg_err( "Capture sound play FAILED.[%x]", ret );
} else {
_mmcam_dbg_log("Wait for signal");
+ MMTA_ACUM_ITEM_BEGIN("CAPTURE SOUND:wait sound play finish", FALSE);
+
if (!pthread_cond_timedwait(&(hcamcorder->sound_cond), &(hcamcorder->sound_lock), &timeout)) {
_mmcam_dbg_log("signal received.");
} else {
mm_sound_stop_sound(sound_handle);
}
}
+
+ MMTA_ACUM_ITEM_END("CAPTURE SOUND:wait sound play finish", FALSE);
}
}
- MMTA_ACUM_ITEM_END("CAPTURE SOUND:mm_sound_play_loud_solo_sound", FALSE);
-
pthread_mutex_unlock(&(hcamcorder->sound_lock));
_mmcam_dbg_log("DONE");
#include <sys/time.h>
#include <sys/times.h>
#include <gst/interfaces/cameracontrol.h>
+#include <mm_sound.h>
#include "mm_camcorder_internal.h"
#include "mm_camcorder_stillshot.h"
#include "mm_camcorder_exifinfo.h"
/*---------------------------------------------------------------------------------------
| LOCAL VARIABLE DEFINITIONS for internal |
---------------------------------------------------------------------------------------*/
+#define THUMBNAIL_WIDTH 320
+#define THUMBNAIL_HEIGHT 240
+#define THUMBNAIL_DEFAULT_RATIO 1.34
+#define THUMBNAIL_JPEG_QUALITY 50
+#define TRY_LOCK_MAX_COUNT 100
+#define TRY_LOCK_TIME 50000 /* ms */
/*---------------------------------------------------------------------------------------
int _mmcamcorder_image_cmd_preview_stop(MMHandleType handle);
static void __mmcamcorder_image_capture_cb(GstElement *element, GstBuffer *buffer1, GstBuffer *buffer2, GstBuffer *buffer3, gpointer u_data);
-/* Functions for JPEG capture with Encode bin */
-int _mmcamcorder_image_cmd_capture_with_encbin(MMHandleType handle);
-int _mmcamcorder_image_cmd_preview_start_with_encbin(MMHandleType handle);
-int _mmcamcorder_image_cmd_preview_stop_with_encbin(MMHandleType handle);
+/* Function for JPEG capture with Encode bin */
static gboolean __mmcamcorder_encodesink_handoff_callback(GstElement *fakesink, GstBuffer *buffer, GstPad *pad, gpointer u_data);
+/* sound status changed callback */
+static void __sound_status_changed_cb(keynode_t* node, void *data);
+static void __volume_level_changed_cb(void* user_data);
+
/*=======================================================================================
| FUNCTION DEFINITIONS |
=======================================================================================*/
GstPad *srcpad = NULL;
GstPad *sinkpad = NULL;
- mmf_camcorder_t *hcamcorder= MMF_CAMCORDER(handle);
+ mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
_MMCamcorderSubContext *sc = NULL;
_MMCamcorderImageInfo *info = NULL;
mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
sc = MMF_CAMCORDER_SUBCONTEXT(handle);
- mmf_return_val_if_fail(sc && sc->info && sc->element, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
+ mmf_return_val_if_fail(sc && sc->info_image && sc->element, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
- info = sc->info;
+ info = sc->info_image;
_mmcam_dbg_log("");
- //Create gstreamer element
- //Check main pipeline
+ /* Check main pipeline */
if (!sc->element[_MMCAMCORDER_MAIN_PIPE].gst) {
_mmcam_dbg_err( "Main Pipeline is not existed." );
- err = MM_ERROR_CAMCORDER_RESOURCE_CREATION;
- goto pipeline_creation_error;
+ return MM_ERROR_CAMCORDER_RESOURCE_CREATION;
}
- _mmcamcorder_conf_get_value_int(hcamcorder->conf_main,
- CONFIGURE_CATEGORY_MAIN_CAPTURE,
- "UseEncodebin",
- &sc->bencbin_capture);
-
- if (sc->bencbin_capture) {
- _mmcam_dbg_log("Using Encodebin for capturing");
- __ta__(" _mmcamcorder_create_encodesink_bin",
- err = _mmcamcorder_create_encodesink_bin((MMHandleType)hcamcorder);
- );
- if (err != MM_ERROR_NONE) {
- return err;
- }
-
- gst_bin_add_many(GST_BIN(sc->element[_MMCAMCORDER_MAIN_PIPE].gst),
- sc->element[_MMCAMCORDER_ENCSINK_BIN].gst,
- NULL);
+ /* Create gstreamer element */
+ _mmcam_dbg_log("Using Encodebin for capturing");
- /* Link each element */
- srcpad = gst_element_get_static_pad(sc->element[_MMCAMCORDER_VIDEOSRC_BIN].gst, "src1");
- sinkpad = gst_element_get_static_pad(sc->element[_MMCAMCORDER_ENCSINK_BIN].gst, "image_sink0");
- _MM_GST_PAD_LINK_UNREF(srcpad, sinkpad, err, element_link_error)
+ __ta__(" _mmcamcorder_create_encodesink_bin",
+ err = _mmcamcorder_create_encodesink_bin((MMHandleType)hcamcorder, MM_CAMCORDER_ENCBIN_PROFILE_IMAGE);
+ );
+ if (err != MM_ERROR_NONE) {
+ return err;
+ }
- MMCAMCORDER_SIGNAL_CONNECT(sc->element[_MMCAMCORDER_ENCSINK_SINK].gst,
- _MMCAMCORDER_HANDLER_STILLSHOT, "handoff",
- G_CALLBACK(__mmcamcorder_encodesink_handoff_callback),
- hcamcorder);
- } else {
- _mmcam_dbg_log("NOT using Encodebin for capturing");
+ gst_bin_add_many(GST_BIN(sc->element[_MMCAMCORDER_MAIN_PIPE].gst),
+ sc->element[_MMCAMCORDER_ENCSINK_BIN].gst,
+ NULL);
- /*set video source element*/
- MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "signal-still-capture", TRUE);
+ /* Link each element */
+ srcpad = gst_element_get_static_pad(sc->element[_MMCAMCORDER_VIDEOSRC_BIN].gst, "src1");
+ sinkpad = gst_element_get_static_pad(sc->element[_MMCAMCORDER_ENCSINK_BIN].gst, "image_sink0");
+ _MM_GST_PAD_LINK_UNREF(srcpad, sinkpad, err, element_link_error)
- MMCAMCORDER_SIGNAL_CONNECT(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst,
- _MMCAMCORDER_HANDLER_STILLSHOT, "still-capture",
- G_CALLBACK(__mmcamcorder_image_capture_cb),
- hcamcorder);
- }
+ MMCAMCORDER_SIGNAL_CONNECT(sc->element[_MMCAMCORDER_ENCSINK_SINK].gst,
+ _MMCAMCORDER_HANDLER_STILLSHOT, "handoff",
+ G_CALLBACK(__mmcamcorder_encodesink_handoff_callback),
+ hcamcorder);
return MM_ERROR_NONE;
element_link_error:
- if (sc->bencbin_capture) {
- _mmcam_dbg_err("Link encodebin failed!");
+ _mmcam_dbg_err("Link encodebin failed!");
- if (sc->element[_MMCAMCORDER_ENCSINK_BIN].gst != NULL) {
- int ret = MM_ERROR_NONE;
+ if (sc->element[_MMCAMCORDER_ENCSINK_BIN].gst != NULL) {
+ int ret = MM_ERROR_NONE;
- __ta__( " EncodeBin Set NULL",
- ret = _mmcamcorder_gst_set_state(handle, sc->element[_MMCAMCORDER_ENCSINK_BIN].gst, GST_STATE_NULL);
- );
- if (ret != MM_ERROR_NONE) {
- _mmcam_dbg_err("Faile to change encode bin state[%d]", ret);
- /* Can't return here. */
- /* return ret; */
- }
+ __ta__( " EncodeBin Set NULL",
+ ret = _mmcamcorder_gst_set_state(handle, sc->element[_MMCAMCORDER_ENCSINK_BIN].gst, GST_STATE_NULL);
+ );
+ _mmcam_dbg_log("encodebin _mmcamcorder_gst_set_state NULL ret[%d]", ret);
- gst_bin_remove(GST_BIN(sc->element[_MMCAMCORDER_MAIN_PIPE].gst),
- sc->element[_MMCAMCORDER_ENCSINK_BIN].gst);
+ gst_bin_remove(GST_BIN(sc->element[_MMCAMCORDER_MAIN_PIPE].gst),
+ sc->element[_MMCAMCORDER_ENCSINK_BIN].gst);
- _mmcamcorder_remove_element_handle(handle, _MMCAMCORDER_ENCSINK_BIN, _MMCAMCORDER_ENCSINK_SINK);
+ _mmcamcorder_remove_element_handle(handle, _MMCAMCORDER_ENCSINK_BIN, _MMCAMCORDER_ENCSINK_SINK);
- _mmcam_dbg_log("Encodebin removed");
- }
+ _mmcam_dbg_log("Encodebin removed");
}
return MM_ERROR_CAMCORDER_GST_LINK;
+}
+
-pipeline_creation_error:
- return err;
+int _mmcamcorder_connect_capture_signal(MMHandleType handle)
+{
+ mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
+ _MMCamcorderSubContext *sc = NULL;
+
+ mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
+
+ sc = MMF_CAMCORDER_SUBCONTEXT(handle);
+ mmf_return_val_if_fail(sc && sc->element, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
+
+ /*set video source element*/
+ if (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst) {
+ MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "signal-still-capture", TRUE);
+
+ MMCAMCORDER_SIGNAL_CONNECT(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst,
+ _MMCAMCORDER_HANDLER_STILLSHOT, "still-capture",
+ G_CALLBACK(__mmcamcorder_image_capture_cb),
+ hcamcorder);
+ return MM_ERROR_NONE;
+ } else {
+ _mmcam_dbg_err("videosrc element is not created yet");
+ return MM_ERROR_CAMCORDER_NOT_INITIALIZED;
+ }
}
mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
sc = MMF_CAMCORDER_SUBCONTEXT(handle);
- mmf_return_val_if_fail(sc && sc->info && sc->element, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
+ mmf_return_val_if_fail(sc && sc->info_image && sc->element, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
- info = sc->info;
+ info = sc->info_image;
_mmcam_dbg_log("");
}
-void _mmcamcorder_destroy_image_pipeline(MMHandleType handle)
+void _mmcamcorder_destroy_video_capture_pipeline(MMHandleType handle)
{
GstPad *reqpad1 = NULL;
GstPad *reqpad2 = NULL;
sc = MMF_CAMCORDER_SUBCONTEXT(handle);
mmf_return_if_fail(sc && sc->element);
-
+
_mmcam_dbg_log("");
if (sc->element[_MMCAMCORDER_MAIN_PIPE].gst) {
gst_object_unref(reqpad1);
gst_object_unref(reqpad2);
- if (sc->bencbin_capture) {
- if (sc->element[_MMCAMCORDER_ENCSINK_ENCBIN].gst) {
- GstPad *reqpad0 = NULL;
- reqpad0 = gst_element_get_static_pad(sc->element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "image");
- gst_element_release_request_pad(sc->element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, reqpad0);
- gst_object_unref(reqpad0);
- }
- }
-
gst_object_unref(sc->element[_MMCAMCORDER_MAIN_PIPE].gst);
- /* Why is this commented? */
- /* sc->element[_MMCAMCORDER_MAIN_PIPE].gst = NULL; */
+ /* NULL initialization will be done in _mmcamcorder_element_release_noti */
}
}
int height = 0;
int fps = 0;
int cap_format = MM_PIXEL_FORMAT_NV12;
- int cap_jpeg_quality = 0;
int image_encoder = MM_IMAGE_CODEC_JPEG;
+ int strobe_mode = MM_CAMCORDER_STROBE_MODE_OFF;
unsigned int cap_fourcc = 0;
char *err_name = NULL;
_MMCamcorderImageInfo *info = NULL;
_MMCamcorderSubContext *sc = NULL;
type_element *VideosrcElement = NULL;
+ MMCamcorderStateType current_state = MM_CAMCORDER_STATE_NONE;
mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
sc = MMF_CAMCORDER_SUBCONTEXT(handle);
- mmf_return_val_if_fail(sc && sc->info && sc->element, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
+ mmf_return_val_if_fail(sc && sc->info_image && sc->element, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
_mmcam_dbg_log("");
pipeline = sc->element[_MMCAMCORDER_MAIN_PIPE].gst;
- info = sc->info;
+ info = sc->info_image;
_mmcamcorder_conf_get_value_int(hcamcorder->conf_main,
CONFIGURE_CATEGORY_MAIN_CAPTURE,
MMTA_ACUM_ITEM_BEGIN("Real First Capture Start",false);
+ /* get current state */
+ mm_camcorder_get_state(handle, ¤t_state);
+
/* set capture flag */
info->capturing = TRUE;
- ret = mm_camcorder_get_attributes(handle, &err_name,
- MMCAM_IMAGE_ENCODER_QUALITY, &cap_jpeg_quality,
- MMCAM_IMAGE_ENCODER, &image_encoder,
- MMCAM_CAMERA_WIDTH, &width,
- MMCAM_CAMERA_HEIGHT, &height,
- MMCAM_CAMERA_FPS, &fps,
- MMCAM_CAPTURE_FORMAT, &cap_format,
- MMCAM_CAPTURE_WIDTH, &info->width,
- MMCAM_CAPTURE_HEIGHT, &info->height,
- MMCAM_CAPTURE_COUNT, &info->count,
- MMCAM_CAPTURE_INTERVAL, &info->interval,
- NULL);
- if (ret != MM_ERROR_NONE) {
- _mmcam_dbg_warn("Get attrs fail. (%s:%x)", err_name, ret);
- SAFE_FREE (err_name);
- goto cmd_error;
- }
-
+ mm_camcorder_get_attributes(handle, &err_name,
+ MMCAM_IMAGE_ENCODER, &image_encoder,
+ MMCAM_CAMERA_WIDTH, &width,
+ MMCAM_CAMERA_HEIGHT, &height,
+ MMCAM_CAMERA_FPS, &fps,
+ MMCAM_CAMERA_HDR_CAPTURE, &info->hdr_capture_mode,
+ MMCAM_CAPTURE_FORMAT, &cap_format,
+ MMCAM_CAPTURE_WIDTH, &info->width,
+ MMCAM_CAPTURE_HEIGHT, &info->height,
+ MMCAM_CAPTURE_COUNT, &info->count,
+ MMCAM_CAPTURE_INTERVAL, &info->interval,
+ MMCAM_STROBE_MODE, &strobe_mode,
+ NULL);
+ if (err_name) {
+ _mmcam_dbg_warn("get_attributes err %s", err_name);
+ free(err_name);
+ err_name = NULL;
+ }
+
+ /* check capture count */
if (info->count < 1) {
_mmcam_dbg_err("capture count[%d] is invalid", info->count);
ret = MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
info->type = _MMCamcorder_MULTI_SHOT;
info->next_shot_time = 0;
info->multi_shot_stop = FALSE;
+
+ /* sound init to pause other session */
+ __ta__(" _mmcamcorder_sound_init",
+#ifdef _MMCAMCORDER_UPLOAD_SAMPLE
+ _mmcamcorder_sound_init(handle, _MMCAMCORDER_FILEPATH_CAPTURE2_SND);
+#else /* _MMCAMCORDER_UPLOAD_SAMPLE */
+ _mmcamcorder_sound_init(handle);
+#endif /* _MMCAMCORDER_UPLOAD_SAMPLE */
+ );
+ }
+
+ _mmcam_dbg_log("preview(%dx%d,fmt:%d), capture(%dx%d,fmt:%d), count(%d), hdr mode(%d)",
+ width, height, info->preview_format,
+ info->width, info->height, cap_format,
+ info->count, info->hdr_capture_mode);
+
+ /* check state */
+ if (current_state >= MM_CAMCORDER_STATE_RECORDING) {
+ if (info->type == _MMCamcorder_MULTI_SHOT ||
+ info->hdr_capture_mode != MM_CAMCORDER_HDR_OFF ||
+ info->preview_format != MM_PIXEL_FORMAT_ITLV_JPEG_UYVY) {
+ _mmcam_dbg_err("not support multi/HDR capture while recording or NOT ITLV format");
+ ret = MM_ERROR_CAMCORDER_INVALID_STATE;
+ goto cmd_error;
+ }
}
info->capture_cur_count = 0;
info->capture_send_count = 0;
- _mmcam_dbg_log("videosource(%dx%d), capture(%dx%d), count(%d)",
- width, height, info->width, info->height, info->count);
-
sc->internal_encode = FALSE;
- if (!strcmp(videosrc_name, "avsysvideosrc") || !strcmp(videosrc_name, "camerasrc")) {
+ if (!sc->bencbin_capture) {
/* Check encoding method */
if (cap_format == MM_PIXEL_FORMAT_ENCODED) {
if (sc->SensorEncodedCapture && info->type == _MMCamcorder_SINGLE_SHOT) {
cap_fourcc = _mmcamcorder_get_fourcc(cap_format, image_encoder, hcamcorder->use_zero_copy_format);
_mmcam_dbg_log("Sensor JPEG Capture");
} else {
- int raw_capture_format = MM_PIXEL_FORMAT_I420;
-
- ret = mm_camcorder_get_attributes(handle, &err_name,
- MMCAM_RECOMMEND_PREVIEW_FORMAT_FOR_CAPTURE, &raw_capture_format,
- NULL );
- if (ret != MM_ERROR_NONE) {
- _mmcam_dbg_warn("Get Recommend capture format failed.");
- SAFE_FREE(err_name);
- goto cmd_error;
+ /* no need to encode internally if ITLV format */
+ if (info->preview_format != MM_PIXEL_FORMAT_ITLV_JPEG_UYVY) {
+ sc->internal_encode = TRUE;
}
- cap_fourcc = _mmcamcorder_get_fourcc(raw_capture_format, image_encoder, hcamcorder->use_zero_copy_format);
- sc->internal_encode = TRUE;
+ cap_fourcc = _mmcamcorder_get_fourcc(info->preview_format, image_encoder, hcamcorder->use_zero_copy_format);
- _mmcam_dbg_log("MSL JPEG Capture");
+ _mmcam_dbg_log("MSL JPEG Capture : capture fourcc %c%c%c%c",
+ cap_fourcc, cap_fourcc>>8, cap_fourcc>>16, cap_fourcc>>24);
}
} else {
cap_fourcc = _mmcamcorder_get_fourcc(cap_format, MM_IMAGE_CODEC_INVALID, hcamcorder->use_zero_copy_format);
}
}
- _mmcam_dbg_log("capture format (%d), jpeg quality (%d)", cap_format, cap_jpeg_quality);
+ _mmcam_dbg_log("capture format (%d)", cap_format);
/* Note: width/height of capture is set in commit function of attribute or in create function of pipeline */
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "capture-fourcc", cap_fourcc);
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "capture-interval", info->interval);
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "capture-count", info->count);
- MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "capture-jpg-quality", cap_jpeg_quality);
+ MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "hdr-capture", info->hdr_capture_mode);
if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
_mmcam_dbg_err("Can't cast Video source into camera control.");
int need_change = 0;
int set_width = 0;
int set_height = 0;
+ int cap_jpeg_quality = 0;
+
+ if (current_state >= MM_CAMCORDER_STATE_RECORDING) {
+ _mmcam_dbg_err("could not capture in this target while recording");
+ ret = MM_ERROR_CAMCORDER_INVALID_STATE;
+ goto cmd_error;
+ }
if (UseCaptureMode) {
if (width != MMFCAMCORDER_HIGHQUALITY_WIDTH || height != MMFCAMCORDER_HIGHQUALITY_HEIGHT) {
}
}
+ /* make pipeline state as READY */
+ ret = _mmcamcorder_gst_set_state(handle, sc->element[_MMCAMCORDER_MAIN_PIPE].gst, GST_STATE_READY);
+ if (ret != MM_ERROR_NONE) {
+ _mmcam_dbg_err("failed to set state PAUSED %x", ret);
+ return ret;
+ }
+
+ /* add encodesinkbin */
+ ret = _mmcamcorder_add_stillshot_pipeline((MMHandleType)hcamcorder);
+ if (ret != MM_ERROR_NONE) {
+ _mmcam_dbg_err("failed to create encodesinkbin %x", ret);
+ return ret;
+ }
+
+ /* set JPEG quality */
+ mm_camcorder_get_attributes(handle, &err_name,
+ MMCAM_IMAGE_ENCODER_QUALITY, &cap_jpeg_quality,
+ NULL);
+ MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_ENCSINK_IENC].gst, "quality", cap_jpeg_quality);
+
if (need_change) {
_mmcam_dbg_log("Need to change resolution");
_mmcam_dbg_log("Change to target resolution(%d, %d)", set_width, set_height);
} else {
_mmcam_dbg_log("No need to change resolution. Open toggle now.");
- MMCAMCORDER_G_OBJECT_SET( sc->element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "block", FALSE);
+ }
+
+ MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_ENCSINK_SINK].gst,"signal-handoffs", TRUE);
+ MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "block", FALSE);
+
+ /* make pipeline state as PLAYING */
+ ret = _mmcamcorder_gst_set_state(handle, sc->element[_MMCAMCORDER_MAIN_PIPE].gst, GST_STATE_PLAYING);
+ if (ret != MM_ERROR_NONE) {
+ _mmcam_dbg_err("failed to set state PLAYING %x", ret);
+ return ret;
}
}
/* Play capture sound here if single capture */
- if (info->type == _MMCamcorder_SINGLE_SHOT) {
- _mmcamcorder_sound_solo_play(handle, _MMCAMCORDER_FILEPATH_CAPTURE_SND, FALSE);
+ if ((info->type == _MMCamcorder_SINGLE_SHOT &&
+ (info->preview_format != MM_PIXEL_FORMAT_ITLV_JPEG_UYVY || strobe_mode == MM_CAMCORDER_STROBE_MODE_OFF)) ||
+ info->hdr_capture_mode) {
+ if (current_state < MM_CAMCORDER_STATE_RECORDING) {
+ __ta__(" _mmcamcorder_sound_solo_play",
+ _mmcamcorder_sound_solo_play((MMHandleType)hcamcorder, _MMCAMCORDER_FILEPATH_CAPTURE_SND, FALSE);
+ );
+ }
+
+ /* set flag */
+ info->played_capture_sound = TRUE;
+ } else {
+ /* set flag */
+ info->played_capture_sound = FALSE;
}
+ return ret;
+
cmd_error:
+ info->capturing = FALSE;
return ret;
}
int cap_width = 0;
int cap_height = 0;
int rotation = 0;
- int input_index = 0;
int set_width = 0;
int set_height = 0;
int set_rotate = 0;
int current_framecount = 0;
+ int current_state = MM_CAMCORDER_STATE_NONE;
gboolean fps_auto = FALSE;
char *err_name = NULL;
char *videosrc_name = NULL;
mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
sc = MMF_CAMCORDER_SUBCONTEXT(handle);
- mmf_return_val_if_fail(sc && sc->info && sc->element, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
+ mmf_return_val_if_fail(sc && sc->info_image && sc->element, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
_mmcam_dbg_log("");
pipeline = sc->element[_MMCAMCORDER_MAIN_PIPE].gst;
- info = sc->info;
+ info = sc->info_image;
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", TRUE);
sc->previous_slot_time = 0;
/* Image info */
- info->capture_cur_count = 0;
- info->capture_send_count = 0;
info->next_shot_time = 0;
info->multi_shot_stop = TRUE;
info->capturing = FALSE;
_mmcamcorder_vframe_stablize(handle);
- if (!strcmp(videosrc_name, "avsysvideosrc") || !strcmp(videosrc_name, "camerasrc")) {
- _mmcam_dbg_log("Capture Preview start : avsysvideosrc - No need to set new caps.");
-
- ret = mm_camcorder_get_attributes(handle, &err_name,
- MMCAM_CAMERA_FPS_AUTO, &fps_auto,
- NULL);
- if (ret != MM_ERROR_NONE) {
- _mmcam_dbg_warn("Get attrs fail. (%s:%x)", err_name, ret);
- SAFE_FREE (err_name);
- goto cmd_error;
- }
+ current_state = _mmcamcorder_get_state(handle);
+ _mmcam_dbg_log("current state [%d]", current_state);
- MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "fps-auto", fps_auto);
+ if (!sc->bencbin_capture) {
+ _mmcam_dbg_log("Capture Preview start : avsysvideosrc - No need to set new caps.");
- if (_mmcamcorder_get_state(handle) == MM_CAMCORDER_STATE_CAPTURING) {
+ /* just set capture stop command if current state is CAPTURING */
+ if (current_state == MM_CAMCORDER_STATE_CAPTURING) {
if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
_mmcam_dbg_err("Can't cast Video source into camera control.");
return MM_ERROR_CAMCORDER_NOT_SUPPORTED;
if (info->type == _MMCamcorder_SINGLE_SHOT) {
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", FALSE);
}
+ } else {
+ int focus_mode = 0;
+
+ /* This case is starting of preview */
+ ret = mm_camcorder_get_attributes(handle, &err_name,
+ MMCAM_CAMERA_FPS_AUTO, &fps_auto,
+ MMCAM_CAMERA_FOCUS_MODE, &focus_mode,
+ NULL);
+ if (ret != MM_ERROR_NONE) {
+ _mmcam_dbg_warn("Get attrs fail. (%s:%x)", err_name, ret);
+ SAFE_FREE (err_name);
+ }
+
+ MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "fps-auto", fps_auto);
+
+ /* set focus mode */
+ mm_camcorder_set_attributes(handle, NULL,
+ MMCAM_CAMERA_FOCUS_MODE, focus_mode,
+ NULL);
}
} else {
/* check if resolution need to rollback */
- ret = mm_camcorder_get_attributes(handle, &err_name,
- MMCAM_CAMERA_DEVICE, &input_index,
- MMCAM_CAMERA_WIDTH, &width,
- MMCAM_CAMERA_HEIGHT, &height,
- MMCAM_CAMERA_FPS, &fps,
- MMCAM_CAMERA_FPS_AUTO, &fps_auto,
- MMCAM_CAMERA_ROTATION, &rotation,
- MMCAM_CAPTURE_WIDTH, &cap_width,
- MMCAM_CAPTURE_HEIGHT, &cap_height,
- NULL);
- if (ret != MM_ERROR_NONE) {
- _mmcam_dbg_warn("Get attrs fail. (%s:%x)", err_name, ret);
- SAFE_FREE (err_name);
- goto cmd_error;
- }
+ mm_camcorder_get_attributes(handle, &err_name,
+ MMCAM_CAMERA_WIDTH, &width,
+ MMCAM_CAMERA_HEIGHT, &height,
+ MMCAM_CAMERA_FPS, &fps,
+ MMCAM_CAMERA_FPS_AUTO, &fps_auto,
+ MMCAM_CAMERA_ROTATION, &rotation,
+ MMCAM_CAPTURE_WIDTH, &cap_width,
+ MMCAM_CAPTURE_HEIGHT, &cap_height,
+ NULL);
- if (_mmcamcorder_get_state((MMHandleType)hcamcorder) == MM_CAMCORDER_STATE_CAPTURING) {
+ if (current_state == MM_CAMCORDER_STATE_CAPTURING) {
switch (rotation) {
case MM_VIDEO_INPUT_ROTATION_90:
set_width = height;
if (!strcmp(videosrc_name, "avsysvideosrc") || !strcmp(videosrc_name, "camerasrc")) {
int try_count = 0;
- __ta__( " Wait preview frame after capture",
- while (current_framecount >= sc->kpi.video_framecount &&
- try_count++ < _MMCAMCORDER_CAPTURE_STOP_CHECK_COUNT) {
- usleep(_MMCAMCORDER_CAPTURE_STOP_CHECK_INTERVAL);
+ if (info->preview_format != MM_PIXEL_FORMAT_ITLV_JPEG_UYVY) {
+ mmf_attrs_t *attr = (mmf_attrs_t *)MMF_CAMCORDER_ATTRS(handle);
+
+ /* Set strobe mode - strobe mode can not be set to driver while captuing */
+ if (attr) {
+ __ta__(" Set strobe mode after capture",
+ mmf_attribute_set_modified(&(attr->items[MM_CAM_STROBE_MODE]));
+ if (mmf_attrs_commit((MMHandleType) attr) == -1) {
+ _mmcam_dbg_warn("Failed to set strobe mode");
+ }
+ );
+ }
+
+ __ta__(" Wait preview frame after capture",
+ while (current_framecount >= sc->kpi.video_framecount &&
+ try_count++ < _MMCAMCORDER_CAPTURE_STOP_CHECK_COUNT) {
+ usleep(_MMCAMCORDER_CAPTURE_STOP_CHECK_INTERVAL);
+ }
+ );
}
- );
if (info->type == _MMCamcorder_MULTI_SHOT) {
MMCAMCORDER_G_OBJECT_SET( sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", FALSE);
_mmcam_dbg_log("Wait Frame Done. count before[%d],after[%d], try_count[%d]",
current_framecount, sc->kpi.video_framecount, try_count);
} else {
+ MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", TRUE);
ret = _mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_READY);
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", FALSE);
-
- if (ret != MM_ERROR_NONE) {
- goto cmd_error;
- }
-
- ret = _mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_PLAYING);
+ MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "block", FALSE);
if (ret != MM_ERROR_NONE) {
goto cmd_error;
}
- }
- } else {
- int cap_count = 0;
- int sound_ret = FALSE;
-
- MMCAMCORDER_G_OBJECT_SET( sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", FALSE);
-
- __ta__(" _MMCamcorder_CMD_PREVIEW_START:GST_STATE_PLAYING",
- ret = _mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_PLAYING);
- );
- if (ret != MM_ERROR_NONE) {
- goto cmd_error;
- }
-
- mm_camcorder_get_attributes(handle, NULL, MMCAM_CAPTURE_COUNT, &cap_count, NULL);
- if (cap_count > 1) {
- __ta__("_mmcamcorder_sound_init",
- sound_ret = _mmcamcorder_sound_init(handle, _MMCAMCORDER_FILEPATH_CAPTURE2_SND);
- );
- if (sound_ret) {
- __ta__("_mmcamcorder_sound_prepare",
- sound_ret = _mmcamcorder_sound_prepare(handle);
- );
- _mmcam_dbg_log("sound prepare [%d]", sound_ret);
- }
- }
- }
-
-cmd_error:
- return ret;
-}
-
-
-int _mmcamcorder_image_cmd_preview_stop(MMHandleType handle)
-{
- int ret = MM_ERROR_NONE;
-
- GstElement *pipeline = NULL;
-
- _MMCamcorderSubContext *sc = NULL;
-
- _mmcam_dbg_log("");
-
- mmf_return_val_if_fail(handle, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
-
- sc = MMF_CAMCORDER_SUBCONTEXT(handle);
- mmf_return_val_if_fail(sc && sc->info && sc->element, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
-
- pipeline = sc->element[_MMCAMCORDER_MAIN_PIPE].gst;
-
- MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", TRUE);
- ret = _mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_READY);
- MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", FALSE);
-
- return ret;
-}
-
-
-int _mmcamcorder_image_cmd_capture_with_encbin(MMHandleType handle)
-{
- int ret = MM_ERROR_NONE;
- int UseCaptureMode = 0;
- int width = 0;
- int height = 0;
- int fps = 0;
- int cap_format = MM_PIXEL_FORMAT_ENCODED;
- int cap_jpeg_quality = 0;
- int image_encoder = MM_IMAGE_CODEC_JPEG;
- unsigned int cap_fourcc = GST_MAKE_FOURCC('J','P','E','G');
- char *err_name = NULL;
- char *videosrc_name = NULL;
-
- GstCaps *caps = NULL;
- GstClock *clock = NULL;
- GstElement *pipeline = NULL;
- GstCameraControl *control = NULL;
-
- mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
- _MMCamcorderImageInfo *info = NULL;
- _MMCamcorderSubContext *sc = NULL;
- type_element *VideosrcElement = NULL;
-
- mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
-
- sc = MMF_CAMCORDER_SUBCONTEXT(hcamcorder);
- mmf_return_val_if_fail(sc && sc->info && sc->element, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
-
- _mmcam_dbg_log("");
-
- pipeline = sc->element[_MMCAMCORDER_MAIN_PIPE].gst;
- info = sc->info;
-
- _mmcamcorder_conf_get_value_int(hcamcorder->conf_main,
- CONFIGURE_CATEGORY_MAIN_CAPTURE,
- "UseCaptureMode",
- &UseCaptureMode);
-
- _mmcamcorder_conf_get_element(hcamcorder->conf_main,
- CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
- "VideosrcElement",
- &VideosrcElement);
-
- _mmcamcorder_conf_get_value_element_name(VideosrcElement, &videosrc_name);
-
- if (info->capturing) {
- ret = MM_ERROR_CAMCORDER_DEVICE_BUSY;
- goto cmd_error;
- }
-
- MMTA_ACUM_ITEM_BEGIN("Real First Capture Start",false);
-
- info->capturing = TRUE;
-
- ret = mm_camcorder_get_attributes(handle, &err_name,
- MMCAM_IMAGE_ENCODER_QUALITY, &cap_jpeg_quality,
- MMCAM_IMAGE_ENCODER, &image_encoder,
- MMCAM_CAMERA_WIDTH, &width,
- MMCAM_CAMERA_HEIGHT, &height,
- MMCAM_CAMERA_FPS, &fps,
- MMCAM_CAPTURE_FORMAT, &cap_format,
- MMCAM_CAPTURE_WIDTH, &info->width,
- MMCAM_CAPTURE_HEIGHT, &info->height,
- MMCAM_CAPTURE_COUNT, &info->count,
- MMCAM_CAPTURE_INTERVAL, &info->interval,
- NULL);
- if (ret != MM_ERROR_NONE) {
- _mmcam_dbg_err("Get attrs fail. (%s:%x)", err_name, ret);
- SAFE_FREE (err_name);
- goto cmd_error;
- }
-
- if (info->count < 1) {
- _mmcam_dbg_err("capture count[%d] is invalid", info->count);
- ret = MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
- goto cmd_error;
- } else if (info->count == 1) {
- info->type = _MMCamcorder_SINGLE_SHOT;
- } else {
- info->type = _MMCamcorder_MULTI_SHOT;
- info->capture_cur_count = 0;
- info->capture_send_count = 0;
- info->next_shot_time = 0;
- info->multi_shot_stop = FALSE;
- }
-
- _mmcam_dbg_log("videosource(%dx%d), capture(%dx%d), count(%d)",
- width, height, info->width, info->height, info->count);
- if (!strcmp(videosrc_name, "avsysvideosrc") || !strcmp(videosrc_name, "camerasrc")) {
- cap_fourcc = _mmcamcorder_get_fourcc(cap_format, image_encoder, hcamcorder->use_zero_copy_format);
- _mmcam_dbg_log("capture format (%d), jpeg quality (%d)", cap_format, cap_jpeg_quality);
+ /* remove handoff signal handler */
+ _mmcamcorder_remove_all_handlers(handle, _MMCAMCORDER_HANDLER_STILLSHOT);
- MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "capture-fourcc", cap_fourcc);
- MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "capture-interval", info->interval);
- MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "capture-width", info->width);
- MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "capture-height", info->height);
- MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "capture-count", info->count);
- MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "capture-jpg-quality", cap_jpeg_quality);
+ /* remove encodesinkbin after capture */
+ if (!sc->element[_MMCAMCORDER_ENCSINK_BIN].gst) {
+ _mmcam_dbg_log("ENCSINK_BIN is already removed");
+ } else {
+ GstPad *reqpad0 = NULL;
+ GstPad *srcpad = NULL;
+ GstPad *sinkpad = NULL;
- if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
- _mmcam_dbg_err("Can't cast Video source into camera control.");
- return MM_ERROR_CAMCORDER_NOT_SUPPORTED;
- }
+ /* release requested pad */
+ reqpad0 = gst_element_get_static_pad(sc->element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "image");
+ gst_element_release_request_pad(sc->element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, reqpad0);
+ gst_object_unref(reqpad0);
- control = GST_CAMERA_CONTROL( sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst );
- gst_camera_control_set_capture_command( control, GST_CAMERA_CONTROL_CAPTURE_COMMAND_START );
- } else {
- int need_change = 0;
- int set_width = 0;
- int set_height = 0;
+ /* Unlink each element */
+ srcpad = gst_element_get_static_pad(sc->element[_MMCAMCORDER_VIDEOSRC_BIN].gst, "src1");
+ sinkpad = gst_element_get_static_pad(sc->element[_MMCAMCORDER_ENCSINK_BIN].gst, "image_sink0");
+ _MM_GST_PAD_UNLINK_UNREF(srcpad, sinkpad);
- if (UseCaptureMode) {
- if (width != MMFCAMCORDER_HIGHQUALITY_WIDTH || height != MMFCAMCORDER_HIGHQUALITY_HEIGHT) {
- need_change = 1;
- }
- } else {
- if (width != info->width || height != info->height) {
- need_change = 1;
- }
- }
+ /* make state of encodesinkbin as NULL */
+ _mmcamcorder_gst_set_state(handle, sc->element[_MMCAMCORDER_ENCSINK_BIN].gst, GST_STATE_NULL);
- if (need_change) {
- _mmcam_dbg_log("Need to change resolution");
+ gst_bin_remove(GST_BIN(sc->element[_MMCAMCORDER_MAIN_PIPE].gst),
+ sc->element[_MMCAMCORDER_ENCSINK_BIN].gst);
- if (UseCaptureMode) {
- set_width = MMFCAMCORDER_HIGHQUALITY_WIDTH;
- set_height = MMFCAMCORDER_HIGHQUALITY_HEIGHT;
- } else {
- set_width = info->width;
- set_height = info->height;
+ _mmcamcorder_remove_element_handle(handle, _MMCAMCORDER_ENCSINK_BIN, _MMCAMCORDER_ENCSINK_SINK);
}
- caps = gst_caps_new_simple("video/x-raw-yuv",
- "format", GST_TYPE_FOURCC, sc->fourcc,
- "width", G_TYPE_INT, set_width,
- "height", G_TYPE_INT, set_height,
- "framerate", GST_TYPE_FRACTION, fps, 1,
- "rotate", G_TYPE_INT, 0,
- NULL);
- if (caps == NULL) {
- _mmcam_dbg_err("failed to create caps");
- ret = MM_ERROR_CAMCORDER_LOW_MEMORY;
+ ret = _mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_PLAYING);
+ if (ret != MM_ERROR_NONE) {
goto cmd_error;
}
-
- info->resolution_change = TRUE;
- MMCAMCORDER_G_OBJECT_SET( sc->element[_MMCAMCORDER_VIDEOSRC_FILT].gst, "caps", caps);
- gst_caps_unref(caps);
-
- MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "req-negotiation",TRUE);
-
- /* FIXME: consider delay */
- clock = gst_pipeline_get_clock(GST_PIPELINE(pipeline));
- sc->stillshot_time = gst_clock_get_time(clock) - gst_element_get_base_time(GST_ELEMENT(pipeline));
- _mmcam_dbg_log("Change to target resolution(%d, %d)", info->width, info->height);
- MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_ENCSINK_SINK].gst,"signal-handoffs",TRUE);
- MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "block", FALSE);
-
- } else {
- _mmcam_dbg_log("No need to change resolution. Open toggle now.");
- MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_ENCSINK_SINK].gst,"signal-handoffs",TRUE);
- MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "block", FALSE);
}
- }
-
- /* Play capture sound here if single capture */
- if (info->type == _MMCamcorder_SINGLE_SHOT) {
- _mmcamcorder_sound_solo_play(handle, _MMCAMCORDER_FILEPATH_CAPTURE_SND, FALSE);
- }
-cmd_error:
- return ret;
-}
-
-
-int _mmcamcorder_image_cmd_preview_start_with_encbin(MMHandleType handle)
-{
- int ret = MM_ERROR_NONE;
- int width = 0;
- int height = 0;
- int fps = 0;
- int cap_width = 0;
- int cap_height = 0;
- int rotation = 0;
- int input_index = 0;
- int set_width = 0;
- int set_height = 0;
- int set_rotate = 0;
- int current_framecount = 0;
- int current_state = MM_CAMCORDER_STATE_NONE;
- gboolean fps_auto = FALSE;
- char *err_name = NULL;
- char *videosrc_name = NULL;
-
- GstState state = GST_STATE_NULL;
- GstCaps *caps = NULL;
- GstElement *pipeline = NULL;
- GstCameraControl *control = NULL;
-
- mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
- _MMCamcorderImageInfo *info = NULL;
- _MMCamcorderSubContext *sc = NULL;
- type_element *VideosrcElement = NULL;
-
- mmf_return_val_if_fail(hcamcorder, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
-
- sc = MMF_CAMCORDER_SUBCONTEXT(hcamcorder);
- mmf_return_val_if_fail(sc && sc->info && sc->element, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
-
- _mmcam_dbg_log("");
-
- info = sc->info;
- pipeline = sc->element[_MMCAMCORDER_MAIN_PIPE].gst;
-
- _mmcamcorder_conf_get_element(hcamcorder->conf_main,
- CONFIGURE_CATEGORY_MAIN_VIDEO_INPUT,
- "VideosrcElement",
- &VideosrcElement);
-
- _mmcamcorder_conf_get_value_element_name(VideosrcElement, &videosrc_name);
-
- sc->display_interval = 0;
- sc->previous_slot_time = 0;
-
- /* init image info */
- info->capture_cur_count = 0;
- info->capture_send_count = 0;
- info->next_shot_time = 0;
- info->multi_shot_stop = TRUE;
- info->capturing = FALSE;
-
- _mmcamcorder_vframe_stablize(handle);
-
- current_state = _mmcamcorder_get_state(handle);
- _mmcam_dbg_log("current state [%d]", current_state);
-
- if (!strcmp(videosrc_name, "avsysvideosrc") || !strcmp(videosrc_name, "camerasrc")) {
- _mmcam_dbg_log("Capture Preview start : %s - No need to set new caps.", videosrc_name);
-
- ret = mm_camcorder_get_attributes(handle, &err_name,
- MMCAM_CAMERA_FPS_AUTO, &fps_auto,
- NULL);
- if (ret != MM_ERROR_NONE) {
- _mmcam_dbg_warn("Get attrs fail. (%s:%x)", err_name, ret);
- SAFE_FREE (err_name);
- goto cmd_error;
+ /* sound finalize */
+ if (info->type == _MMCamcorder_MULTI_SHOT) {
+ __ta__(" _mmcamcorder_sound_finalize",
+ _mmcamcorder_sound_finalize(handle);
+ );
}
+ } else {
+ int cap_count = 0;
+ int sound_ret = FALSE;
- /* set fps-auto to videosrc */
- MMCAMCORDER_G_OBJECT_SET( sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "fps-auto", fps_auto);
-
- if (current_state == MM_CAMCORDER_STATE_CAPTURING) {
- if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
- _mmcam_dbg_err("Can't cast Video source into camera control.");
- return MM_ERROR_CAMCORDER_NOT_SUPPORTED;
- }
-
- current_framecount = sc->kpi.video_framecount;
+ MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", FALSE);
- control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
- gst_camera_control_set_capture_command(control, GST_CAMERA_CONTROL_CAPTURE_COMMAND_STOP);
- }
- } else {
- /* check if resolution need to roll back */
- ret = mm_camcorder_get_attributes(handle, &err_name,
- MMCAM_CAMERA_DEVICE, &input_index,
- MMCAM_CAMERA_WIDTH, &width,
- MMCAM_CAMERA_HEIGHT, &height,
- MMCAM_CAMERA_FPS, &fps,
- MMCAM_CAMERA_FPS_AUTO, &fps_auto,
- MMCAM_CAMERA_ROTATION, &rotation,
- MMCAM_CAPTURE_WIDTH, &cap_width,
- MMCAM_CAPTURE_HEIGHT, &cap_height,
- NULL);
+ __ta__(" _MMCamcorder_CMD_PREVIEW_START:GST_STATE_PLAYING",
+ ret = _mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_PLAYING);
+ );
if (ret != MM_ERROR_NONE) {
- _mmcam_dbg_warn("Get attrs fail. (%s:%x)", err_name, ret);
- SAFE_FREE (err_name);
goto cmd_error;
}
- if (current_state == MM_CAMCORDER_STATE_CAPTURING) {
- switch (rotation) {
- case MM_VIDEO_INPUT_ROTATION_90:
- set_width = height;
- set_height = width;
- set_rotate = 90;
- break;
- case MM_VIDEO_INPUT_ROTATION_180:
- set_width = width;
- set_height = height;
- set_rotate = 180;
- break;
- case MM_VIDEO_INPUT_ROTATION_270:
- set_width = height;
- set_height = width;
- set_rotate = 270;
- break;
- case MM_VIDEO_INPUT_ROTATION_NONE:
- default:
- set_width = width;
- set_height = height;
- set_rotate = 0;
- break;
- }
-
- caps = gst_caps_new_simple("video/x-raw-yuv",
- "format", GST_TYPE_FOURCC, sc->fourcc,
- "width", G_TYPE_INT, set_width,
- "height", G_TYPE_INT,set_height,
- "framerate", GST_TYPE_FRACTION, fps, 1,
- "rotate", G_TYPE_INT, set_rotate,
- NULL);
- if (caps == NULL) {
- _mmcam_dbg_err("failed to create caps");
- ret = MM_ERROR_CAMCORDER_LOW_MEMORY;
- goto cmd_error;
- }
-
- MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_FILT].gst, "caps", caps);
- gst_caps_unref(caps);
- caps = NULL;
- _mmcam_dbg_log("Rollback to original resolution(%d, %d)", width, height);
- }
- }
+ /* get sound status/volume level and register changed_cb */
+ if (hcamcorder->shutter_sound_policy == VCONFKEY_CAMERA_SHUTTER_SOUND_POLICY_OFF &&
+ info->sound_status == _SOUND_STATUS_INIT) {
+ _mmcam_dbg_log("get sound status/volume level and register vconf changed_cb");
- MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", FALSE);
+ /* get sound status */
+ __ta__(" GET:VCONFKEY_SETAPPL_SOUND_STATUS_BOOL",
+ vconf_get_bool(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL, &(info->sound_status));
+ );
- gst_element_get_state(pipeline, &state, NULL, -1);
+ _mmcam_dbg_log("sound status %d", info->sound_status);
- if (state == GST_STATE_PLAYING) {
- if (!strcmp(videosrc_name, "avsysvideosrc") || !strcmp(videosrc_name, "camerasrc")) {
- __ta__( " Wait preview frame after capture",
- while (current_framecount == sc->kpi.video_framecount) {
- usleep(_MMCAMCORDER_CAPTURE_STOP_CHECK_INTERVAL);
- }
+ /* get volume level */
+ __ta__(" mm_sound_volume_get_value",
+ mm_sound_volume_get_value(VOLUME_TYPE_MEDIA, &info->volume_level);
);
- _mmcam_dbg_log("Wait Frame Done. count before[%d],after[%d]",
- current_framecount, sc->kpi.video_framecount);
- } else {
-#if 1
- MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", TRUE);
- ret = _mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_READY);
- MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", FALSE);
- MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "block", FALSE);
-#else /* This code wasn't work. So rollback to previous code. Plz tell me why. It's weired. */
- MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "block", FALSE);
- MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", FALSE);
- ret = _mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_READY);
-#endif
- if (ret != MM_ERROR_NONE) {
- goto cmd_error;
- }
+ _mmcam_dbg_log("volume level %d", info->volume_level);
- ret = _mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_PLAYING);
- if (ret != MM_ERROR_NONE) {
- goto cmd_error;
- }
- MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "block", TRUE);
+ /* register changed_cb */
+ vconf_notify_key_changed(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL, __sound_status_changed_cb, hcamcorder);
+ mm_sound_volume_add_callback(VOLUME_TYPE_MEDIA, __volume_level_changed_cb, hcamcorder);
}
- } else {
- __ta__(" _MMCamcorder_CMD_PREVIEW_START:GST_STATE_PLAYING",
- ret = _mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_PLAYING);
- );
- if (ret != MM_ERROR_NONE) {
- goto cmd_error;
+
+ mm_camcorder_get_attributes(handle, NULL, MMCAM_CAPTURE_COUNT, &cap_count, NULL);
+ if (cap_count > 1) {
+ __ta__("_mmcamcorder_sound_init",
+#ifdef _MMCAMCORDER_UPLOAD_SAMPLE
+ sound_ret = _mmcamcorder_sound_init(handle, _MMCAMCORDER_FILEPATH_CAPTURE2_SND);
+#else /* _MMCAMCORDER_UPLOAD_SAMPLE */
+ sound_ret = _mmcamcorder_sound_init(handle);
+#endif /* _MMCAMCORDER_UPLOAD_SAMPLE */
+ );
}
}
cmd_error:
- MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_ENCSINK_SINK].gst,"signal-handoffs",FALSE);
- MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "block", TRUE);
return ret;
}
-int _mmcamcorder_image_cmd_preview_stop_with_encbin(MMHandleType handle)
+int _mmcamcorder_image_cmd_preview_stop(MMHandleType handle)
{
int ret = MM_ERROR_NONE;
mmf_return_val_if_fail(handle, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
sc = MMF_CAMCORDER_SUBCONTEXT(handle);
- mmf_return_val_if_fail(sc && sc->info && sc->element, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
+ mmf_return_val_if_fail(sc && sc->element, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
pipeline = sc->element[_MMCAMCORDER_MAIN_PIPE].gst;
- /* set signal handler off */
- MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_ENCSINK_SINK].gst,"signal-handoffs",FALSE);
-
- MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "block", FALSE);
- MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", FALSE);
+ MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", TRUE);
ret = _mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_READY);
- if (ret != MM_ERROR_NONE) {
- goto cmd_error;
+ MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", FALSE);
+
+ /* deregister sound status callback */
+ if (sc->info_image->sound_status != _SOUND_STATUS_INIT) {
+ _mmcam_dbg_log("deregister sound status callback");
+
+ __ta__(" vconf_ignore_key_changed",
+ vconf_ignore_key_changed(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL, __sound_status_changed_cb);
+ );
+ __ta__(" mm_sound_volume_remove_callback",
+ mm_sound_volume_remove_callback(VOLUME_TYPE_MEDIA);
+ );
+
+ sc->info_image->sound_status = _SOUND_STATUS_INIT;
}
-cmd_error:
return ret;
}
-int _mmcamcorder_image_command(MMHandleType handle, int command)
+int _mmcamcorder_video_capture_command(MMHandleType handle, int command)
{
int ret = MM_ERROR_NONE;
sc = MMF_CAMCORDER_SUBCONTEXT(handle);
mmf_return_val_if_fail(sc && sc->element, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
- _mmcam_dbg_log("command=%d", command);
+ _mmcam_dbg_log("command %d", command);
switch (command) {
case _MMCamcorder_CMD_CAPTURE:
- if (!sc->bencbin_capture) {
- ret = _mmcamcorder_image_cmd_capture(handle);
- } else {
- ret = _mmcamcorder_image_cmd_capture_with_encbin(handle);
- }
- break;
- case _MMCamcorder_CMD_CAPTURE_CANCEL:
- /* TODO: Is this needed? */
+ ret = _mmcamcorder_image_cmd_capture(handle);
break;
case _MMCamcorder_CMD_PREVIEW_START:
- if (!sc->bencbin_capture) {
- ret = _mmcamcorder_image_cmd_preview_start(handle);
- } else {
- ret = _mmcamcorder_image_cmd_preview_start_with_encbin(handle);
- }
+ ret = _mmcamcorder_image_cmd_preview_start(handle);
+
/* I place this function last because it miscalculates a buffer that sents in GST_STATE_PAUSED */
_mmcamcorder_video_current_framerate_init(handle);
break;
case _MMCamcorder_CMD_PREVIEW_STOP:
- if (!sc->bencbin_capture) {
- ret = _mmcamcorder_image_cmd_preview_stop(handle);
- } else {
- ret = _mmcamcorder_image_cmd_preview_stop_with_encbin(handle);
- }
+ ret = _mmcamcorder_image_cmd_preview_stop(handle);
+ break;
+ case _MMCamcorder_CMD_RECORD:
+ case _MMCamcorder_CMD_PAUSE:
+ case _MMCamcorder_CMD_CANCEL:
+ case _MMCamcorder_CMD_COMMIT:
+ /* video recording command */
+ ret = _mmcamcorder_video_command(handle, command);
break;
default:
ret = MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
void __mmcamcorder_init_stillshot_info (MMHandleType handle)
{
- int type = _MMCamcorder_SINGLE_SHOT;
-
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
_MMCamcorderSubContext *sc = NULL;
_MMCamcorderImageInfo *info = NULL;
mmf_return_if_fail(hcamcorder);
sc = MMF_CAMCORDER_SUBCONTEXT(hcamcorder);
- mmf_return_if_fail(sc && sc->info);
+ mmf_return_if_fail(sc && sc->info_image);
- info = sc->info;
- type = info->type;
+ info = sc->info_image;
- _mmcam_dbg_log("capture type[%d], capture send count[%d]", type, info->capture_send_count);
+ _mmcam_dbg_log("capture type[%d], capture send count[%d]", info->type, info->capture_send_count);
- if (type ==_MMCamcorder_SINGLE_SHOT || info->capture_send_count == info->count) {
+ if (info->type ==_MMCamcorder_SINGLE_SHOT || info->capture_send_count == info->count) {
info->capture_cur_count = 0;
info->capture_send_count = 0;
info->multi_shot_stop = TRUE;
info->next_shot_time = 0;
- info->type = _MMCamcorder_SINGLE_SHOT;
/* capturing flag set to FALSE here */
info->capturing = FALSE;
- MMTA_ACUM_ITEM_END("Real First Capture Start", FALSE);
}
return;
}
-gboolean __mmcamcorder_capture_save_exifinfo(MMHandleType handle, MMCamcorderCaptureDataType *original, MMCamcorderCaptureDataType *thumbnail)
+int __mmcamcorder_capture_save_exifinfo(MMHandleType handle, MMCamcorderCaptureDataType *original, MMCamcorderCaptureDataType *thumbnail)
{
int ret = MM_ERROR_NONE;
unsigned char *data = NULL;
if (!original || original->data == NULL || original->length == 0) {
_mmcam_dbg_err("original=%p, data=%p, length=%d", original, original->data, original->length);
- return FALSE;
+ return MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
} else {
/* original is input/output param. save original values to local var. */
data = original->data;
datalen = original->length;
}
- /* exif 090227 */
- ret = mm_exif_create_exif_info(&(hcamcorder->exif_info));
- if (hcamcorder->exif_info == NULL || ret != MM_ERROR_NONE) {
- _MMCamcorderMsgItem msg;
-
- msg.id = MM_MESSAGE_CAMCORDER_ERROR;
- msg.param.code = ret;
- _mmcamcroder_send_message(handle, &msg);
-
- _mmcam_dbg_err("Failed to create exif_info [%x]", ret);
- return FALSE;
- }
-
- /* add basic exif info */
- _mmcam_dbg_log("add basic exif info");
- __ta__(" __mmcamcorder_set_exif_basic_info",
- ret = __mmcamcorder_set_exif_basic_info(handle);
- );
- if (ret != MM_ERROR_NONE) {
- _MMCamcorderMsgItem msg;
-
- msg.id = MM_MESSAGE_CAMCORDER_ERROR;
- msg.param.code = ret;
- _mmcamcroder_send_message(handle, &msg);
-
- _mmcam_dbg_err("Failed to set_exif_basic_info [%x]", ret);
- }
-
- if (thumbnail != NULL) {
- int bthumbnail = TRUE;
-
- /* check whether thumbnail should be included */
- mm_camcorder_get_attributes(handle, NULL, "capture-thumbnail", &bthumbnail, NULL);
-
- if (thumbnail->data && thumbnail->length >0 && bthumbnail) {
+ if (thumbnail) {
+ if (thumbnail->data && thumbnail->length > 0) {
_mmcam_dbg_log("thumbnail is added!thumbnail->data=%p thumbnail->width=%d ,thumbnail->height=%d",
thumbnail->data, thumbnail->width, thumbnail->height);
/* add thumbnail exif info */
- __ta__(" mm_exif_add_thumbnail_info",
- ret = mm_exif_add_thumbnail_info(hcamcorder->exif_info, thumbnail->data,thumbnail->width, thumbnail->height, thumbnail->length);
+ __ta__(" mm_exif_add_thumbnail_info",
+ ret = mm_exif_add_thumbnail_info(hcamcorder->exif_info,
+ thumbnail->data,
+ thumbnail->width,
+ thumbnail->height,
+ thumbnail->length);
);
- if (ret != MM_ERROR_NONE) {
- _MMCamcorderMsgItem msg;
-
- msg.id = MM_MESSAGE_CAMCORDER_ERROR;
- msg.param.code = ret;
- _mmcamcroder_send_message(handle, &msg);
-
- _mmcam_dbg_err("Failed to set_exif_thumbnail [%x]",ret);
- }
} else {
- _mmcam_dbg_err("Skip adding thumbnail (data=%p, length=%d, capture-thumbnail=%d)",
- thumbnail->data, thumbnail->length , bthumbnail);
+ _mmcam_dbg_err("Skip adding thumbnail (data=%p, length=%d)",
+ thumbnail->data, thumbnail->length);
}
}
- /* write jpeg with exif */
- ret = mm_exif_write_exif_jpeg_to_memory(&original->data, &original->length ,hcamcorder->exif_info, data, datalen);
-
- if (ret != MM_ERROR_NONE) {
- _MMCamcorderMsgItem msg;
-
- msg.id = MM_MESSAGE_CAMCORDER_ERROR;
- msg.param.code = ret;
- _mmcamcroder_send_message(handle, &msg);
-
- _mmcam_dbg_err("mm_exif_write_exif_jpeg_to_memory error! [%x]",ret);
- }
-
- /* destroy exif info */
- mm_exif_destory_exif_info(hcamcorder->exif_info);
- hcamcorder->exif_info = NULL;
-
- _mmcam_dbg_log("END");
-
- if (ret != MM_ERROR_NONE) {
- return FALSE;
- } else {
- return TRUE;
+ if (ret == MM_ERROR_NONE) {
+ /* write jpeg with exif */
+ __ta__(" mm_exif_write_exif_jpeg_to_memory",
+ ret = mm_exif_write_exif_jpeg_to_memory(&original->data, &original->length ,hcamcorder->exif_info, data, datalen);
+ );
+ if (ret != MM_ERROR_NONE) {
+ _mmcam_dbg_err("mm_exif_write_exif_jpeg_to_memory error! [0x%x]",ret);
+ }
}
-}
+ _mmcam_dbg_log("END ret 0x%x", ret);
-gboolean __mmcamcorder_capture_send_msg(MMHandleType handle, int type, int count)
-{
- mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
- _MMCamcorderImageInfo *info = NULL;
- _MMCamcorderSubContext *sc = NULL;
- _MMCamcorderMsgItem msg;
-
- mmf_return_val_if_fail(hcamcorder, FALSE);
-
- sc = MMF_CAMCORDER_SUBCONTEXT(hcamcorder);
- mmf_return_val_if_fail(sc && sc->info, FALSE);
-
- info = sc->info;
-
- _mmcam_dbg_log("type [%d], capture count [%d]", type, count);
-
- msg.id = MM_MESSAGE_CAMCORDER_CAPTURED;
- msg.param.code = count;
-
- _mmcamcroder_send_message((MMHandleType)hcamcorder, &msg);
-
- _mmcam_dbg_log("END");
- return TRUE;
+ return ret;
}
gst_structure_get_int(structure, "height", &capture_data->height);
capture_data->length = GST_BUFFER_SIZE(buffer);
- _mmcam_dbg_err("buffer data[%p],size[%dx%d],length[%d],format[%d]",
- capture_data->data, capture_data->width, capture_data->height,
- capture_data->length, capture_data->format);
+ _mmcam_dbg_warn("buffer data[%p],size[%dx%d],length[%d],format[%d]",
+ capture_data->data, capture_data->width, capture_data->height,
+ capture_data->length, capture_data->format);
gst_caps_unref(caps);
caps = NULL;
}
-gboolean __mmcamcorder_set_jpeg_data(MMHandleType handle, MMCamcorderCaptureDataType *dest, MMCamcorderCaptureDataType *thumbnail)
+int __mmcamcorder_set_jpeg_data(MMHandleType handle, MMCamcorderCaptureDataType *dest, MMCamcorderCaptureDataType *thumbnail)
{
- int tag_enable = 0;
- int provide_exif = FALSE;
-
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
_MMCamcorderSubContext *sc = NULL;
- mmf_return_val_if_fail(hcamcorder, FALSE);
- mmf_return_val_if_fail(dest, FALSE);
+ mmf_return_val_if_fail(hcamcorder && dest, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
sc = MMF_CAMCORDER_SUBCONTEXT(hcamcorder);
- mmf_return_val_if_fail(sc, FALSE);
+ mmf_return_val_if_fail(sc, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
_mmcam_dbg_log("");
- mm_camcorder_get_attributes(handle, NULL, MMCAM_TAG_ENABLE, &tag_enable, NULL);
- MMCAMCORDER_G_OBJECT_GET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "provide-exif", &provide_exif);
-
- _mmcam_dbg_log("tag enable[%d], provide exif[%d]", tag_enable, provide_exif);
-
/* if tag enable and doesn't provide exif, we make it */
- if (tag_enable && !provide_exif) {
- _mmcam_dbg_log("Add exif information if existed(thumbnail[%p])", thumbnail);
- if (thumbnail && thumbnail->data) {
- if (!__mmcamcorder_capture_save_exifinfo(handle, dest, thumbnail)) {
- return FALSE;
- }
- } else {
- if (!__mmcamcorder_capture_save_exifinfo(handle, dest, NULL)) {
- return FALSE;
- }
- }
+ _mmcam_dbg_log("Add exif information if existed(thumbnail[%p])", thumbnail);
+ if (thumbnail && thumbnail->data) {
+ return __mmcamcorder_capture_save_exifinfo(handle, dest, thumbnail);
+ } else {
+ return __mmcamcorder_capture_save_exifinfo(handle, dest, NULL);
}
-
- return TRUE;
}
_mmcam_dbg_log("");
+ __ta__( " Get:MMCAM_TAG_ENABLE and \"provide-exif\"",
mm_camcorder_get_attributes(handle, NULL, MMCAM_TAG_ENABLE, &tag_enable, NULL);
- MMCAMCORDER_G_OBJECT_GET (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "provide-exif", &provide_exif);
+ MMCAMCORDER_G_OBJECT_GET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "provide-exif", &provide_exif);
+ );
/* if dest->data is allocated in MSL, release it */
if (tag_enable && !provide_exif) {
if (dest->data) {
+ __ta__( " Free data",
free(dest->data);
+ );
dest->length = 0;
dest->data = NULL;
_mmcam_dbg_log("Jpeg is released!");
int pixtype = MM_PIXEL_FORMAT_INVALID;
int pixtype_sub = MM_PIXEL_FORMAT_INVALID;
int codectype = MM_IMAGE_CODEC_JPEG;
- int type = _MMCamcorder_SINGLE_SHOT;
int attr_index = 0;
int count = 0;
- int stop_cont_shot = 0;
- gboolean send_msg = FALSE;
+ int stop_cont_shot = FALSE;
+ int tag_enable = FALSE;
+ int provide_exif = FALSE;
+ int capture_quality = 0;
+ int try_lock_count = 0;
+ gboolean send_captured_message = FALSE;
+ unsigned char *exif_raw_data = NULL;
+ MMCamcorderStateType current_state = MM_CAMCORDER_STATE_NONE;
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(u_data);
_MMCamcorderImageInfo *info = NULL;
_MMCamcorderSubContext *sc = NULL;
MMCamcorderCaptureDataType scrnail = {0,};
mmf_attrs_t *attrs = NULL;
- mmf_attribute_t *item = NULL;
-
- void *encoded_data = NULL;
- char *err_attr_name = NULL;
+ mmf_attribute_t *item_screennail = NULL;
+ mmf_attribute_t *item_exif_raw_data = NULL;
mmf_return_if_fail(hcamcorder);
sc = MMF_CAMCORDER_SUBCONTEXT(hcamcorder);
- mmf_return_if_fail(sc && sc->info);
+ mmf_return_if_fail(sc && sc->info_image);
- info = sc->info;
+ info = sc->info_image;
- _mmcam_dbg_err("START");
+ /* get current state */
+ current_state = _mmcamcorder_get_state((MMHandleType)hcamcorder);
+
+ _mmcam_dbg_err("START - current state %d", current_state);
MMTA_ACUM_ITEM_BEGIN(" MSL capture callback", FALSE);
/* check capture state */
if (info->type == _MMCamcorder_MULTI_SHOT && info->capture_send_count > 0) {
mm_camcorder_get_attributes((MMHandleType)hcamcorder, NULL, "capture-break-cont-shot", &stop_cont_shot, NULL);
- if (stop_cont_shot == TRUE) {
- _mmcam_dbg_warn("capture stop command already come. skip this...");
- MMTA_ACUM_ITEM_END( " MSL capture callback", FALSE );
- goto error;
- }
}
- if (!info->capturing) {
- _mmcam_dbg_err("It's Not capturing now.");
- goto error;
+ if (!info->capturing || stop_cont_shot) {
+ _mmcam_dbg_warn("stop command[%d] or not capturing state[%d]. skip this...",
+ stop_cont_shot, info->capturing);
+
+ MMTA_ACUM_ITEM_END(" MSL capture callback", FALSE);
+
+ /*free GstBuffer*/
+ if (buffer1) {
+ gst_buffer_unref(buffer1);
+ }
+ if (buffer2) {
+ gst_buffer_unref(buffer2);
+ }
+ if (buffer3) {
+ gst_buffer_unref(buffer3);
+ }
+
+ return;
}
- /* play capture sound here if multi capture */
- if (info->type == _MMCamcorder_MULTI_SHOT) {
- _mmcamcorder_sound_play((MMHandleType)hcamcorder);
+ /* check command lock to block capture callback if capture start API is not returned
+ wait for 2 seconds at worst case */
+ try_lock_count = 0;
+ do {
+ _mmcam_dbg_log("Try command LOCK");
+ if (_MMCAMCORDER_TRYLOCK_CMD(hcamcorder)) {
+ _mmcam_dbg_log("command LOCK OK");
+ _MMCAMCORDER_UNLOCK_CMD(hcamcorder);
+ break;
+ }
+
+ if (try_lock_count++ < TRY_LOCK_MAX_COUNT) {
+ _mmcam_dbg_warn("command LOCK Failed, retry...[count %d]", try_lock_count);
+ usleep(TRY_LOCK_TIME);
+ } else {
+ _mmcam_dbg_err("failed to lock command LOCK");
+ break;
+ }
+ } while (TRUE);
+
+ if (current_state < MM_CAMCORDER_STATE_RECORDING) {
+ /* play capture sound here if multi capture
+ or preview format is ITLV(because of AF and flash control in plugin) */
+ if (info->type == _MMCamcorder_MULTI_SHOT) {
+ __ta__(" _mmcamcorder_sound_play",
+ _mmcamcorder_sound_play((MMHandleType)hcamcorder);
+ );
+ } else if (!info->played_capture_sound) {
+ __ta__(" _mmcamcorder_sound_solo_play",
+ _mmcamcorder_sound_solo_play((MMHandleType)hcamcorder, _MMCAMCORDER_FILEPATH_CAPTURE_SND, FALSE);
+ );
+ }
}
+ /* init capture data */
+ memset((void *)&dest, 0x0, sizeof(MMCamcorderCaptureDataType));
+ memset((void *)&thumb, 0x0, sizeof(MMCamcorderCaptureDataType));
+ memset((void *)&scrnail, 0x0, sizeof(MMCamcorderCaptureDataType));
+
/* Prepare main, thumbnail buffer */
pixtype = _mmcamcorder_get_pixel_format(buffer1);
if (pixtype == MM_PIXEL_FORMAT_INVALID) {
_mmcam_dbg_err("Unsupported pixel type");
+
+ MMCAM_SEND_MESSAGE(hcamcorder, MM_MESSAGE_CAMCORDER_ERROR, MM_ERROR_CAMCORDER_INTERNAL);
+
goto error;
}
__mmcamcorder_get_capture_data_from_buffer(&dest, pixtype, buffer1);
} else {
_mmcam_dbg_err("buffer1 has wrong pointer. (buffer1=%p)",buffer1);
+ MMCAM_SEND_MESSAGE(hcamcorder, MM_MESSAGE_CAMCORDER_ERROR, MM_ERROR_CAMCORDER_INTERNAL);
goto error;
}
/* Encode JPEG */
if (sc->internal_encode) {
- int capture_quality = 0;
- ret = mm_camcorder_get_attributes((MMHandleType)hcamcorder, &err_attr_name,
- MMCAM_IMAGE_ENCODER_QUALITY, &capture_quality,
- NULL);
- if (ret != MM_ERROR_NONE) {
- _mmcam_dbg_err("Get attribute failed[%s][%x]", err_attr_name, ret);
- SAFE_FREE(err_attr_name);
- goto error;
- }
-
- __ta__(" _mmcamcorder_encode_jpeg",
+#ifdef _MMCAMCORDER_MAKE_THUMBNAIL_INTERNAL_ENCODE
+ int thumb_width = 0;
+ int thumb_height = 0;
+ int thumb_length = 0;
+ unsigned char *thumb_raw_data = NULL;
+#endif /* _MMCAMCORDER_MAKE_THUMBNAIL_INTERNAL_ENCODE */
+
+ mm_camcorder_get_attributes((MMHandleType)hcamcorder, NULL,
+ MMCAM_IMAGE_ENCODER_QUALITY, &capture_quality,
+ NULL);
+ _mmcam_dbg_log("Start Internal Encode - capture_quality %d", capture_quality);
+
+ __ta__(" _mmcamcorder_encode_jpeg:MAIN",
ret = _mmcamcorder_encode_jpeg(GST_BUFFER_DATA(buffer1), dest.width, dest.height,
pixtype, dest.length, capture_quality, &(dest.data), &(dest.length));
);
- if (ret == FALSE) {
+ if (!ret) {
+ _mmcam_dbg_err("_mmcamcorder_encode_jpeg failed");
+
+ MMCAM_SEND_MESSAGE(hcamcorder, MM_MESSAGE_CAMCORDER_ERROR, MM_ERROR_CAMCORDER_INTERNAL);
+
goto error;
}
- encoded_data = dest.data;
+ /* set format */
dest.format = MM_PIXEL_FORMAT_ENCODED;
- }
- /* Thumbnail image buffer */
- if (buffer2 && GST_BUFFER_DATA(buffer2) && (GST_BUFFER_SIZE(buffer2) !=0)) {
- pixtype_sub = _mmcamcorder_get_pixel_format(buffer2);
- _mmcam_dbg_log("Thumnail (buffer2=%p)",buffer2);
+ _mmcam_dbg_log("Done Internal Encode - data %p, length %d", dest.data, dest.length);
+
+#ifdef _MMCAMCORDER_MAKE_THUMBNAIL_INTERNAL_ENCODE
+ /* make thumbnail image */
+ _mmcam_dbg_log("Make thumbnail image");
+
+ if (dest.width > THUMBNAIL_WIDTH) {
+ float img_ratio = (float)dest.width / (float)dest.height;
+
+ _mmcam_dbg_log("image ratio %f , default ratio %f", img_ratio, THUMBNAIL_DEFAULT_RATIO);
+
+ if (img_ratio > THUMBNAIL_DEFAULT_RATIO) {
+ thumb_height = THUMBNAIL_HEIGHT;
+ thumb_width = (thumb_height * dest.width) / dest.height;
+ } else {
+ thumb_width = THUMBNAIL_WIDTH;
+ thumb_height = (thumb_width * dest.height) / dest.width;
+ }
+
+ _mmcam_dbg_log("need to resize : thumbnail size %dx%d", thumb_width, thumb_height);
+
+ if (!_mmcamcorder_resize_frame(GST_BUFFER_DATA(buffer1), dest.width, dest.height, GST_BUFFER_SIZE(buffer1), pixtype,
+ &thumb_raw_data, &thumb_width, &thumb_height, &thumb_length)) {
+ thumb_raw_data = NULL;
+ _mmcam_dbg_warn("_mmcamcorder_resize_frame failed. skip thumbnail making...");
+ }
+ } else {
+ thumb_width = dest.width;
+ thumb_height = dest.height;
+
+ _mmcam_dbg_log("NO need to resize : thumbnail size %dx%d", thumb_width, thumb_height);
+
+ thumb_raw_data = GST_BUFFER_DATA(buffer1);
+ }
+
+ if (thumb_raw_data) {
+ __ta__(" _mmcamcorder_encode_jpeg:THUMBNAIL",
+ ret = _mmcamcorder_encode_jpeg(thumb_raw_data, thumb_width, thumb_height,
+ pixtype, thumb_length, THUMBNAIL_JPEG_QUALITY, &(thumb.data), &(thumb.length));
+ );
+ if (ret) {
+ _mmcam_dbg_log("encode THUMBNAIL done - data %p, length %d", thumb.data, thumb.length);
+
+ thumb.width = thumb_width;
+ thumb.height = thumb_height;
+ thumb.format = MM_PIXEL_FORMAT_ENCODED;
+ } else {
+ _mmcam_dbg_warn("failed to encode THUMBNAIL");
+ }
- __mmcamcorder_get_capture_data_from_buffer(&thumb, pixtype_sub, buffer2);
+ if (thumb_raw_data != GST_BUFFER_DATA(buffer1)) {
+ free(thumb_raw_data);
+ thumb_raw_data = NULL;
+ _mmcam_dbg_log("release thumb_raw_data");
+ }
+ } else {
+ _mmcam_dbg_warn("thumb_raw_data is NULL");
+ }
+#endif /* _MMCAMCORDER_MAKE_THUMBNAIL_INTERNAL_ENCODE */
} else {
- _mmcam_dbg_log("buffer2 has wrong pointer. Not Error. (buffer2=%p)",buffer2);
+ /* Thumbnail image buffer */
+ if (buffer2 && GST_BUFFER_DATA(buffer2) && (GST_BUFFER_SIZE(buffer2) !=0)) {
+ _mmcam_dbg_log("Thumnail (buffer2=%p)",buffer2);
+
+ pixtype_sub = _mmcamcorder_get_pixel_format(buffer2);
+ __mmcamcorder_get_capture_data_from_buffer(&thumb, pixtype_sub, buffer2);
+ } else {
+ _mmcam_dbg_log("buffer2 has wrong pointer. Not Error. (buffer2=%p)",buffer2);
+ }
}
/* Screennail image buffer */
attrs = (mmf_attrs_t*)MMF_CAMCORDER_ATTRS(hcamcorder);
- mm_attrs_get_index((MMHandleType)attrs, "captured-screennail", &attr_index);
- item = &attrs->items[attr_index];
+ mm_attrs_get_index((MMHandleType)attrs, MMCAM_CAPTURED_SCREENNAIL, &attr_index);
+ item_screennail = &attrs->items[attr_index];
if (buffer3 && GST_BUFFER_DATA(buffer3) && GST_BUFFER_SIZE(buffer3) != 0) {
_mmcam_dbg_log("Screennail (buffer3=%p,size=%d)", buffer3, GST_BUFFER_SIZE(buffer3));
__mmcamcorder_get_capture_data_from_buffer(&scrnail, pixtype_sub, buffer3);
/* Set screennail attribute for application */
- mmf_attribute_set_data(item, &scrnail, sizeof(scrnail));
+ ret = mmf_attribute_set_data(item_screennail, &scrnail, sizeof(scrnail));
+ _mmcam_dbg_log("Screennail set attribute data %p, size %d, ret %x", &scrnail, sizeof(scrnail), ret);
} else {
- mmf_attribute_set_data(item, NULL, 0);
-
_mmcam_dbg_log("buffer3 has wrong pointer. Not Error. (buffer3=%p)",buffer3);
+ mmf_attribute_set_data(item_screennail, NULL, 0);
}
- mmf_attrs_commit_err((MMHandleType)attrs, &err_attr_name);
+ /* commit screennail data */
+ mmf_attribute_commit(item_screennail);
+
+ /* create EXIF info */
+ __ta__(" mm_exif_create_exif_info",
+ ret = mm_exif_create_exif_info(&(hcamcorder->exif_info));
+ );
+ if (ret != MM_ERROR_NONE) {
+ _mmcam_dbg_err("Failed to create exif_info [%x], but keep going...", ret);
+ } else {
+ /* add basic exif info */
+ _mmcam_dbg_log("add basic exif info");
+ __ta__(" __mmcamcorder_set_exif_basic_info",
+ ret = __mmcamcorder_set_exif_basic_info((MMHandleType)hcamcorder, dest.width, dest.height);
+ );
+ if (ret != MM_ERROR_NONE) {
+ _mmcam_dbg_warn("Failed set_exif_basic_info [%x], but keep going...", ret);
+ ret = MM_ERROR_NONE;
+ }
+ }
- /* Set extra data for jpeg */
- if (dest.format == MM_PIXEL_FORMAT_ENCODED) {
- int err = 0;
- char *err_attr_name = NULL;
+ /* get attribute item for EXIF data */
+ mm_attrs_get_index((MMHandleType)attrs, MMCAM_CAPTURED_EXIF_RAW_DATA, &attr_index);
+ item_exif_raw_data = &attrs->items[attr_index];
- err = mm_camcorder_get_attributes((MMHandleType)hcamcorder, &err_attr_name,
- MMCAM_IMAGE_ENCODER, &codectype,
- NULL);
- if (err != MM_ERROR_NONE) {
- _mmcam_dbg_warn("Getting codectype failed. (%s:%x)", err_attr_name, err);
- SAFE_FREE (err_attr_name);
- goto error;
+ /* set EXIF data to attribute */
+ if (hcamcorder->exif_info && hcamcorder->exif_info->data) {
+ exif_raw_data = (unsigned char *)malloc(hcamcorder->exif_info->size);
+ if (exif_raw_data) {
+ memcpy(exif_raw_data, hcamcorder->exif_info->data, hcamcorder->exif_info->size);
+ mmf_attribute_set_data(item_exif_raw_data, exif_raw_data, hcamcorder->exif_info->size);
+ _mmcam_dbg_log("set EXIF raw data %p, size %d", exif_raw_data, hcamcorder->exif_info->size);
+ } else {
+ _mmcam_dbg_warn("failed to alloc for EXIF, size %d", hcamcorder->exif_info->size);
}
+ } else {
+ _mmcam_dbg_warn("failed to create EXIF. set EXIF as NULL");
+ mmf_attribute_set_data(item_exif_raw_data, NULL, 0);
+ }
+
+ /* commit EXIF data */
+ mmf_attribute_commit(item_exif_raw_data);
+
+ /* get tag-enable and provide-exif */
+ mm_camcorder_get_attributes((MMHandleType)hcamcorder, NULL, MMCAM_TAG_ENABLE, &tag_enable, NULL);
+ MMCAMCORDER_G_OBJECT_GET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "provide-exif", &provide_exif);
+
+ /* Set extra data for JPEG if tag enabled and doesn't provide EXIF */
+ if (dest.format == MM_PIXEL_FORMAT_ENCODED &&
+ tag_enable && !provide_exif) {
+ mm_camcorder_get_attributes((MMHandleType)hcamcorder, NULL,
+ MMCAM_IMAGE_ENCODER, &codectype,
+ NULL);
+ _mmcam_dbg_log("codectype %d", codectype);
switch (codectype) {
case MM_IMAGE_CODEC_JPEG:
__ta__( " __mmcamcorder_set_jpeg_data",
ret = __mmcamcorder_set_jpeg_data((MMHandleType)hcamcorder, &dest, &thumb);
);
- if (!ret) {
+ if (ret != MM_ERROR_NONE) {
_mmcam_dbg_err("Error on setting extra data to jpeg");
+ MMCAM_SEND_MESSAGE(hcamcorder, MM_MESSAGE_CAMCORDER_ERROR, ret);
goto error;
}
break;
default:
_mmcam_dbg_err("The codectype is not supported. (%d)", codectype);
+
+ MMCAM_SEND_MESSAGE(hcamcorder, MM_MESSAGE_CAMCORDER_ERROR, MM_ERROR_CAMCORDER_INTERNAL);
+
goto error;
}
}
_mmcam_dbg_log("APPLICATION CALLBACK END");
} else {
_mmcam_dbg_err("Capture callback is NULL.");
+
+ MMCAM_SEND_MESSAGE(hcamcorder, MM_MESSAGE_CAMCORDER_ERROR, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
+
goto err_release_exif;
}
- /* Set send msg flag and capture count */
- send_msg = TRUE;
- type = info->type;
+ /* Set capture count */
count = ++(info->capture_send_count);
+ send_captured_message = TRUE;
err_release_exif:
_MMCAMCORDER_UNLOCK_VCAPTURE_CALLBACK(hcamcorder);
+ /* init screennail and EXIF raw data */
+ __ta__(" init attributes:scrnl and EXIF",
+ mmf_attribute_set_data(item_screennail, NULL, 0);
+ mmf_attribute_commit(item_screennail);
+ if (exif_raw_data) {
+ free(exif_raw_data);
+ exif_raw_data = NULL;
+
+ mmf_attribute_set_data(item_exif_raw_data, NULL, 0);
+ mmf_attribute_commit(item_exif_raw_data);
+ }
+ );
+
/* Release jpeg data */
if (pixtype == MM_PIXEL_FORMAT_ENCODED) {
- __ta__( " __mmcamcorder_release_jpeg_data",
+ __ta__(" __mmcamcorder_release_jpeg_data",
__mmcamcorder_release_jpeg_data((MMHandleType)hcamcorder, &dest);
);
}
error:
/* Check end condition and set proper value */
- __mmcamcorder_init_stillshot_info((MMHandleType)hcamcorder);
-
- /* send captured message if no problem */
- if (send_msg) {
- __mmcamcorder_capture_send_msg((MMHandleType)hcamcorder, type, count);
+ if (info->hdr_capture_mode != MM_CAMCORDER_HDR_ON_AND_ORIGINAL ||
+ (info->hdr_capture_mode == MM_CAMCORDER_HDR_ON_AND_ORIGINAL && count == 2)) {
+ __mmcamcorder_init_stillshot_info((MMHandleType)hcamcorder);
}
/* release internal allocated data */
- if (encoded_data) {
- if (dest.data == encoded_data) {
+ if (sc->internal_encode) {
+ if (dest.data) {
+ free(dest.data);
dest.data = NULL;
+ dest.length = 0;
+ _mmcam_dbg_log("release internal encoded data MAIN");
+ }
+ if (thumb.data) {
+ free(thumb.data);
+ thumb.data = NULL;
+ thumb.length = 0;
+ _mmcam_dbg_log("release internal encoded data THUMB");
}
-
- free(encoded_data);
- encoded_data = NULL;
}
/*free GstBuffer*/
gst_buffer_unref(buffer3);
}
+ /* destroy exif info */
+ __ta__(" mm_exif_destory_exif_info",
+ mm_exif_destory_exif_info(hcamcorder->exif_info);
+ );
+ hcamcorder->exif_info = NULL;
+
+ /* send captured message */
+ if (send_captured_message) {
+ MMTA_ACUM_ITEM_BEGIN(" CAPTURED MESSAGE DELAY", FALSE);
+
+ if (info->hdr_capture_mode != MM_CAMCORDER_HDR_ON_AND_ORIGINAL) {
+ MMCamcorderStateType current_state = MM_CAMCORDER_STATE_NONE;
+
+ mm_camcorder_get_state((MMHandleType)hcamcorder, ¤t_state);
+
+ /* Send CAPTURED message and count - capture success */
+ if (current_state >= MM_CAMCORDER_STATE_RECORDING) {
+ MMCAM_SEND_MESSAGE(hcamcorder, MM_MESSAGE_CAMCORDER_VIDEO_SNAPSHOT_CAPTURED, count);
+ } else {
+ MMCAM_SEND_MESSAGE(hcamcorder, MM_MESSAGE_CAMCORDER_CAPTURED, count);
+ }
+ } else if (info->hdr_capture_mode == MM_CAMCORDER_HDR_ON_AND_ORIGINAL && count == 2) {
+ /* send captured message only once in HDR and Original Capture mode */
+ MMCAM_SEND_MESSAGE(hcamcorder, MM_MESSAGE_CAMCORDER_CAPTURED, 1);
+ }
+ }
+
MMTA_ACUM_ITEM_END( " MSL capture callback", FALSE );
_mmcam_dbg_err("END");
}
-int __mmcamcorder_set_exif_basic_info(MMHandleType handle)
+int __mmcamcorder_set_exif_basic_info(MMHandleType handle, int image_width, int image_height)
{
int ret = MM_ERROR_NONE;
int value;
double f_longitude = INVALID_GPS_VALUE;
double f_altitude = INVALID_GPS_VALUE;
char *str_value = NULL;
+#ifdef WRITE_EXIF_MAKER_INFO /* FIXME */
char *maker = NULL;
+#endif
char *user_comment = NULL;
char *err_name = NULL;
ExifData *ed = NULL;
static ExifLong elong[10];
GstCameraControl *control = NULL;
- GstCameraControlExifInfo avsys_exif_info = {0,};
+ GstCameraControlExifInfo avsys_exif_info;
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(handle);
_MMCamcorderSubContext *sc = NULL;
sc = MMF_CAMCORDER_SUBCONTEXT(handle);
mmf_return_val_if_fail(sc && sc->element, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
+ CLEAR(avsys_exif_info);
+
if (!GST_IS_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst)) {
- _mmcam_dbg_err("Can't cast Video source into camera control. Just return true.");
- return MM_ERROR_NONE;
+ _mmcam_dbg_err("Can't cast Video source into camera control. Skip camera control values...");
+ } else {
+ control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
+ /* get device information */
+ __ta__(" gst_camera_control_get_exif_info",
+ gst_camera_control_get_exif_info(control, &avsys_exif_info);
+ );
}
- control = GST_CAMERA_CONTROL(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst);
- /* get device information */
- gst_camera_control_get_exif_info(control, &avsys_exif_info);
-
/* get ExifData from exif info */
+ __ta__(" mm_exif_get_exif_from_info",
ed = mm_exif_get_exif_from_info(hcamcorder->exif_info);
+ );
if (ed == NULL || ed->ifd == NULL) {
_mmcam_dbg_err("get exif data error!!(%p, %p)", ed, (ed ? ed->ifd : NULL));
return MM_ERROR_INVALID_HANDLE;
}
/*1. EXIF_TAG_IMAGE_WIDTH */ /*EXIF_TAG_PIXEL_X_DIMENSION*/
- mm_camcorder_get_attributes(handle, NULL, MMCAM_CAPTURE_WIDTH, &value, NULL);
+ value = image_width;
exif_set_long((unsigned char *)&elong[cntl], exif_data_get_byte_order(ed), value);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_0, EXIF_TAG_IMAGE_WIDTH,
_mmcam_dbg_log("width[%d]", value);
/*2. EXIF_TAG_IMAGE_LENGTH*/ /*EXIF_TAG_PIXEL_Y_DIMENSION*/
- mm_camcorder_get_attributes(handle, NULL, MMCAM_CAPTURE_HEIGHT, &value, NULL);
+ value = image_height;
exif_set_long((unsigned char *)&elong[cntl], exif_data_get_byte_order (ed), value);
ret = mm_exif_set_add_entry(ed, EXIF_IFD_0, EXIF_TAG_IMAGE_LENGTH,
free(b);
}
+#ifdef WRITE_EXIF_MAKER_INFO /* FIXME */
/*5. EXIF_TAG_MAKE */
maker = strdup(MM_MAKER_NAME);
if (maker) {
} else {
_mmcam_dbg_warn("failed to get model name");
}
-
+#endif
/*6. EXIF_TAG_IMAGE_DESCRIPTION */
mm_camcorder_get_attributes(handle, NULL, MMCAM_TAG_IMAGE_DESCRIPTION, &str_value, &str_val_len, NULL);
_mmcam_dbg_log("desctiption [%s]", str_value);
/*7. EXIF_TAG_SOFTWARE*/
/*
- {
+ if (control != NULL) {
char software[50] = {0,};
unsigned int len = 0;
}
*/
- /*8. EXIF_TAG_ORIENTATION */
+ /*8. EXIF_TAG_ORIENTATION */
mm_camcorder_get_attributes(handle, NULL, MMCAM_TAG_ORIENTATION, &value, NULL);
-
- _mmcam_dbg_log("orientation [%d]",value);
+ _mmcam_dbg_log("get orientation [%d]",value);
if (value == 0) {
value = MM_EXIF_ORIENTATION;
}
}
/*9. EXIF_TAG_COLOR_SPACE */
- exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order(ed), avsys_exif_info.colorspace);
- ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_COLOR_SPACE,
- EXIF_FORMAT_SHORT, 1, (unsigned char *)&eshort[cnts++]);
- if (ret != MM_ERROR_NONE) {
- EXIF_SET_ERR(ret, EXIF_TAG_COLOR_SPACE);
+ if (control != NULL) {
+ exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order(ed), avsys_exif_info.colorspace);
+ ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_COLOR_SPACE,
+ EXIF_FORMAT_SHORT, 1, (unsigned char *)&eshort[cnts++]);
+ if (ret != MM_ERROR_NONE) {
+ EXIF_SET_ERR(ret, EXIF_TAG_COLOR_SPACE);
+ }
}
/*10. EXIF_TAG_COMPONENTS_CONFIGURATION */
- config = avsys_exif_info.component_configuration;
- _mmcam_dbg_log("EXIF_TAG_COMPONENTS_CONFIGURATION [%4x] ",config);
- ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_COMPONENTS_CONFIGURATION,
- EXIF_FORMAT_UNDEFINED, 4, (unsigned char *)&config);
- if (ret != MM_ERROR_NONE) {
- EXIF_SET_ERR(ret, EXIF_TAG_COMPONENTS_CONFIGURATION);
+ if (control != NULL) {
+ config = avsys_exif_info.component_configuration;
+ _mmcam_dbg_log("EXIF_TAG_COMPONENTS_CONFIGURATION [%4x] ",config);
+ ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_COMPONENTS_CONFIGURATION,
+ EXIF_FORMAT_UNDEFINED, 4, (unsigned char *)&config);
+ if (ret != MM_ERROR_NONE) {
+ EXIF_SET_ERR(ret, EXIF_TAG_COMPONENTS_CONFIGURATION);
+ }
}
/*11. EXIF_TAG_COMPRESSED_BITS_PER_PIXEL */
/*12. EXIF_TAG_DATE_TIME_ORIGINAL */
/*13. EXIF_TAG_DATE_TIME_DIGITIZED*/
+
/*14. EXIF_TAG_EXPOSURE_TIME*/
if (avsys_exif_info.exposure_time_numerator && avsys_exif_info.exposure_time_denominator) {
unsigned char *b = NULL;
/* defualt : none */
/*24. EXIF_TAG_METERING_MODE */
- exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order(ed),avsys_exif_info.metering_mode);
- _mmcam_dbg_log("EXIF_TAG_METERING_MODE [%d]", avsys_exif_info.metering_mode);
- ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_METERING_MODE,
- EXIF_FORMAT_SHORT, 1, (unsigned char *)&eshort[cnts++]);
- if (ret != MM_ERROR_NONE) {
- EXIF_SET_ERR(ret, EXIF_TAG_METERING_MODE);
+ if (control != NULL) {
+ exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order(ed),avsys_exif_info.metering_mode);
+ _mmcam_dbg_log("EXIF_TAG_METERING_MODE [%d]", avsys_exif_info.metering_mode);
+ ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_METERING_MODE,
+ EXIF_FORMAT_SHORT, 1, (unsigned char *)&eshort[cnts++]);
+ if (ret != MM_ERROR_NONE) {
+ EXIF_SET_ERR(ret, EXIF_TAG_METERING_MODE);
+ }
}
/*25. EXIF_TAG_LIGHT_SOURCE*/
/*26. EXIF_TAG_FLASH*/
- exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order (ed),avsys_exif_info.flash);
- _mmcam_dbg_log("EXIF_TAG_FLASH [%d]", avsys_exif_info.flash);
- ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_FLASH,
- EXIF_FORMAT_SHORT, 1, (unsigned char *)&eshort[cnts++]);
- if (ret != MM_ERROR_NONE) {
- EXIF_SET_ERR(ret, EXIF_TAG_FLASH);
+ if (control != NULL) {
+ exif_set_short((unsigned char *)&eshort[cnts], exif_data_get_byte_order (ed),avsys_exif_info.flash);
+ _mmcam_dbg_log("EXIF_TAG_FLASH [%d]", avsys_exif_info.flash);
+ ret = mm_exif_set_add_entry(ed, EXIF_IFD_EXIF, EXIF_TAG_FLASH,
+ EXIF_FORMAT_SHORT, 1, (unsigned char *)&eshort[cnts++]);
+ if (ret != MM_ERROR_NONE) {
+ EXIF_SET_ERR(ret, EXIF_TAG_FLASH);
+ }
}
/*27. EXIF_TAG_FOCAL_LENGTH*/
return ret;
}
+
+
+static void __sound_status_changed_cb(keynode_t* node, void *data)
+{
+ mmf_camcorder_t *hcamcorder = (mmf_camcorder_t *)data;
+ _MMCamcorderImageInfo *info = NULL;
+
+ mmf_return_if_fail(hcamcorder && hcamcorder->sub_context && hcamcorder->sub_context->info_image);
+
+ _mmcam_dbg_log("START");
+
+ info = hcamcorder->sub_context->info_image;
+
+ __ta__(" GET_IN_CB:VCONFKEY_SETAPPL_SOUND_STATUS_BOOL",
+ vconf_get_bool(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL, &(info->sound_status));
+ );
+
+ _mmcam_dbg_log("DONE : sound status %d", info->sound_status);
+
+ return;
+}
+
+
+static void __volume_level_changed_cb(void *data)
+{
+ mmf_camcorder_t *hcamcorder = (mmf_camcorder_t *)data;
+ _MMCamcorderImageInfo *info = NULL;
+
+ mmf_return_if_fail(hcamcorder && hcamcorder->sub_context && hcamcorder->sub_context->info_image);
+
+ _mmcam_dbg_log("START");
+
+ info = hcamcorder->sub_context->info_image;
+
+ __ta__(" GET_IN_CB:mm_sound_volume_get_value",
+ mm_sound_volume_get_value(VOLUME_TYPE_MEDIA, &info->volume_level);
+ );
+
+ _mmcam_dbg_log("DONE : volume level %d", info->volume_level);
+
+ return;
+}
*
*/
-/*===========================================================================================
-| |
-| INCLUDE FILES |
-| |
-========================================================================================== */
+/*=======================================================================================
+| INCLUDE FILES |
+=======================================================================================*/
#include <stdio.h>
#include <stdarg.h>
#include <camsrcjpegenc.h>
#include "mm_camcorder_internal.h"
#include "mm_camcorder_util.h"
+#include <mm_util_imgp.h>
-/*---------------------------------------------------------------------------
-| GLOBAL VARIABLE DEFINITIONS for internal |
----------------------------------------------------------------------------*/
+/*-----------------------------------------------------------------------
+| GLOBAL VARIABLE DEFINITIONS for internal |
+-----------------------------------------------------------------------*/
+
+/*-----------------------------------------------------------------------
+| LOCAL VARIABLE DEFINITIONS for internal |
+-----------------------------------------------------------------------*/
+#define TIME_STRING_MAX_LEN 64
-/*---------------------------------------------------------------------------
-| LOCAL VARIABLE DEFINITIONS for internal |
----------------------------------------------------------------------------*/
-#define TIME_STRING_MAX_LEN 64
#define FPUTC_CHECK(x_char, x_file)\
{\
if (fputc(x_char, x_file) == EOF) \
}
// find top level tag only, do not use this function for finding sub level tags
-gint _mmcamcorder_find_tag(FILE *f, guint32 tag_fourcc)
+gint _mmcamcorder_find_tag(FILE *f, guint32 tag_fourcc, gboolean do_rewind)
{
guchar buf[8];
- rewind(f);
+ if (do_rewind) {
+ rewind(f);
+ }
- while(fread(&buf, sizeof(guchar), 8, f)>0)
- {
- gulong buf_size = 0;
- guint32 buf_fourcc = MMCAM_FOURCC(buf[4], buf[5],buf[6],buf[7]);
+ while (fread(&buf, sizeof(guchar), 8, f)>0) {
+ unsigned long long buf_size = 0;
+ unsigned int buf_fourcc = MMCAM_FOURCC(buf[4], buf[5], buf[6], buf[7]);
- if(tag_fourcc == buf_fourcc)
- {
+ if (tag_fourcc == buf_fourcc) {
_mmcam_dbg_log("find tag : %c%c%c%c", MMCAM_FOURCC_ARGS(tag_fourcc));
- return 1;
- }
- else
- {
- _mmcam_dbg_log("skip [%c%c%c%c] tag", MMCAM_FOURCC_ARGS(buf_fourcc));
- buf_size = _mmcamcorder_get_container_size(buf);
- if(fseek(f, buf_size-8, SEEK_CUR) != 0)
- {
- _mmcam_dbg_err("fseek() fail");
- return 0;
- }
+ return TRUE;
+ } else {
+ _mmcam_dbg_log("skip [%c%c%c%c] tag", MMCAM_FOURCC_ARGS(buf_fourcc));
+
+ buf_size = (unsigned long long)_mmcamcorder_get_container_size(buf);
+ buf_size = buf_size - 8; /* include tag */
+
+ do {
+ if (buf_size > _MMCAMCORDER_MAX_INT) {
+ _mmcam_dbg_log("seek %d", _MMCAMCORDER_MAX_INT);
+ if (fseek(f, _MMCAMCORDER_MAX_INT, SEEK_CUR) != 0) {
+ _mmcam_dbg_err("fseek() fail");
+ return FALSE;
+ }
+
+ buf_size -= _MMCAMCORDER_MAX_INT;
+ } else {
+ _mmcam_dbg_log("seek %d", buf_size);
+ if (fseek(f, buf_size, SEEK_CUR) != 0) {
+ _mmcam_dbg_err("fseek() fail");
+ return FALSE;
+ }
+ break;
+ }
+ } while (TRUE);
}
}
+
_mmcam_dbg_log("cannot find tag : %c%c%c%c", MMCAM_FOURCC_ARGS(tag_fourcc));
- return 0;
+
+ return FALSE;
}
gboolean _mmcamcorder_update_size(FILE *f, gint64 prev_pos, gint64 curr_pos)
}
-gulong _mmcamcorder_get_container_size(const guchar *size)
+guint64 _mmcamcorder_get_container_size(const guchar *size)
{
- gulong result = 0;
- gulong temp = 0;
+ guint64 result = 0;
+ guint64 temp = 0;
+
temp = size[0];
result = temp << 24;
temp = size[1];
result = result | (temp << 16);
temp = size[2];
result = result | (temp << 8);
- result = result | size[3];
+ result = result | size[3];
+
+ _mmcam_dbg_log("result : %lld", (unsigned long long)result);
+
return result;
}
+gboolean _mmcamcorder_update_composition_matrix(FILE *f, int orientation)
+{
+ /* for 0 degree */
+ guint32 a = 0x00010000;
+ guint32 b = 0;
+ guint32 c = 0;
+ guint32 d = 0x00010000;
+
+ switch (orientation) {
+ case MM_CAMCORDER_TAG_ORT_0R_VR_0C_VT:/* 90 degree */
+ a = 0;
+ b = 0x00010000;
+ c = 0xffff0000;
+ d = 0;
+ break;
+ case MM_CAMCORDER_TAG_ORT_0R_VB_0C_VR:/* 180 degree */
+ a = 0xffff0000;
+ d = 0xffff0000;
+ break;
+ case MM_CAMCORDER_TAG_ORT_0R_VL_0C_VB:/* 270 degree */
+ a = 0;
+ b = 0xffff0000;
+ c = 0x00010000;
+ d = 0;
+ break;
+ case MM_CAMCORDER_TAG_ORT_0R_VT_0C_VL:/* 0 degree */
+ default:
+ break;
+ }
+
+ write_to_32(f, a);
+ write_to_32(f, b);
+ write_to_32(f, 0);
+ write_to_32(f, c);
+ write_to_32(f, d);
+ write_to_32(f, 0);
+ write_to_32(f, 0);
+ write_to_32(f, 0);
+ write_to_32(f, 0x40000000);
+
+ _mmcam_dbg_log("orientation : %d, write data 0x%x 0x%x 0x%x 0x%x",
+ orientation, a, b, c, d);
+
+ return TRUE;
+}
+
+
int _mmcamcorder_get_freespace(const gchar *path, guint64 *free_space)
{
struct statfs fs;
_mmcam_dbg_log("LEAVE");
}
+
void _mmcamcorder_element_release_noti(gpointer data, GObject *where_the_object_was)
{
int i=0;
mmf_return_if_fail(sc);
mmf_return_if_fail(sc->element);
- for(i=0;i< _MMCamcorder_PIPELINE_ELEMENT_NUM; i++)
- {
- if(sc->element[i].gst && (G_OBJECT(sc->element[i].gst) == where_the_object_was))
- {
+ for (i = 0 ; i < _MMCamcorder_PIPELINE_ELEMENT_NUM ; i++) {
+ if (sc->element[i].gst && (G_OBJECT(sc->element[i].gst) == where_the_object_was)) {
_mmcam_dbg_log("The element[%d][%p] is finalized", sc->element[i].id, sc->element[i].gst);
sc->element[i].gst = NULL;
sc->element[i].id = _MMCAMCORDER_NONE;
gboolean
_mmcamcroder_msg_callback(void *data)
{
- _MMCamcorderMsgItem * item = (_MMCamcorderMsgItem*)data;
- mmf_camcorder_t *hcamcorder= NULL;
- mmf_return_val_if_fail( item, FALSE );
-
+ _MMCamcorderMsgItem *item = (_MMCamcorderMsgItem*)data;
+ mmf_camcorder_t *hcamcorder = NULL;
+ mmf_return_val_if_fail(item, FALSE);
+
hcamcorder = MMF_CAMCORDER(item->handle);
- mmf_return_val_if_fail( hcamcorder, FALSE );
+ mmf_return_val_if_fail(hcamcorder, FALSE);
-// _mmcam_dbg_log("msg id:%x, msg_cb:%p, msg_data:%p, item:%p", item->id, hcamcorder->msg_cb, hcamcorder->msg_data, item);
+ /*_mmcam_dbg_log("msg id:%x, msg_cb:%p, msg_data:%p, item:%p", item->id, hcamcorder->msg_cb, hcamcorder->msg_data, item);*/
- _MMCAMCORDER_LOCK_MESSAGE_CALLBACK( hcamcorder );
+ _MMCAMCORDER_LOCK_MESSAGE_CALLBACK(hcamcorder);
+
+ /* check delay of CAPTURED message */
+ if (item->id == MM_MESSAGE_CAMCORDER_CAPTURED) {
+ MMTA_ACUM_ITEM_END(" CAPTURED MESSAGE DELAY", FALSE);
+ }
if ((hcamcorder) && (hcamcorder->msg_cb)) {
hcamcorder->msg_cb(item->id, (MMMessageParamType*)(&(item->param)), hcamcorder->msg_cb_param);
}
- _MMCAMCORDER_UNLOCK_MESSAGE_CALLBACK( hcamcorder );
+ _MMCAMCORDER_UNLOCK_MESSAGE_CALLBACK(hcamcorder);
_MMCAMCORDER_LOCK((MMHandleType)hcamcorder);
-
- if (hcamcorder->msg_data)
+
+ if (hcamcorder->msg_data) {
hcamcorder->msg_data = g_list_remove(hcamcorder->msg_data, item);
+ }
+
+ /* release allocated memory */
+ if (item->id == MM_MESSAGE_CAMCORDER_FACE_DETECT_INFO) {
+ MMCamFaceDetectInfo *cam_fd_info = (MMCamFaceDetectInfo *)item->param.data;
+ if (cam_fd_info) {
+ SAFE_FREE(cam_fd_info->face_info);
+ free(cam_fd_info);
+ cam_fd_info = NULL;
+ }
- SAFE_FREE(item);
+ item->param.data = NULL;
+ item->param.size = 0;
+ }
+
+ free(item);
+ item = NULL;
_MMCAMCORDER_UNLOCK((MMHandleType)hcamcorder);
- return FALSE; //For not being called again
+ /* For not being called again */
+ return FALSE;
}
case MM_MESSAGE_CAMCORDER_ERROR:
case MM_MESSAGE_CAMCORDER_FOCUS_CHANGED:
case MM_MESSAGE_CAMCORDER_CAPTURED:
+ case MM_MESSAGE_CAMCORDER_VIDEO_CAPTURED:
+ case MM_MESSAGE_CAMCORDER_AUDIO_CAPTURED:
case MM_MESSAGE_READY_TO_RESUME:
default:
data->param.union_type = MM_MSG_UNION_CODE;
hcamcorder->msg_data = NULL;
}
+ /* remove idle function for playing capture sound */
+ do {
+ ret = g_idle_remove_by_data(hcamcorder);
+ _mmcam_dbg_log("remove idle function for playing capture sound. ret[%d]", ret);
+ } while (ret);
+
_MMCAMCORDER_UNLOCK(handle);
return;
fourcc = GST_MAKE_FOURCC ('J', 'P', 'E', 'G');
}
break;
+ case MM_PIXEL_FORMAT_ITLV_JPEG_UYVY:
+ fourcc = GST_MAKE_FOURCC('I','T','L','V');
+ break;
default:
- _mmcam_dbg_log("Not proper pixel type. Set default.");
- fourcc = GST_MAKE_FOURCC ('S', '4', '2', '0');
+ _mmcam_dbg_log("Not proper pixel type[%d]. Set default - I420", pixtype);
+ if (use_zero_copy_format) {
+ fourcc = GST_MAKE_FOURCC ('S', '4', '2', '0');
+ } else {
+ fourcc = GST_MAKE_FOURCC ('I', '4', '2', '0');
+ }
break;
}
case GST_MAKE_FOURCC ('P', 'N', 'G', ' '):
pixtype = MM_PIXEL_FORMAT_ENCODED;
break;
+ /*FIXME*/
+ case GST_MAKE_FOURCC ('I', 'T', 'L', 'V'):
+ pixtype = MM_PIXEL_FORMAT_ITLV_JPEG_UYVY;
+ break;
default:
_mmcam_dbg_log("Not supported fourcc type(%x)", fourcc);
pixtype = MM_PIXEL_FORMAT_INVALID;
}
+gboolean _mmcamcorder_resize_frame(unsigned char *src_data, int src_width, int src_height, int src_length, int src_format,
+ unsigned char **dst_data, int *dst_width, int *dst_height, int *dst_length)
+{
+ int ret = TRUE;
+ int mm_ret = MM_ERROR_NONE;
+ int input_format = MM_UTIL_IMG_FMT_YUV420;
+ unsigned char *dst_tmp_data = NULL;
+
+ if (!src_data || !dst_data || !dst_width || !dst_height || !dst_length) {
+ _mmcam_dbg_err("something is NULL %p,%p,%p,%p,%p",
+ src_data, dst_data, dst_width, dst_height, dst_length);
+ return FALSE;
+ }
+
+ /* set input format for mm-util */
+ switch (src_format) {
+ case MM_PIXEL_FORMAT_I420:
+ input_format = MM_UTIL_IMG_FMT_I420;
+ break;
+ case MM_PIXEL_FORMAT_YV12:
+ input_format = MM_UTIL_IMG_FMT_YUV420;
+ break;
+ case MM_PIXEL_FORMAT_NV12:
+ input_format = MM_UTIL_IMG_FMT_NV12;
+ break;
+ case MM_PIXEL_FORMAT_YUYV:
+ input_format = MM_UTIL_IMG_FMT_YUYV;
+ break;
+ case MM_PIXEL_FORMAT_UYVY:
+ input_format = MM_UTIL_IMG_FMT_UYVY;
+ break;
+ default:
+ _mmcam_dbg_err("NOT supported format", src_format);
+ return FALSE;
+ }
+
+ _mmcam_dbg_log("src size %dx%d -> dst size %dx%d",
+ src_width, src_height, *dst_width, *dst_height);
+
+ /* get length of resized image */
+ __ta__(" mm_util_get_image_size 2",
+ mm_ret = mm_util_get_image_size(input_format, *dst_width, *dst_height, dst_length);
+ );
+ if (mm_ret != MM_ERROR_NONE) {
+ GST_ERROR("mm_util_get_image_size failed 0x%x", ret);
+ return FALSE;
+ }
+
+ _mmcam_dbg_log("dst_length : %d", *dst_length);
+
+ dst_tmp_data = (unsigned char *)malloc(*dst_length);
+ if (dst_tmp_data == NULL) {
+ _mmcam_dbg_err("failed to alloc dst_thumb_size(size %d)", *dst_length);
+ return FALSE;
+ }
+
+ __ta__(" mm_util_resize_image",
+ mm_ret = mm_util_resize_image(src_data, src_width, src_height, input_format,
+ dst_tmp_data, dst_width, dst_height);
+ );
+ if (mm_ret != MM_ERROR_NONE) {
+ GST_ERROR("mm_util_resize_image failed 0x%x", ret);
+ free(dst_tmp_data);
+ return FALSE;
+ }
+
+ *dst_data = dst_tmp_data;
+
+ _mmcam_dbg_log("resize done %p, %dx%d", *dst_data, *dst_width, *dst_height);
+
+ return TRUE;
+}
+
+
gboolean _mmcamcorder_encode_jpeg(void *src_data, unsigned int src_width, unsigned int src_height,
int src_format, unsigned int src_length, unsigned int jpeg_quality,
void **result_data, unsigned int *result_length)
{
int ret = 0;
int i = 0;
+ int enc_type = JPEG_ENCODER_SOFTWARE;
guint32 src_fourcc = 0;
gboolean do_encode = FALSE;
jpegenc_parameter enc_param;
src_fourcc = _mmcamcorder_get_fourcc(src_format, 0, FALSE);
camsrcjpegenc_get_src_fmt(src_fourcc, &(enc_param.src_fmt));
- if (enc_param.src_fmt != COLOR_FORMAT_NOT_SUPPORT &&
- enc_info.sw_support == TRUE) {
+ if (enc_param.src_fmt == COLOR_FORMAT_NOT_SUPPORT) {
+ _mmcam_dbg_err("Not Supported FOURCC(format:%d)", src_format);
+ return FALSE;
+ }
+
+ /* check H/W encoder */
+ if (enc_info.hw_support) {
+ _mmcam_dbg_log("check H/W encoder supported format list");
+ /* Check supported format */
+ for (i = 0 ; i < enc_info.hw_enc.input_fmt_num ; i++) {
+ if (enc_param.src_fmt == enc_info.hw_enc.input_fmt_list[i]) {
+ do_encode = TRUE;
+ break;
+ }
+ }
+
+ if (do_encode) {
+ enc_type = JPEG_ENCODER_HARDWARE;
+ }
+ }
+
+ /* check S/W encoder */
+ if (!do_encode && enc_info.sw_support) {
+ _mmcam_dbg_log("check S/W encoder supported format list");
/* Check supported format */
for (i = 0 ; i < enc_info.sw_enc.input_fmt_num ; i++) {
if (enc_param.src_fmt == enc_info.sw_enc.input_fmt_list[i]) {
}
if (do_encode) {
- enc_param.src_data = src_data;
- enc_param.width = src_width;
- enc_param.height = src_height;
- enc_param.src_len = src_length;
- enc_param.jpeg_mode = JPEG_MODE_BASELINE;
- enc_param.jpeg_quality = jpeg_quality;
-
- __ta__(" camsrcjpegenc_encode",
- ret = camsrcjpegenc_encode(&enc_info, JPEG_ENCODER_SOFTWARE, &enc_param );
- );
- if (ret == CAMSRC_JPEGENC_ERROR_NONE) {
- *result_data = enc_param.result_data;
- *result_length = enc_param.result_len;
-
- _mmcam_dbg_log("JPEG encode length(%d)", *result_length);
-
- return TRUE;
- } else {
- _mmcam_dbg_err("camsrcjpegenc_encode failed(%x)", ret);
- return FALSE;
- }
+ enc_type = JPEG_ENCODER_SOFTWARE;
+ }
+ }
+
+ if (do_encode) {
+ enc_param.src_data = src_data;
+ enc_param.width = src_width;
+ enc_param.height = src_height;
+ enc_param.src_len = src_length;
+ enc_param.jpeg_mode = JPEG_MODE_BASELINE;
+ enc_param.jpeg_quality = jpeg_quality;
+
+ _mmcam_dbg_log("%ux%u, size %u, quality %u, type %d",
+ src_width, src_height, src_length,
+ jpeg_quality, enc_type);
+
+ __ta__(" camsrcjpegenc_encode",
+ ret = camsrcjpegenc_encode(&enc_info, enc_type, &enc_param );
+ );
+ if (ret == CAMSRC_JPEGENC_ERROR_NONE) {
+ *result_data = enc_param.result_data;
+ *result_length = enc_param.result_len;
+
+ _mmcam_dbg_log("JPEG encode length(%d)", *result_length);
+
+ return TRUE;
} else {
- _mmcam_dbg_err("S/W JPEG codec does NOT support format [%d]", src_format);
+ _mmcam_dbg_err("camsrcjpegenc_encode failed(%x)", ret);
return FALSE;
}
- } else {
- _mmcam_dbg_err("Not Supported FOURCC(format:%d) or There is NO S/W encoder(%d)",
- src_format, enc_info.sw_support);
- return FALSE;
}
+
+ _mmcam_dbg_err("No encoder supports %d format", src_format);
+
+ return FALSE;
}
/*=======================================================================================
| INCLUDE FILES |
=======================================================================================*/
+#include <gst/interfaces/cameracontrol.h>
#include "mm_camcorder_internal.h"
#include "mm_camcorder_videorec.h"
| GLOBAL VARIABLE DEFINITIONS for internal |
---------------------------------------------------------------------------------------*/
#define _MMCAMCORDER_LOCATION_INFO // for add gps information
+#define MAX_ERROR_MESSAGE_LEN 128
/*---------------------------------------------------------------------------------------
| LOCAL VARIABLE DEFINITIONS for internal |
---------------------------------------------------------------------------------------*/
-#define _MMCAMCORDER_MINIMUM_FRAME 10
+#define _MMCAMCORDER_MINIMUM_FRAME 3
#define _MMCAMCORDER_RETRIAL_COUNT 10
#define _MMCAMCORDER_FRAME_WAIT_TIME 200000 /* ms */
#define _MMCAMCORDER_FREE_SPACE_CHECK_INTERVAL 5
+#define _OFFSET_COMPOSITION_MATRIX 40L
/*---------------------------------------------------------------------------------------
| LOCAL FUNCTION PROTOTYPES: |
static gboolean __mmcamcorder_audio_dataprobe_check(GstPad *pad, GstBuffer *buffer, gpointer u_data);
static gboolean __mmcamcorder_video_dataprobe_record(GstPad *pad, GstBuffer *buffer, gpointer u_data);
static gboolean __mmcamcorder_audioque_dataprobe(GstPad *pad, GstBuffer *buffer, gpointer u_data);
-static gboolean __mmcamcorder_video_dataprobe_slow(GstPad *pad, GstBuffer *buffer, gpointer u_data);
+static gboolean __mmcamcorder_video_dataprobe_audio_disable(GstPad *pad, GstBuffer *buffer, gpointer u_data);
static gboolean __mmcamcorder_audio_dataprobe_audio_mute(GstPad *pad, GstBuffer *buffer, gpointer u_data);
static gboolean __mmcamcorder_add_locationinfo(MMHandleType handle, int fileformat);
static gboolean __mmcamcorder_add_locationinfo_mp4(MMHandleType handle);
int _mmcamcorder_add_recorder_pipeline(MMHandleType handle)
{
int err = MM_ERROR_NONE;
+ int audio_disable = FALSE;
char* gst_element_rsink_name = NULL;
GstPad *srcpad = NULL;
goto pipeline_creation_error;
}
- if (sc->is_slow == FALSE) {
+ /* get audio disable */
+ mm_camcorder_get_attributes(handle, NULL,
+ MMCAM_AUDIO_DISABLE, &audio_disable,
+ NULL);
+
+ if (sc->is_modified_rate || audio_disable) {
+ sc->audio_disable = TRUE;
+ } else {
+ sc->audio_disable = FALSE;
+ }
+ _mmcam_dbg_log("AUDIO DISABLE : %d (is_modified_rate %d, audio_disable %d)",
+ sc->audio_disable, sc->is_modified_rate, audio_disable);
+
+ if (sc->audio_disable == FALSE) {
/* Sub pipeline */
__ta__(" __mmcamcorder_create_audiosrc_bin",
err = _mmcamcorder_create_audiosrc_bin((MMHandleType)hcamcorder);
}
__ta__(" _mmcamcorder_create_encodesink_bin",
- err = _mmcamcorder_create_encodesink_bin((MMHandleType)hcamcorder);
+ err = _mmcamcorder_create_encodesink_bin((MMHandleType)hcamcorder, MM_CAMCORDER_ENCBIN_PROFILE_VIDEO);
);
if (err != MM_ERROR_NONE) {
return err;
sinkpad = gst_element_get_static_pad(sc->element[_MMCAMCORDER_ENCSINK_BIN].gst, "video_sink0");
_MM_GST_PAD_LINK_UNREF(srcpad, sinkpad, err, pipeline_creation_error);
- if (sc->is_slow == FALSE) {
+ if (sc->audio_disable == FALSE) {
srcpad = gst_element_get_static_pad (sc->element[_MMCAMCORDER_AUDIOSRC_BIN].gst, "src");
sinkpad = gst_element_get_static_pad (sc->element[_MMCAMCORDER_ENCSINK_BIN].gst, "audio_sink0");
_MM_GST_PAD_LINK_UNREF(srcpad, sinkpad, err, pipeline_creation_error);
/* set data probe function for audio */
- if (sc->is_slow == FALSE) {
+ if (sc->audio_disable == FALSE) {
sinkpad = gst_element_get_static_pad(sc->element[_MMCAMCORDER_ENCSINK_AENC].gst, "sink");
MMCAMCORDER_ADD_BUFFER_PROBE(sinkpad, _MMCAMCORDER_HANDLER_VIDEOREC,
__mmcamcorder_audioque_dataprobe, hcamcorder);
srcpad = NULL;
}
- if (sc->is_slow) {
+ if (sc->audio_disable) {
sinkpad = gst_element_get_static_pad(sc->element[_MMCAMCORDER_ENCSINK_VENC].gst, "sink");
MMCAMCORDER_ADD_BUFFER_PROBE(sinkpad, _MMCAMCORDER_HANDLER_VIDEOREC,
- __mmcamcorder_video_dataprobe_slow, hcamcorder);
+ __mmcamcorder_video_dataprobe_audio_disable, hcamcorder);
gst_object_unref(sinkpad);
sinkpad = NULL;
}
_mmcamcorder_remove_all_handlers((MMHandleType)hcamcorder, _MMCAMCORDER_HANDLER_VIDEOREC);
- ret = _mmcamcorder_remove_encoder_pipeline(handle);
+ /* remove audio pipeline first */
+ ret = _mmcamcorder_remove_audio_pipeline(handle);
if (ret != MM_ERROR_NONE) {
- _mmcam_dbg_err("Fail to remove encoder pipeline");
+ _mmcam_dbg_err("Fail to remove audio pipeline");
return ret;
}
- ret = _mmcamcorder_remove_audio_pipeline(handle);
+ ret = _mmcamcorder_remove_encoder_pipeline(handle);
if (ret != MM_ERROR_NONE) {
- _mmcam_dbg_err("Fail to remove audio pipeline");
+ _mmcam_dbg_err("Fail to remove encoder pipeline");
return ret;
}
int size = 0;
int fileformat = 0;
int ret = MM_ERROR_NONE;
+ double motion_rate = _MMCAMCORDER_DEFAULT_RECORDING_MOTION_RATE;
char *temp_filename = NULL;
char *err_name = NULL;
gint fps = 0;
- gint slow_fps = 0;
GstElement *pipeline = NULL;
GstPad *pad = NULL;
sc = MMF_CAMCORDER_SUBCONTEXT(handle);
mmf_return_val_if_fail(sc, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
- mmf_return_val_if_fail(sc->info, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
+ mmf_return_val_if_fail(sc->info_video, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
mmf_return_val_if_fail(sc->element, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
- info = sc->info;
+ info = sc->info_video;
_mmcam_dbg_log("Command(%d)", command);
case _MMCamcorder_CMD_RECORD:
{
if (_mmcamcorder_get_state((MMHandleType)hcamcorder) != MM_CAMCORDER_STATE_PAUSED) {
+ guint imax_size = 0;
guint imax_time = 0;
/* Play record start sound */
/* Recording */
_mmcam_dbg_log("Record Start");
+ /* set hybrid mode when ITLV format */
+ if (sc->info_image->preview_format == MM_PIXEL_FORMAT_ITLV_JPEG_UYVY) {
+ _mmcam_dbg_log("flush cache TRUE");
+ MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "flush-cache", TRUE);
+ }
+
ret = _mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_PAUSED);
if (ret != MM_ERROR_NONE) {
goto _ERR_CAMCORDER_VIDEO_COMMAND;
ret = mm_camcorder_get_attributes(handle, &err_name,
MMCAM_CAMERA_FPS, &fps,
- "camera-slow-motion-fps", &slow_fps,
+ MMCAM_CAMERA_RECORDING_MOTION_RATE, &motion_rate,
MMCAM_FILE_FORMAT, &fileformat,
MMCAM_TARGET_FILENAME, &temp_filename, &size,
+ MMCAM_TARGET_MAX_SIZE, &imax_size,
MMCAM_TARGET_TIME_LIMIT, &imax_time,
MMCAM_FILE_FORMAT, &(info->fileformat),
NULL);
goto _ERR_CAMCORDER_VIDEO_COMMAND;
}
+ /* set max size */
+ if (imax_size <= 0) {
+ info->max_size = 0; /* do not check */
+ } else {
+ info->max_size = ((guint64)imax_size) << 10; /* to byte */
+ }
+
/* set max time */
if (imax_time <= 0) {
info->max_time = 0; /* do not check */
info->max_time = ((guint64)imax_time) * 1000; /* to millisecond */
}
- if (sc->is_slow) {
- info->multiple_fps = fps/slow_fps;
- _mmcam_dbg_log("high speed recording fps:%d,slow_fps:%d,multiple_fps:%d",
- fps, slow_fps, info->multiple_fps);
+ if (sc->is_modified_rate) {
+ info->record_timestamp_ratio = (_MMCAMCORDER_DEFAULT_RECORDING_MOTION_RATE/motion_rate);
+ _mmcam_dbg_log("high speed recording fps:%d, slow_rate:%f, timestamp_ratio:%f",
+ fps, motion_rate, info->record_timestamp_ratio);
+ } else {
+ info->record_timestamp_ratio = _MMCAMCORDER_DEFAULT_RECORDING_MOTION_RATE;
+ _mmcam_dbg_log("normal recording");
}
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "hold-af-after-capturing", TRUE);
}
for (count = 0 ; count <= _MMCAMCORDER_RETRIAL_COUNT ; count++) {
- if (sc->is_slow) {
+ if (sc->audio_disable) {
/* check only video frame */
if (info->video_frame_count >= _MMCAMCORDER_MINIMUM_FRAME) {
break;
return MM_ERROR_CAMCORDER_CMD_IS_RUNNING;
}
- MMCAMCORDER_G_OBJECT_SET( sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", TRUE);
- MMCAMCORDER_G_OBJECT_SET( sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "hold-af-after-capturing", FALSE);
-
- if (sc->now_continuous_af) {
- sc->now_continuous_af = FALSE;
- _mmcam_dbg_log("Set now_continuous_af as FALSE when CANCEL recording");
- }
+ MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", TRUE);
+ MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "hold-af-after-capturing", FALSE);
__ta__(" _MMCamcorder_CMD_CANCEL:GST_STATE_READY",
ret =_mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_READY);
);
- MMCAMCORDER_G_OBJECT_SET( sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", FALSE);
+ MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", FALSE);
if (ret != MM_ERROR_NONE) {
goto _ERR_CAMCORDER_VIDEO_COMMAND;
}
info->audio_frame_count = 0;
info->filesize =0;
+ /* set flush cache as FALSE */
+ if (sc->info_image->preview_format == MM_PIXEL_FORMAT_ITLV_JPEG_UYVY) {
+ MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "flush-cache", FALSE);
+ }
+
__ta__(" _MMCamcorder_CMD_CANCEL:GST_STATE_PLAYING",
ret =_mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_PLAYING);
);
if (ret != MM_ERROR_NONE) {
goto _ERR_CAMCORDER_VIDEO_COMMAND;
}
-
break;
}
case _MMCamcorder_CMD_COMMIT:
}
for (count = 0 ; count <= _MMCAMCORDER_RETRIAL_COUNT ; count++) {
- if (sc->is_slow) {
+ if (sc->audio_disable) {
/* check only video frame */
if (info->video_frame_count >= _MMCAMCORDER_MINIMUM_FRAME) {
break;
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "hold-af-after-capturing", FALSE);
- if (sc->now_continuous_af) {
- sc->now_continuous_af = FALSE;
- _mmcam_dbg_log("Set now_continuous_af as FALSE when COMMIT recording");
- }
-
if (sc->error_occurs) {
GstPad *video= NULL;
GstPad *audio = NULL;
_mmcam_dbg_err("Sending EOS video encoder src pad : %d", ret);
gst_object_unref(video);
- if (!sc->is_slow) {
+ if (sc->audio_disable == FALSE) {
audio = gst_element_get_static_pad(sc->element[_MMCAMCORDER_ENCSINK_AENC].gst, "src");
gst_pad_push_event (audio, gst_event_new_flush_start());
gst_pad_push_event (audio, gst_event_new_flush_stop());
/* Wait EOS */
_mmcam_dbg_log("Start to wait EOS");
ret =_mmcamcorder_get_eos_message(handle);
- if (ret != MM_ERROR_NONE) {
- goto _ERR_CAMCORDER_VIDEO_COMMAND;
- }
- }
- break;
- case _MMCamcorder_CMD_PREVIEW_START:
- {
- int fps_auto = 0;
- _mmcamcorder_vframe_stablize((MMHandleType)hcamcorder);
-
- /* sc */
- sc->display_interval = 0;
- sc->previous_slot_time = 0;
-
- mm_camcorder_get_attributes(handle, NULL, MMCAM_CAMERA_FPS_AUTO, &fps_auto, NULL);
-
- MMCAMCORDER_G_OBJECT_SET( sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "fps-auto", fps_auto);
-
- __ta__(" _MMCamcorder_CMD_PREVIEW_START:GST_STATE_PLAYING",
- ret =_mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_PLAYING);
- );
- if (ret != MM_ERROR_NONE) {
- goto _ERR_CAMCORDER_VIDEO_COMMAND;
+ /* set flush cache as FALSE */
+ if (sc->info_image->preview_format == MM_PIXEL_FORMAT_ITLV_JPEG_UYVY) {
+ MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "flush-cache", FALSE);
}
- /* I place this function last because it miscalculates a buffer that sents in GST_STATE_PAUSED */
- _mmcamcorder_video_current_framerate_init(handle);
- }
- break;
- case _MMCamcorder_CMD_PREVIEW_STOP:
- MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", TRUE);
- ret = _mmcamcorder_gst_set_state(handle, sc->element[_MMCAMCORDER_MAIN_PIPE].gst, GST_STATE_READY);
- MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", FALSE);
if (ret != MM_ERROR_NONE) {
+ info->b_commiting = FALSE;
goto _ERR_CAMCORDER_VIDEO_COMMAND;
}
-
- if (sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst) {
- int op_status = 0;
- MMCAMCORDER_G_OBJECT_GET(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "operation-status", &op_status);
- _mmcam_dbg_err("Current Videosrc status[0x%x]", op_status);
- }
-
+ }
break;
default:
ret = MM_ERROR_CAMCORDER_INVALID_ARGUMENT;
{
int ret = MM_ERROR_NONE;
int enabletag = 0;
- int camcorder_rotate = MM_VIDEO_INPUT_ROTATION_NONE;
- int camera_rotate = MM_VIDEO_INPUT_ROTATION_NONE;
- int display_rotate = MM_DISPLAY_ROTATION_NONE;
guint64 file_size = 0;
GstPad *pad = NULL;
sc = MMF_CAMCORDER_SUBCONTEXT(handle);
mmf_return_val_if_fail(sc, FALSE);
- mmf_return_val_if_fail(sc->info, FALSE);
+ mmf_return_val_if_fail(sc->info_video, FALSE);
- info = sc->info;
+ info = sc->info_video;
_mmcam_dbg_err("");
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "block", FALSE);
MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", TRUE);
+ mm_camcorder_get_attributes(handle, NULL,
+ MMCAM_TAG_ENABLE, &enabletag,
+ NULL);
+
_mmcam_dbg_log("Set state of pipeline as PAUSED");
__ta__(" _MMCamcorder_CMD_COMMIT:GST_STATE_PAUSED",
ret = _mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_PAUSED);
);
if (ret != MM_ERROR_NONE) {
- _mmcam_dbg_warn("_MMCamcorder_CMD_COMMIT:GST_STATE_PAUSED failed. error[%x]", ret);
+ _mmcam_dbg_warn("_MMCamcorder_CMD_COMMIT:GST_STATE_READY or PAUSED failed. error[%x]", ret);
}
- MMCAMCORDER_G_OBJECT_SET( sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", FALSE);
+ MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_VIDEOSINK_QUE].gst, "empty-buffers", FALSE);
__ta__(" _MMCamcorder_CMD_COMMIT:__mmcamcorder_remove_recorder_pipeline",
ret = _mmcamcorder_remove_recorder_pipeline((MMHandleType)hcamcorder);
}
}
- /* Recovering camera-rotation and display-rotation when start recording */
- if (camcorder_rotate != camera_rotate &&
- camera_rotate < MM_VIDEO_INPUT_ROTATION_FLIP_HORZ) {
- _mmcamcorder_set_videosrc_rotation(handle, camera_rotate);
- _mmcamcorder_set_display_rotation(handle, display_rotate);
- _mmcam_dbg_log("## Recovering camcorder rotation is done. camcorder_rotate=%d, camera_rotate=%d, display_rotate=%d",
- camcorder_rotate,camera_rotate,display_rotate);
- } else {
- _mmcam_dbg_log("## No need to recover camcorder rotation. camcorder_rotate=%d, camera_rotate=%d, display_rotate=%d",
- camcorder_rotate,camera_rotate,display_rotate);
-
- /* Flush EOS event to avoid pending pipeline */
- pad = gst_element_get_static_pad(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "sink");
- gst_pad_push_event(pad, gst_event_new_flush_start());
- gst_pad_push_event(pad, gst_event_new_flush_stop());
- gst_object_unref(pad);
- pad = NULL;
-
- pad = gst_element_get_static_pad(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "src");
- gst_pad_push_event(pad, gst_event_new_flush_start());
- gst_pad_push_event(pad, gst_event_new_flush_stop());
- gst_object_unref(pad);
- pad = NULL;
+ /* Check file size */
+ if (info->max_size > 0) {
+ _mmcamcorder_get_file_size(info->filename, &file_size);
+ _mmcam_dbg_log("MAX size %lld byte - created filesize %lld byte",
+ info->max_size, file_size);
+
+ if (file_size > info->max_size) {
+ _MMCamcorderMsgItem message;
+ _mmcam_dbg_err("File size is greater than max size !!");
+ message.id = MM_MESSAGE_CAMCORDER_ERROR;
+ message.param.code = MM_ERROR_CAMCORDER_FILE_SIZE_OVER;
+ _mmcamcroder_send_message((MMHandleType)hcamcorder, &message);
+ }
}
+ /* Flush EOS event to avoid pending pipeline */
+ _mmcam_dbg_log("Flush EOS event");
+ pad = gst_element_get_static_pad(sc->element[_MMCAMCORDER_VIDEOSINK_SINK].gst, "sink");
+ gst_pad_push_event(pad, gst_event_new_flush_start());
+ gst_pad_push_event(pad, gst_event_new_flush_stop());
+ gst_object_unref(pad);
+ pad = NULL;
+
+ pad = gst_element_get_static_pad(sc->element[_MMCAMCORDER_VIDEOSRC_SRC].gst, "src");
+ gst_pad_push_event(pad, gst_event_new_flush_start());
+ gst_pad_push_event(pad, gst_event_new_flush_stop());
+ gst_object_unref(pad);
+ pad = NULL;
+
_mmcam_dbg_log("Set state as PLAYING");
__ta__(" _MMCamcorder_CMD_COMMIT:GST_STATE_PLAYING",
ret =_mmcamcorder_gst_set_state(handle, pipeline, GST_STATE_PLAYING);
}
/* Send recording report to application */
- msg.id = MM_MESSAGE_CAMCORDER_CAPTURED;
+ msg.id = MM_MESSAGE_CAMCORDER_VIDEO_CAPTURED;
report = (MMCamRecordingReport *)malloc(sizeof(MMCamRecordingReport));
if (!report) {
_mmcam_dbg_err("Recording report fail(%s). Out of memory.", info->filename);
return TRUE;
}
+
/**
* This function is record video data probing function.
* If this function is linked with certain pad by gst_pad_add_buffer_probe(),
{
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(u_data);
_MMCamcorderSubContext *sc = NULL;
- _MMCamcorderVideoInfo * info = NULL;
+ _MMCamcorderVideoInfo *info = NULL;
mmf_return_val_if_fail(hcamcorder, TRUE);
mmf_return_val_if_fail(buffer, FALSE);
sc = MMF_CAMCORDER_SUBCONTEXT(hcamcorder);
- mmf_return_val_if_fail(sc && sc->info, TRUE);
- info = sc->info;
+ mmf_return_val_if_fail(sc && sc->info_video, TRUE);
+ info = sc->info_video;
/*_mmcam_dbg_err("[%" GST_TIME_FORMAT "]", GST_TIME_ARGS(GST_BUFFER_TIMESTAMP(buffer)));*/
mmf_return_val_if_fail(buffer, FALSE);
sc = MMF_CAMCORDER_SUBCONTEXT(hcamcorder);
- mmf_return_val_if_fail(sc && sc->info, TRUE);
- info = sc->info;
+ mmf_return_val_if_fail(sc && sc->info_video, TRUE);
+ info = sc->info_video;
/*_mmcam_dbg_log("[%" GST_TIME_FORMAT "]", GST_TIME_ARGS(GST_BUFFER_TIMESTAMP(buffer)));*/
if (sc->ferror_send) {
buffer_size = GST_BUFFER_SIZE(buffer);
- if (sc->now_continuous_af) {
- _mmcam_dbg_log("Start continuous AF when START recording");
- __ta__(" _MMCamcorder_CMD_RECORD:START CAF",
- ret = _mmcamcorder_adjust_auto_focus((MMHandleType)hcamcorder);
- );
- sc->now_continuous_af = FALSE;
- if (ret != MM_ERROR_NONE) {
- _mmcam_dbg_warn("Failed continuous AF when START recording");
- }
- }
-
/* get trailer size */
if (info->fileformat == MM_FILE_FORMAT_3GP || info->fileformat == MM_FILE_FORMAT_MP4) {
MMCAMCORDER_G_OBJECT_GET(sc->element[_MMCAMCORDER_ENCSINK_MUX].gst, "expected-trailer-size", &trailer_size);
default: /* succeeded to get free space */
/* check free space for recording */
/* get queued buffer size */
- MMCAMCORDER_G_OBJECT_GET(sc->element[_MMCAMCORDER_ENCSINK_AENC_QUE].gst, "current-level-bytes", &aq_size);
- MMCAMCORDER_G_OBJECT_GET(sc->element[_MMCAMCORDER_ENCSINK_VENC_QUE].gst, "current-level-bytes", &vq_size);
+ if (sc->element[_MMCAMCORDER_ENCSINK_AENC_QUE].gst) {
+ MMCAMCORDER_G_OBJECT_GET(sc->element[_MMCAMCORDER_ENCSINK_AENC_QUE].gst, "current-level-bytes", &aq_size);
+ }
+ if (sc->element[_MMCAMCORDER_ENCSINK_VENC_QUE].gst) {
+ MMCAMCORDER_G_OBJECT_GET(sc->element[_MMCAMCORDER_ENCSINK_VENC_QUE].gst, "current-level-bytes", &vq_size);
+ }
+
queued_buffer = aq_size + vq_size;
/* check free space */
}
}
+ /* check max size of recorded file */
+ if (info->max_size > 0 &&
+ info->max_size < info->filesize + buffer_size + trailer_size + _MMCAMCORDER_MMS_MARGIN_SPACE) {
+ GstState pipeline_state = GST_STATE_VOID_PENDING;
+ GstElement *pipeline = sc->element[_MMCAMCORDER_MAIN_PIPE].gst;
+ _mmcam_dbg_warn("Max size!!! Recording is paused.");
+ _mmcam_dbg_warn("Max size : [%" G_GUINT64_FORMAT "], current file size : [%" G_GUINT64_FORMAT "]," \
+ " buffer size : [%" G_GUINT64_FORMAT "], trailer size : [%" G_GUINT64_FORMAT "]",
+ info->max_size, info->filesize, buffer_size, trailer_size);
+
+ if (!sc->isMaxsizePausing) {
+ gst_element_get_state(pipeline, &pipeline_state, NULL, -1) ;
+ if (pipeline_state == GST_STATE_PLAYING) {
+ MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "block", TRUE);
+ sc->isMaxsizePausing = TRUE;
+ }
+
+ msg.id = MM_MESSAGE_CAMCORDER_MAX_SIZE;
+ _mmcamcroder_send_message((MMHandleType)hcamcorder, &msg);
+ }
+
+ return FALSE;
+ }
+
info->filesize += (guint64)buffer_size;
+ _mmcam_dbg_log("filesize %lld Byte, ", info->filesize);
+
return TRUE;
}
-static gboolean __mmcamcorder_video_dataprobe_slow(GstPad *pad, GstBuffer *buffer, gpointer u_data)
+static gboolean __mmcamcorder_video_dataprobe_audio_disable(GstPad *pad, GstBuffer *buffer, gpointer u_data)
{
- guint min_fps = 15;
guint64 trailer_size = 0;
- static guint count = 0;
+ guint64 rec_pipe_time = 0;
+ unsigned int remained_time = 0;
GstClockTime b_time;
sc = MMF_CAMCORDER_SUBCONTEXT(u_data);
mmf_return_val_if_fail(sc, TRUE);
- mmf_return_val_if_fail(sc->info, TRUE);
+ mmf_return_val_if_fail(sc->info_video, TRUE);
+
+ info = sc->info_video;
- info = sc->info;
- count %= min_fps;
b_time = GST_BUFFER_TIMESTAMP(buffer);
- if (!count) {
- if (info->fileformat == MM_FILE_FORMAT_3GP || info->fileformat == MM_FILE_FORMAT_MP4) {
- MMCAMCORDER_G_OBJECT_GET(sc->element[_MMCAMCORDER_ENCSINK_MUX].gst, "expected-trailer-size", &trailer_size);
- } else {
- trailer_size = 0;
+ rec_pipe_time = GST_TIME_AS_MSECONDS(b_time);
+
+ if (info->fileformat == MM_FILE_FORMAT_3GP || info->fileformat == MM_FILE_FORMAT_MP4) {
+ MMCAMCORDER_G_OBJECT_GET(sc->element[_MMCAMCORDER_ENCSINK_MUX].gst, "expected-trailer-size", &trailer_size);
+ } else {
+ trailer_size = 0;
+ }
+
+ /* check max time */
+ if (info->max_time > 0 && rec_pipe_time > info->max_time) {
+ _mmcam_dbg_warn("Current time : [%" G_GUINT64_FORMAT "], Maximum time : [%" G_GUINT64_FORMAT "]", \
+ rec_pipe_time, info->max_time);
+
+ if (!sc->isMaxtimePausing) {
+ MMCAMCORDER_G_OBJECT_SET(sc->element[_MMCAMCORDER_ENCSINK_ENCBIN].gst, "block", TRUE);
+
+ sc->isMaxtimePausing = TRUE;
+
+ msg.id = MM_MESSAGE_CAMCORDER_RECORDING_STATUS;
+ msg.param.recording_status.elapsed = (unsigned long long)rec_pipe_time;
+ msg.param.recording_status.filesize = (unsigned long long)((info->filesize + trailer_size) >> 10);
+ msg.param.recording_status.remained_time = 0;
+ _mmcamcroder_send_message((MMHandleType)hcamcorder, &msg);
+
+ msg.id = MM_MESSAGE_CAMCORDER_TIME_LIMIT;
+ _mmcamcroder_send_message((MMHandleType)hcamcorder, &msg);
}
- msg.id = MM_MESSAGE_CAMCORDER_RECORDING_STATUS;
- msg.param.recording_status.elapsed = (unsigned int)GST_TIME_AS_MSECONDS(b_time);
- msg.param.recording_status.filesize = (unsigned int)((info->filesize + trailer_size) >> 10);
- _mmcamcroder_send_message((MMHandleType)hcamcorder, &msg);
+ return FALSE;
}
- count++;
+ /* calculate remained time can be recorded */
+ if (info->max_time > 0 && info->max_time < (remained_time + rec_pipe_time)) {
+ remained_time = info->max_time - rec_pipe_time;
+ } else if (info->max_size > 0) {
+ long double max_size = (long double)info->max_size;
+ long double current_size = (long double)(info->filesize + trailer_size);
- GST_BUFFER_TIMESTAMP(buffer) = b_time * (info->multiple_fps);
+ remained_time = (unsigned int)((long double)rec_pipe_time * (max_size/current_size)) - rec_pipe_time;
+ }
+
+ msg.id = MM_MESSAGE_CAMCORDER_RECORDING_STATUS;
+ msg.param.recording_status.elapsed = (unsigned long long)rec_pipe_time;
+ msg.param.recording_status.filesize = (unsigned long long)((info->filesize + trailer_size) >> 10);
+ msg.param.recording_status.remained_time = remained_time;
+ _mmcamcroder_send_message((MMHandleType)hcamcorder, &msg);
+
+ _mmcam_dbg_log("time [%" GST_TIME_FORMAT "], size [%d]",
+ GST_TIME_ARGS(rec_pipe_time), msg.param.recording_status.filesize);
+
+ if (info->record_timestamp_ratio != _MMCAMCORDER_DEFAULT_RECORDING_MOTION_RATE) {
+ GST_BUFFER_TIMESTAMP(buffer) = b_time * (info->record_timestamp_ratio);
+ }
return TRUE;
}
GstElement *pipeline = NULL;
mmf_camcorder_t *hcamcorder = MMF_CAMCORDER(u_data);
_MMCamcorderVideoInfo *info = NULL;
+ unsigned int remained_time = 0;
mmf_return_val_if_fail(buffer, FALSE);
mmf_return_val_if_fail(hcamcorder, TRUE);
sc = MMF_CAMCORDER_SUBCONTEXT(u_data);
mmf_return_val_if_fail(sc, TRUE);
- mmf_return_val_if_fail(sc->info, TRUE);
+ mmf_return_val_if_fail(sc->info_video, TRUE);
mmf_return_val_if_fail(sc->element, TRUE);
- info = sc->info;
+ info = sc->info_video;
pipeline = sc->element[_MMCAMCORDER_MAIN_PIPE].gst;
if (!GST_CLOCK_TIME_IS_VALID(GST_BUFFER_TIMESTAMP(buffer))) {
trailer_size = 0;
}
+ /* calculate remained time can be recorded */
+ if (info->max_time > 0 && info->max_time < (remained_time + rec_pipe_time)) {
+ remained_time = info->max_time - rec_pipe_time;
+ } else if (info->max_size > 0) {
+ long double max_size = (long double)info->max_size;
+ long double current_size = (long double)(info->filesize + trailer_size);
+
+ remained_time = (unsigned long long)((long double)rec_pipe_time * (max_size/current_size)) - rec_pipe_time;
+ }
+
if (info->max_time > 0 && rec_pipe_time > info->max_time) {
_mmcam_dbg_warn("Current time : [%" G_GUINT64_FORMAT "], Maximum time : [%" G_GUINT64_FORMAT "]", \
rec_pipe_time, info->max_time);
sc->isMaxtimePausing = TRUE;
msg.id = MM_MESSAGE_CAMCORDER_RECORDING_STATUS;
- msg.param.recording_status.elapsed = (unsigned int)rec_pipe_time;
- msg.param.recording_status.filesize = (unsigned int)((info->filesize + trailer_size) >> 10);
+ msg.param.recording_status.elapsed = (unsigned long long)rec_pipe_time;
+ msg.param.recording_status.filesize = (unsigned long long)((info->filesize + trailer_size) >> 10);
+ msg.param.recording_status.remained_time = 0;
_mmcamcroder_send_message((MMHandleType)hcamcorder, &msg);
msg.id = MM_MESSAGE_CAMCORDER_TIME_LIMIT;
return FALSE;
}
- /*_mmcam_dbg_log("_mmcamcorder_audioque_dataprobe :: time [%" GST_TIME_FORMAT "], size [%d]",
- GST_TIME_ARGS(rec_pipe_time), (info->filesize + trailer_size) >> 10);*/
-
msg.id = MM_MESSAGE_CAMCORDER_RECORDING_STATUS;
- msg.param.recording_status.elapsed = (unsigned int)rec_pipe_time;
- msg.param.recording_status.filesize = (unsigned int)((info->filesize + trailer_size) >> 10);
+ msg.param.recording_status.elapsed = (unsigned long long)rec_pipe_time;
+ msg.param.recording_status.filesize = (unsigned long long)((info->filesize + trailer_size) >> 10);
+ msg.param.recording_status.remained_time = remained_time;
_mmcamcroder_send_message((MMHandleType)hcamcorder, &msg);
+ _mmcam_dbg_log("audio data probe :: time [%" GST_TIME_FORMAT "], size [%lld KB]",
+ GST_TIME_ARGS(rec_pipe_time), msg.param.recording_status.filesize);
+
return TRUE;
}
gdouble latitude = 0;
gdouble altitude = 0;
int err = 0;
+ int orientation = 0;
char *err_name = NULL;
+ char err_msg[MAX_ERROR_MESSAGE_LEN] = {'\0',};
_MMCamcorderLocationInfo location_info = {0,};
_MMCamcorderVideoInfo *info = NULL;
sc = MMF_CAMCORDER_SUBCONTEXT(handle);
mmf_return_val_if_fail(sc, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
- mmf_return_val_if_fail(sc->info, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
+ mmf_return_val_if_fail(sc->info_video, MM_ERROR_CAMCORDER_NOT_INITIALIZED);
_mmcam_dbg_log("");
- info = sc->info;
+ info = sc->info_video;
f = fopen(info->filename, "rb+");
if (f == NULL) {
+ strerror_r(errno, err_msg, MAX_ERROR_MESSAGE_LEN);
+ _mmcam_dbg_err("file open failed [%s]", err_msg);
return FALSE;
}
- err = mm_camcorder_get_attributes(handle, &err_name,
- MMCAM_TAG_LATITUDE, &latitude,
- MMCAM_TAG_LONGITUDE, &longitude,
- MMCAM_TAG_ALTITUDE, &altitude,
- NULL);
- if (err != MM_ERROR_NONE) {
+ mm_camcorder_get_attributes(handle, &err_name,
+ MMCAM_TAG_LATITUDE, &latitude,
+ MMCAM_TAG_LONGITUDE, &longitude,
+ MMCAM_TAG_ALTITUDE, &altitude,
+ MMCAM_TAG_ORIENTATION, &orientation,
+ NULL);
+ if (err_name) {
_mmcam_dbg_warn("Get tag attrs fail. (%s:%x)", err_name, err);
SAFE_FREE (err_name);
- fclose(f);
- f = NULL;
- return FALSE;
}
location_info.longitude = _mmcamcorder_double_to_fix(longitude);
/* find udta container.
if, there are udta container, write loci box after that
else, make udta container and write loci box. */
- if (_mmcamcorder_find_tag(f, MMCAM_FOURCC('u','d','t','a'))) {
+ if (_mmcamcorder_find_tag(f, MMCAM_FOURCC('u','d','t','a'), TRUE)) {
+ size_t nread = 0;
+
_mmcam_dbg_log("find udta container");
/* read size */
goto ftell_fail;
}
- fread(&buf, sizeof(char), sizeof(buf), f);
+ nread = fread(&buf, sizeof(char), sizeof(buf), f);
+
+ _mmcam_dbg_log("recorded file fread %d", nread);
+
udta_size = _mmcamcorder_get_container_size(buf);
/* goto end of udta and write 'loci' box */
update moov container size. */
if((current_pos = ftell(f))<0)
goto ftell_fail;
-
- if (_mmcamcorder_find_tag(f, MMCAM_FOURCC('m','o','o','v'))) {
- _mmcam_dbg_log("find moov container");
+
+ if (_mmcamcorder_find_tag(f, MMCAM_FOURCC('m','o','o','v'), TRUE)) {
+ gint64 internal_pos = ftell(f);
+
+ _mmcam_dbg_log("found moov container");
if (fseek(f, -8L, SEEK_CUR) !=0) {
goto fail;
}
if (!_mmcamcorder_update_size(f, moov_pos, current_pos)) {
goto fail;
}
+
+ /* add orientation info */
+ fseek(f, internal_pos, SEEK_SET);
+ if (!_mmcamcorder_find_tag(f, MMCAM_FOURCC('t','r','a','k'), FALSE)) {
+ _mmcam_dbg_err("failed to find [trak] tag");
+ goto fail;
+ }
+
+ if (!_mmcamcorder_find_tag(f, MMCAM_FOURCC('t','k','h','d'), FALSE)) {
+ _mmcam_dbg_err("failed to find [tkhd] tag");
+ goto fail;
+ }
+
+ _mmcam_dbg_log("found [tkhd] tag");
+
+ /* seek to start position of composition matrix */
+ fseek(f, _OFFSET_COMPOSITION_MATRIX, SEEK_CUR);
+
+ /* update composition matrix for orientation */
+ _mmcamcorder_update_composition_matrix(f, orientation);
} else {
_mmcam_dbg_err("No 'moov' container");
goto fail;
$(MMTA_CFLAGS)\
$(MM_SOUND_CFLAGS)
+
############################################
#mm_camcorder_testsuite_CFLAGS += -DAPPSRC_TEST
############################################
*/
-/*===========================================================================================
-| |
-| INCLUDE FILES |
-| |
-========================================================================================== */
+/*=======================================================================================
+| INCLUDE FILES |
+=======================================================================================*/
#include <stdio.h>
#include <stdlib.h>
#include <glib.h>
#include <gst/gst.h>
#include <sys/time.h>
-#include <mm_camcorder.h>
-#include <mm_camcorder_internal.h>
-#include <mm_camcorder_util.h>
+#include "../src/include/mm_camcorder.h"
+#include "../src/include/mm_camcorder_internal.h"
+#include "../src/include/mm_camcorder_util.h"
#include <gst/interfaces/colorbalance.h>
#include <mm_ta.h>
-/*---------------------------------------------------------------------------
-| GLOBAL VARIABLE DEFINITIONS: |
----------------------------------------------------------------------------*/
+/*-----------------------------------------------------------------------
+| GLOBAL VARIABLE DEFINITIONS: |
+-----------------------------------------------------------------------*/
#define EXPORT_API __attribute__((__visibility__("default")))
#define PACKAGE "mm_camcorder_testsuite"
-GMainLoop *g_loop;
+GMainLoop *g_loop;
GIOChannel *stdin_channel;
int resolution_set;
-int g_current_state;
+int g_current_state;
int src_w, src_h;
GstCaps *filtercaps;
-bool isMultishot;
+bool isMultishot;
MMCamPreset cam_info;
int mmcamcorder_state;
int mmcamcorder_print_state;
int multishot_num;
-static int audio_stream_cb_cnt, video_stream_cb_cnt;
+static int audio_stream_cb_cnt;
+static int video_stream_cb_cnt;
static GTimer *timer = NULL;
-/*---------------------------------------------------------------------------
-| GLOBAL CONSTANT DEFINITIONS: |
----------------------------------------------------------------------------*/
+/*-----------------------------------------------------------------------
+| GLOBAL CONSTANT DEFINITIONS: |
+-----------------------------------------------------------------------*/
-/*---------------------------------------------------------------------------
-| IMPORTED VARIABLE DECLARATIONS: |
----------------------------------------------------------------------------*/
+/*-----------------------------------------------------------------------
+| IMPORTED VARIABLE DECLARATIONS: |
+-----------------------------------------------------------------------*/
-/*---------------------------------------------------------------------------
-| IMPORTED FUNCTION DECLARATIONS: |
----------------------------------------------------------------------------*/
+/*-----------------------------------------------------------------------
+| IMPORTED FUNCTION DECLARATIONS: |
+-----------------------------------------------------------------------*/
-/*---------------------------------------------------------------------------
-| LOCAL #defines: |
----------------------------------------------------------------------------*/
+/*-----------------------------------------------------------------------
+| LOCAL #defines: |
+-----------------------------------------------------------------------*/
#define test_ffmux_mp4
// FULLHD(1080P)
#define IMAGE_ENC_QUALITY 85 // quality of jpeg
#define IMAGE_CAPTURE_COUNT_STILL 1 // the number of still-shot
#define IMAGE_CAPTURE_COUNT_MULTI 3 // default the number of multi-shot
-#define IMAGE_CAPTURE_COUNT_INTERVAL 500 // mili seconds
+#define IMAGE_CAPTURE_COUNT_INTERVAL 100 // mili seconds
#define MAX_FILE_SIZE_FOR_MMS (250 * 1024)
#define EXT_AMR "amr"
#define EXT_MKV "mkv"
-#define STILL_CAPTURE_FILE_PATH_NAME "/root/StillshotCapture"
-#define MULTI_CAPTURE_FILE_PATH_NAME "/root/MultishotCapture"
+#define STILL_CAPTURE_FILE_PATH_NAME "/opt/media/StillshotCapture"
+#define MULTI_CAPTURE_FILE_PATH_NAME "/opt/media/MultishotCapture"
+#define IMAGE_CAPTURE_THUMBNAIL_PATH "/opt/media/thumbnail.jpg"
+#define IMAGE_CAPTURE_SCREENNAIL_PATH "/opt/media/screennail.yuv"
+#define IMAGE_CAPTURE_EXIF_PATH "/opt/media/exif.raw"
#define TARGET_FILENAME_PATH "/opt/media/"
#define TARGET_FILENAME_VIDEO "/opt/media/test_rec_video.3gp"
#define TARGET_FILENAME_AUDIO "/opt/media/test_rec_audio.amr"
#define AUDIO_SOURCE_FORMAT MM_CAMCORDER_AUDIO_FORMAT_PCM_S16_LE
#define AUDIO_SOURCE_CHANNEL_AAC 2
#define AUDIO_SOURCE_CHANNEL_AMR 1
+#define VIDEO_ENCODE_BITRATE 40000000 /* bps */
-#define DEFAULT_CAM_DEVICE MM_VIDEO_DEVICE_CAMERA1
+#define DEFAULT_CAM_DEVICE MM_VIDEO_DEVICE_CAMERA1
/*
* D E B U G M E S S A G E
GTimeVal previous;
-GTimeVal current;
+GTimeVal current;
GTimeVal result;
//temp
* Enumerations for command
*/
#define SENSOR_WHITEBALANCE_NUM 10
-#define SENSOR_COLOR_TONE_NUM 27
-#define SENSOR_FLIP_NUM 3
+#define SENSOR_COLOR_TONE_NUM 37
+#define SENSOR_FLIP_NUM 3
#define SENSOR_PROGRAM_MODE_NUM 15
-#define SENSOR_FOCUS_NUM 5
-#define SENSOR_INPUT_ROTATION 6
-#define SENSOR_AF_SCAN_NUM 4
-#define SENSOR_ISO_NUM 8
-#define SENSOR_EXPOSURE_NUM 9
-#define SENSOR_IMAGE_FORMAT 9
+#define SENSOR_FOCUS_NUM 6
+#define SENSOR_INPUT_ROTATION 4
+#define SENSOR_AF_SCAN_NUM 4
+#define SENSOR_ISO_NUM 8
+#define SENSOR_EXPOSURE_NUM 9
+#define SENSOR_IMAGE_FORMAT 9
-/*---------------------------------------------------------------------------
-| LOCAL CONSTANT DEFINITIONS: |
----------------------------------------------------------------------------*/
+/*-----------------------------------------------------------------------
+| LOCAL CONSTANT DEFINITIONS: |
+-----------------------------------------------------------------------*/
enum
{
- MODE_IMAGE, /* capture mode */
- MODE_VIDEO, /* recording mode */
+ MODE_VIDEO_CAPTURE, /* recording and image capture mode */
MODE_AUDIO, /* audio recording*/
MODE_NUM,
};
MENU_STATE_NUM,
};
-/*---------------------------------------------------------------------------
-| LOCAL DATA TYPE DEFINITIONS: |
----------------------------------------------------------------------------*/
+/*-----------------------------------------------------------------------
+| LOCAL DATA TYPE DEFINITIONS: |
+-----------------------------------------------------------------------*/
typedef struct _cam_handle
{
MMHandleType camcorder;
- int mode; /* image(capture)/video(recording) mode */
- bool isMultishot;
- int stillshot_count; /* total stillshot count */
- int multishot_count; /* total multishot count */
- char *stillshot_filename; /* stored filename of stillshot */
- char *multishot_filename; /* stored filename of multishot */
- int menu_state;
- int fps;
- bool isMute;
- unsigned int elapsed_time;
+ int mode; /* image(capture)/video(recording) mode */
+ bool isMultishot; /* flag for multishot mode */
+ int stillshot_count; /* total stillshot count */
+ int multishot_count; /* total multishot count */
+ char *stillshot_filename; /* stored filename of stillshot */
+ char *multishot_filename; /* stored filename of multishot */
+ int menu_state;
+ int fps;
+ bool isMute;
+ unsigned long long elapsed_time;
} cam_handle_t;
typedef struct _cam_xypair
"PURPLE",
"EMBOSS",
"OUTLINE",
- "SOLARIZATION_1",
- "SOLARIZATION_2",
- "SOLARIZATION_3",
- "SOLARIZATION_4",
- "SKETCH_1",
- "SKETCH_2",
- "SKETCH_3",
- "SKETCH_4",
+ "SOLARIZATION",
+ "SKETCH",
+ "WASHED",
+ "VINTAGE_WARM",
+ "VINTAGE_COLD",
+ "POSTERIZATION",
+ "CARTOON",
+ "SELECTVE_COLOR_RED",
+ "SELECTVE_COLOR_GREEN",
+ "SELECTVE_COLOR_BLUE",
+ "SELECTVE_COLOR_YELLOW",
+ "SELECTVE_COLOR_RED_YELLOW",
};
char *flip[SENSOR_FLIP_NUM] = {
"Auto",
"Manual",
"Touch Auto",
+ "Continuous Auto",
};
char *camera_rotation[SENSOR_INPUT_ROTATION] = {
"90",
"180",
"270",
- "Flip Horizontal",
- "Flip Vertical",
};
char *af_scan[SENSOR_AF_SCAN_NUM] = {
"YV12",
};
+char *face_zoom_mode[] = {
+ "Face Zoom OFF",
+ "Face Zoom ON",
+};
+
+char *display_mode[] = {
+ "Default",
+ "Primary Video ON and Secondary Video Full Screen",
+ "Primary Video OFF and Secondary Video Full Screen",
+};
+
char *output_mode[] = {
"Letter Box mode",
"Original Size mode",
"90",
"180",
"270",
- "Flip Horizontal",
- "Flip Vertical",
};
char* strobe_mode[] = {
"WDR AUTO",
};
+char *hdr_mode[] = {
+ "HDR OFF",
+ "HDR ON",
+ "HDR ON and Original",
+};
+
char *ahs_mode[] = {
"Anti-handshake OFF",
"Anti-handshake ON",
"Anti-handshake MOVIE",
};
+char *vs_mode[] = {
+ "Video-stabilization OFF",
+ "Video-stabilization ON",
+};
+
char *visible_mode[] = {
"Display OFF",
"Display ON",
};
-char *camcorder_rotate_val[] = {
- "0",
- "90",
- "180",
- "270",
-};
/*---------------------------------------------------------------------------
| LOCAL FUNCTION PROTOTYPES: |
}
}
+#ifdef USE_AUDIO_STREAM_CB
static int camcordertest_audio_stream_cb(MMCamcorderAudioStreamDataType *stream, void *user_param)
{
- if ( (int)(stream->timestamp)/1000 == audio_stream_cb_cnt ) {
- audio_stream_cb_cnt++;
- printf("audio_stream cb is called ( data:%p, format:%d, channel:%d, volume_dB:%f, length:%d, timestamp:%d)\n", stream->data, stream->format, stream->channel, stream->volume_dB, stream->length, stream->timestamp);
- }
+ audio_stream_cb_cnt++;
+ printf("audio_stream cb is called (stream:%p, data:%p, format:%d, channel:%d, volume_dB:%f, length:%d, timestamp:%d)\n",
+ stream, stream->data, stream->format, stream->channel, stream->volume_dB, stream->length, stream->timestamp);
+
return TRUE;
}
+#endif /* USE_AUDIO_STREAM_CB */
static int camcordertest_video_stream_cb(MMCamcorderVideoStreamDataType *stream, void *user_param)
{
- if ( (int)(stream->timestamp)/1000 == video_stream_cb_cnt ) {
- video_stream_cb_cnt++;
- printf("video_stream cb is called ( data:%p, format:%d, length:%d, width:%d, height:%d, timestamp:%d)\n", stream->data, stream->format, stream->length, stream->width, stream->height, stream->timestamp);
- }
+ video_stream_cb_cnt++;
+
+ printf("VIDEO STREAM CALLBACK total length :%u, size %dx%d\n", stream->length_total, stream->width, stream->height);
+
return TRUE;
}
+static void _file_write(char *path, void *data, int size)
+{
+ FILE *fp = NULL;
+
+ if (!path || !data || size <= 0) {
+ printf("ERROR %p %p %d\n", path, data, size);
+ return;
+ }
+
+ fp = fopen(path, "w");
+ if (fp == NULL) {
+ printf("open error! [%s], errno %d\n", path, errno);
+ return;
+ } else {
+ printf("open success [%s]\n", path);
+ if (fwrite(data, size, 1, fp) != 1) {
+ printf("write error! errno %d\n", errno);
+ } else {
+ printf("write success [%s]\n", path);
+ }
+
+ fclose(fp);
+ fp = NULL;
+ }
+}
+
+
static int
camcordertest_video_capture_cb(MMCamcorderCaptureDataType *main, MMCamcorderCaptureDataType *thumb, void *data)
{
int nret = 0;
int scrnl_size = 0;
+ int exif_size = 0;
char m_filename[CAPTURE_FILENAME_LEN];
- FILE *fp = NULL;
MMCamcorderCaptureDataType *scrnl = NULL;
-
- debug_msg_t("hcamcorder->isMultishot=%d =>1: MULTI, 0: STILL",hcamcorder->isMultishot);
+ unsigned char *exif_data = NULL;
if (main == NULL) {
warn_msg_t("Capture callback : Main image buffer is NULL!!!");
return FALSE;
}
- if (hcamcorder->isMultishot == TRUE) {
- snprintf(m_filename, CAPTURE_FILENAME_LEN, "%s%03d.jpg", hcamcorder->multishot_filename,hcamcorder->multishot_count++);
+ if (hcamcorder->isMultishot) {
+ snprintf(m_filename, CAPTURE_FILENAME_LEN, "%s%03d.jpg", hcamcorder->multishot_filename, hcamcorder->multishot_count++);
} else {
- snprintf(m_filename, CAPTURE_FILENAME_LEN, "%s%03d.jpg", hcamcorder->stillshot_filename,hcamcorder->stillshot_count++);
+ snprintf(m_filename, CAPTURE_FILENAME_LEN, "%s%03d.jpg", hcamcorder->stillshot_filename, hcamcorder->stillshot_count++);
}
- debug_msg_t("filename : %s", m_filename);
+ debug_msg_t("hcamcorder->isMultishot=%d =>1: MULTI, 0: STILL, filename : %s",
+ hcamcorder->isMultishot, m_filename);
if (main->format != MM_PIXEL_FORMAT_ENCODED) {
unsigned int dst_size = 0;
nret = _mmcamcorder_encode_jpeg(main->data, main->width, main->height, main->format,
main->length, 90, &dst, &dst_size);
if (nret) {
- fp = fopen(m_filename, "w+");
- if (fp == NULL) {
- printf("FileOPEN error!!\n");
- warn_msg_t("FileOPEN error!!");
- return FALSE;
- } else {
- printf("open success\n");
- if (fwrite(dst, dst_size, 1, fp) != 1) {
- printf("File write error!!\n");
- warn_msg_t("File write error!!");
- fclose(fp);
- return FALSE;
- }
- printf("write success\n");
- }
- fclose(fp);
- fp = NULL;
+ _file_write(m_filename, dst, dst_size);
} else {
printf("Failed to encode YUV(%d) -> JPEG. \n", main->format);
}
free(dst);
dst = NULL;
- } else {
+ } else if (!hcamcorder->isMultishot) {
+
printf("MM_PIXEL_FORMAT_ENCODED main->data=%p main->length=%d, main->width=%d, main->heigtht=%d \n",
main->data, main->length, main->width, main->height);
/* main image */
- fp = fopen(m_filename, "w+");
- if (fp == NULL) {
- printf("FileOPEN error!!\n");
- warn_msg_t("FileOPEN error!!");
- return FALSE;
- } else {
- printf("open success\n");
- if (fwrite(main->data, main->length, 1, fp) != 1) {
- printf("File write error!!\n");
- warn_msg_t("File write error!!");
- fclose(fp);
- return FALSE;
- }
- printf("write success\n");
- }
- fclose(fp);
- fp = NULL;
+ _file_write(m_filename, main->data, main->length);
/* thumbnail */
if (thumb != NULL) {
- fp = fopen("./thumbnail.jpg", "w+");
- if (fp == NULL) {
- printf("FileOPEN error!!\n");
- warn_msg_t("FileOPEN error!!");
- return FALSE;
- } else {
- printf("open success\n");
- if (fwrite(thumb->data, thumb->length, 1, fp) != 1) {
- printf("File write error!!\n");
- warn_msg_t("File write error!!");
- fclose(fp);
- return FALSE;
- }
- printf("write success\n");
- }
- fclose(fp);
- fp = NULL;
+ _file_write(IMAGE_CAPTURE_THUMBNAIL_PATH, thumb->data, thumb->length);
}
/* screennail */
"captured-screennail", &scrnl, &scrnl_size,
NULL);
if (scrnl != NULL) {
- fp = fopen("./screennail.yuv", "w+");
- if (fp == NULL) {
- printf("FileOPEN error!!\n");
- warn_msg_t("FileOPEN error!!");
- return FALSE;
- } else {
- printf("open success\n");
-
- if (fwrite(scrnl->data, scrnl->length, 1, fp) != 1) {
- printf("File write error!!\n");
- warn_msg_t("File write error!!");
- fclose(fp);
- fp = NULL;
- return FALSE;
- }
-
- fclose(fp);
- fp = NULL;
-
- printf("write success\n");
- }
+ _file_write(IMAGE_CAPTURE_SCREENNAIL_PATH, scrnl->data, scrnl->length);
} else {
printf( "Screennail buffer is NULL.\n" );
}
+
+ /* EXIF data */
+ mm_camcorder_get_attributes(hcamcorder->camcorder, NULL,
+ "captured-exif-raw-data", &exif_data, &exif_size,
+ NULL);
+ if (exif_data) {
+ _file_write(IMAGE_CAPTURE_EXIF_PATH, exif_data, exif_size);
+ }
}
return TRUE;
{
int err;
- if (!hcamcorder->isMultishot)
- {
- camcordertest_set_attr_int("capture-format", MM_PIXEL_FORMAT_ENCODED);
- camcordertest_set_attr_int(MMCAM_IMAGE_ENCODER, MM_IMAGE_CODEC_JPEG);
- }
- else
- {
-// camcordertest_set_attr_int("capture-format", MM_PIXEL_FORMAT_I420);
- camcordertest_set_attr_int("capture-format", MM_PIXEL_FORMAT_YUYV);
- }
+ camcordertest_set_attr_int(MMCAM_CAPTURE_FORMAT, MM_PIXEL_FORMAT_ENCODED);
+ camcordertest_set_attr_int(MMCAM_IMAGE_ENCODER, MM_IMAGE_CODEC_JPEG);
g_timer_reset(timer);
err = mm_camcorder_capture_start(hcamcorder->camcorder);
char * err_attr_name = NULL;
int err;
- if (hcamcorder)
- {
- if (hcamcorder->camcorder)
- {
+ if (hcamcorder) {
+ if (hcamcorder->camcorder) {
debug_msg_t("camcordertest_set_attr_int(%s, %d)", attr_subcategory, value);
err = mm_camcorder_set_attributes(hcamcorder->camcorder, &err_attr_name,
- attr_subcategory, value,
- NULL);
- if (err < 0)
- {
+ attr_subcategory, value,
+ NULL);
+ if (err != MM_ERROR_NONE) {
err_msg_t("camcordertest_set_attr_int : Error(%s:%x)!!!!!!!", err_attr_name, err);
- SAFE_FREE (err_attr_name);
+ SAFE_FREE(err_attr_name);
return FALSE;
}
//success
return TRUE;
}
-
+
debug_msg_t("camcordertest_set_attr_int(!hcamcorder->camcorde)");
}
debug_msg_t("camcordertest_set_attr_int(!hcamcorder)");
- return FALSE;
+ return FALSE;
}
int camcordertest_set_attr_xypair(cam_xypair_t pair)
{
if (hcamcorder->camcorder)
{
- debug_msg_t("camcordertest_get_attr_valid_intarray((%s),(%p, %p))", attr_name, array, count);
+ debug_msg_t("camcordertest_get_attr_valid_intarray(%s)", attr_name);
err = mm_camcorder_get_attribute_info(hcamcorder->camcorder, attr_name, &info);
-
- if (err < 0)
- {
- err_msg_t("camcordertest_get_attr_valid_intarray : Error(%x)!!", err);
+ if (err != MM_ERROR_NONE) {
+ err_msg_t("camcordertest_get_attr_valid_intarray : Error(%x)!!", err);
return FALSE;
- }
- else
- {
- if (info.type == MM_CAM_ATTRS_TYPE_INT)
- if (info.validity_type == MM_CAM_ATTRS_VALID_TYPE_INT_ARRAY)
- {
+ } else {
+ if (info.type == MM_CAM_ATTRS_TYPE_INT) {
+ if (info.validity_type == MM_CAM_ATTRS_VALID_TYPE_INT_ARRAY) {
*array = info.int_array.array;
*count = info.int_array.count;
+ debug_msg_t("INT ARRAY - default value : %d", info.int_array.def);
return TRUE;
}
+ }
err_msg_t("camcordertest_get_attr_valid_intarray : Type mismatched!!");
return FALSE;
{
if (hcamcorder->camcorder)
{
- debug_msg_t("camcordertest_get_attr_valid_intarray((%s),(%p, %p))", attr_name, min, max);
+ debug_msg_t("camcordertest_get_attr_valid_intrange(%s)", attr_name);
err = mm_camcorder_get_attribute_info(hcamcorder->camcorder, attr_name, &info);
-
- if (err < 0)
- {
+ if (err != MM_ERROR_NONE) {
err_msg_t("camcordertest_get_attr_valid_intarray : Error(%x)!!", err);
return FALSE;
- }
- else
- {
- if (info.type == MM_CAM_ATTRS_TYPE_INT)
- if (info.validity_type == MM_CAM_ATTRS_VALID_TYPE_INT_RANGE)
- {
+ } else {
+ if (info.type == MM_CAM_ATTRS_TYPE_INT) {
+ if (info.validity_type == MM_CAM_ATTRS_VALID_TYPE_INT_RANGE) {
*min = info.int_range.min;
*max = info.int_range.max;
+ debug_msg_t("INT RANGE - default : %d", info.int_range.def);
return TRUE;
}
+ }
err_msg_t("camcordertest_get_attr_valid_intarray : Type mismatched!!");
return FALSE;
switch(hcamcorder->menu_state)
{
case MENU_STATE_MAIN:
- if (hcamcorder->mode == MODE_IMAGE)
- {
- g_print("\n\t=======================================\n");
- if ( cam_info.videodev_type == MM_VIDEO_DEVICE_CAMERA1 )
- g_print("\t Image Capture (Front camera)\n");
- else if( cam_info.videodev_type == MM_VIDEO_DEVICE_CAMERA0 )
- g_print("\t Image Capture (Rear camera)\n");
- g_print("\t=======================================\n");
- g_print("\t '1' Take a photo\n");
- g_print("\t '2' Setting\n");
- g_print("\t '3' Print FPS\n");
- g_print("\t 'b' back\n");
- g_print("\t=======================================\n");
- }
- else if (hcamcorder->mode == MODE_VIDEO)
- {
+ if (hcamcorder->mode == MODE_VIDEO_CAPTURE) {
g_print("\n\t=======================================\n");
if ( cam_info.videodev_type == MM_VIDEO_DEVICE_CAMERA1 )
- g_print("\t Video Recording (Front camera)\n");
+ g_print("\t Video Capture (Front camera)\n");
else if( cam_info.videodev_type == MM_VIDEO_DEVICE_CAMERA0 )
- g_print("\t Video Recording (Rear camera)\n");
+ g_print("\t Video Capture (Rear camera)\n");
g_print("\t=======================================\n");
if(mmcamcorder_print_state <= MM_CAMCORDER_STATE_PREPARE) {
- g_print("\t '1' Start Recording\n");
- g_print("\t '2' Setting\n");
- g_print("\t '3' Print FPS\n");
+ g_print("\t '1' Take a photo\n");
+ g_print("\t '2' Start Recording\n");
+ g_print("\t '3' Setting\n");
+ g_print("\t '4' Print FPS\n");
g_print("\t 'b' back\n");
- }
- else if(mmcamcorder_print_state == MM_CAMCORDER_STATE_RECORDING) {
+ } else if(mmcamcorder_print_state == MM_CAMCORDER_STATE_RECORDING) {
g_print("\t 'p' Pause Recording\n");
g_print("\t 'c' Cancel\n");
g_print("\t 's' Save\n");
- }
- else if(mmcamcorder_print_state == MM_CAMCORDER_STATE_PAUSED) {
+ g_print("\t 'n' Capture video snapshot\n");
+ } else if(mmcamcorder_print_state == MM_CAMCORDER_STATE_PAUSED) {
g_print("\t 'r' Resume Recording\n");
g_print("\t 'c' Cancel\n");
g_print("\t 's' Save\n");
+ g_print("\t 'n' Capture video snapshot\n");
}
g_print("\t=======================================\n");
- }
- else if (hcamcorder->mode == MODE_AUDIO)
- {
+ } else if (hcamcorder->mode == MODE_AUDIO) {
g_print("\n\t=======================================\n");
g_print("\t Audio Recording\n");
g_print("\t=======================================\n");
break;
case MENU_STATE_SETTING:
- if (hcamcorder->mode == MODE_IMAGE) {
- g_print("\n\t=======================================\n");
- g_print("\t Image Capture > Setting\n");
- g_print("\t=======================================\n");
- g_print("\t >>>>>>>>>>>>>>>>>>>>>>>>>>>> [Camera] \n");
- g_print("\t '1' Capture resolution \n");
- g_print("\t '2' Digital zoom level \n");
- g_print("\t '3' Optical zoom level \n");
- g_print("\t '4' AF mode \n");
- g_print("\t '5' AF scan range \n");
- g_print("\t '6' Exposure mode \n");
- g_print("\t '7' Exposure value \n");
- g_print("\t '8' F number \n");
- g_print("\t '9' Shutter speed \n");
- g_print("\t 'i' ISO \n");
- g_print("\t 'r' Rotate camera input \n");
- g_print("\t 'j' Jpeg quality \n");
- g_print("\t 'p' Picture format \n");
- g_print("\t >>>>>>>>>>>>>>>>>>>> [Display/Filter]\n");
- g_print("\t 'v' Visible \n");
- g_print("\t 'o' Output mode \n");
- g_print("\t 'y' Rotate display \n");
- g_print("\t 'g' Brightness \n");
- g_print("\t 'c' Contrast \n");
- g_print("\t 's' Saturation \n");
- g_print("\t 'h' Hue \n");
- g_print("\t 'a' Sharpness \n");
- g_print("\t 'w' White balance \n");
- g_print("\t 't' Color tone \n");
- g_print("\t 'd' WDR \n");
- g_print("\t 'e' EV program mode \n");
- g_print("\t >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [etc.]\n");
- g_print("\t 'z' Strobe (Flash) \n");
- g_print("\t 'x' Capture mode (Still/Multishot)\n");
- g_print("\t 'f' Face detection \n");
- g_print("\t 'k' Anti-handshake \n");
- g_print("\t 'u' Touch AF area \n");
- g_print("\t 'm' Stream callback function \n");
- g_print("\t 'b' back\n");
- g_print("\t=======================================\n");
-
- } else if (hcamcorder->mode == MODE_VIDEO) {
- g_print("\n\t=======================================\n");
- g_print("\t Video Recording > Setting\n");
- g_print("\t=======================================\n");
- g_print("\t >>>>>>>>>>>>>>>>>>>>>>>>>>>> [Camera] \n");
- g_print("\t '1' Recording resolution \n");
- g_print("\t '2' Digital zoom level \n");
- g_print("\t '3' Optical zoom level \n");
- g_print("\t '4' AF mode \n");
- g_print("\t '5' AF scan range \n");
- g_print("\t '6' Exposure mode \n");
- g_print("\t '7' Exposure value \n");
- g_print("\t '8' F number \n");
- g_print("\t 'i' ISO \n");
- g_print("\t 'r' Rotate camera input \n");
- g_print("\t 'p' FPS \n");
- g_print("\t >>>>>>>>>>>>>>>>>>>> [Display/Filter]\n");
- g_print("\t 'v' Visible \n");
- g_print("\t 'o' Output mode \n");
- g_print("\t 'y' Rotate display \n");
- g_print("\t 'g' Brightness \n");
- g_print("\t 'c' Contrast \n");
- g_print("\t 's' Saturation \n");
- g_print("\t 'h' Hue \n");
- g_print("\t 'a' Sharpness \n");
- g_print("\t 'w' White balance \n");
- g_print("\t 't' Color tone \n");
- g_print("\t 'd' WDR \n");
- g_print("\t >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [etc.]\n");
- g_print("\t 'x' High speed recording\n");
- g_print("\t 'u' Mute \n");
- g_print("\t 'z' Strobe (Flash) \n");
- g_print("\t 'k' Anti-handshake \n");
- g_print("\t 'e' Camcorder-rotation setting \n");
- g_print("\t 'm' Stream callback function \n");
- g_print("\t 'b' back\n");
- g_print("\t=======================================\n");
- }
+ g_print("\n\t=======================================\n");
+ g_print("\t Video Capture > Setting\n");
+ g_print("\t=======================================\n");
+ g_print("\t >>>>>>>>>>>>>>>>>>>>>>>>>>>> [Camera] \n");
+ g_print("\t '1' Capture resolution \n");
+ g_print("\t '2' Digital zoom level \n");
+ g_print("\t '3' Optical zoom level \n");
+ g_print("\t '4' AF mode \n");
+ g_print("\t '5' AF scan range \n");
+ g_print("\t '6' Exposure mode \n");
+ g_print("\t '7' Exposure value \n");
+ g_print("\t '8' F number \n");
+ g_print("\t '9' Shutter speed \n");
+ g_print("\t 'i' ISO \n");
+ g_print("\t 'r' Rotate camera input \n");
+ g_print("\t 'f' Flip camera input \n");
+ g_print("\t 'j' Jpeg quality \n");
+ g_print("\t 'p' Picture format \n");
+ g_print("\t 'E' EXIF orientation \n");
+ g_print("\t >>>>>>>>>>>>>>>>>>>> [Display/Filter]\n");
+ g_print("\t 'v' Visible \n");
+ g_print("\t 'n' Display mode \n");
+ g_print("\t 'o' Output mode \n");
+ g_print("\t 'y' Rotate display \n");
+ g_print("\t 'Y' Flip display \n");
+ g_print("\t 'g' Brightness \n");
+ g_print("\t 'c' Contrast \n");
+ g_print("\t 's' Saturation \n");
+ g_print("\t 'h' Hue \n");
+ g_print("\t 'a' Sharpness \n");
+ g_print("\t 'w' White balance \n");
+ g_print("\t 't' Color tone \n");
+ g_print("\t 'd' WDR \n");
+ g_print("\t 'e' EV program mode \n");
+ g_print("\t >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [etc.]\n");
+ g_print("\t 'z' Strobe (Flash) \n");
+ g_print("\t 'x' Capture mode (Still/Multishot/HDR)\n");
+ g_print("\t 'l' Face detection \n");
+ g_print("\t 'k' Anti-handshake \n");
+ g_print("\t 'K' Video-stabilization \n");
+ g_print("\t 'u' Touch AF area \n");
+ g_print("\t 'm' Stream callback function \n");
+ g_print("\t 'b' back\n");
+ g_print("\t=======================================\n");
break;
default:
int current_fps = 0;
int average_fps = 0;
char *err_attr_name = NULL;
- int width = 0, height = 0;
-
- if (hcamcorder->mode == MODE_IMAGE) {
- switch(buf) {
- case '1' : //Capture
- if(hcamcorder->isMultishot) {
- err = mm_camcorder_set_attributes(hcamcorder->camcorder, &err_attr_name,
- MMCAM_CAPTURE_WIDTH, 640,
- MMCAM_CAPTURE_HEIGHT, 480,
- MMCAM_CAPTURE_COUNT, multishot_num,
- MMCAM_CAPTURE_INTERVAL, IMAGE_CAPTURE_COUNT_INTERVAL,
- NULL);
- if (err < 0) {
- err_msg_t("Attribute setting fail : (%s:%x)", err_attr_name, err);
- SAFE_FREE (err_attr_name);
- }
- } else {
- err = mm_camcorder_set_attributes(hcamcorder->camcorder, &err_attr_name,
- MMCAM_CAPTURE_COUNT, IMAGE_CAPTURE_COUNT_STILL,
- NULL);
- if (err < 0) {
- err_msg_t("Attribute setting fail : (%s:%x)", err_attr_name, err);
- SAFE_FREE (err_attr_name);
- }
- }
- g_idle_add_full(G_PRIORITY_DEFAULT_IDLE, (GSourceFunc)test_idle_capture_start, NULL, NULL);
- break;
-
- case '2' : // Setting
- hcamcorder->menu_state = MENU_STATE_SETTING;
- break;
-
- case '3' : // Print frame rate
- current_fps = _mmcamcorder_video_current_framerate(hcamcorder->camcorder);
- average_fps = _mmcamcorder_video_average_framerate(hcamcorder->camcorder);
- g_print("\tVideo Frame Rate[Current : %d.0 fps, Average : %d.0 fps]\n", current_fps, average_fps);
- break;
+ if (hcamcorder->mode == MODE_VIDEO_CAPTURE) {
+ if (mmcamcorder_state == MM_CAMCORDER_STATE_PREPARE) {
+ switch (buf) {
+ case '1' : //Capture
+ if(hcamcorder->isMultishot) {
+ int interval = 0;
+ flush_stdin();
+ printf("\ninput interval(ms) \n");
+ err = scanf("%d", &interval);
+ if (err == EOF) {
+ printf("\nscanf error : errno %d\n", errno);
+ interval = 300;
+ }
+ err = mm_camcorder_set_attributes(hcamcorder->camcorder, &err_attr_name,
+ MMCAM_CAPTURE_INTERVAL, interval,
+ NULL);
+ if (err != MM_ERROR_NONE) {
+ err_msg_t("Attribute setting fail : (%s:%x)", err_attr_name, err);
+ SAFE_FREE (err_attr_name);
+ }
+ } else {
+ err = mm_camcorder_set_attributes(hcamcorder->camcorder, &err_attr_name,
+ MMCAM_CAPTURE_COUNT, IMAGE_CAPTURE_COUNT_STILL,
+ NULL);
+ if (err != MM_ERROR_NONE) {
+ err_msg_t("Attribute setting fail : (%s:%x)", err_attr_name, err);
+ SAFE_FREE (err_attr_name);
+ }
+ }
- case 'b' : // back
- hcamcorder->menu_state = MENU_STATE_MAIN;
- mode_change();
- break;
+ g_idle_add_full(G_PRIORITY_DEFAULT_IDLE, (GSourceFunc)test_idle_capture_start, NULL, NULL);
+ break;
- default:
- g_print("\t Invalid input \n");
- break;
- }
- }
- else if (hcamcorder->mode == MODE_VIDEO)
- {
- if (mmcamcorder_state == MM_CAMCORDER_STATE_PREPARE) {
- switch(buf) {
- case '1' : // Start Recording
+ case '2' : // Start Recording
g_print("*Recording start!\n");
video_stream_cb_cnt = 0;
audio_stream_cb_cnt = 0;
- mm_camcorder_get_attributes( hcamcorder->camcorder, NULL,
- MMCAM_CAMERA_WIDTH, &width,
- MMCAM_CAMERA_HEIGHT, &height,
- NULL );
-
- mm_camcorder_set_attributes( hcamcorder->camcorder, NULL,
- MMCAM_CAMERA_AF_TOUCH_X, width>>1,
- MMCAM_CAMERA_AF_TOUCH_Y, height>>1,
- MMCAM_CAMERA_AF_TOUCH_WIDTH, 30,
- MMCAM_CAMERA_AF_TOUCH_HEIGHT, 30,
- NULL );
-
- mm_camcorder_start_focusing(hcamcorder->camcorder);
-
g_timer_reset(timer);
err = mm_camcorder_record(hcamcorder->camcorder);
- if (err < 0) {
- warn_msg_t("Rec start mm_camcorder_record = %x", err);
+ if (err != MM_ERROR_NONE) {
+ warn_msg_t("Rec start mm_camcorder_record 0x%x", err);
}
mmcamcorder_print_state = MM_CAMCORDER_STATE_RECORDING;
break;
- case '2' : // Setting
+ case '3' : // Setting
hcamcorder->menu_state = MENU_STATE_SETTING;
break;
- case '3' :
+ case '4' : // Print frame rate
current_fps = _mmcamcorder_video_current_framerate(hcamcorder->camcorder);
average_fps = _mmcamcorder_video_average_framerate(hcamcorder->camcorder);
g_print("\tVideo Frame Rate[Current : %d.0 fps, Average : %d.0 fps]\n", current_fps, average_fps);
hcamcorder->menu_state = MENU_STATE_MAIN;
mode_change();
break;
+
+ default:
+ g_print("\t Invalid input \n");
+ break;
}
} else if (mmcamcorder_state == MM_CAMCORDER_STATE_RECORDING || mmcamcorder_state == MM_CAMCORDER_STATE_PAUSED) {
- switch(buf) {
+ switch (buf) {
if (mmcamcorder_state == MM_CAMCORDER_STATE_RECORDING) {
case 'p' : // Pause Recording
g_print("*Pause!\n");
mmcamcorder_print_state = MM_CAMCORDER_STATE_PREPARE;
break;
+ case 'n' : /* Capture video snapshot */
+ err = mm_camcorder_capture_start(hcamcorder->camcorder);
+ break;
+
default :
g_print("\t Invalid input \n");
break;
} else {
err_msg_t("Wrong camcorder state, check status!!");
}
- }
- else if (hcamcorder->mode == MODE_AUDIO)
- {
+ } else if (hcamcorder->mode == MODE_AUDIO) {
if (mmcamcorder_state == MM_CAMCORDER_STATE_PREPARE) {
switch(buf) {
case '1' : // Start Recording
int min = 0;
int max = 0;
int width_count = 0;
- int heigh_count = 0;
+ int height_count = 0;
int i=0;
int count = 0;
int value = 0;
int* array = NULL;
int *width_array = NULL;
- int *heigh_array = NULL;
+ int *height_array = NULL;
char *err_attr_name = NULL;
cam_xypair_t input_pair;
int err = MM_ERROR_NONE;
int x = 0, y = 0, width = 0, height = 0;
- double new_volume = 0.0;
gint error_num=0;
- if (hcamcorder->mode == MODE_IMAGE)
- {
- switch(buf) {
- /* Camera setting */
+ if (hcamcorder->mode == MODE_VIDEO_CAPTURE) {
+ switch (buf) {
+ /* Camera setting */
case '1' : // Setting > Capture Resolution setting
+ /* check recommend preview resolution */
+ camcordertest_get_attr_valid_intarray(MMCAM_RECOMMEND_CAMERA_WIDTH, &width_array, &width_count);
+ camcordertest_get_attr_valid_intarray(MMCAM_RECOMMEND_CAMERA_HEIGHT, &height_array, &height_count);
+ if(width_count != height_count) {
+ err_msg_t("System has wrong information!!\n");
+ } else if (width_count == 0) {
+ g_print("MMCAM_RECOMMEND_CAMERA_WIDTH/HEIGHT Not supported!!\n");
+ } else {
+ g_print("\n - MMCAM_RECOMMEND_CAMERA_WIDTH and HEIGHT (count %d) -\n", width_count);
+ g_print("\t NORMAL ratio : %dx%d\n",
+ width_array[MM_CAMCORDER_PREVIEW_TYPE_NORMAL], height_array[MM_CAMCORDER_PREVIEW_TYPE_NORMAL]);
+ if (width_count >= 2) {
+ g_print("\t WIDE ratio : %dx%d\n\n",
+ width_array[MM_CAMCORDER_PREVIEW_TYPE_WIDE], height_array[MM_CAMCORDER_PREVIEW_TYPE_WIDE]);
+ } else {
+ g_print("\t There is ONLY NORMAL resolution\n\n");
+ }
+ }
+
g_print("*Select the resolution!\n");
camcordertest_get_attr_valid_intarray("capture-width", &width_array, &width_count);
- camcordertest_get_attr_valid_intarray("capture-height", &heigh_array, &heigh_count);
+ camcordertest_get_attr_valid_intarray("capture-height", &height_array, &height_count);
- if(width_count != heigh_count) {
- err_msg_t("System has wrong information!!");
+ if(width_count != height_count) {
+ err_msg_t("System has wrong information!!\n");
} else if (width_count == 0) {
g_print("Not supported!!\n");
} else {
flush_stdin();
for ( i = 0; i < width_count; i++) {
- g_print("\t %d. %d*%d\n", i+1, width_array[i], heigh_array[i]);
+ g_print("\t %d. %d*%d\n", i+1, width_array[i], height_array[i]);
}
- scanf("%d",&index);
-
- if( index > 0 && index <= width_count ) {
- //Set capture size first
- input_pair.attr_subcat_x = "capture-width";
- input_pair.attr_subcat_y = "capture-height";
- input_pair.x = width_array[index-1];
- input_pair.y = heigh_array[index-1];
- bret = camcordertest_set_attr_xypair(input_pair);
+ err = scanf("%d",&index);
+ if (err == EOF) {
+ printf("\nscanf error : errno %d\n", errno);
+ } else {
+ if( index > 0 && index <= width_count ) {
+ //Set capture size first
+ input_pair.attr_subcat_x = "capture-width";
+ input_pair.attr_subcat_y = "capture-height";
+ input_pair.x = width_array[index-1];
+ input_pair.y = height_array[index-1];
+ bret = camcordertest_set_attr_xypair(input_pair);
+ }
}
}
break;
} else {
flush_stdin();
g_print("\n Select Digital zoom level (%d ~ %d)\n", min, max);
- scanf("%d",&index);
+ err = scanf("%d",&index);
bret = camcordertest_set_attr_int("camera-digital-zoom", index);
}
break;
} else {
flush_stdin();
g_print("\n Select Optical zoom level (%d ~ %d)\n", min, max);
- scanf("%d",&index);
+ err = scanf("%d",&index);
bret = camcordertest_set_attr_int("camera-optical-zoom", index);
}
break;
case '4' : // Setting > AF mode
- g_print("*Focus mode !\n");
- camcordertest_get_attr_valid_intarray("camera-focus-mode", &array, &count);
+ g_print("\t0. AF Mode setting !\n");
+ g_print("\t1. AF Start !\n");
+ g_print("\t2. AF Stop !\n\n");
- if(count <= 0) {
- g_print("Not supported !! \n");
- } else {
- g_print("\n Select Focus mode \n");
- flush_stdin();
- for ( i = 0; i < count; i++) {
- g_print("\t %d. %s\n", array[i], focus_mode[array[i]]);
+ flush_stdin();
+ err = scanf("%d", &index);
+
+ switch (index) {
+ case 0:
+ {
+ g_print("*Focus mode !\n");
+ camcordertest_get_attr_valid_intarray("camera-focus-mode", &array, &count);
+
+ if(count <= 0) {
+ g_print("Not supported !! \n");
+ } else {
+ g_print("\n Select Focus mode \n");
+ flush_stdin();
+ for (i = 0 ; i < count ; i++) {
+ g_print("\t %d. %s\n", array[i], focus_mode[array[i]]);
+ }
+ err = scanf("%d",&index);
+ bret = camcordertest_set_attr_int("camera-focus-mode", index);
}
- scanf("%d",&index);
- bret = camcordertest_set_attr_int("camera-focus-mode", index);
+ }
+ break;
+ case 1:
+ mm_camcorder_start_focusing(hcamcorder->camcorder);
+ break;
+ case 2:
+ mm_camcorder_stop_focusing(hcamcorder->camcorder);
+ break;
+ default:
+ g_print("Wrong Input[%d] !! \n", index);
+ break;
}
break;
for ( i = 0; i < count; i++) {
g_print("\t %d. %s\n", array[i], af_scan[array[i]]);
}
- scanf("%d",&index);
- bret = camcordertest_set_attr_int("camera-af-scan-range", index);
-
- if( bret ) {
- mm_camcorder_start_focusing(hcamcorder->camcorder);
- }
+ err = scanf("%d",&index);
+ camcordertest_set_attr_int("camera-af-scan-range", index);
}
break;
for ( i = 0; i < count; i++) {
g_print("\t %d. %s\n", array[i], exposure_mode[array[i]]);
}
- scanf("%d",&index);
+ err = scanf("%d",&index);
bret = camcordertest_set_attr_int("camera-exposure-mode", index);
}
break;
} else {
flush_stdin();
g_print("\n Select Exposure value(%d ~ %d)\n", min, max);
- scanf("%d",&index);
+ err = scanf("%d",&index);
bret = camcordertest_set_attr_int("camera-exposure-value", index);
}
break;
for ( i = 0; i < count; i++) {
g_print("\t %d. %d \n", i+1, array[i]);
}
- scanf("%d",&index);
+ err = scanf("%d",&index);
if( index > 0 && index <= count ) {
bret = camcordertest_set_attr_int("camera-shutter-speed", array[index-1]);
for ( i = 0; i < count; i++) {
g_print("\t %d. %s\n", array[i], iso_name[array[i]]);
}
- scanf("%d",&index);
+ err = scanf("%d",&index);
bret = camcordertest_set_attr_int("camera-iso", index);
}
break;
case 'r' : // Setting > Rotate camera input when recording
- g_print("*Rotate camera input when recording !\n");
- camcordertest_get_attr_valid_intarray(MMCAM_CAMERA_ROTATION, &array, &count);
+ g_print("*Rotate camera input\n");
+ camcordertest_get_attr_valid_intrange(MMCAM_CAMERA_ROTATION, &min, &max);
- if(count <= 0) {
+ if(min >= max) {
g_print("Not supported !! \n");
} else {
- g_print("\n Select Rotate angle of camera \n");
flush_stdin();
- for ( i = 0; i < count; i++) {
- g_print("\t %d. %s\n", array[i], camera_rotation[array[i]]);
+ for (i = min ; i <= max ; i++) {
+ g_print("\t %d. %s\n", i, camera_rotation[i]);
}
- scanf("%d",&index);
- bret = camcordertest_set_attr_int(MMCAM_CAMERA_ROTATION, index);
+ err = scanf("%d",&index);
CHECK_MM_ERROR(mm_camcorder_stop(hcamcorder->camcorder));
- CHECK_MM_ERROR(mm_camcorder_unrealize(hcamcorder->camcorder));
- CHECK_MM_ERROR(mm_camcorder_realize(hcamcorder->camcorder));
+ bret = camcordertest_set_attr_int(MMCAM_CAMERA_ROTATION, index);
CHECK_MM_ERROR(mm_camcorder_start(hcamcorder->camcorder));
}
break;
+ case 'f' : // Setting > Flip camera input
+ flush_stdin();
+ g_print("*Flip camera input\n");
+ g_print(" 0. Flip NONE\n");
+ g_print(" 1. Flip HORIZONTAL\n");
+ g_print(" 2. Flip VERTICAL\n");
+ g_print(" 3. Flip BOTH\n");
+
+ err = scanf("%d", &index);
+
+ CHECK_MM_ERROR(mm_camcorder_stop(hcamcorder->camcorder));
+ CHECK_MM_ERROR(mm_camcorder_unrealize(hcamcorder->camcorder));
+
+ camcordertest_set_attr_int(MMCAM_CAMERA_FLIP, index);
+
+ CHECK_MM_ERROR(mm_camcorder_realize(hcamcorder->camcorder));
+ CHECK_MM_ERROR(mm_camcorder_start(hcamcorder->camcorder));
+ break;
+
case 'j' : // Setting > Jpeg quality
g_print("*Jpeg quality !\n");
camcordertest_get_attr_valid_intrange("image-encoder-quality", &min, &max);
} else {
flush_stdin();
g_print("\n Select Jpeg quality (%d ~ %d)\n", min, max);
- scanf("%d",&index);
+ err = scanf("%d",&index);
bret = camcordertest_set_attr_int("image-encoder-quality", index);
}
break;
for ( i = 0; i < count; i++) {
g_print("\t %d. %s\n", array[i], image_fmt[array[i]]);
}
- scanf("%d",&index);
+ err = scanf("%d",&index);
bret = camcordertest_set_attr_int("camera-format", index);
CHECK_MM_ERROR(mm_camcorder_stop(hcamcorder->camcorder));
CHECK_MM_ERROR(mm_camcorder_unrealize(hcamcorder->camcorder));
}
break;
- /* Display / Filter setting */
+ case 'E' : // Setting > EXIF orientation
+ g_print("* EXIF Orientation\n");
+
+ g_print("\t 1. TOP_LEFT\n");
+ g_print("\t 2. TOP_RIGHT(flipped)\n");
+ g_print("\t 3. BOTTOM_RIGHT\n");
+ g_print("\t 4. BOTTOM_LEFT(flipped)\n");
+ g_print("\t 5. LEFT_TOP(flipped)\n");
+ g_print("\t 6. RIGHT_TOP\n");
+ g_print("\t 7. RIGHT_BOTTOM(flipped)\n");
+ g_print("\t 8. LEFT_BOTTOM\n");
+
+ flush_stdin();
+ err = scanf("%d", &index);
+
+ if (index < 1 || index > 8) {
+ g_print("Wrong INPUT[%d]!! \n", index);
+ } else {
+ camcordertest_set_attr_int(MMCAM_TAG_ORIENTATION, index);
+ }
+
+ break;
+
+ /* Display / Filter setting */
case 'v' : // Display visible
g_print("* Display visible setting !\n");
camcordertest_get_attr_valid_intarray( "display-visible", &array, &count );
for ( i = 0; i < count; i++) {
g_print("\t %d. %s\n", array[i], visible_mode[array[i]]);
}
- scanf("%d",&value);
+ err = scanf("%d",&value);
bret = camcordertest_set_attr_int( "display-visible", value );
}
break;
+ case 'n' : // Setting > Display mode
+ g_print("* Display mode!\n");
+ camcordertest_get_attr_valid_intarray(MMCAM_DISPLAY_MODE, &array, &count);
+
+ if (count <= 0 || count > 255) {
+ g_print("Not supported !! \n");
+ } else {
+ flush_stdin();
+ g_print("\n Select Display mode\n");
+ for (i = 0 ; i < count ; i++) {
+ g_print("\t %d. %s\n", array[i], display_mode[array[i]]);
+ }
+ err = scanf("%d",&index);
+ bret = camcordertest_set_attr_int(MMCAM_DISPLAY_MODE, index);
+ }
+ break;
+
case 'o' : // Setting > Output mode
g_print("* Output mode!\n");
camcordertest_get_attr_valid_intrange("display-geometry-method", &min, &max);
for( i = min ; i <= max ; i++ ) {
g_print( "%d. %s\n", i, output_mode[i] );
}
- scanf("%d",&index);
+ err = scanf("%d",&index);
bret = camcordertest_set_attr_int("display-geometry-method", index);
}
break;
case 'y' : // Setting > Rotate Display
- camcordertest_get_attr_valid_intarray( MMCAM_DISPLAY_ROTATION, &array, &count );
+ camcordertest_get_attr_valid_intrange(MMCAM_DISPLAY_ROTATION, &min, &max);
- if( count <= 0 || count > 256 ) {
+ if( min > max ) {
g_print("Not supported !! \n");
} else {
flush_stdin();
- g_print("\n Select Rotation mode\n");
- for ( i = 0; i < count; i++) {
- g_print("\t %d. %s\n", array[i], rotate_mode[array[i]]);
- }
- scanf("%d",&index);
- bret = camcordertest_set_attr_int( MMCAM_DISPLAY_ROTATION, index );
+ g_print("\n Select Rotate mode(%d ~ %d)\n", min, max);
+ g_print("\t0. 0\n\t1. 90\n\t2. 180\n\t3. 270\n\n");
+ err = scanf("%d",&index);
+ bret = camcordertest_set_attr_int(MMCAM_DISPLAY_ROTATION, index);
}
break;
+ case 'Y' : // Setting > Flip Display
+ flush_stdin();
+ g_print("\n Select Rotate mode(%d ~ %d)\n", min, max);
+ g_print("\t0. NONE\n\t1. HORIZONTAL\n\t2. VERTICAL\n\t3. BOTH\n\n");
+ err = scanf("%d",&index);
+ camcordertest_set_attr_int(MMCAM_DISPLAY_FLIP, index);
+ break;
+
case 'g' : // Setting > Brightness
g_print("*Brightness !\n");
camcordertest_get_attr_valid_intrange("filter-brightness", &min, &max);
} else {
flush_stdin();
g_print("\n Select brightness (%d ~ %d)\n", min, max);
- scanf("%d",&index);
+ err = scanf("%d",&index);
bret = camcordertest_set_attr_int("filter-brightness", index);
}
break;
} else {
flush_stdin();
g_print("\n Select Contrast (%d ~ %d)\n", min, max);
- scanf("%d",&index);
+ err = scanf("%d",&index);
bret = camcordertest_set_attr_int("filter-contrast", index);
}
break;
} else {
flush_stdin();
g_print("\n Select Saturation (%d ~ %d)\n", min, max);
- scanf("%d",&index);
+ err = scanf("%d",&index);
bret = camcordertest_set_attr_int("filter-saturation", index);
}
break;
} else {
flush_stdin();
g_print("\n Select Hue (%d ~ %d)\n", min, max);
- scanf("%d",&index);
+ err = scanf("%d",&index);
bret = camcordertest_set_attr_int("filter-hue", index);
}
break;
} else {
flush_stdin();
g_print("\n Select Sharpness (%d ~ %d)\n", min, max);
- scanf("%d",&index);
+ err = scanf("%d",&index);
bret = camcordertest_set_attr_int("filter-sharpness", index);
}
break;
for ( i = 0; i < count; i++) {
g_print("\t %d. %s\n", array[i], wb[array[i]]);
}
- scanf("%d",&index);
+ err = scanf("%d",&index);
bret = camcordertest_set_attr_int("filter-wb", index);
}
break;
for ( i = 0; i < count; i++) {
g_print("\t %d. %s\n", array[i], ct[array[i]]);
}
- scanf("%d",&index);
+ err = scanf("%d",&index);
bret = camcordertest_set_attr_int("filter-color-tone", index);
}
break;
for ( i = 0; i < count; i++) {
g_print("\t %d. %s\n", array[i], wdr_mode[array[i]]);
}
- scanf("%d",&index);
+ err = scanf("%d",&index);
bret = camcordertest_set_attr_int("camera-wdr", index);
}
break;
for ( i = 0; i < count; i++) {
g_print("\t %d. %s\n", array[i], program_mode[array[i]]);
}
- scanf("%d",&index);
+ err = scanf("%d",&index);
bret = camcordertest_set_attr_int("filter-scene-mode", index);
}
break;
- /* ext. setting */
+ /* ext. setting */
case 'z' : // Setting > Strobe setting
g_print("*Strobe Mode\n");
camcordertest_get_attr_valid_intarray("strobe-mode", &array, &count);
for ( i = 0; i < count; i++) {
g_print("\t %d. %s\n", array[i], strobe_mode[array[i]]);
}
- scanf("%d",&index);
+ err = scanf("%d",&index);
bret = camcordertest_set_attr_int("strobe-mode", index);
}
break;
case 'x' : // Setting > Capture mode ,Muitishot?
g_print("*Select Capture mode!\n");
flush_stdin();
- g_print(" \n\t1. Stillshot mode\n\t2. Multishot mode \n");
- scanf("%d",&index);
+ g_print(" \n\t1. Stillshot mode\n\t2. Multishot mode\n\t3. HDR capture\n");
+ err = scanf("%d",&index);
- if(index == 1) {
+ switch (index) {
+ case 1:
g_print("stillshot mode selected and capture callback is set!!!!\n");
hcamcorder->isMultishot = FALSE;
- } else if (index == 2) {
+ camcordertest_set_attr_int(MMCAM_CAMERA_HDR_CAPTURE, 0);
+ break;
+ case 2:
g_print("Multilshot mode selected!!\n");
+ camcordertest_set_attr_int(MMCAM_CAMERA_HDR_CAPTURE, 0);
+
index = 0;
min = 0;
max = 0;
flush_stdin();
//g_print("\n Check Point!!! [Change resolution to 800x480]\n");
g_print("Select mulitshot number (%d ~ %d)\n", min, max);
- scanf("%d",&index);
+ err = scanf("%d",&index);
if( index >= min && index <= max ) {
multishot_num = index;
+ mm_camcorder_set_attributes(hcamcorder->camcorder, &err_attr_name,
+ MMCAM_CAPTURE_COUNT, multishot_num,
+ NULL);
hcamcorder->isMultishot = TRUE;
} else {
g_print("Wrong input value, Multishot setting failed!!\n");
}
}
- } else {
- g_print("Wrong input, select again!!\n");
- }
- break;
+ break;
+ case 3:
+ g_print("HDR Capture mode selected\n");
+ hcamcorder->isMultishot = FALSE;
- case 'f' : // Setting > Face detection setting
- //hcamcorder->menu_state = MENU_STATE_SETTING_DETECTION;
- g_print("* Face detect mode !\n");
-
- camcordertest_get_attr_valid_intarray("detect-mode", &array, &count);
- if(count <= 0 || count > 256) {
- g_print("Not supported !! \n");
- } else {
- g_print("\n Face detect mode \n");
- flush_stdin();
- for ( i = 0; i < count; i++) {
- g_print("\t %d. %s \n", array[i], detection_mode[array[i]]);
- }
- scanf("%d",&index);
-
- if( index >= 0 && index < count ) {
- bret = camcordertest_set_attr_int("detect-mode", array[index]);
- } else {
- g_print("Wrong input value. Try again!!\n");
- bret = FALSE;
- }
- }
- break;
-
- case 'k' : // Setting > Anti-handshake
- g_print("*Anti-handshake !\n");
- camcordertest_get_attr_valid_intarray("camera-anti-handshake", &array, &count);
-
- if(count <= 0) {
- g_print("Not supported !! \n");
- } else {
- g_print("\n Select Anti-handshake mode \n");
- flush_stdin();
- for ( i = 0; i < count; i++) {
- g_print("\t %d. %s\n", array[i], ahs_mode[array[i]]);
- }
- scanf("%d",&index);
- bret = camcordertest_set_attr_int("camera-anti-handshake", index);
- }
- break;
-
- case 'u': // Touch AF area
- g_print("* Touch AF area !\n");
- camcordertest_get_attr_valid_intrange("camera-af-touch-x", &min, &max);
- if( max < min ) {
- g_print( "Not Supported camera-af-touch-x !!\n" );
- break;
- }
- camcordertest_get_attr_valid_intrange("camera-af-touch-y", &min, &max);
- if( max < min ) {
- g_print( "Not Supported camera-af-touch-y !!\n" );
- break;
- }
- camcordertest_get_attr_valid_intrange("camera-af-touch-width", &min, &max);
- if( max < min ) {
- g_print( "Not Supported camera-af-touch-width !!\n" );
- break;
- }
- camcordertest_get_attr_valid_intrange("camera-af-touch-height", &min, &max);
- if( max < min ) {
- g_print( "Not Supported camera-af-touch-height!!\n" );
- break;
- }
-
- flush_stdin();
- g_print( "\n Input x,y,width,height \n" );
- scanf( "%d,%d,%d,%d", &x, &y, &width, &height );
- err = mm_camcorder_set_attributes(hcamcorder->camcorder, &err_attr_name,
- MMCAM_CAMERA_AF_TOUCH_X, x,
- MMCAM_CAMERA_AF_TOUCH_Y, y,
- MMCAM_CAMERA_AF_TOUCH_WIDTH, width,
- MMCAM_CAMERA_AF_TOUCH_HEIGHT, height,
- NULL);
-
- if( err != MM_ERROR_NONE ) {
- g_print( "Failed to set touch AF area.(%x)(%s)\n", err, err_attr_name );
- free( err_attr_name );
- err_attr_name = NULL;
- } else {
- g_print( "Succeed to set touch AF area.\n" );
- }
- break;
-
- case 'm' : // Setting > Stream callback function
- g_print("Not supported !! \n");
- break;
-
- case 'b' : // back
- hcamcorder->menu_state = MENU_STATE_MAIN;
- break;
-
- default :
- g_print("\t Invalid input \n");
- break;
- }
- }
- else if(hcamcorder->mode == MODE_VIDEO)
- {
- switch(buf)
- {
- /* Camera setting */
- case '1' : // Setting > Recording Resolution
- g_print("*Select resolution!\n");
-
- camcordertest_get_attr_valid_intarray("camera-width", &width_array, &width_count);
- camcordertest_get_attr_valid_intarray("camera-height", &heigh_array, &heigh_count);
-
- if(width_count != heigh_count) {
- err_msg_t("System has wrong information!!");
- } else if(width_count == 0) {
- g_print("Not supported !! \n");
- } else {
- g_print("\n Select the resolution \n");
- flush_stdin();
- for ( i = 0; i < width_count; i++) {
- g_print("\t %d. %d*%d\n", i+1, width_array[i], heigh_array[i]);
- }
- scanf("%d",&index);
-
- if( index > 0 && index <= width_count ) {
- g_timer_reset(timer);
- CHECK_MM_ERROR(mm_camcorder_stop(hcamcorder->camcorder));
- CHECK_MM_ERROR(mm_camcorder_unrealize(hcamcorder->camcorder));
-
- //Set source size
- input_pair.attr_subcat_x = "camera-width";
- input_pair.attr_subcat_y = "camera-height";
- input_pair.x = width_array[index-1];
- input_pair.y = heigh_array[index-1];
-
- bret = camcordertest_set_attr_xypair(input_pair);
-
- CHECK_MM_ERROR(mm_camcorder_realize(hcamcorder->camcorder));
- CHECK_MM_ERROR(mm_camcorder_start(hcamcorder->camcorder));
- time_msg_t("Resolution change : %12.6lf s", g_timer_elapsed(timer, NULL));
- } else {
- warn_msg_t( "Out of index" );
- }
- }
- break;
-
- case '2' : // Setting > Digital zoom level
- g_print("*Digital zoom level !\n");
- camcordertest_get_attr_valid_intrange("camera-digital-zoom", &min, &max);
-
- if(min >= max) {
- g_print("Not supported !! \n");
- } else {
- flush_stdin();
- g_print("\n Select Digital zoom level (%d ~ %d)\n", min, max);
- scanf("%d",&index);
- bret = camcordertest_set_attr_int("camera-digital-zoom", index);
- }
- break;
-
- case '3' : // Setting > Optical zoom level
- g_print("*Optical zoom level !\n");
- camcordertest_get_attr_valid_intrange("camera-optical-zoom", &min, &max);
-
- if(min >= max) {
- g_print("Not supported !! \n");
- } else {
- flush_stdin();
- g_print("\n Select Optical zoom level (%d ~ %d)\n", min, max);
- scanf("%d",&index);
- bret = camcordertest_set_attr_int("camera-optical-zoom", index);
- }
- break;
-
- case '4' : // Setting > AF mode
- g_print("*Focus mode !\n");
- camcordertest_get_attr_valid_intarray("camera-focus-mode", &array, &count);
-
- if(count <= 0) {
- g_print("Not supported !! \n");
- } else {
- g_print("\n Select Focus mode \n");
- flush_stdin();
- for ( i = 0; i < count; i++) {
- g_print("\t %d. %s\n", array[i], focus_mode[array[i]]);
- }
- scanf("%d",&index);
- bret = camcordertest_set_attr_int("camera-focus-mode", index);
- }
- break;
-
- case '5' : // Setting > AF scan range
- g_print("*AF scan range !\n");
- camcordertest_get_attr_valid_intarray("camera-af-scan-range", &array, &count);
-
- if(count <= 0) {
- g_print("Not supported !! \n");
- } else {
- g_print("\n Select AF scan range \n");
- flush_stdin();
- for ( i = 0; i < count; i++) {
- g_print("\t %d. %s\n", array[i], af_scan[array[i]]);
- }
- scanf("%d",&index);
- bret = camcordertest_set_attr_int("camera-af-scan-range", index);
-
- if( bret ) {
- mm_camcorder_start_focusing(hcamcorder->camcorder);
- }
- }
- break;
-
- case '6' : // Setting > Exposure mode
- g_print("* Exposure mode!\n");
- camcordertest_get_attr_valid_intarray("camera-exposure-mode", &array, &count);
-
- if(count <= 0) {
- g_print("Not supported !! \n");
- } else {
- g_print("\n Select Exposure mode \n");
- flush_stdin();
- for ( i = 0; i < count; i++) {
- g_print("\t %d. %s\n", array[i], exposure_mode[array[i]]);
- }
- scanf("%d",&index);
- bret = camcordertest_set_attr_int("camera-exposure-mode", index);
- }
- break;
-
- case '7' : // Setting > Exposure value
- g_print("*Exposure value !\n");
- camcordertest_get_attr_valid_intrange("camera-exposure-value", &min, &max);
-
- if(min >= max) {
- g_print("Not supported !! \n");
- } else {
- flush_stdin();
- g_print("\n Select Exposure value(%d ~ %d)\n", min, max);
- scanf("%d",&index);
- bret = camcordertest_set_attr_int("camera-exposure-value", index);
- }
- break;
-
- case '8' : // Setting > F number
- g_print("Not supported !! \n");
- break;
-
- case 'i' : // Setting > ISO
- g_print("*ISO !\n");
- camcordertest_get_attr_valid_intarray("camera-iso", &array, &count);
-
- if(count <= 0) {
- g_print("Not supported !! \n");
- } else {
- g_print("\n Select ISO \n");
- flush_stdin();
- for ( i = 0; i < count; i++) {
- g_print("\t %d. %s\n", array[i], iso_name[array[i]]);
- }
- scanf("%d",&index);
- bret = camcordertest_set_attr_int("camera-iso", index);
- }
- break;
-
- case 'r' : // Setting > Rotate camera input when recording
- g_print("*Rotate camera input !\n");
- camcordertest_get_attr_valid_intarray(MMCAM_CAMERA_ROTATION, &array, &count);
-
- if(count <= 0) {
- g_print("Not supported !! \n");
- } else {
- g_print("\n Select Rotate angle of camera (Do Not use it for recording test !!) \n");
- flush_stdin();
- for ( i = 0; i < count; i++) {
- g_print("\t %d. %s\n", array[i], camera_rotation[array[i]]);
- }
- scanf("%d",&index);
-
- CHECK_MM_ERROR(mm_camcorder_stop(hcamcorder->camcorder));
- CHECK_MM_ERROR(mm_camcorder_unrealize(hcamcorder->camcorder));
-
- bret = camcordertest_set_attr_int(MMCAM_CAMERA_ROTATION, index);
-
- CHECK_MM_ERROR(mm_camcorder_realize(hcamcorder->camcorder));
- CHECK_MM_ERROR(mm_camcorder_start(hcamcorder->camcorder));
- }
- break;
-
- case 'p' : // Setting > FPS
- g_print("* FPS !\n");
-
- camcordertest_get_attr_valid_intarray("camera-fps", &array, &count);
-
- if(count <= 0 || count > 256)
- {
- g_print("Not supported !! \n");
- }
- else
- {
- g_print("\n Select FPS \n");
- flush_stdin();
- for ( i = 0; i < count; i++)
- {
- g_print("\t %d. %d \n", i+1, array[i]);
- }
- scanf("%d",&index);
-
- if( index > 0 && index <= count )
- {
- bret = camcordertest_set_attr_int("camera-fps", array[index-1]);
- hcamcorder->fps = array[index-1];
- }
- else
- {
- bret = FALSE;
- g_print("\n Out of index \n");
- }
- }
- break;
-
- /* Display / Filter setting */
- case 'v' : // Setting > Display visible
- g_print("* Display visible setting !\n");
- camcordertest_get_attr_valid_intarray( "display-visible", &array, &count );
-
- if( count < 1 ) {
- g_print("Not supported !! \n");
- } else {
- g_print("\n Select Display visible \n");
- flush_stdin();
- for ( i = 0; i < count; i++) {
- g_print("\t %d. %s\n", array[i], visible_mode[array[i]]);
- }
- scanf("%d",&value);
- bret = camcordertest_set_attr_int( "display-visible", value );
- }
- break;
-
- case 'o' : // Setting > Output mode
- g_print("* Output mode!\n");
- camcordertest_get_attr_valid_intrange("display-geometry-method", &min, &max);
-
- if( min > max ) {
- g_print("Not supported !! \n");
- } else {
- flush_stdin();
- g_print("\n Select Output mode(%d ~ %d)\n", min, max);
- for( i = min ; i <= max ; i++ ) {
- g_print( "%d. %s\n", i, output_mode[i] );
- }
- scanf("%d",&index);
- bret = camcordertest_set_attr_int("display-geometry-method", index);
- }
- break;
-
- case 'y' : // Setting > Rotate Display
- camcordertest_get_attr_valid_intarray( MMCAM_DISPLAY_ROTATION, &array, &count );
-
- if( count <= 0 || count > 256 ) {
- g_print("Not supported !! \n");
- } else {
- flush_stdin();
- g_print("\n Select Rotation mode\n");
- for ( i = 0; i < count; i++) {
- g_print("\t %d. %s\n", array[i], rotate_mode[array[i]]);
- }
- scanf("%d",&index);
- bret = camcordertest_set_attr_int( MMCAM_DISPLAY_ROTATION, index );
- }
- break;
-
- case 'g' : // Setting > Brightness
- g_print("*Brightness !\n");
- camcordertest_get_attr_valid_intrange("filter-brightness", &min, &max);
-
- if(min >= max) {
- g_print("Not supported !! \n");
- } else {
- flush_stdin();
- g_print("\n Select brightness (%d ~ %d)\n", min, max);
- scanf("%d",&index);
- bret = camcordertest_set_attr_int("filter-brightness", index);
- }
- break;
-
- case 'c' : // Setting > Contrast
- g_print("*Contrast !\n");
- camcordertest_get_attr_valid_intrange("filter-contrast", &min, &max);
-
- if(min >= max) {
- g_print("Not supported !! \n");
- } else {
- flush_stdin();
- g_print("\n Select Contrast (%d ~ %d)\n", min, max);
- scanf("%d",&index);
- bret = camcordertest_set_attr_int("filter-contrast", index);
- }
- break;
-
- case 's' : // Setting > Saturation
- g_print("*Saturation !\n");
- camcordertest_get_attr_valid_intrange("filter-saturation", &min, &max);
-
- if(min >= max) {
- g_print("Not supported !! \n");
- } else {
- flush_stdin();
- g_print("\n Select Saturation (%d ~ %d)\n", min, max);
- scanf("%d",&index);
- bret = camcordertest_set_attr_int("filter-saturation", index);
- }
- break;
-
- case 'h' : // Setting > Hue
- g_print("*Hue !\n");
- camcordertest_get_attr_valid_intrange("filter-hue", &min, &max);
-
- if(min >= max) {
- g_print("Not supported !! \n");
- } else {
- flush_stdin();
- g_print("\n Select Hue (%d ~ %d)\n", min, max);
- scanf("%d",&index);
- bret = camcordertest_set_attr_int("filter-hue", index);
- }
- break;
-
- case 'a' : // Setting > Sharpness
- g_print("*Sharpness !\n");
- camcordertest_get_attr_valid_intrange("filter-sharpness", &min, &max);
-
- if(min >= max) {
- g_print("Not supported !! \n");
- } else {
- flush_stdin();
- g_print("\n Select Sharpness (%d ~ %d)\n", min, max);
- scanf("%d",&index);
- bret = camcordertest_set_attr_int("filter-sharpness", index);
+ camcordertest_get_attr_valid_intarray(MMCAM_CAMERA_HDR_CAPTURE, &array, &count);
+ if(count <= 0) {
+ g_print("Not supported !! \n");
+ } else {
+ g_print("\nSelect HDR capture mode\n");
+ flush_stdin();
+ for ( i = 0; i < count; i++) {
+ g_print("\t %d. %s\n", array[i], hdr_mode[array[i]]);
+ }
+ err = scanf("%d",&index);
+ bret = camcordertest_set_attr_int(MMCAM_CAMERA_HDR_CAPTURE, index);
+ }
+ break;
+ default:
+ g_print("Wrong input, select again!!\n");
+ break;
}
break;
- case 'w' : // Setting > White balance
- g_print("*White balance !\n");
- camcordertest_get_attr_valid_intarray("filter-wb", &array, &count);
+ case 'l' : // Setting > Face detection setting
+ //hcamcorder->menu_state = MENU_STATE_SETTING_DETECTION;
+ g_print("* Face detect mode !\n");
- if(count <= 0) {
+ camcordertest_get_attr_valid_intarray("detect-mode", &array, &count);
+ if(count <= 0 || count > 256) {
g_print("Not supported !! \n");
} else {
+ g_print("\n Face detect mode \n");
flush_stdin();
- g_print("\n Select White balance \n");
for ( i = 0; i < count; i++) {
- g_print("\t %d. %s\n", array[i], wb[array[i]]);
+ g_print("\t %d. %s \n", array[i], detection_mode[array[i]]);
+ }
+ err = scanf("%d",&index);
+
+ if( index >= 0 && index < count ) {
+ bret = camcordertest_set_attr_int("detect-mode", array[index]);
+ } else {
+ g_print("Wrong input value. Try again!!\n");
+ bret = FALSE;
}
- scanf("%d",&index);
- bret = camcordertest_set_attr_int("filter-wb", index);
}
break;
- case 't' : // Setting > Color tone
- g_print("*Color tone !\n");
- camcordertest_get_attr_valid_intarray("filter-color-tone", &array, &count);
+ case 'k' : // Setting > Anti-handshake
+ g_print("*Anti-handshake !\n");
+ camcordertest_get_attr_valid_intarray(MMCAM_CAMERA_ANTI_HANDSHAKE, &array, &count);
if(count <= 0) {
g_print("Not supported !! \n");
} else {
- g_print("\n Select Color tone \n");
+ g_print("\n Select Anti-handshake mode \n");
flush_stdin();
for ( i = 0; i < count; i++) {
- g_print("\t %d. %s\n", array[i], ct[array[i]]);
+ g_print("\t %d. %s\n", array[i], ahs_mode[array[i]]);
}
- scanf("%d",&index);
- bret = camcordertest_set_attr_int("filter-color-tone", index);
+ err = scanf("%d",&index);
+ bret = camcordertest_set_attr_int(MMCAM_CAMERA_ANTI_HANDSHAKE, index);
}
break;
- case 'd' : // Setting > WDR
- g_print("*WDR !\n");
- camcordertest_get_attr_valid_intarray("camera-wdr", &array, &count);
+ case 'K' : // Setting > Video-stabilization
+ g_print("*Video-stabilization !\n");
+ camcordertest_get_attr_valid_intarray(MMCAM_CAMERA_VIDEO_STABILIZATION, &array, &count);
if(count <= 0) {
g_print("Not supported !! \n");
- }
- else {
- g_print("\n Select WDR Mode \n");
+ } else {
+ g_print("\n Select Video-stabilization mode \n");
flush_stdin();
for ( i = 0; i < count; i++) {
- g_print("\t %d. %s\n", array[i], wdr_mode[array[i]]);
+ g_print("\t %d. %s\n", array[i], vs_mode[array[i]]);
}
- scanf("%d",&index);
- bret = camcordertest_set_attr_int("camera-wdr", index);
- }
- break;
-
- /* ext. setting */
- case 'x' : // Setting > High Speed
- {
- static int backup_width = 0;
- static int backup_height = 0;
-
- g_print("\n Select High Speed Recording mode\n");
- g_print("\t 1. High Speed Recording mode ON\n");
- g_print("\t 2. High Speed Recording mode OFF \n");
+ err = scanf("%d",&index);
- flush_stdin();
- scanf("%d",&index);
- if (index == 1) {
- mm_camcorder_get_attributes(hcamcorder->camcorder, &err_attr_name,
- MMCAM_CAMERA_WIDTH, &backup_width,
- MMCAM_CAMERA_HEIGHT, &backup_height,
- NULL);
-
- CHECK_MM_ERROR(mm_camcorder_stop(hcamcorder->camcorder));
- CHECK_MM_ERROR(mm_camcorder_unrealize(hcamcorder->camcorder));
-
- err = mm_camcorder_set_attributes(hcamcorder->camcorder, &err_attr_name,
- MMCAM_CAMERA_WIDTH, 320,
- MMCAM_CAMERA_HEIGHT, 240,
- MMCAM_CAMERA_FPS, 120,
- "camera-slow-motion-fps", 30,
- NULL);
- if (err != MM_ERROR_NONE) {
- warn_msg_t("High speed recording. mm_camcorder_set_attributes fail. (%s:%x)", err_attr_name, err);
- SAFE_FREE(err_attr_name);
- }
+ if (index == MM_CAMCORDER_VIDEO_STABILIZATION_ON) {
+ g_print("\n Restart preview with NV12 and 720p resolution\n");
- CHECK_MM_ERROR(mm_camcorder_realize(hcamcorder->camcorder));
- CHECK_MM_ERROR(mm_camcorder_start(hcamcorder->camcorder));
+ err = mm_camcorder_stop(hcamcorder->camcorder);
+ if (err == MM_ERROR_NONE) {
+ err = mm_camcorder_unrealize(hcamcorder->camcorder);
+ }
- } else if(index == 2) {
- CHECK_MM_ERROR(mm_camcorder_stop(hcamcorder->camcorder));
- CHECK_MM_ERROR(mm_camcorder_unrealize(hcamcorder->camcorder));
+ input_pair.attr_subcat_x = MMCAM_CAMERA_WIDTH;
+ input_pair.attr_subcat_y = MMCAM_CAMERA_HEIGHT;
+ input_pair.x = 1280;
+ input_pair.y = 720;
+ camcordertest_set_attr_xypair(input_pair);
+ camcordertest_set_attr_int(MMCAM_CAMERA_FORMAT, MM_PIXEL_FORMAT_NV12);
+ camcordertest_set_attr_int(MMCAM_CAMERA_VIDEO_STABILIZATION, index);
+
+ if (err == MM_ERROR_NONE) {
+ err = mm_camcorder_realize(hcamcorder->camcorder);
+ if (err == MM_ERROR_NONE) {
+ err = mm_camcorder_start(hcamcorder->camcorder);
+ }
+ }
- if (backup_width && backup_height) {
- err = mm_camcorder_set_attributes(hcamcorder->camcorder, &err_attr_name,
- MMCAM_CAMERA_WIDTH, backup_width,
- MMCAM_CAMERA_HEIGHT, backup_height,
- NULL);
if (err != MM_ERROR_NONE) {
- warn_msg_t("get_attributes fail. (%s:%x)", err_attr_name, err);
- SAFE_FREE (err_attr_name);
+ g_print("\n Restart FAILED! %x\n", err);
}
+ } else {
+ camcordertest_set_attr_int(MMCAM_CAMERA_VIDEO_STABILIZATION, index);
}
-
- err = mm_camcorder_set_attributes(hcamcorder->camcorder, &err_attr_name,
- MMCAM_CAMERA_FPS, SRC_VIDEO_FRAME_RATE_30,
- "camera-slow-motion-fps", 0,
- NULL);
- if (err != MM_ERROR_NONE) {
- warn_msg_t("Normal speed recording. mm_camcorder_set_attributes fail. (%s:%x)", err_attr_name, err);
- SAFE_FREE (err_attr_name);
- }
-
- CHECK_MM_ERROR(mm_camcorder_realize(hcamcorder->camcorder));
- CHECK_MM_ERROR(mm_camcorder_start(hcamcorder->camcorder));
- } else {
- g_print("Wrong input, Try again!!\n");
}
break;
- }
- case 'u' : // Setting > Mute
- g_print("*Mute!(%d)\n", hcamcorder->isMute);
- if (hcamcorder->isMute) {
- new_volume = 0.0;
- } else {
- new_volume = 1.0;
+ case 'u': // Touch AF area
+ g_print("* Touch AF area !\n");
+ camcordertest_get_attr_valid_intrange("camera-af-touch-x", &min, &max);
+ if( max < min ) {
+ g_print( "Not Supported camera-af-touch-x !!\n" );
+ break;
}
-
- err = mm_camcorder_set_attributes(hcamcorder->camcorder, &err_attr_name,
- MMCAM_AUDIO_VOLUME, new_volume,
- NULL);
- if (err < 0) {
- warn_msg_t("Can' Mute. mm_camcorder_set_attributes fail. (%s:%x)", err_attr_name, err);
- SAFE_FREE (err_attr_name);
+ camcordertest_get_attr_valid_intrange("camera-af-touch-y", &min, &max);
+ if( max < min ) {
+ g_print( "Not Supported camera-af-touch-y !!\n" );
+ break;
}
-
- hcamcorder->isMute = !(hcamcorder->isMute);
- break;
-
- case 'z' : // Setting > Strobe setting
- g_print("*Strobe Mode\n");
- camcordertest_get_attr_valid_intarray("strobe-mode", &array, &count);
- if(count <= 0) {
- g_print("Not supported !! \n");
- } else {
- g_print("\n Select Strobe Mode \n");
- flush_stdin();
- for ( i = 0; i < count; i++) {
- g_print("\t %d. %s\n", array[i], strobe_mode[array[i]]);
- }
- scanf("%d",&index);
- bret = camcordertest_set_attr_int("strobe-mode", index);
+ camcordertest_get_attr_valid_intrange("camera-af-touch-width", &min, &max);
+ if( max < min ) {
+ g_print( "Not Supported camera-af-touch-width !!\n" );
+ break;
}
- break;
-
- case 'k' : // Setting > Anti-handshake
- g_print("*Anti-handshake !\n");
- camcordertest_get_attr_valid_intarray("camera-anti-handshake", &array, &count);
-
- if(count <= 0) {
- g_print("Not supported !! \n");
- } else {
- g_print("\n Select Anti-handshake mode \n");
- flush_stdin();
- for ( i = 0; i < count; i++) {
- g_print("\t %d. %s\n", array[i], ahs_mode[array[i]]);
- }
- scanf("%d",&index);
- bret = camcordertest_set_attr_int("camera-anti-handshake", index);
+ camcordertest_get_attr_valid_intrange("camera-af-touch-height", &min, &max);
+ if( max < min ) {
+ g_print( "Not Supported camera-af-touch-height!!\n" );
+ break;
}
- break;
- case 'e' : // Setting > Camcorder-rotation setting
- g_print("*Camcorder-rotation setting!\n");
- camcordertest_get_attr_valid_intrange("camcorder-rotation", &min, &max);
+ flush_stdin();
+ g_print( "\n Input x,y,width,height \n" );
+ err = scanf( "%d,%d,%d,%d", &x, &y, &width, &height );
+ err = mm_camcorder_set_attributes(hcamcorder->camcorder, &err_attr_name,
+ MMCAM_CAMERA_AF_TOUCH_X, x,
+ MMCAM_CAMERA_AF_TOUCH_Y, y,
+ MMCAM_CAMERA_AF_TOUCH_WIDTH, width,
+ MMCAM_CAMERA_AF_TOUCH_HEIGHT, height,
+ NULL);
- if(min >= max) {
- g_print("Not supported !! \n");
+ if( err != MM_ERROR_NONE ) {
+ g_print( "Failed to set touch AF area.(%x)(%s)\n", err, err_attr_name );
+ free( err_attr_name );
+ err_attr_name = NULL;
} else {
- g_print("\n Select camcorder-rotation value \n");
- flush_stdin();
- for ( i = 0; i < (max-min+1); i++) {
- g_print("\t %d. %s\n", i, camcorder_rotate_val[i]);
- }
- scanf("%d",&index);
- bret = camcordertest_set_attr_int("camcorder-rotation", index);
+ g_print( "Succeed to set touch AF area.\n" );
}
break;
case 'm' : // Setting > Stream callback function
g_print("\n Select Stream Callback Function\n");
g_print("\t 1. Set Video Stream Callback \n");
- g_print("\t 2. Set Audio Stream Callback \n");
- g_print("\t 3. Unset Stream Callback \n");
+ g_print("\t 2. Unset Video Stream Callback \n");
flush_stdin();
- scanf("%d", &index);
+ err = scanf("%d", &index);
if(index == 1) {
video_stream_cb_cnt = 0;
error_num = mm_camcorder_set_video_stream_callback(hcamcorder->camcorder, (mm_camcorder_video_stream_callback)camcordertest_video_stream_cb, (void*)hcamcorder->camcorder);
g_print("\n Setting Failure\n");
}
} else if(index == 2) {
- audio_stream_cb_cnt = 0;
- error_num = mm_camcorder_set_audio_stream_callback(hcamcorder->camcorder, (mm_camcorder_audio_stream_callback)camcordertest_audio_stream_cb, (void*)hcamcorder->camcorder);
- if( error_num == MM_ERROR_NONE ) {
- g_print("\n Setting Success\n");
- } else {
- g_print("\n Setting Failure\n");
- }
- } else if(index == 3) {
mm_camcorder_set_video_stream_callback(hcamcorder->camcorder, NULL, (void*)hcamcorder->camcorder);
- mm_camcorder_set_audio_stream_callback(hcamcorder->camcorder, NULL, (void*)hcamcorder->camcorder);
video_stream_cb_cnt = 0;
audio_stream_cb_cnt = 0;
g_print("\n Unset stream callback success\n");
} else {
g_print("\t Invalid input \n");
}
- //g_print("Not supported !! \n");
break;
- case 'b' : // back
+ case 'b' : // back
hcamcorder->menu_state = MENU_STATE_MAIN;
break;
g_print("\t Invalid input \n");
break;
}
- }
- else
- {
+ } else {
g_print("\t Invalid mode, back to upper menu \n");
hcamcorder->menu_state = MENU_STATE_MAIN;
}
*
* @return This function returns TRUE/FALSE
* @remark
- * @see
+ * @see
*/
static gboolean cmd_input(GIOChannel *channel)
{
int size;
int preview_format = MM_PIXEL_FORMAT_NV12;
MMHandleType cam_handle = 0;
-
+
char *err_attr_name = NULL;
if (!hcamcorder)
return FALSE;
-
+
if(!hcamcorder->camcorder)
return FALSE;
cam_handle = (MMHandleType)(hcamcorder->camcorder);
-
+
/*================================================================================
- image mode
+ Video capture mode
*=================================================================================*/
- if (type == MODE_IMAGE)
- {
+ if (type == MODE_VIDEO_CAPTURE) {
mm_camcorder_get_attributes((MMHandleType)cam_handle, NULL,
MMCAM_RECOMMEND_PREVIEW_FORMAT_FOR_CAPTURE, &preview_format,
NULL);
/* camcorder attribute setting */
err = mm_camcorder_set_attributes( (MMHandleType)cam_handle, &err_attr_name,
- MMCAM_MODE, MM_CAMCORDER_MODE_IMAGE,
+ MMCAM_MODE, MM_CAMCORDER_MODE_VIDEO_CAPTURE,
MMCAM_CAMERA_FORMAT, preview_format,
"camera-delay-attr-setting", TRUE,
MMCAM_IMAGE_ENCODER, MM_IMAGE_CODEC_JPEG,
MMCAM_DISPLAY_RECT_WIDTH, 480,
MMCAM_DISPLAY_RECT_HEIGHT, 640,
MMCAM_DISPLAY_ROTATION, MM_DISPLAY_ROTATION_270,
+ //MMCAM_DISPLAY_FLIP, MM_FLIP_HORIZONTAL,
MMCAM_DISPLAY_GEOMETRY_METHOD, MM_DISPLAY_METHOD_LETTER_BOX,
MMCAM_CAPTURE_COUNT, IMAGE_CAPTURE_COUNT_STILL,
"capture-thumbnail", TRUE,
"tag-gps-time-stamp", 72815.5436243543,
"tag-gps-date-stamp", "2010:09:20", 10,
"tag-gps-processing-method", "GPS NETWORK HYBRID ARE ALL FINE.", 32,
- "capture-sound-enable", TRUE,
- NULL );
-
- if (err != MM_ERROR_NONE) {
- warn_msg_t("Init fail. (%s:%x)", err_attr_name, err);
- SAFE_FREE (err_attr_name);
- goto ERROR;
- }
-
- mm_camcorder_set_video_capture_callback(hcamcorder->camcorder, (mm_camcorder_video_capture_callback)camcordertest_video_capture_cb, hcamcorder);
- }
- /*================================================================================
- video mode
- *=================================================================================*/
- else if (type == MODE_VIDEO)
- {
- mm_camcorder_get_attributes((MMHandleType)cam_handle, NULL,
- MMCAM_RECOMMEND_PREVIEW_FORMAT_FOR_RECORDING, &preview_format,
- NULL);
-
- size = strlen(TARGET_FILENAME_VIDEO)+1;
-
- /* camcorder attribute setting */
- err = mm_camcorder_set_attributes( (MMHandleType)cam_handle, &err_attr_name,
- MMCAM_MODE, MM_CAMCORDER_MODE_VIDEO,
MMCAM_AUDIO_DEVICE, MM_AUDIO_DEVICE_MIC,
- MMCAM_AUDIO_ENCODER, MM_AUDIO_CODEC_AMR,
- MMCAM_VIDEO_ENCODER, MM_VIDEO_CODEC_H264,
+ MMCAM_AUDIO_ENCODER, MM_AUDIO_CODEC_AAC,
+ MMCAM_VIDEO_ENCODER, MM_VIDEO_CODEC_MPEG4,
+ MMCAM_VIDEO_ENCODER_BITRATE, VIDEO_ENCODE_BITRATE,
MMCAM_FILE_FORMAT, MM_FILE_FORMAT_3GP,
- MMCAM_CAMERA_FORMAT, preview_format,
MMCAM_CAMERA_FPS, SRC_VIDEO_FRAME_RATE_30,
MMCAM_CAMERA_FPS_AUTO, 0,
- "camera-delay-attr-setting", TRUE,
MMCAM_CAMERA_ROTATION, MM_VIDEO_INPUT_ROTATION_NONE,
- MMCAM_AUDIO_SAMPLERATE, AUDIO_SOURCE_SAMPLERATE_AMR,
+ MMCAM_AUDIO_SAMPLERATE, AUDIO_SOURCE_SAMPLERATE_AAC,
MMCAM_AUDIO_FORMAT, AUDIO_SOURCE_FORMAT,
- MMCAM_AUDIO_CHANNEL, AUDIO_SOURCE_CHANNEL_AMR,
- MMCAM_AUDIO_INPUT_ROUTE, MM_AUDIOROUTE_CAPTURE_NORMAL,
- MMCAM_TAG_ENABLE, 1,
- MMCAM_TAG_LATITUDE, 37.25796666,
- MMCAM_TAG_LONGITUDE, 127.05332222,
- MMCAM_TAG_ALTITUDE, 45.0000,
- MMCAM_DISPLAY_DEVICE, MM_DISPLAY_DEVICE_MAINLCD,
- MMCAM_DISPLAY_SURFACE, MM_DISPLAY_SURFACE_X,
- MMCAM_DISPLAY_RECT_X, DISPLAY_X_0,
- MMCAM_DISPLAY_RECT_Y, DISPLAY_Y_0,
- MMCAM_DISPLAY_RECT_WIDTH, 480,
- MMCAM_DISPLAY_RECT_HEIGHT, 640,
- MMCAM_DISPLAY_ROTATION, MM_DISPLAY_ROTATION_270,
- MMCAM_TARGET_FILENAME, TARGET_FILENAME_VIDEO, size,
- "capture-sound-enable", TRUE,
+ MMCAM_AUDIO_CHANNEL, AUDIO_SOURCE_CHANNEL_AAC,
+ //MMCAM_AUDIO_DISABLE, TRUE,
+ MMCAM_TARGET_FILENAME, TARGET_FILENAME_VIDEO, strlen(TARGET_FILENAME_VIDEO),
+ //MMCAM_TARGET_TIME_LIMIT, 360000,
+#ifndef _TIZEN_PUBLIC_
+ //MMCAM_TARGET_MAX_SIZE, 102400,
+#endif /* _TIZEN_PUBLIC_ */
NULL );
if (err != MM_ERROR_NONE) {
- fprintf(stderr, "video mode init fail. [%s][%x)", err_attr_name, err);
+ warn_msg_t("Init fail. (%s:%x)", err_attr_name, err);
SAFE_FREE (err_attr_name);
goto ERROR;
}
-// mm_camcorder_set_audio_stream_callback(hcamcorder->camcorder, (mm_camcorder_audio_stream_callback)camcordertest_audio_stream_cb, (void*)hcamcorder->camcorder);
- }
+ mm_camcorder_set_video_capture_callback(hcamcorder->camcorder, (mm_camcorder_video_capture_callback)camcordertest_video_capture_cb, hcamcorder);
+ }
/*================================================================================
Audio mode
*=================================================================================*/
MMCAM_FILE_FORMAT, MM_FILE_FORMAT_AMR,
MMCAM_AUDIO_SAMPLERATE, AUDIO_SOURCE_SAMPLERATE_AMR,
MMCAM_AUDIO_FORMAT, AUDIO_SOURCE_FORMAT,
- MMCAM_AUDIO_CHANNEL, AUDIO_SOURCE_CHANNEL_AMR,
- MMCAM_AUDIO_INPUT_ROUTE, MM_AUDIOROUTE_CAPTURE_NORMAL,
+ MMCAM_AUDIO_CHANNEL, AUDIO_SOURCE_CHANNEL_AAC,
MMCAM_TARGET_FILENAME, TARGET_FILENAME_AUDIO, size,
MMCAM_TARGET_TIME_LIMIT, 360000,
+ MMCAM_AUDIO_ENCODER_BITRATE, 12200,
+#ifndef _TIZEN_PUBLIC_
+ MMCAM_TARGET_MAX_SIZE, 300,
+#endif /* _TIZEN_PUBLIC_ */
NULL);
- if (err < 0)
- {
+ if (err < 0) {
warn_msg_t("Init fail. (%s:%x)", err_attr_name, err);
SAFE_FREE (err_attr_name);
goto ERROR;
}
-// mm_camcorder_set_audio_stream_callback(hcamcorder->camcorder, (mm_camcorder_audio_stream_callback)camcordertest_audio_stream_cb, (void*)hcamcorder->camcorder);
+#ifdef USE_AUDIO_STREAM_CB
+ mm_camcorder_set_audio_stream_callback(hcamcorder->camcorder, (mm_camcorder_audio_stream_callback)camcordertest_audio_stream_cb, (void*)hcamcorder->camcorder);
+#endif /* USE_AUDIO_STREAM_CB */
}
debug_msg_t("Init DONE.");
break;
case MM_MESSAGE_CAMCORDER_CAPTURED:
- {
- if (hcamcorder->mode == MODE_IMAGE)
- {
- time_msg_t("Stillshot capture : %12.6lf s", g_timer_elapsed(timer, NULL));
-
- g_print("*******************************************************\n");
- g_print("[Camcorder Testsuite] Camcorder Stillshot Captured!!\n");
- g_print("*******************************************************\n");
-
- if (hcamcorder->isMultishot) //multishot
- {
- g_print("[CamcorderApp] Camcorder Captured(Capture Count=%d)\n", param->code);
-
- if (param->code >= multishot_num)
- {
- get_me_out();
-// g_timeout_add (100, (GSourceFunc)get_me_out, NULL);
-// hcamcorder->isMultishot = FALSE;
- }
- }
- else //singleshot
- {
+ time_msg_t("Stillshot capture : %12.6lf s", g_timer_elapsed(timer, NULL));
+ if (hcamcorder->isMultishot) {
+ //g_print("[CamcorderApp] Camcorder Captured(Capture Count=%d)\n", param->code);
+ if (param->code >= multishot_num) {
get_me_out();
-// g_timeout_add (1000, (GSourceFunc)get_me_out, NULL);
+// g_timeout_add (100, (GSourceFunc)get_me_out, NULL);
+// hcamcorder->isMultishot = FALSE;
}
-
+ } else {
+ get_me_out();
+// g_timeout_add (1000, (GSourceFunc)get_me_out, NULL);
}
- else
- {
- MMCamRecordingReport* report ;
-
- time_msg_t("Recording commit time : %12.6lf s", g_timer_elapsed(timer, NULL));
+ break;
+ case MM_MESSAGE_CAMCORDER_VIDEO_CAPTURED:
+ case MM_MESSAGE_CAMCORDER_AUDIO_CAPTURED:
+ {
+ MMCamRecordingReport* report ;
- if (param)
- report = (MMCamRecordingReport*)(param->data);
- else
- return FALSE;
+ time_msg_t("Recording commit time : %12.6lf s", g_timer_elapsed(timer, NULL));
- if( report != NULL )
- {
- g_print("*******************************************************\n");
- g_print("[Camcorder Testsuite] Camcorder Captured(filename=%s)\n", report->recording_filename);
- g_print("*******************************************************\n");
+ if (param) {
+ report = (MMCamRecordingReport*)(param->data);
+ } else {
+ return FALSE;
+ }
- SAFE_FREE (report->recording_filename);
- SAFE_FREE (report);
- }
- else
- {
- g_print( "[Camcorder Testsuite] report is NULL.\n" );
- }
+ if (report != NULL) {
+ g_print("*******************************************************\n");
+ g_print("[Camcorder Testsuite] Camcorder Captured(filename=%s)\n", report->recording_filename);
+ g_print("*******************************************************\n");
+
+ SAFE_FREE (report->recording_filename);
+ SAFE_FREE (report);
+ } else {
+ g_print( "[Camcorder Testsuite] report is NULL.\n" );
}
}
break;
break;
case MM_MESSAGE_CAMCORDER_RECORDING_STATUS:
{
- unsigned int elapsed;
+ unsigned long long elapsed;
elapsed = param->recording_status.elapsed / 1000;
if (hcamcorder->elapsed_time != elapsed) {
- unsigned int temp_time;
- int hour, minute, second;
+ unsigned long temp_time;
+ unsigned long long hour, minute, second;
hcamcorder->elapsed_time = elapsed;
temp_time = elapsed;
hour = temp_time / 3600;
temp_time = elapsed % 3600;
minute = temp_time / 60;
second = temp_time % 60;
- debug_msg_t("Current Time - %d:%d:%d", hour, minute, second);
+ debug_msg_t("Current Time - %lld:%lld:%lld, remained %lld ms, filesize %lld KB",
+ hour, minute, second, param->recording_status.remained_time, param->recording_status.filesize);
}
}
break;
g_print( "Focus State changed. State:[%d]\n", param->code );
}
break;
+ case MM_MESSAGE_CAMCORDER_FACE_DETECT_INFO:
+ {
+ static int info_count = 0;
+ MMCamFaceDetectInfo *cam_fd_info = NULL;
+
+ cam_fd_info = (MMCamFaceDetectInfo *)(param->data);
+
+ if (cam_fd_info) {
+ int i = 0;
+
+ g_print("\tface detect num %d, pointer %p\n", cam_fd_info->num_of_faces, cam_fd_info);
+
+ for (i = 0 ; i < cam_fd_info->num_of_faces ; i++) {
+ g_print("\t\t[%2d][score %d] position %d,%d %dx%d\n",
+ cam_fd_info->face_info[i].id,
+ cam_fd_info->face_info[i].score,
+ cam_fd_info->face_info[i].rect.x,
+ cam_fd_info->face_info[i].rect.y,
+ cam_fd_info->face_info[i].rect.width,
+ cam_fd_info->face_info[i].rect.height);
+ }
+
+ if (info_count == 0) {
+ mm_camcorder_set_attributes(hcamcorder->camcorder, NULL,
+ MMCAM_CAMERA_FACE_ZOOM_MODE, MM_CAMCORDER_FACE_ZOOM_MODE_ON,
+ MMCAM_CAMERA_FACE_ZOOM_X, cam_fd_info->face_info[0].rect.x + (cam_fd_info->face_info[0].rect.width>>1),
+ MMCAM_CAMERA_FACE_ZOOM_Y, cam_fd_info->face_info[0].rect.y + (cam_fd_info->face_info[0].rect.height>>1),
+ MMCAM_CAMERA_FACE_ZOOM_LEVEL, 0,
+ NULL);
+ info_count = 1;
+ g_print("\n\t##### START FACE ZOOM [%d,%d] #####\n", cam_fd_info->face_info[0].rect.x, cam_fd_info->face_info[0].rect.y);
+ } else if (info_count++ == 90) {
+ mm_camcorder_set_attributes(hcamcorder->camcorder, NULL,
+ MMCAM_CAMERA_FACE_ZOOM_MODE, MM_CAMCORDER_FACE_ZOOM_MODE_OFF,
+ NULL);
+ g_print("\n\t##### STOP FACE ZOOM #####\n");
+ info_count = -60;
+ }
+ }
+ }
+ break;
default:
g_print("Message %x received\n", message);
break;
static gboolean init_handle()
{
- hcamcorder->mode = MODE_IMAGE; /* image(capture)/video(recording) mode */
+ hcamcorder->mode = MODE_VIDEO_CAPTURE; /* image(capture)/video(recording) mode */
hcamcorder->isMultishot = FALSE;
- hcamcorder->stillshot_count = 0; /* total stillshot count */
- hcamcorder->multishot_count = 0; /* total multishot count */
- hcamcorder->stillshot_filename = STILL_CAPTURE_FILE_PATH_NAME; /* stored filename of stillshot */
- hcamcorder->multishot_filename = MULTI_CAPTURE_FILE_PATH_NAME; /* stored filename of multishot */
+ hcamcorder->stillshot_count = 0; /* total stillshot count */
+ hcamcorder->multishot_count = 0; /* total multishot count */
+ hcamcorder->stillshot_filename = STILL_CAPTURE_FILE_PATH_NAME; /* stored filename of stillshot */
+ hcamcorder->multishot_filename = MULTI_CAPTURE_FILE_PATH_NAME; /* stored filename of multishot */
hcamcorder->menu_state = MENU_STATE_MAIN;
- hcamcorder->isMute = FALSE;
+ hcamcorder->isMute = FALSE;
hcamcorder->elapsed_time = 0;
- hcamcorder->fps = SRC_VIDEO_FRAME_RATE_15; //SRC_VIDEO_FRAME_RATE_30;
+ hcamcorder->fps = SRC_VIDEO_FRAME_RATE_15; /*SRC_VIDEO_FRAME_RATE_30;*/
multishot_num = IMAGE_CAPTURE_COUNT_MULTI;
return TRUE;
static gboolean mode_change()
{
int err = MM_ERROR_NONE;
- int state;
+ int state = MM_CAMCORDER_STATE_NONE;
+ int name_size = 0;
+ int device_count = 0;
+ int facing_direction = 0;
char media_type = '\0';
+ char *evassink_name = NULL;
bool check= FALSE;
debug_msg_t("MMCamcorder State : %d", mmcamcorder_state);
g_print("\n\t=======================================\n");
g_print("\t MM_CAMCORDER_TESTSUIT\n");
g_print("\t=======================================\n");
- g_print("\t '1' Image Capture - Front Camera\n");
- g_print("\t '2' Image Capture - Rear Camera\n");
- g_print("\t '3' Video Recording - Front Camera\n");
- g_print("\t '4' Video Recording - Rear Camera\n");
- g_print("\t '5' Audio Recording\n");
+ g_print("\t '1' Video Capture - Front Camera\n");
+ g_print("\t '2' Video Capture - Rear Camera\n");
+ g_print("\t '3' Audio Recording\n");
g_print("\t 'q' Exit\n");
g_print("\t=======================================\n");
g_print("\t Enter the media type:\n\t");
- while ((media_type=getchar()) == '\n');
+ err = scanf("%c", &media_type);
- switch(media_type) {
- case '1':
- hcamcorder->mode= MODE_IMAGE;
- cam_info.videodev_type = MM_VIDEO_DEVICE_CAMERA1;
- check = TRUE;
- break;
- case '2':
- hcamcorder->mode= MODE_IMAGE;
- cam_info.videodev_type = MM_VIDEO_DEVICE_CAMERA0;
- check = TRUE;
- break;
- case '3':
- hcamcorder->mode= MODE_VIDEO;
- cam_info.videodev_type = MM_VIDEO_DEVICE_CAMERA1;
- check = TRUE;
- break;
- case '4':
- hcamcorder->mode= MODE_VIDEO;
- cam_info.videodev_type = MM_VIDEO_DEVICE_CAMERA0;
- check = TRUE;
- break;
- case '5':
- hcamcorder->mode= MODE_AUDIO;
- cam_info.videodev_type = MM_VIDEO_DEVICE_NONE;
- check = TRUE;
- break;
- case 'q':
- g_print("\t Quit Camcorder Testsuite!!\n");
- hcamcorder->mode = -1;
- if(g_main_loop_is_running(g_loop)) {
- g_main_loop_quit(g_loop);
- }
- return FALSE;
- default:
- g_print("\t Invalid media type(%d)\n", media_type);
- continue;
+ switch (media_type) {
+ case '1':
+ hcamcorder->mode= MODE_VIDEO_CAPTURE;
+ cam_info.videodev_type = MM_VIDEO_DEVICE_CAMERA1;
+ check = TRUE;
+ break;
+ case '2':
+ hcamcorder->mode= MODE_VIDEO_CAPTURE;
+ cam_info.videodev_type = MM_VIDEO_DEVICE_CAMERA0;
+ check = TRUE;
+ break;
+ case '3':
+ hcamcorder->mode= MODE_AUDIO;
+ cam_info.videodev_type = MM_VIDEO_DEVICE_NONE;
+ check = TRUE;
+ break;
+ case 'q':
+ g_print("\t Quit Camcorder Testsuite!!\n");
+ hcamcorder->mode = -1;
+ if(g_main_loop_is_running(g_loop)) {
+ g_main_loop_quit(g_loop);
+ }
+ return FALSE;
+ default:
+ g_print("\t Invalid media type(%d)\n", media_type);
+ continue;
}
}
-
+
debug_msg_t("mm_camcorder_create");
g_get_current_time(&previous);
g_timer_reset(timer);
mmcamcorder_state = MM_CAMCORDER_STATE_NULL;
}
+ /* get evassink name */
+ mm_camcorder_get_attributes(hcamcorder->camcorder, NULL,
+ MMCAM_DISPLAY_EVAS_SURFACE_SINK, &evassink_name, &name_size,
+ MMCAM_CAMERA_DEVICE_COUNT, &device_count,
+ MMCAM_CAMERA_FACING_DIRECTION, &facing_direction,
+ NULL);
+ debug_msg_t("evassink name[%s], device count[%d], facing direction[%d]",
+ evassink_name, device_count, facing_direction);
+
mm_camcorder_set_message_callback(hcamcorder->camcorder, (MMMessageCallback)msg_callback, hcamcorder);
if (!init(hcamcorder->mode)) {
projects / framework / multimedia / libmm-camcorder.git / commitdiff