--- /dev/null
+sahil bansal <sahil.bansal at samsung dot com>
+ruchika saxena <r.saxena at samsung dot com>
+hyuntae kim <ht1211.kim at samsung dot com>
+Jeongmo Yang <jm80.yang at samsung dot com>
+Heechul Jeon <heechul.jeon at samsung dot com>
--- /dev/null
+CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
+
+SET(Services
+ "application"
+ "base"
+ "content"
+ "location"
+ "media"
+ "messaging"
+ "network"
+ "social"
+ "telephony"
+ "system"
+ )
+
+# project
+SET(project_prefix "capi")
+SET(prefix "/usr")
+SET(maintainer "Sahil Bansal <sahil.bansal@samsung.com>")
+SET(description "A Stream Recorder library in Tizen Native API")
+SET(service "media")
+SET(submodule "streamrecorder")
+
+# for package file
+SET(dependents "dlog mm-streamrecorder capi-media-audio-io capi-media-tool")
+SET(pc_dependents "capi-base-common capi-media-audio-io capi-media-tool")
+
+SET(fw_name "${project_prefix}-${service}-${submodule}")
+
+PROJECT(${fw_name})
+
+SET(CMAKE_INSTALL_PREFIX ${prefix})
+SET(PREFIX ${CMAKE_INSTALL_PREFIX})
+
+SET(INC_DIR include)
+INCLUDE_DIRECTORIES(${INC_DIR})
+
+INCLUDE(FindPkgConfig)
+pkg_check_modules(${fw_name} REQUIRED ${dependents})
+FOREACH(flag ${${fw_name}_CFLAGS})
+ SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}")
+ENDFOREACH(flag)
+
+SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS} -fPIC -Wall -Wextra -Wno-array-bounds -Wno-empty-body -Wno-ignored-qualifiers -Wno-unused-parameter -Wshadow -Wwrite-strings -Wswitch-default -Wno-unused-but-set-parameter -Wno-unused-but-set-variable")
+SET(CMAKE_C_FLAGS_DEBUG "-O0 -g")
+
+IF("${ARCH}" STREQUAL "arm")
+ ADD_DEFINITIONS("-DTARGET")
+ENDIF("${ARCH}" STREQUAL "arm")
+
+ADD_DEFINITIONS("-DPREFIX=\"${CMAKE_INSTALL_PREFIX}\"")
+ADD_DEFINITIONS("-DTIZEN_DEBUG")
+
+SET(CMAKE_EXE_LINKER_FLAGS "-Wl,--as-needed -Wl,--rpath=${LIB_INSTALL_DIR}")
+
+aux_source_directory(src SOURCES)
+ADD_LIBRARY(${fw_name} SHARED ${SOURCES})
+
+SET_TARGET_PROPERTIES(${fw_name}
+ PROPERTIES
+ VERSION ${FULLVER}
+ SOVERSION ${MAJORVER}
+ CLEAN_DIRECT_OUTPUT 1
+)
+
+TARGET_LINK_LIBRARIES(${fw_name} ${${fw_name}_LDFLAGS})
+
+INSTALL(TARGETS ${fw_name} DESTINATION ${LIB_INSTALL_DIR})
+INSTALL(
+ DIRECTORY ${INC_DIR}/ DESTINATION include/${service}
+ FILES_MATCHING
+ PATTERN "*_private.h" EXCLUDE
+ PATTERN "${INC_DIR}/*.h"
+ )
+
+SET(PC_NAME ${fw_name})
+SET(PC_REQUIRED ${pc_dependents})
+SET(PC_LDFLAGS -l${fw_name})
+
+CONFIGURE_FILE(
+ ${fw_name}.pc.in
+ ${CMAKE_CURRENT_SOURCE_DIR}/${fw_name}.pc
+ @ONLY
+)
+INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/${fw_name}.pc DESTINATION ${LIB_INSTALL_DIR}/pkgconfig)
+
+ADD_SUBDIRECTORY(test)
+
+IF(UNIX)
+
+ADD_CUSTOM_TARGET (distclean @echo cleaning for source distribution)
+ADD_CUSTOM_COMMAND(
+ DEPENDS clean
+ COMMENT "distribution clean"
+ COMMAND find
+ ARGS .
+ -not -name config.cmake -and \(
+ -name tester.c -or
+ -name Testing -or
+ -name CMakeFiles -or
+ -name cmake.depends -or
+ -name cmake.check_depends -or
+ -name CMakeCache.txt -or
+ -name cmake.check_cache -or
+ -name *.cmake -or
+ -name Makefile -or
+ -name core -or
+ -name core.* -or
+ -name gmon.out -or
+ -name install_manifest.txt -or
+ -name *.pc -or
+ -name *~ \)
+ | grep -v TC | xargs rm -rf
+ TARGET distclean
+ VERBATIM
+)
+
+ENDIF(UNIX)
--- /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.
--- /dev/null
+<manifest>
+ <request>
+ <domain name="_" />
+ </request>
+</manifest>
--- /dev/null
+
+# Package Information for pkg-config
+
+prefix=@PREFIX@
+exec_prefix=/usr
+libdir=@LIB_INSTALL_DIR@
+includedir=/usr/include/media
+
+Name: @PC_NAME@
+Description: @PACKAGE_DESCRIPTION@
+Version: @VERSION@
+Requires: @PC_REQUIRED@
+Libs: -L${libdir} @PC_LDFLAGS@
+Cflags: -I${includedir}
+
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+#ifndef __TIZEN_MEDIA_STREAMRECORDER_DOC_H__
+#define __TIZEN_MEDIA_STREAMRECORDER_DOC_H__
+
+
+/**
+ * @file streamrecorder_doc.h
+ * @brief The file contains the high level documentation for the StreamRecorder API.
+ */
+
+/**
+ * @ingroup CAPI_MEDIA_FRAMEWORK
+ * @defgroup CAPI_MEDIA_STREAMRECORDER_MODULE StreamRecorder
+ * @brief The @ref CAPI_MEDIA_STREAMRECORDER_MODULE API provides functions for StreamRecorder with buffer including media packet.
+ *
+ * @section CAPI_MEDIA_STREAMRECORDER_MODULE_HEADER Required Header
+ * \#include <streamrecorder.h>
+ *
+ * @section CAPI_MEDIA_STREAMRECORDER_MODULE_OVERVIEW Overview
+ * The StreamRecorder API allows application developers to support using the video or audio recorder. It includes functions that record video or audio and supports to set up
+ * notifications for state changes of creation, prepared, record, pause, information about resolution and binary data format, and functions for artistic.
+ *
+ * The StreamRecorder API allows creation of components required in recording video or audio including:
+ * - selecting a proper output format
+ * - controlling the StreamRecorder state
+ * - getting supported formats and video resolutions
+ *
+ * The StreamRecorder API also notifies you (by callback mechanism) when a significant parameter changes.
+ *
+ * @subsection CAPI_MEDIA_STREAMRECORDER_DIFFERENCE Difference
+ * Basically, the StreamRecorder API can help easily to make video/audio content same as the Recorder API.\n
+ *
+ * However, the StreamRecorder API is different from Recorder API. \n
+ * The StreamRecorder API is able to record user buffer from application. This allows the user to make unique contents with a purpose.
+ *
+ * <div><table class="doxtable" >
+ * <tr>
+ * <th><b>Difference </b></th>
+ * <th><b>Recorder</b></th>
+ * <th><b>StreamRecorder</b></th>
+ * </tr>
+ * <tr>
+ * <td> INPUT </td>
+ * <td> Camera / Mic Device </td>
+ * <td> Media Packet / Buffer </td>
+ * </tr>
+ * </table></div>
+ *
+ * @subsection CAPI_MEDIA_STREAMRECORDER_LIFE_CYCLE_STATE_DIAGRAM State Diagram
+ * @image html capi_media_streamrecorder_state_diagram.png
+ *
+ * @subsection CAPI_MEDIA_STREAMRECORDER_LIFE_CYCLE_STATE_TRANSITIONS State Transitions
+ * <div><table class="doxtable" >
+ * <tr>
+ * <th><b>FUNCTION</b></th>
+ * <th><b>PRE-STATE</b></th>
+ * <th><b>POST-STATE</b></th>
+ * <th><b>SYNC TYPE</b></th>
+ * </tr>
+ * <tr>
+ * <td> streamrecorder_create() </td>
+ * <td> NONE </td>
+ * <td> CREATED </td>
+ * <td> SYNC </td>
+ * </tr>
+ * <tr>
+ * <td> streamrecorder_prepare() </td>
+ * <td> CREATED </td>
+ * <td> PREPARED </td>
+ * <td> SYNC </td>
+ * </tr>
+ * <tr>
+ * <td> streamrecorder_start() </td>
+ * <td> PREPARED / PAUSED </td>
+ * <td> RECORDING </td>
+ * <td> SYNC </td>
+ * </tr>
+ * <tr>
+ * <td> streamrecorder_pause() </td>
+ * <td> RECORDING </td>
+ * <td> PAUSED </td>
+ * <td> SYNC </td>
+ * </tr>
+ * <tr>
+ * <td> streamrecorder_commit() </td>
+ * <td> RECORDING/ PAUSED </td>
+ * <td> PREPARED </td>
+ * <td> SYNC </td>
+ * </tr>
+ * <tr>
+ * <td> streamrecorder_cancel() </td>
+ * <td> RECORDING/ PAUSED </td>
+ * <td> PREPARED </td>
+ * <td> SYNC </td>
+ * </tr>
+ * <tr>
+ * <td> streamrecorder_unprepare() </td>
+ * <td> PREPARED </td>
+ * <td> CREATED </td>
+ * <td> SYNC </td>
+ * </tr>
+ * <tr>
+ * <td> streamrecorder_destroy() </td>
+ * <td> CREATED </td>
+ * <td> NONE </td>
+ * <td> SYNC </td>
+ * </tr>
+ * </table></div>
+ *
+ * @subsection CAPI_MEDIA_STREAMRECORDER_LIFE_CYCLE_CALLBACK_OPERATIONS Callback(Event) Operations
+ * The callback mechanism is used to notify the application about significant StreamRecorder events.
+ * <div><table class="doxtable" >
+ * <tr>
+ * <th><b>REGISTER</b></th>
+ * <th><b>UNREGISTER</b></th>
+ * <th><b>CALLBACK</b></th>
+ * <th><b>DESCRIPTION</b></th>
+ * </tr>
+ * <tr>
+ * <td>streamrecorder_set_error_cb()</td>
+ * <td>streamrecorder_unset_error_cb()</td>
+ * <td>streamrecorder_error_cb()</td>
+ * <td>This callback is used to notify error has occurred</td>
+ * </tr>
+ *</table></div>
+ *
+ * @subsection CAPI_MEDIA_STREAMRECORDER_FOREACH_OPERATIONS Foreach Operations
+ * <div><table class="doxtable" >
+ * <tr>
+ * <th><b>FOREACH</b></th>
+ * <th><b>CALLBACK</b></th>
+ * <th><b>DESCRIPTION</b></th>
+ * </tr>
+ * <tr>
+ * <td>streamrecorder_foreach_supported_audio_encoder()</td>
+ * <td>streamrecorder_supported_audio_encoder_cb()</td>
+ * <td>Supported audio encoders</td>
+ * </tr>
+ * <tr>
+ * <td>streamrecorder_foreach_supported_video_encoder()</td>
+ * <td>streamrecorder_supported_video_encoder_cb()</td>
+ * <td>Supported video encoders</td>
+ * </tr>
+ * <tr>
+ * <td>streamrecorder_foreach_supported_file_format()</td>
+ * <td>streamrecorder_supported_file_format_cb()</td>
+ * <td>Supported file formats</td>
+ * </tr>
+ * <tr>
+ * <td>streamrecorder_foreach_supported_video_resolution()</td>
+ * <td>streamrecorder_supported_video_resolution_cb()</td>
+ * <td>Supported video resolutions</td>
+ * </tr>
+ *</table></div>
+ *
+ */
+
+
+/**
+ * @defgroup CAPI_MEDIA_STREAMRECORDER_ATTRIBUTES_MODULE Attributes
+ * @brief The @ref CAPI_MEDIA_STREAMRECORDER_ATTRIBUTES_MODULE API provides functions to fetch StreamRecorder attributes.
+ * @ingroup CAPI_MEDIA_STREAMRECORDER_MODULE
+ *
+ * @section CAPI_MEDIA_STREAMRECORDER_ATTRIBUTES_MODULE_HEADER Required Header
+ * \#include <streamrecorder.h>
+ *
+ * @section CAPI_MEDIA_STREAMRECORDER_ATTRIBUTES_MODULE_OVERVIEW Overview
+ * The StreamRecorder Attributes API provides functions to get/set basic StreamRecorder attributes.
+ *
+ * With the StreamRecorder Attributes API you are able to set and get StreamRecorder attributes like:
+ * <ul>
+ * <li>File name</li>
+ * <li>File format</li>
+ * <li>Audio encoder</li>
+ * <li>Video encoder</li>
+ * <li>Recording size limit</li>
+ * <li>Recording time limit</li>
+ * <li>Audio samplerate</li>
+ * <li>Audio encoder bitrate</li>
+ * <li>Video encoder bitrate</li>
+ * <li>Audio channel</li>
+ * </ul>
+ *
+ */
+
+/**
+ * @defgroup CAPI_MEDIA_STREAMRECORDER_CALLBACK_MODULE Callback
+ * @brief The @ref CAPI_MEDIA_STREAMRECORDER_CALLBACK_MODULE API Callbacks from the StreamRecorder frameworks.
+ * @ingroup CAPI_MEDIA_STREAMRECORDER_MODULE
+ *
+ * @section CAPI_MEDIA_STREAMRECORDER_CALLBACK_MODULE_HEADER Required Header
+ * \#include <streamrecorder.h>
+ *
+ * @section CAPI_MEDIA_STREAMRECORDER_CALLBACK_MODULE_OVERVIEW Overview
+ * The StreamRecorder Callback API provides functions status.
+ *
+ */
+
+/**
+ * @ingroup CAPI_MEDIA_STREAMRECORDER_MODULE
+ * @defgroup CAPI_MEDIA_STREAMRECORDER_CAPABILITY_MODULE Capability
+ * @brief The @ref CAPI_MEDIA_STREAMRECORDER_CAPABILITY_MODULE API provides capability information of the StreamRecorder.
+ * @section CAPI_MEDIA_STREAMRECORDER_CAPABILITY_MODULE_HEADER Required Header
+ * \#include <streamrecorder.h>
+ *
+ * @section CAPI_MEDIA_STREAMRECORDER_CAPABILITY_MODULE_OVERVIEW Overview
+ * The StreamRecorder Capability API provides functions to obtain capability information of the StreamRecorder.
+ *
+ */
+
+#endif /* __TIZEN_MEDIA_STREAMRECORDER_DOC_H__ */
+
+
--- /dev/null
+/*
+* Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+#ifndef __TIZEN_MEDIA_STREAMRECORDER_H__
+#define __TIZEN_MEDIA_STREAMRECORDER_H__
+
+#include <tizen.h>
+#include <media_packet.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @file streamrecorder.h
+ * @brief This file contains the Streamrecorder API, related structures and enumerations.
+ * @since_tizen 3.0
+ */
+
+/**
+ * @addtogroup CAPI_MEDIA_STREAMRECORDER_MODULE
+ * @{
+ */
+
+#ifndef TIZEN_ERROR_STREAMRECORDER
+#define TIZEN_ERROR_STREAMRECORDER -0x01B0000
+#endif /* TIZEN_ERROR_STREAMRECORDER */
+
+/**
+ * @brief The Streamrecorder handle.
+ * @since_tizen 3.0
+ */
+typedef struct streamrecorder_s *streamrecorder_h;
+
+/**
+ * @brief Enumeration for the source type.
+ * @since_tizen 3.0
+ */
+typedef enum {
+ STREAMRECORDER_SOURCE_VIDEO, /**< Video only */
+ STREAMRECORDER_SOURCE_AUDIO, /**< Audio only */
+ STREAMRECORDER_SOURCE_VIDEO_AUDIO, /**< Video and Audio */
+} streamrecorder_source_e;
+
+/**
+ * @brief Enumeration for the pixel format.
+ * @since_tizen 3.0
+ */
+typedef enum {
+ STREAMRECORDER_VIDEO_SOURCE_FORMAT_INVALID = -1, /**< Invalid pixel format */
+ STREAMRECORDER_VIDEO_SOURCE_FORMAT_NV12, /**< NV12 pixel format */
+ STREAMRECORDER_VIDEO_SOURCE_FORMAT_NV21, /**< NV12 pixel format */
+ STREAMRECORDER_VIDEO_SOURCE_FORMAT_I420, /**< I420 pixel format */
+ STREAMRECORDER_VIDEO_SOURCE_FORMAT_NUM /**< Number of the video source format */
+} streamrecorder_video_source_format_e;
+
+/**
+ * @brief Enumeration for the file container format.
+ * @since_tizen 3.0
+ */
+typedef enum {
+ STREAMRECORDER_FILE_FORMAT_3GP, /**< 3GP file format */
+ STREAMRECORDER_FILE_FORMAT_MP4, /**< MP4 file format */
+ STREAMRECORDER_FILE_FORMAT_AMR, /**< AMR file format */
+ STREAMRECORDER_FILE_FORMAT_ADTS, /**< ADTS file format */
+ STREAMRECORDER_FILE_FORMAT_WAV, /**< WAV file format */
+} streamrecorder_file_format_e;
+
+/**
+ * @brief Enumeration for the audio codec.
+ * @since_tizen 3.0
+ */
+typedef enum {
+ STREAMRECORDER_AUDIO_CODEC_AMR = 0, /**< AMR codec */
+ STREAMRECORDER_AUDIO_CODEC_AAC, /**< AAC codec */
+ STREAMRECORDER_AUDIO_CODEC_PCM /**< PCM codec */
+} streamrecorder_audio_codec_e;
+
+/**
+ * @brief Enumeration for the video codec.
+ * @since_tizen 3.0
+ */
+typedef enum {
+ STREAMRECORDER_VIDEO_CODEC_H263, /**< H263 codec */
+ STREAMRECORDER_VIDEO_CODEC_MPEG4, /**< MPEG4 codec */
+} streamrecorder_video_codec_e;
+
+/**
+ * @brief Enumeration for the recording limit reached.
+ * @since_tizen 3.0
+ */
+typedef enum {
+ STREAMRECORDER_RECORDING_LIMIT_TYPE_TIME, /**< Time limit (second) of recording file */
+ STREAMRECORDER_RECORDING_LIMIT_TYPE_SIZE, /**< Size limit (kilo bytes [KB]) of recording file */
+} streamrecorder_recording_limit_type_e;
+
+/**
+ * @brief Enumeration for Streamrecorder error type.
+ * @since_tizen 3.0
+ */
+typedef enum {
+ STREAMRECORDER_ERROR_NONE = TIZEN_ERROR_NONE, /**< Successful */
+ STREAMRECORDER_ERROR_INVALID_PARAMETER = TIZEN_ERROR_INVALID_PARAMETER, /**< Invalid parameter */
+ STREAMRECORDER_ERROR_INVALID_STATE = TIZEN_ERROR_STREAMRECORDER | 0x01, /**< Invalid state */
+ STREAMRECORDER_ERROR_OUT_OF_MEMORY = TIZEN_ERROR_OUT_OF_MEMORY , /**< Out of memory */
+ STREAMRECORDER_ERROR_INVALID_OPERATION = TIZEN_ERROR_INVALID_OPERATION, /**< Internal error */
+ STREAMRECORDER_ERROR_OUT_OF_STORAGE = TIZEN_ERROR_STREAMRECORDER | 0x02, /**< Out of storage */
+ STREAMRECORDER_ERROR_PERMISSION_DENIED = TIZEN_ERROR_PERMISSION_DENIED, /**< The access to the resources can not be granted */
+ STREAMRECORDER_ERROR_NOT_SUPPORTED = TIZEN_ERROR_NOT_SUPPORTED, /**< The feature is not supported */
+} streamrecorder_error_e;
+
+/**
+ * @brief Enumeration for the Streamrecorder notification.
+ * @since_tizen 3.0
+ */
+typedef enum {
+ STREAMRECORDER_NOTIFY_NONE = 0, /**< None */
+ STREAMRECORDER_NOTIFY_STATE_CHANGED, /**< The notification of normal state changes */
+} streamrecorder_notify_e;
+
+/**
+ * @brief Enumeration for Streamrecorder states.
+ * @since_tizen 3.0
+ */
+typedef enum {
+ STREAMRECORDER_STATE_NONE, /**< StreamRecorder is not created */
+ STREAMRECORDER_STATE_CREATED, /**< StreamRecorder is created, but not prepared */
+ STREAMRECORDER_STATE_PREPARED, /**< StreamRecorder is prepared to record */
+ STREAMRECORDER_STATE_RECORDING, /**< StreamRecorder is recording media */
+ STREAMRECORDER_STATE_PAUSED, /**< StreamRecorder is paused while recording media */
+} streamrecorder_state_e;
+
+/**
+ * @}
+ */
+
+/**
+ * @addtogroup CAPI_MEDIA_STREAMRECORDER_CALLBACK_MODULE
+ * @{
+ */
+
+/**
+ * @brief Called when limitation error occurs while recording.
+ * @details The callback function is possible to receive three types of limits: time and size.
+ * @since_tizen 3.0
+ * @remarks After being called, recording data except present recorded data will be discarded and not written in the recording file. Also the state of streamrecorder is not changed.
+ * @param[in] type The imitation type
+ * @param[in] user_data The user data passed from the callback registration function
+ * @pre You have to register a callback using streamrecorder_set_recording_limit_reached_cb().
+ * @see streamrecorder_set_recording_status_cb()
+ * @see streamrecorder_set_recording_limit_reached_cb()
+ * @see streamrecorder_unset_recording_limit_reached_cb()
+ */
+typedef void (*streamrecorder_recording_limit_reached_cb)(streamrecorder_recording_limit_type_e type, void *user_data);
+
+/**
+ * @brief Called to indicate the recording status.
+ * @since_tizen 3.0
+ * @remarks This callback function is repeatedly invoked during the #STREAMRECORDER_STATE_RECORDING state.
+ * @param[in] elapsed_time The time of the recording (milliseconds)
+ * @param[in] file_size The size of the recording file (KB)
+ * @param[in] user_data The user data passed from the callback registration function
+ * @pre streamrecorder_start() will invoke this callback if you register it using streamrecorder_set_recording_status_cb().
+ * @see streamrecorder_set_recording_status_cb()
+ * @see streamrecorder_unset_recording_status_cb()
+ * @see streamrecorder_start()
+ */
+typedef void (*streamrecorder_recording_status_cb)(unsigned long long elapsed_time, unsigned long long file_size, void *user_data);
+
+/**
+ * @brief Called when the streamrecorder gets some nofications.
+ * @since_tizen 3.0
+ * @param[in] previous The previous state of the streamrecorder
+ * @param[in] current The current state of the streamrecorder
+ * @param[in] notification The notification type of the srecorder
+ * @param[in] user_data The user data passed from the callback registration function
+ * @pre This function is required to register a callback using streamrecorder_set_notify_cb().
+ * @see streamrecorder_set_notify_cb()
+ * @see streamrecorder_prepare()
+ * @see streamrecorder_unprepare()
+ * @see streamrecorder_start()
+ * @see streamrecorder_pause()
+ * @see streamrecorder_commit()
+ * @see streamrecorder_cancel()
+ */
+typedef void (*streamrecorder_notify_cb)(streamrecorder_state_e previous, streamrecorder_state_e current, streamrecorder_notify_e notification, void *user_data);
+
+/**
+ * @brief Called when the error occurred.
+ * @since_tizen 3.0
+ * @remarks This callback informs about the critical error situation. \n
+ * When being invoked, user should release the resource and terminate the application. \n
+ * This error code will be reported. \n
+ * #STREAMRECORDER_ERROR_INVALID_OPERATION \n
+ * #STREAMRECORDER_ERROR_OUT_OF_MEMORY
+ * @param[in] error The error code
+ * @param[in] current_state The current state of the streamrecorder
+ * @param[in] user_data The user data passed from the callback registration function
+ * @pre This callback function is invoked if you register this callback using streamrecorder_set_error_cb().
+ * @see streamrecorder_set_error_cb()
+ * @see streamrecorder_unset_error_cb()
+ */
+typedef void (*streamrecorder_error_cb)(streamrecorder_error_e error, streamrecorder_state_e current_state, void *user_data);
+
+/**
+ * @brief Called iteratively to notify about the buffer has been consumed
+ * @since_tizen 3.0
+ * @remarks The user needs to release consumed buffer if buffer is allocated by user including media packet
+ * @param[in] buffer The consumed buffer that user pushed
+ * @param[in] user_data The user data passed
+ * @see streamrecorder_set_buffer_consume_completed_cb() will invoke this callback.
+ * @see streamrecorder_unset_buffer_consume_completed_cb()
+ */
+typedef void (*streamrecorder_consume_completed_cb)(void *buffer, void *user_data);
+
+/**
+ * @}
+ */
+
+/**
+ * @addtogroup CAPI_MEDIA_STREAMRECORDER_CAPABILITY_MODULE
+ * @{
+ */
+
+/**
+ * @brief Called once for each supported video resolution.
+ * @since_tizen 3.0
+ * @param[in] width The video image width
+ * @param[in] height The video image height
+ * @param[in] user_data The user data passed from the foreach function
+ * @return @c true to continue with the next iteration of the loop, \n otherwise @c false to break out of the loop
+ * @pre streamrecorder_foreach_supported_video_resolution() will invoke this callback.
+ * @see streamrecorder_foreach_supported_video_resolution()
+ */
+typedef bool (*streamrecorder_supported_video_resolution_cb)(int width, int height, void *user_data);
+
+/**
+ * @brief Called iteratively to notify about the supported file formats.
+ * @since_tizen 3.0
+ * @param[in] format The format of recording files
+ * @param[in] user_data The user data passed from the foreach function
+ * @return @c true to continue with the next iteration of the loop, \n otherwise @c false to break out of the loop
+ * @pre streamrecorder_foreach_supported_file_format() will invoke this callback.
+ * @see streamrecorder_foreach_supported_file_format()
+ */
+typedef bool (*streamrecorder_supported_file_format_cb)(streamrecorder_file_format_e format, void *user_data);
+
+/**
+ * @brief Called iteratively to notify about the supported audio encoders.
+ * @since_tizen 3.0
+ * @param[in] codec The codec of audio encoder
+ * @param[in] user_data The user data passed from the foreach function
+ * @return @c true to continue with the next iteration of the loop, \n otherwise @c false to break out of the loop
+ * @pre streamrecorder_foreach_supported_audio_encoder() will invoke this callback.
+ * @see streamrecorder_foreach_supported_audio_encoder()
+ */
+typedef bool (*streamrecorder_supported_audio_encoder_cb)(streamrecorder_audio_codec_e codec, void *user_data);
+
+/**
+ * @brief Called iteratively to notify about the supported video encoders.
+ * @since_tizen 3.0
+ * @param[in] codec The codec of video encoder
+ * @param[in] user_data The user data passed from the foreach function
+ * @return @c true to continue with the next iteration of the loop, \n otherwise @c false to break out of the loop
+ * @pre streamrecorder_foreach_supported_video_encoder() will invoke this callback.
+ * @see streamrecorder_foreach_supported_video_encoder()
+ */
+typedef bool (*streamrecorder_supported_video_encoder_cb)(streamrecorder_video_codec_e codec, void *user_data);
+
+/**
+ * @}
+ */
+
+/**
+ * @addtogroup CAPI_MEDIA_STREAMRECORDER_MODULE
+ * @{
+ */
+
+/**
+ * @brief Creates a streamrecorder handle to record a video or audio
+ * @since_tizen 3.0
+ * @remarks You must release @a recorder using streamrecorder_destroy().
+ * @param[out] recorder A handle to the streamrecorder
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #STREAMRECORDER_ERROR_NONE Successful
+ * @retval #STREAMRECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #STREAMRECORDER_ERROR_OUT_OF_MEMORY Out of memory
+ * @retval #STREAMRECORDER_ERROR_INVALID_OPERATION Invalid operation
+ */
+int streamrecorder_create(streamrecorder_h *recorder);
+
+/**
+ * @brief Destroys the streamrecorder handle
+ * @since_tizen 3.0
+ * @param[in] recorder The handle to the streamrecorder
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #STREAMRECORDER_ERROR_NONE Successful
+ * @retval #STREAMRECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #STREAMRECORDER_ERROR_INVALID_OPERATION Invalid operation
+ * @retval #STREAMRECORDER_ERROR_INVALID_STATE Invalid state
+ * @pre The recorder state should be #STREAMRECORDER_STATE_CREATED.
+ * @post The recorder state will be #STREAMRECORDER_STATE_NONE.
+ */
+int streamrecorder_destroy(streamrecorder_h recorder);
+
+/**
+ * @brief Prepares the streamrecorder for recording.
+ * @since_tizen 3.0
+ * @remarks Before calling the function, it is required to properly set streamrecorder_enable_source_buffer(),
+ * audio encoder (streamrecorder_set_audio_encoder()),
+ * video encoder(streamrecorder_set_video_encoder()) and file format (streamrecorder_set_file_format()).
+ * @param[in] recorder The handle to the streamrecorder
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #STREAMRECORDER_ERROR_NONE Successful
+ * @retval #STREAMRECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #STREAMRECORDER_ERROR_INVALID_OPERATION Invalid operation
+ * @retval #STREAMRECORDER_ERROR_INVALID_STATE Invalid state
+ * @pre The recorder state should be #STREAMRECORDER_STATE_CREATED. \n
+ * The streamrecorder_enable_source_buffer() should be invoked before this function.
+ * @post The streamrecorder state will be #STREAMRECORDER_STATE_PREPARED
+ * @see streamrecorder_unprepare()
+ * @see streamrecorder_set_audio_encoder()
+ * @see streamrecorder_set_video_encoder()
+ * @see streamrecorder_set_file_format()
+ */
+int streamrecorder_prepare(streamrecorder_h recorder);
+
+/**
+ * @brief Resets the streamrecorder.
+ * @since_tizen 3.0
+ * @param[in] recorder The handle to the streamrecorder
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #STREAMRECORDER_ERROR_NONE Successful
+ * @retval #STREAMRECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #STREAMRECORDER_ERROR_INVALID_OPERATION Invalid operation
+ * @retval #STREAMRECORDER_ERROR_INVALID_STATE Invalid state
+ * @pre The streamrecorder state should be #STREAMRECORDER_STATE_PREPARED set by streamrecorder_prepare(), streamrecorder_cancel() or streamrecorder_commit().
+ * @post The streamrecorder state will be #STREAMRECORDER_STATE_CREATED.
+ * @see streamrecorder_prepare()
+ * @see streamrecorder_cancel()
+ * @see streamrecorder_commit()
+ */
+int streamrecorder_unprepare(streamrecorder_h recorder);
+
+/**
+ * @brief Starts the recording.
+ * @since_tizen 3.0
+ * @remarks If file path has been set to an existing file, this file is removed automatically and updated by new one. \n
+ * When you want to record audio or video file, you need to add privilege according to rules below additionally. \n
+ * http://tizen.org/privilege/mediastorage is needed if input or output path are relevant to media storage.\n
+ * http://tizen.org/privilege/externalstorage is needed if input or output path are relevant to external storage.
+ * The filename should be set before this function is invoked.
+ * @param[in] recorder The handle to the streamrecorder
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #STREAMRECORDER_ERROR_NONE Successful
+ * @retval #STREAMRECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #STREAMRECORDER_ERROR_INVALID_OPERATION Invalid operation
+ * @retval #STREAMRECORDER_ERROR_INVALID_STATE Invalid state
+ * @retval #STREAMRECORDER_ERROR_PERMISSION_DENIED The access to the resources can not be granted
+ * @pre The streamrecorder state must be #STREAMRECORDER_STATE_PREPARED by streamrecorder_prepare() or #STREAMRECORDER_STATE_PAUSED by streamrecorder_pause(). \n
+ * The filename should be set by streamrecorder_set_filename().
+ * @post The recorder state will be #STREAMRECORDER_STATE_RECORDING.
+ * @see streamrecorder_pause()
+ * @see streamrecorder_commit()
+ * @see streamrecorder_cancel()
+ * @see streamrecorder_set_audio_encoder()
+ * @see streamrecorder_set_filename()
+ * @see streamrecorder_set_file_format()
+ * @see streamrecorder_recording_status_cb()
+ * @see streamrecorder_set_filename()
+ */
+int streamrecorder_start(streamrecorder_h recorder);
+
+/**
+ * @brief Pauses the recording.
+ * @since_tizen 3.0
+ * @remarks Recording can be resumed with streamrecorder_start().
+ * @param[in] recorder The handle to the streamrecorder
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #STREAMRECORDER_ERROR_NONE Successful
+ * @retval #STREAMRECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #STREAMRECORDER_ERROR_INVALID_OPERATION Invalid operation
+ * @retval #STREAMRECORDER_ERROR_INVALID_STATE Invalid state
+ * @pre The streamrecorder state must be #STREAMRECORDER_STATE_RECORDING.
+ * @post The streamrecorder state will be #STREAMRECORDER_STATE_PAUSED.
+ * @see streamrecorder_pause()
+ * @see streamrecorder_commit()
+ * @see streamrecorder_cancel()
+ */
+int streamrecorder_pause(streamrecorder_h recorder);
+
+/**
+ * @brief Stops recording and saves the result.
+ * @since_tizen 3.0
+ * @remarks When you want to record audio or video file, you need to add privilege according to rules below additionally. \n
+ * http://tizen.org/privilege/mediastorage is needed if input or output path are relevant to media storage.\n
+ * http://tizen.org/privilege/externalstorage is needed if input or output path are relevant to external storage.
+ * @param[in] recorder The handle to the streamrecorder
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #STREAMRECORDER_ERROR_NONE Successful
+ * @retval #STREAMRECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #STREAMRECORDER_ERROR_INVALID_OPERATION Invalid operation
+ * @retval #STREAMRECORDER_ERROR_INVALID_STATE Invalid state
+ * @retval #STREAMRECORDER_ERROR_PERMISSION_DENIED The access to the resources can not be granted
+ * @pre The streamrecorder state must be #STREAMRECORDER_STATE_RECORDING set by streamrecorder_start() or #STREAMRECORDER_STATE_PAUSED by streamrecorder_pause().
+ * @post The streamrecorder state will be #STREAMRECORDER_STATE_PREPARED.
+ * @see streamrecorder_pause()
+ * @see streamrecorder_cancel()
+ * @see streamrecorder_set_filename()
+ * @see streamrecorder_start()
+ */
+int streamrecorder_commit(streamrecorder_h recorder);
+
+/**
+ * @brief Cancels the recording.
+ * @details The recording data is discarded and not written in the recording file.
+ * @since_tizen 3.0
+ * @remarks When you want to record audio or video file, you need to add privilege according to rules below additionally. \n
+ * http://tizen.org/privilege/mediastorage is needed if input or output path are relevant to media storage.\n
+ * http://tizen.org/privilege/externalstorage is needed if input or output path are relevant to external storage.
+ * @param[in] recorder The handle to the streamrecorder
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #STREAMRECORDER_ERROR_NONE Successful
+ * @retval #STREAMRECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #STREAMRECORDER_ERROR_INVALID_OPERATION Invalid operation
+ * @retval #STREAMRECORDER_ERROR_INVALID_STATE Invalid state
+ * @retval #STREAMRECORDER_ERROR_PERMISSION_DENIED The access to the resources can not be granted
+ * @pre The streamrecorder state must be #STREAMRECORDER_STATE_RECORDING set by streamrecorder_start() or #STREAMRECORDER_STATE_PAUSED by streamrecorder_pause().
+ * @post The streamrecorder state will be #STREAMRECORDER_STATE_PREPARED.
+ * @see streamrecorder_pause()
+ * @see streamrecorder_commit()
+ * @see streamrecorder_cancel()
+ * @see streamrecorder_start()
+ */
+int streamrecorder_cancel(streamrecorder_h recorder);
+
+/**
+ * @brief Pushes buffer to StreamRecorder to record audio/video
+ * @since_tizen 3.0
+ * @remarks When you want to record audio or video file, you need to add privilege according to rules below additionally. \n
+ * http://tizen.org/privilege/mediastorage is needed if input or output path are relevant to media storage.\n
+ * http://tizen.org/privilege/externalstorage is needed if input or output path are relevant to external storage.
+ * @param[in] recorder The handle to the streamrecorder
+ * @param[in] inbuf The media packet containing buffer and other associated values
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #STREAMRECORDER_ERROR_NONE Successful
+ * @retval #STREAMRECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #STREAMRECORDER_ERROR_PERMISSION_DENIED The access to the resources can not be granted
+ */
+int streamrecorder_push_stream_buffer(streamrecorder_h recorder, media_packet_h inbuf);
+
+/**
+ * @brief Sets the video source as live buffer to be used for recording
+ * @since_tizen 3.0
+ * @remarks if you want to enable video or audio or both recording, call before streamrecorder_prepare()
+ * @param[in] recorder A handle to the streamrecorder
+ * @param[in] type The type of source input
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #STREAMRECORDER_ERROR_NONE Successful
+ * @retval #STREAMRECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #STREAMRECORDER_ERROR_INVALID_STATE Invalid state
+ * @pre The streamrecorder state must be only #STREAMRECORDER_STATE_CREATED
+ */
+int streamrecorder_enable_source_buffer(streamrecorder_h recorder, streamrecorder_source_e type);
+
+/**
+ * @brief Gets the streamrecorder's current state.
+ * @since_tizen 3.0
+ * @param[in] recorder The handle to the streamrecorder
+ * @param[out] state The current state of the streamrecorder
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #STREAMRECORDER_ERROR_NONE Successful
+ * @retval #STREAMRECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ */
+int streamrecorder_get_state(streamrecorder_h recorder, streamrecorder_state_e *state);
+
+/**
+ * @}
+ */
+
+/**
+ * @addtogroup CAPI_MEDIA_STREAMRECORDER_ATTRIBUTES_MODULE
+ * @{
+ */
+
+
+/**
+ * @brief Sets the file path to record.
+ * @details This function sets file path which defines where newly recorded data should be stored.
+ * @since_tizen 3.0
+ * @remarks If the same file already exists in the file system, then old file will be overwritten.
+ * @param[in] recorder The handle to the streamrecorder
+ * @param[in] path The recording file path
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #STREAMRECORDER_ERROR_NONE Successful
+ * @retval #STREAMRECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #STREAMRECORDER_ERROR_INVALID_STATE Invalid state
+ * @pre The streamrecorder state must be #STREAMRECORDER_STATE_CREATED. \n
+ * streamrecorder_enable_source_buffer() should be invoked before this function.
+ * @see streamrecorder_get_filename()
+ */
+int streamrecorder_set_filename(streamrecorder_h recorder, const char *path);
+
+/**
+ * @brief Gets the file path to record.
+ * @since_tizen 3.0
+ * @remarks You must release @a path using free().
+ * @param[in] recorder The handle to the streamrecorder
+ * @param[out] path The recording file path
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #STREAMRECORDER_ERROR_NONE Successful
+ * @retval #STREAMRECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ * streamrecorder_enable_source_buffer() should be invoked before this function.
+ * @see streamrecorder_set_filename()
+ */
+int streamrecorder_get_filename(streamrecorder_h recorder, char **path);
+
+/**
+ * @brief Sets the file format for recording media stream.
+ * @since_tizen 3.0
+ * @param[in] recorder The handle to the streamrecorder
+ * @param[in] format The media file format
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #STREAMRECORDER_ERROR_NONE Successful
+ * @retval #STREAMRECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #STREAMRECORDER_ERROR_INVALID_STATE Invalid state
+ * @retval #STREAMRECORDER_ERROR_INVALID_OPERATION Invalid operation
+ * @pre The streamrecorder state must be #STREAMRECORDER_STATE_CREATED. \n
+ * streamrecorder_enable_source_buffer() should be invoked before this function.
+ * @see streamrecorder_get_file_format()
+ * @see streamrecorder_foreach_supported_file_format()
+ */
+int streamrecorder_set_file_format(streamrecorder_h recorder, streamrecorder_file_format_e format);
+
+
+/**
+ * @brief Gets the file format for recording media stream.
+ * @since_tizen 3.0
+ * @param[in] recorder The handle to the streamrecorder
+ * @param[out] format The media file format
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #STREAMRECORDER_ERROR_NONE Successful
+ * @retval #STREAMRECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @pre The streamrecorder_enable_source_buffer() should be invoked before this function.
+ * @see streamrecorder_set_file_format()
+ * @see streamrecorder_foreach_supported_file_format()
+ */
+int streamrecorder_get_file_format(streamrecorder_h recorder, streamrecorder_file_format_e *format);
+
+
+/**
+ * @brief Sets the audio codec for encoding an audio stream.
+ * @since_tizen 3.0
+ * @remarks You can get available audio encoders by using streamrecorder_foreach_supported_audio_encoder(). \n
+ * @param[in] recorder The handle to the streamrecorder
+ * @param[in] codec The audio codec
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #STREAMRECORDER_ERROR_NONE Successful
+ * @retval #STREAMRECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #STREAMRECORDER_ERROR_INVALID_STATE Invalid state
+ * @retval #STREAMRECORDER_ERROR_NOT_SUPPORTED The feature is not supported
+ * @retval #STREAMRECORDER_ERROR_INVALID_OPERATION Invalid operation
+ * @pre The streamrecorder state must be #STREAMRECORDER_STATE_CREATED. \n
+ * streamrecorder_enable_source_buffer() should be invoked before this function.
+ * @see streamrecorder_get_audio_encoder()
+ * @see streamrecorder_foreach_supported_audio_encoder()
+ */
+int streamrecorder_set_audio_encoder(streamrecorder_h recorder, streamrecorder_audio_codec_e codec);
+
+/**
+ * @brief Gets the audio codec for encoding an audio stream.
+ * @since_tizen 3.0
+ * @param[in] recorder The handle to the streamrecorder
+ * @param[out] codec The audio codec
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #STREAMRECORDER_ERROR_NONE Successful
+ * @retval #STREAMRECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #STREAMRECORDER_ERROR_NOT_SUPPORTED The feature is not supported
+ * @pre The streamrecorder_enable_source_buffer() should be invoked before this function.
+ * @see streamrecorder_set_audio_encoder()
+ * @see streamrecorder_foreach_supported_audio_encoder()
+ */
+int streamrecorder_get_audio_encoder(streamrecorder_h recorder, streamrecorder_audio_codec_e *codec);
+
+/**
+ * @brief Sets the resolution of the video recording.
+ * @since_tizen 3.0
+ * @remarks This function should be called before recording (streamrecorder_start()).
+ * @param[in] recorder The handle to the streamrecorder
+ * @param[in] width The input width
+ * @param[in] height The input height
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #STREAMRECORDER_ERROR_NONE Successful
+ * @retval #STREAMRECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #STREAMRECORDER_ERROR_INVALID_STATE Invalid state
+ * @retval #STREAMRECORDER_ERROR_NOT_SUPPORTED The feature is not supported
+ * @pre The streamrecorder state must be #STREAMRECORDER_STATE_CREATED. \n
+ * streamrecorder_enable_source_buffer() should be invoked before this function.
+ * @see streamrecorder_start()
+ * @see streamrecorder_get_video_resolution()
+ * @see streamrecorder_foreach_supported_video_resolution()
+ */
+int streamrecorder_set_video_resolution(streamrecorder_h recorder, int width, int height);
+
+/**
+ * @brief Gets the resolution of the video recording.
+ * @since_tizen 3.0
+ * @param[in] recorder The handle to the streamrecorder
+ * @param[out] width The video width
+ * @param[out] height The video height
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #STREAMRECORDER_ERROR_NONE Successful
+ * @retval #STREAMRECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #STREAMRECORDER_ERROR_NOT_SUPPORTED The feature is not supported
+ * @pre The streamrecorder_enable_source_buffer() should be invoked before this function.
+ * @see streamrecorder_set_video_resolution()
+ * @see streamrecorder_foreach_supported_video_resolution()
+ */
+int streamrecorder_get_video_resolution(streamrecorder_h recorder, int *width, int *height);
+
+/**
+ * @brief Sets the video codec for encoding video stream.
+ * @since_tizen 3.0
+ * @remarks You can get available video encoders by using recorder_foreach_supported_video_encoder().
+ * @param[in] recorder The handle to the streamrecorder
+ * @param[in] codec The video codec
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #STREAMRECORDER_ERROR_NONE Successful
+ * @retval #STREAMRECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #STREAMRECORDER_ERROR_INVALID_STATE Invalid state
+ * @retval #STREAMRECORDER_ERROR_NOT_SUPPORTED The feature is not supported
+ * @pre The streamrecorder state must be #STREAMRECORDER_STATE_CREATED. \n
+ * streamrecorder_enable_source_buffer() should be invoked before this function.
+ * @see streamrecorder_get_video_encoder()
+ * @see streamrecorder_foreach_supported_video_encoder()
+ */
+int streamrecorder_set_video_encoder(streamrecorder_h recorder, streamrecorder_video_codec_e codec);
+
+/**
+ * @brief Gets the video codec for encoding video stream.
+ * @since_tizen 3.0
+ * @param[in] recorder The handle to the streamrecorder
+ * @param[out] codec The video codec
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #STREAMRECORDER_ERROR_NONE Successful
+ * @retval #STREAMRECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #STREAMRECORDER_ERROR_NOT_SUPPORTED The feature is not supported
+ * @pre The streamrecorder_enable_source_buffer() should be invoked before this function.
+ * @see streamrecorder_set_video_encoder()
+ * @see streamrecorder_foreach_supported_video_encoder()
+ */
+int streamrecorder_get_video_encoder(streamrecorder_h recorder, streamrecorder_video_codec_e *codec);
+
+/**
+ * @brief Sets the recording frame rate.
+ * @since_tizen 3.0
+ * @remarks This function should be called before prepared state.
+ * @param[in] recorder The handle to the streamrecorder
+ * @param[in] framerate The frame rate for recording
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #STREAMRECORDER_ERROR_NONE Successful
+ * @retval #STREAMRECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #STREAMRECORDER_ERROR_INVALID_STATE Invalid state
+ * @see streamrecorder_get_video_framerate()
+ */
+int streamrecorder_set_video_framerate(streamrecorder_h recorder, int framerate);
+
+/**
+ * @brief Gets the recording frame rate.
+ * @since_tizen 3.0
+ * @param[in] recorder The handle to the camera
+ * @param[out] framerate The frame rate for recording that already is set
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #STREAMRECORDER_ERROR_NONE Successful
+ * @retval #STREAMRECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @see streamrecorder_set_video_framerate()
+ */
+int streamrecorder_get_video_framerate(streamrecorder_h recorder, int *framerate);
+
+/**
+ * @brief Sets the video source format.
+ * @since_tizen 3.0
+ * @remarks This function should be called before prepared state.
+ * @param[in] recorder The handle to the streamrecorder
+ * @param[in] format The color type of video source
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #STREAMRECORDER_ERROR_NONE Successful
+ * @retval #STREAMRECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #STREAMRECORDER_ERROR_INVALID_STATE Invalid state
+ * @see streamrecorder_get_video_source_format()
+ */
+int streamrecorder_set_video_source_format(streamrecorder_h recorder, streamrecorder_video_source_format_e format);
+
+/**
+ * @brief Gets the video source format.
+ * @since_tizen 3.0
+ * @remarks This function should be called before prepared state.
+ * @param[in] recorder The handle to the streamrecorder
+ * @param[out] format The color type of video source that already is set
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #STREAMRECORDER_ERROR_NONE Successful
+ * @retval #STREAMRECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @see streamrecorder_set_video_source_format()
+ */
+int streamrecorder_get_video_source_format(streamrecorder_h recorder, streamrecorder_video_source_format_e *format);
+
+/**
+ * @brief Sets the maximum size of a recording file.
+ * @since_tizen 3.0
+ * @remarks After reaching the limitation, the recording data is discarded and not written in the recording file.
+ * @param[in] recorder The handle to the streamrecorder
+ * @param[in] type The recording limit type
+ * @param[in] limit If limit type is STREAMRECORDER_RECORDING_LIMIT_TYPE_SIZE, the limit value is the maximum size of the recording file(KB), \n
+ * otherwise limit value is the maximum time of the recording file (in seconds) \n
+ * @c 0 means unlimited recording size or time.
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #STREAMRECORDER_ERROR_NONE Successful
+ * @retval #STREAMRECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #STREAMRECORDER_ERROR_INVALID_STATE Invalid state
+ * @pre The streamrecorder state must be #STREAMRECORDER_STATE_CREATED. \n
+ * streamrecorder_enable_source_buffer() should be invoked before this function.
+ * @see streamrecorder_get_recording_limit()
+ */
+int streamrecorder_set_recording_limit(streamrecorder_h recorder, streamrecorder_recording_limit_type_e type, int limit);
+
+/**
+ * @brief Gets the maximum size of a recording file.
+ * @since_tizen 3.0
+ * @param[in] recorder The handle to the streamrecorder
+ * @param[in] type The recording limit type
+ * @param[out] limit If limit type is STREAMRECORDER_RECORDING_LIMIT_TYPE_SIZE, the limit value is the maximum size of the recording file(KB), \n
+ * otherwise limit value is the maximum time of the recording file (in seconds) \n
+ * @c 0 means unlimited recording size or time.
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #STREAMRECORDER_ERROR_NONE Successful
+ * @retval #STREAMRECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @pre The streamrecorder_enable_source_buffer() should be invoked before this function.
+ * @see streamrecorder_set_recording_limit()
+ */
+int streamrecorder_get_recording_limit(streamrecorder_h recorder, streamrecorder_recording_limit_type_e type, int *limit);
+
+/**
+ * @brief Sets the sampling rate of an audio stream.
+ * @since_tizen 3.0
+ * @param[in] recorder The handle to the streamrecorder
+ * @param[in] samplerate The sample rate in Hertz
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #STREAMRECORDER_ERROR_NONE Successful
+ * @retval #STREAMRECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #STREAMRECORDER_ERROR_INVALID_STATE Invalid state
+ * @pre The streamrecorder state must be #STREAMRECORDER_STATE_CREATED. \n
+ * streamrecorder_enable_source_buffer() should be invoked before this function.
+ * @see streamrecorder_get_audio_samplerate()
+ */
+int streamrecorder_set_audio_samplerate(streamrecorder_h recorder, int samplerate);
+
+/**
+ * @brief Gets the sampling rate of an audio stream.
+ * @since_tizen 3.0
+ * @param[in] recorder The handle to the streamrecorder
+ * @param[out] samplerate The sample rate in Hertz
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #STREAMRECORDER_ERROR_NONE Successful
+ * @retval #STREAMRECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @pre The streamrecorder_enable_source_buffer() should be invoked before this function.
+ * @see streamrecorder_set_audio_samplerate()
+ */
+int streamrecorder_get_audio_samplerate(streamrecorder_h recorder, int *samplerate);
+
+/**
+ * @brief Sets the bitrate of an audio encoder.
+ * @since_tizen 3.0
+ * @param[in] recorder The handle to the streamrecorder
+ * @param[in] bitrate The bitrate (for mms : 12200[bps], normal : 288000[bps])
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #STREAMRECORDER_ERROR_NONE Successful
+ * @retval #STREAMRECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #STREAMRECORDER_ERROR_INVALID_STATE Invalid state
+ * @pre The streamrecorder state must be #STREAMRECORDER_STATE_CREATED. \n
+ * streamrecorder_enable_source_buffer() should be invoked before this function.
+ * @see streamrecorder_get_audio_encoder_bitrate()
+ */
+int streamrecorder_set_audio_encoder_bitrate(streamrecorder_h recorder, int bitrate);
+
+/**
+ * @brief Sets the bitrate of a video encoder.
+ * @since_tizen 3.0
+ * @param[in] recorder The handle to the streamrecorder
+ * @param[in] bitrate The bitrate in bits per second
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #STREAMRECORDER_ERROR_NONE Successful
+ * @retval #STREAMRECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #STREAMRECORDER_ERROR_INVALID_STATE Invalid state
+ * @pre The streamrecorder state must be #STREAMRECORDER_STATE_CREATED. \n
+ * streamrecorder_enable_source_buffer() should be invoked before this function.
+ * @see streamrecorder_get_video_encoder_bitrate()
+ */
+int streamrecorder_set_video_encoder_bitrate(streamrecorder_h recorder, int bitrate);
+
+/**
+ * @brief Gets the bitrate of an audio encoder.
+ * @since_tizen 3.0
+ * @param[in] recorder The handle to the streamrecorder
+ * @param[out] bitrate The bitrate in bits per second
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #STREAMRECORDER_ERROR_NONE Successful
+ * @retval #STREAMRECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @pre The streamrecorder_enable_source_buffer() should be invoked before this function.
+ * @see streamrecorder_set_audio_encoder_bitrate()
+ */
+int streamrecorder_get_audio_encoder_bitrate(streamrecorder_h recorder, int *bitrate);
+
+/**
+ * @brief Gets the bitrate of a video encoder.
+ * @since_tizen 3.0
+ * @param[in] recorder The handle to the streamrecorder
+ * @param[out] bitrate The bitrate in bits per second
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #STREAMRECORDER_ERROR_NONE Successful
+ * @retval #STREAMRECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @pre The streamrecorder_enable_source_buffer() should be invoked before this function.
+ * @see streamrecorder_set_audio_encoder_bitrate()
+ */
+int streamrecorder_get_video_encoder_bitrate(streamrecorder_h recorder, int *bitrate);
+
+/**
+ * @brief Sets the number of the audio channel.
+ * @since_tizen 3.0
+ * @remarks This attribute is applied only in STREAMRECORDER_STATE_CREATED state. \n
+ * For mono recording, setting channel to @c 1. \n
+ * For stereo recording, setting channel to @c 2.
+ * @param[in] recorder The handle to the streamrecorder
+ * @param[in] channel_count The number of the audio channel
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #STREAMRECORDER_ERROR_NONE Successful
+ * @retval #STREAMRECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #STREAMRECORDER_ERROR_INVALID_STATE Invalid state
+ * @pre The streamrecorder state must be #STREAMRECORDER_STATE_CREATED.\n
+ * streamrecorder_enable_source_buffer() should be invoked before this function.
+ * @see streamrecorder_get_audio_channel()
+ */
+int streamrecorder_set_audio_channel(streamrecorder_h recorder, int channel_count);
+
+/**
+ * @brief Gets the number of the audio channel.
+ * @since_tizen 3.0
+ * @param[in] recorder The handle to the streamrecorder
+ * @param[out] channel_count The number of the audio channel
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #STREAMRECORDER_ERROR_NONE Successful
+ * @retval #STREAMRECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @pre The streamrecorder_enable_source_buffer() should be invoked before this function.
+ * @see streamrecorder_set_audio_channel()
+ */
+int streamrecorder_get_audio_channel(streamrecorder_h recorder, int *channel_count);
+
+/**
+ * @}
+ */
+
+/**
+ * @addtogroup CAPI_MEDIA_STREAMRECORDER_CAPABILITY_MODULE
+ * @{
+ */
+
+
+/**
+ * @brief Retrieves all supported file formats by invoking a specific callback for each supported file format.
+ * @since_tizen 3.0
+ * @param[in] recorder The handle to the streamrecorder
+ * @param[in] callback The iteration callback
+ * @param[in] user_data The user data to be passed to the callback function
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #STREAMRECORDER_ERROR_NONE Successful
+ * @retval #STREAMRECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @post streamrecorder_supported_file_format_cb() will be invoked.
+ * @see streamrecorder_get_file_format()
+ * @see streamrecorder_set_file_format()
+ * @see streamrecorder_supported_file_format_cb()
+ */
+int streamrecorder_foreach_supported_file_format(streamrecorder_h recorder, streamrecorder_supported_file_format_cb callback, void *user_data);
+
+/**
+ * @brief Retrieves all supported audio encoders by invoking a specific callback for each supported audio encoder.
+ * @since_tizen 3.0
+ * @param[in] recorder The handle to the streamrecorder
+ * @param[in] callback The iteration callback
+ * @param[in] user_data The user data to be passed to the callback function
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #STREAMRECORDER_ERROR_NONE Successful
+ * @retval #STREAMRECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @post streamrecorder_supported_audio_encoder_cb() will be invoked.
+ * @see streamrecorder_set_audio_encoder()
+ * @see streamrecorder_get_audio_encoder()
+ * @see streamrecorder_supported_audio_encoder_cb()
+ */
+int streamrecorder_foreach_supported_audio_encoder(streamrecorder_h recorder, streamrecorder_supported_audio_encoder_cb callback, void *user_data);
+
+/**
+ * @brief Retrieves all supported video encoders by invoking a specific callback for each supported video encoder.
+ * @since_tizen 3.0
+ * @param[in] recorder The handle to the streamrecorder
+ * @param[in] callback The iteration callback
+ * @param[in] user_data The user data to be passed to the callback function
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #STREAMRECORDER_ERROR_NONE Successful
+ * @retval #STREAMRECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @post streamrecorder_supported_video_encoder_cb() will be invoked.
+ * @see streamrecorder_set_video_encoder()
+ * @see streamrecorder_get_video_encoder()
+ * @see streamrecorder_supported_video_encoder_cb()
+ */
+int streamrecorder_foreach_supported_video_encoder(streamrecorder_h recorder, streamrecorder_supported_video_encoder_cb callback, void *user_data);
+
+/**
+ * @brief Retrieves all supported video resolutions by invoking callback function once for each supported video resolution.
+ * @since_tizen 3.0
+ * @param[in] recorder The handle to the streamrecorder
+ * @param[in] foreach_cb The callback function to be invoked
+ * @param[in] user_data The user data to be passed to the callback function
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #STREAMRECORDER_ERROR_NONE Successful
+ * @retval #STREAMRECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @post This function invokes streamrecorder_supported_video_resolution_cb() repeatedly to retrieve each supported video resolution.
+ * @see streamrecorder_set_video_resolution()
+ * @see streamrecorder_get_video_resolution()
+ * @see streamrecorder_supported_video_resolution_cb()
+ */
+int streamrecorder_foreach_supported_video_resolution(streamrecorder_h recorder,
+ streamrecorder_supported_video_resolution_cb foreach_cb, void *user_data);
+
+/**
+ * @}
+ */
+
+/**
+ * @addtogroup CAPI_MEDIA_STREAMRECORDER_CALLBACK_MODULE
+ * @{
+ */
+
+
+/**
+ * @brief Registers the callback function that will be invoked when the streamrecorder get some notification.
+ * @since_tizen 3.0
+ * @param[in] recorder The handle to the streamrecorder
+ * @param[in] callback The function pointer of user callback
+ * @param[in] user_data The user data to be passed to the callback function
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #STREAMRECORDER_ERROR_NONE Successful
+ * @retval #STREAMRECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @post streamrecorder_notify_cb() will be invoked.
+ * @see streamrecorder_unset_notify_cb()
+ * @see streamrecorder_notify_cb()
+ */
+int streamrecorder_set_notify_cb(streamrecorder_h recorder, streamrecorder_notify_cb callback, void *user_data);
+
+/**
+ * @brief Unregisters the callback function.
+ * @since_tizen 3.0
+ * @param[in] recorder The handle to the streamrecorder
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #STREAMRECORDER_ERROR_NONE Successful
+ * @retval #STREAMRECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @see streamrecorder_set_notify_cb()
+ */
+int streamrecorder_unset_notify_cb(streamrecorder_h recorder);
+
+/**
+ * @brief Registers a callback function to be invoked when the recording information changes.
+ * @since_tizen 3.0
+ * @param[in] recorder The handle to the streamrecorder
+ * @param[in] callback The function pointer of user callback
+ * @param[in] user_data The user data to be passed to the callback function
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #STREAMRECORDER_ERROR_NONE Successful
+ * @retval #STREAMRECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @post streamrecorder_recording_status_cb() will be invoked.
+ * @see streamrecorder_unset_recording_status_cb()
+ * @see streamrecorder_recording_status_cb()
+ */
+int streamrecorder_set_recording_status_cb(streamrecorder_h recorder, streamrecorder_recording_status_cb callback, void *user_data);
+
+/**
+ * @brief Unregisters the callback function.
+ * @since_tizen 3.0
+ * @param[in] recorder The handle to the streamrecorder
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #STREAMRECORDER_ERROR_NONE Successful
+ * @retval #STREAMRECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @see streamrecorder_set_recording_status_cb()
+ */
+int streamrecorder_unset_recording_status_cb(streamrecorder_h recorder);
+
+/**
+ * @brief Registers the callback function to be run when reached the recording limit.
+ * @since_tizen 3.0
+ * @param[in] recorder The handle to treamrecorder
+ * @param[in] callback The function pointer of user callback
+ * @param[in] user_data The user data to be passed to the callback function
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #STREAMRECORDER_ERROR_NONE Successful
+ * @retval #STREAMRECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @post streamrecorder_recording_limit_reached_cb() will be invoked.
+ * @see streamrecorder_unset_recording_limit_reached_cb()
+ * @see streamrecorder_set_size_limit()
+ * @see streamrecorder_set_time_limit()
+ * @see streamrecorder_recording_limit_reached_cb()
+ */
+int streamrecorder_set_recording_limit_reached_cb(streamrecorder_h recorder, streamrecorder_recording_limit_reached_cb callback, void *user_data);
+
+/**
+ * @brief Unregisters the callback function.
+ * @since_tizen 3.0
+ * @param[in] recorder The handle to the streamrecorder
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #STREAMRECORDER_ERROR_NONE Successful
+ * @retval #STREAMRECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @see streamrecorder_set_recording_limit_reached_cb()
+ */
+int streamrecorder_unset_recording_limit_reached_cb(streamrecorder_h recorder);
+
+/**
+ * @brief Registers a callback function to be called when an asynchronous operation error occurred.
+ * @since_tizen 3.0
+ * @remarks This callback informs critical error situation.\n
+ * When this callback is invoked, user should release the resource and terminate the application. \n
+ * These error codes will occur. \n
+ * #STREAMRECORDER_ERROR_INVALID_OPERATION \n
+ * #STREAMRECORDER_ERROR_OUT_OF_MEMORY
+ * @param[in] recorder The handle to the streamrecorder
+ * @param[in] callback The callback function to register
+ * @param[in] user_data The user data to be passed to the callback function
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #STREAMRECORDER_ERROR_NONE Successful
+ * @retval #STREAMRECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @post This function will invoke streamrecorder_error_cb() when an asynchronous operation error occur.
+ * @see streamrecorder_unset_error_cb()
+ * @see streamrecorder_error_cb()
+ */
+int streamrecorder_set_error_cb(streamrecorder_h recorder, streamrecorder_error_cb callback, void *user_data);
+
+
+/**
+ * @brief Unregisters the callback function.
+ * @since_tizen 3.0
+ * @param[in] recorder The handle to the streamrecorder
+ * @return @c on success, otherwise a negative error value
+ * @retval #STREAMRECORDER_ERROR_NONE Successful
+ * @retval #STREAMRECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @see streamrecorder_set_error_cb()
+ */
+int streamrecorder_unset_error_cb(streamrecorder_h recorder);
+
+/**
+ * @brief Registers a callback function to be called when asynchronous buffers are consumed.
+ * @since_tizen 3.0
+ * @remarks This callback informs to user dealloc buffer.\n
+ * When this callback is invoked, user should release the buffer or media packet. \n
+ * @param[in] recorder The handle to the streamrecorder
+ * @param[in] callback The callback function to register
+ * @param[in] user_data The user data to be passed to the callback function
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #STREAMRECORDER_ERROR_NONE Successful
+ * @retval #STREAMRECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @see streamrecorder_unset_buffer_consume_completed_cb()
+ * @see streamrecorder_push_stream_buffer()
+ */
+int streamrecorder_set_buffer_consume_completed_cb(streamrecorder_h recorder, streamrecorder_consume_completed_cb callback, void *user_data);
+
+/**
+ * @brief Unregisters the callback function.
+ * @since_tizen 3.0
+ * @param[in] recorder The handle to the streamrecorder
+ * @return @c on success, otherwise a negative error value
+ * @retval #STREAMRECORDER_ERROR_NONE Successful
+ * @retval #STREAMRECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @see streamrecorder_set_buffer_consume_completed_cb()
+ */
+int streamrecorder_unset_buffer_consume_completed_cb(streamrecorder_h recorder);
+
+/**
+ * @}
+ */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __TIZEN_MEDIA_STREAMRECORDER_H__ */
+
--- /dev/null
+/*
+* Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+
+
+#ifndef __TIZEN_MEDIA_STREAMRECORDER_PRIVATE_H__
+#define __TIZEN_MEDIA_STREAMRECORDER_PRIVATE_H__
+
+#include <streamrecorder.h>
+#include <mm.h>
+#include <mm_types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum {
+ _STREAMRECORDER_EVENT_TYPE_NOTIFY,
+ _STREAMRECORDER_EVENT_TYPE_RECORDING_LIMITED,
+ _STREAMRECORDER_EVENT_TYPE_RECORDING_STATUS,
+ _STREAMRECORDER_EVENT_TYPE_ERROR,
+ _STREAMRECORDER_EVENT_TYPE_CONSUME_COMPLETE,
+ _STREAMRECORDER_EVENT_TYPE_NUM
+}_streamrecorder_event_e;
+
+typedef struct {
+ MMHandleType mm_handle;
+ void* user_cb[_STREAMRECORDER_EVENT_TYPE_NUM];
+ void* user_data[_STREAMRECORDER_EVENT_TYPE_NUM];
+ unsigned int state;
+ _streamrecorder_event_e type;
+ double last_max_input_level;
+}streamrecorder_s;
+
+int __convert_streamrecorder_error_code(const char *func, int code);
+int _streamrecorder_set_videosource_buffer(streamrecorder_h recorder);
+int _streamrecorder_set_audiosource_buffer(streamrecorder_h recorder);
+int _streamrecorder_get_state(streamrecorder_h recorder, streamrecorder_state_e *state);
+int _streamrecorder_destroy(streamrecorder_h recorder);
+int _streamrecorder_prepare(streamrecorder_h recorder);
+int _streamrecorder_unprepare(streamrecorder_h recorder);
+int _streamrecorder_start(streamrecorder_h recorder);
+int _streamrecorder_pause(streamrecorder_h recorder);
+int _streamrecorder_commit(streamrecorder_h recorder);
+int _streamrecorder_cancel(streamrecorder_h recorder);
+int _streamrecorder_set_video_framerate(streamrecorder_h recorder, int framerate);
+int _streamrecorder_get_video_framerate(streamrecorder_h recorder, int *framerate);
+int _streamrecorder_set_video_source_format(streamrecorder_h recorder, int format);
+int _streamrecorder_get_video_source_format(streamrecorder_h recorder, int *format);
+int _streamrecorder_set_video_resolution(streamrecorder_h recorder, int width, int height);
+int _streamrecorder_get_video_resolution(streamrecorder_h recorder, int *width, int *height);
+int _streamrecorder_foreach_supported_video_resolution(streamrecorder_h recorder,streamrecorder_supported_video_resolution_cb foreach_cb, void *user_data);
+int _streamrecorder_set_filename(streamrecorder_h recorder, const char *filename);
+int _streamrecorder_get_filename(streamrecorder_h recorder, char **filename);
+int _streamrecorder_set_file_format(streamrecorder_h recorder, streamrecorder_file_format_e format);
+int _streamrecorder_get_file_format(streamrecorder_h recorder, streamrecorder_file_format_e *format);
+int _streamrecorder_foreach_supported_file_format(streamrecorder_h recorder, streamrecorder_supported_file_format_cb foreach_cb, void *user_data);
+int _streamrecorder_set_size_limit(streamrecorder_h recorder, int kbyte);
+int _streamrecorder_set_time_limit(streamrecorder_h recorder, int second);
+int _streamrecorder_set_audio_encoder(streamrecorder_h recorder, streamrecorder_audio_codec_e codec);
+int _streamrecorder_get_audio_encoder(streamrecorder_h recorder, streamrecorder_audio_codec_e *codec);
+int _streamrecorder_set_video_encoder(streamrecorder_h recorder, streamrecorder_video_codec_e codec);
+int _streamrecorder_get_video_encoder(streamrecorder_h recorder, streamrecorder_video_codec_e *codec);
+int _streamrecorder_set_audio_samplerate(streamrecorder_h recorder, int samplerate);
+int _streamrecorder_set_audio_encoder_bitrate(streamrecorder_h recorder, int bitrate);
+int _streamrecorder_set_video_encoder_bitrate(streamrecorder_h recorder, int bitrate);
+int _streamrecorder_get_size_limit(streamrecorder_h recorder, int *kbyte);
+int _streamrecorder_get_time_limit(streamrecorder_h recorder, int *second);
+int _streamrecorder_get_audio_samplerate(streamrecorder_h recorder, int *samplerate);
+int _streamrecorder_get_audio_encoder_bitrate(streamrecorder_h recorder, int *bitrate);
+int _streamrecorder_get_video_encoder_bitrate(streamrecorder_h recorder, int *bitrate);
+int _streamrecorder_foreach_supported_audio_encoder(streamrecorder_h recorder, streamrecorder_supported_audio_encoder_cb foreach_cb, void *user_data);
+int _streamrecorder_foreach_supported_video_encoder(streamrecorder_h recorder, streamrecorder_supported_video_encoder_cb foreach_cb, void *user_data);
+int _streamrecorder_set_audio_channel(streamrecorder_h recorder, int channel_count);
+int _streamrecorder_get_audio_channel(streamrecorder_h recorder, int *channel_count);
+#ifdef __cplusplus
+}
+#endif
+
+#endif //__TIZEN_MEDIA_STREAMRECORDER_PRIVATE_H__
+
+
--- /dev/null
+Name: capi-media-streamrecorder
+Summary: A Streamrecorder library in Tizen Native API
+Version: 0.0.1
+Release: 0
+Group: Multimedia/Other
+License: Apache-2.0
+Source0: %{name}-%{version}.tar.gz
+BuildRequires: cmake
+BuildRequires: pkgconfig(dlog)
+Buildrequires: pkgconfig(mm-streamrecorder)
+BuildRequires: pkgconfig(capi-base-common)
+BuildRequires: pkgconfig(capi-media-tool)
+BuildRequires: pkgconfig(capi-media-audio-io)
+BuildRequires: pkgconfig(libtbm)
+Requires(post): /sbin/ldconfig
+Requires(postun): /sbin/ldconfig
+
+%description
+A StreamRecorder library in Tizen Native API to record live buffer sent by the application
+
+
+%package devel
+Summary: A StreamRecorder library in Tizen Native API (Development)
+Requires: %{name} = %{version}-%{release}
+
+
+%description devel
+A MediaStreamRecorder library in Tizen Native API Development Package to record live buffer
+
+
+%prep
+%setup -q
+
+
+%build
+MAJORVER=`echo %{version} | awk 'BEGIN {FS="."}{print $1}'`
+%cmake . -DCMAKE_INSTALL_PREFIX=%{_prefix} -DFULLVER=%{version} -DMAJORVER=${MAJORVER}
+
+
+make %{?jobs:-j%jobs}
+
+
+%install
+rm -rf %{buildroot}
+%make_install
+mkdir -p %{buildroot}%{_datadir}/license
+cp LICENSE.APLv2 %{buildroot}%{_datadir}/license/%{name}
+
+
+%post -p /sbin/ldconfig
+
+
+%postun -p /sbin/ldconfig
+
+%files
+%manifest capi-media-streamrecorder.manifest
+%{_libdir}/libcapi-media-streamrecorder.so.*
+%{_datadir}/license/%{name}
+%{_bindir}/*
+
+%files devel
+%{_includedir}/media/streamrecorder.h
+%{_libdir}/pkgconfig/*.pc
+%{_libdir}/libcapi-media-streamrecorder.so
+
--- /dev/null
+/*
+* Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <streamrecorder_private.h>
+#include <streamrecorder.h>
+#include <mm_streamrecorder.h>
+#include <unistd.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <dlog.h>
+#include <tbm_type.h>
+#include <tbm_surface.h>
+#include <tbm_bufmgr.h>
+#include <tbm_surface_internal.h>
+
+#ifdef LOG_TAG
+#undef LOG_TAG
+#endif
+#define LOG_TAG "TIZEN_N_STREAMRECORDER"
+
+static int __mm_streamrecorder_msg_cb(int message, void *param, void *user_data);
+
+
+int streamrecorder_create(streamrecorder_h *recorder)
+{
+ int ret = STREAMRECORDER_ERROR_NONE;
+
+ streamrecorder_s *handle = NULL;
+ handle = (streamrecorder_s *)malloc(sizeof(streamrecorder_s));
+ if (handle == NULL) {
+ LOGE("[%s] malloc error", __func__);
+ return STREAMRECORDER_ERROR_OUT_OF_MEMORY;
+ }
+
+ memset(handle, 0 , sizeof(streamrecorder_s));
+
+ ret = mm_streamrecorder_create(&handle->mm_handle);
+ if (ret != MM_ERROR_NONE) {
+ free(handle);
+ LOGE("[%s] mm_streamrecorder_create fail", __func__);
+ return __convert_streamrecorder_error_code(__func__, ret);
+ }
+
+ mm_streamrecorder_set_message_callback(handle->mm_handle, __mm_streamrecorder_msg_cb, (void *)handle);
+
+ *recorder = (streamrecorder_h)handle;
+ return ret;
+}
+
+int streamrecorder_get_state(streamrecorder_h recorder, streamrecorder_state_e *state)
+{
+ int ret = STREAMRECORDER_ERROR_NONE;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+ ret = _streamrecorder_get_state(recorder, state);
+
+ return ret;
+}
+
+int streamrecorder_enable_source_buffer(streamrecorder_h recorder, streamrecorder_source_e type)
+{
+ int ret = STREAMRECORDER_ERROR_NONE;
+ if (recorder == NULL) {
+ LOGE("NULL video pointer handle");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+ if (type == STREAMRECORDER_SOURCE_VIDEO) {
+ ret = _streamrecorder_set_videosource_buffer(recorder);
+ } else if (type == STREAMRECORDER_SOURCE_AUDIO) {
+ ret = _streamrecorder_set_audiosource_buffer(recorder);
+ } else {
+ ret = _streamrecorder_set_videosource_buffer(recorder);
+ if (ret == STREAMRECORDER_ERROR_NONE) {
+ ret = _streamrecorder_set_audiosource_buffer(recorder);
+ }
+ }
+ return ret;
+}
+
+int streamrecorder_push_stream_buffer(streamrecorder_h recorder, media_packet_h packet)
+{
+ int ret = MM_ERROR_NONE;
+ uint64_t pts = 0;
+ bool flag = FALSE;
+ tbm_surface_h surface = NULL;
+ int width;
+ int height;
+
+ if ((recorder == NULL) || (packet == NULL)) {
+ LOGE("[%s] INVALID_PARAMETER(0x%08x)", __func__, STREAMRECORDER_ERROR_INVALID_PARAMETER);
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+ streamrecorder_s *handle = (streamrecorder_s *)recorder;
+
+ /* pts */
+ media_packet_get_pts(packet, &pts);
+ media_packet_is_video(packet, &flag);
+ if (flag) {
+ media_format_h fmt = NULL;
+ media_format_mimetype_e mimetype = 0;
+ media_packet_get_format(packet, &fmt);
+ media_format_get_video_info(fmt, &mimetype, &width, &height, NULL, NULL);
+ media_format_unref(fmt);
+
+ if ((mimetype == MEDIA_FORMAT_NV12) || (mimetype == MEDIA_FORMAT_NV21)) {
+ MMVideoBuffer *video_buf = NULL;
+ void *dataPtr = NULL;
+ video_buf = (MMVideoBuffer *)malloc(sizeof(MMVideoBuffer));
+ if (!video_buf) {
+ LOGE("Failed to alloc MMVideoBuffer");
+ return STREAMRECORDER_ERROR_OUT_OF_MEMORY;
+ }
+ memset(video_buf, 0x00, sizeof(MMVideoBuffer));
+ media_packet_get_buffer_data_ptr(packet, (void **)&dataPtr);
+ media_packet_get_tbm_surface(packet, &surface);
+ if (surface == NULL) {
+ LOGE("Failed to get surface");
+ free(video_buf);
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+ video_buf->handle_num = tbm_surface_internal_get_num_bos(surface);
+ video_buf->type = MM_VIDEO_BUFFER_TYPE_TBM_BO;
+ video_buf->handle.paddr[0] = dataPtr;
+ video_buf->data[0] = dataPtr;
+ video_buf->width[0] = width;
+ video_buf->height[0] = height;
+ video_buf->stride_width[0] = video_buf->width[0];
+ video_buf->stride_height[0] = video_buf->height[0];
+ video_buf->size[0] = width*height*3/2;
+
+ ret = mm_streamrecorder_push_stream_buffer(handle->mm_handle, MM_STREAM_TYPE_VIDEO, pts, video_buf, video_buf->size[0]);
+ free(video_buf);
+ } else if (mimetype == MEDIA_FORMAT_I420) {
+ void *buf_data = NULL;
+ uint64_t buf_size = 0;
+ ret = media_packet_get_buffer_size(packet, &buf_size);
+ if (ret != MEDIA_PACKET_ERROR_NONE) {
+ LOGW("buffer size get fail");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+ ret = media_packet_get_buffer_data_ptr(packet, (void **)&buf_data);
+ if (ret != MEDIA_PACKET_ERROR_NONE) {
+ LOGW("buffer size get fail");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+ ret = mm_streamrecorder_push_stream_buffer(handle->mm_handle, MM_STREAM_TYPE_VIDEO, pts, buf_data, buf_size);
+ }
+ } else {
+ media_packet_is_audio(packet, &flag);
+ if (flag) {
+ void *buf_data = NULL;
+ uint64_t buf_size = 0;
+ ret = media_packet_get_buffer_size(packet, &buf_size);
+ if (ret != MEDIA_PACKET_ERROR_NONE) {
+ LOGW("buffer size get fail");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+ ret = media_packet_get_buffer_data_ptr(packet, &buf_data);
+ if (ret != MEDIA_PACKET_ERROR_NONE) {
+ LOGW("buffer size get fail");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+ ret = mm_streamrecorder_push_stream_buffer(handle->mm_handle, MM_STREAM_TYPE_AUDIO, pts, buf_data, buf_size);
+ }
+
+ }
+ return __convert_streamrecorder_error_code(__func__, ret);
+}
+
+
+int streamrecorder_destroy(streamrecorder_h recorder)
+{
+ int ret = STREAMRECORDER_ERROR_NONE;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = _streamrecorder_destroy(recorder);
+
+ return ret;
+}
+
+
+int streamrecorder_prepare(streamrecorder_h recorder)
+{
+ int ret = STREAMRECORDER_ERROR_NONE;
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+ ret = _streamrecorder_prepare(recorder);
+
+ return ret;
+}
+
+
+int streamrecorder_unprepare(streamrecorder_h recorder)
+{
+ int ret = STREAMRECORDER_ERROR_NONE;
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+ ret = _streamrecorder_unprepare(recorder);
+
+ return ret;
+
+}
+
+
+int streamrecorder_start(streamrecorder_h recorder)
+{
+ int ret = STREAMRECORDER_ERROR_NONE;
+
+ if (recorder == NULL) {
+ LOGE("NULL startointer handle");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = _streamrecorder_start(recorder);
+ return ret;
+}
+
+
+int streamrecorder_pause(streamrecorder_h recorder)
+{
+ int ret = STREAMRECORDER_ERROR_NONE;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = _streamrecorder_pause(recorder);
+ return ret;
+}
+
+
+int streamrecorder_commit(streamrecorder_h recorder)
+{
+ int ret = STREAMRECORDER_ERROR_NONE;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = _streamrecorder_commit(recorder);
+ return ret;
+}
+
+
+int streamrecorder_cancel(streamrecorder_h recorder)
+{
+ int ret = STREAMRECORDER_ERROR_NONE;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = _streamrecorder_cancel(recorder);
+ return ret;
+}
+
+int streamrecorder_set_video_framerate(streamrecorder_h recorder, int framerate)
+{
+ int ret = STREAMRECORDER_ERROR_NONE;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = _streamrecorder_set_video_framerate(recorder, framerate);
+ return ret;
+
+}
+
+int streamrecorder_get_video_framerate(streamrecorder_h recorder, int *framerate)
+{
+ int ret = STREAMRECORDER_ERROR_NONE;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = _streamrecorder_get_video_framerate(recorder, framerate);
+ return ret;
+}
+
+int streamrecorder_set_video_source_format(streamrecorder_h recorder, streamrecorder_video_source_format_e format)
+{
+ int ret = STREAMRECORDER_ERROR_NONE;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = _streamrecorder_set_video_source_format(recorder, format);
+ return ret;
+}
+
+int streamrecorder_get_video_source_format(streamrecorder_h recorder, streamrecorder_video_source_format_e *format)
+{
+ int ret = STREAMRECORDER_ERROR_NONE;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = _streamrecorder_get_video_source_format(recorder, format);
+ return ret;
+}
+
+
+int streamrecorder_set_video_resolution(streamrecorder_h recorder, int width, int height)
+{
+ int ret = STREAMRECORDER_ERROR_NONE;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = _streamrecorder_set_video_resolution(recorder, width, height);
+ return ret;
+}
+
+int streamrecorder_get_video_resolution(streamrecorder_h recorder, int *width, int *height)
+{
+ int ret = STREAMRECORDER_ERROR_NONE;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = _streamrecorder_get_video_resolution(recorder, width , height);
+ return ret;
+}
+
+
+
+int streamrecorder_foreach_supported_video_resolution(streamrecorder_h recorder,
+ streamrecorder_supported_video_resolution_cb foreach_cb, void *user_data)
+{
+
+ int ret = STREAMRECORDER_ERROR_NONE;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+ ret = _streamrecorder_foreach_supported_video_resolution(recorder, foreach_cb, user_data);
+ return ret;
+
+
+}
+
+int streamrecorder_set_filename(streamrecorder_h recorder, const char *filename)
+{
+ int ret = STREAMRECORDER_ERROR_NONE;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = _streamrecorder_set_filename(recorder, filename);
+ return ret;
+}
+
+
+int streamrecorder_get_filename(streamrecorder_h recorder, char **filename)
+{
+ int ret = STREAMRECORDER_ERROR_NONE;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = _streamrecorder_get_filename(recorder, filename);
+ return ret;
+}
+
+
+int streamrecorder_set_file_format(streamrecorder_h recorder, streamrecorder_file_format_e format)
+{
+ int ret = STREAMRECORDER_ERROR_NONE;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = _streamrecorder_set_file_format(recorder, format);
+ return ret;
+}
+
+
+int streamrecorder_get_file_format(streamrecorder_h recorder, streamrecorder_file_format_e *format)
+{
+
+ int ret = STREAMRECORDER_ERROR_NONE;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = _streamrecorder_get_file_format(recorder, format);
+ return ret;
+
+}
+
+
+int streamrecorder_set_notify_cb(streamrecorder_h recorder, streamrecorder_notify_cb callback, void *user_data)
+{
+ streamrecorder_s *handle = (streamrecorder_s *)recorder;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ if (callback == NULL) {
+ LOGE("NULL pointer callback");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ handle->user_cb[_STREAMRECORDER_EVENT_TYPE_NOTIFY] = callback;
+ handle->user_data[_STREAMRECORDER_EVENT_TYPE_NOTIFY] = user_data;
+
+ return STREAMRECORDER_ERROR_NONE;
+}
+
+
+int streamrecorder_unset_notify_cb(streamrecorder_h recorder)
+{
+ streamrecorder_s *handle = (streamrecorder_s *)recorder;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ handle->user_cb[_STREAMRECORDER_EVENT_TYPE_NOTIFY] = NULL;
+ handle->user_data[_STREAMRECORDER_EVENT_TYPE_NOTIFY] = NULL;
+
+ return STREAMRECORDER_ERROR_NONE;
+}
+
+int streamrecorder_set_buffer_consume_completed_cb(streamrecorder_h recorder, streamrecorder_consume_completed_cb callback, void *user_data)
+{
+ if (recorder == NULL)
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ streamrecorder_s *handle = (streamrecorder_s *)recorder;
+ if (callback == NULL)
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+
+ handle->user_cb[_STREAMRECORDER_EVENT_TYPE_CONSUME_COMPLETE] = callback;
+ handle->user_data[_STREAMRECORDER_EVENT_TYPE_CONSUME_COMPLETE] = user_data;
+ return STREAMRECORDER_ERROR_NONE;
+}
+
+int streamrecorder_unset_buffer_consume_completed_cb(streamrecorder_h recorder)
+{
+ if (recorder == NULL)
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ streamrecorder_s *handle = (streamrecorder_s *)recorder;
+
+ handle->user_cb[_STREAMRECORDER_EVENT_TYPE_CONSUME_COMPLETE] = NULL;
+ handle->user_data[_STREAMRECORDER_EVENT_TYPE_CONSUME_COMPLETE] = NULL;
+ return STREAMRECORDER_ERROR_NONE;
+}
+
+int streamrecorder_set_error_cb(streamrecorder_h recorder, streamrecorder_error_cb callback, void *user_data)
+{
+ streamrecorder_s *handle = (streamrecorder_s *)recorder;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+ if (callback == NULL) {
+ LOGE("NULL pointer callback");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ handle->user_cb[_STREAMRECORDER_EVENT_TYPE_ERROR] = callback;
+ handle->user_data[_STREAMRECORDER_EVENT_TYPE_ERROR] = user_data;
+
+ return STREAMRECORDER_ERROR_NONE;
+}
+
+
+int streamrecorder_unset_error_cb(streamrecorder_h recorder)
+{
+ streamrecorder_s *handle = (streamrecorder_s *)recorder;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ handle->user_cb[_STREAMRECORDER_EVENT_TYPE_ERROR] = NULL;
+ handle->user_data[_STREAMRECORDER_EVENT_TYPE_ERROR] = NULL;
+
+ return STREAMRECORDER_ERROR_NONE;
+}
+
+
+int streamrecorder_set_recording_status_cb(streamrecorder_h recorder, streamrecorder_recording_status_cb callback, void *user_data)
+{
+ streamrecorder_s *handle = (streamrecorder_s *)recorder;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+ if (callback == NULL) {
+ LOGE("NULL pointer callback");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ handle->user_cb[_STREAMRECORDER_EVENT_TYPE_RECORDING_STATUS] = callback;
+ handle->user_data[_STREAMRECORDER_EVENT_TYPE_RECORDING_STATUS] = user_data;
+
+ return STREAMRECORDER_ERROR_NONE;
+}
+
+
+int streamrecorder_unset_recording_status_cb(streamrecorder_h recorder)
+{
+ streamrecorder_s *handle = (streamrecorder_s *)recorder;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ handle->user_cb[_STREAMRECORDER_EVENT_TYPE_RECORDING_STATUS] = NULL;
+ handle->user_data[_STREAMRECORDER_EVENT_TYPE_RECORDING_STATUS] = NULL;
+
+ return STREAMRECORDER_ERROR_NONE;
+}
+
+
+int streamrecorder_set_recording_limit_reached_cb(streamrecorder_h recorder, streamrecorder_recording_limit_reached_cb callback, void *user_data)
+{
+ streamrecorder_s *handle = (streamrecorder_s *)recorder;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+ if (callback == NULL) {
+ LOGE("NULL pointer callback");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ handle->user_cb[_STREAMRECORDER_EVENT_TYPE_RECORDING_LIMITED] = callback;
+ handle->user_data[_STREAMRECORDER_EVENT_TYPE_RECORDING_LIMITED] = user_data;
+
+ return STREAMRECORDER_ERROR_NONE;
+}
+
+
+int streamrecorder_unset_recording_limit_reached_cb(streamrecorder_h recorder)
+{
+ streamrecorder_s *handle = (streamrecorder_s *)recorder;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ handle->user_cb[_STREAMRECORDER_EVENT_TYPE_RECORDING_LIMITED] = NULL;
+ handle->user_data[_STREAMRECORDER_EVENT_TYPE_RECORDING_LIMITED] = NULL;
+
+ return STREAMRECORDER_ERROR_NONE;
+}
+
+
+int streamrecorder_foreach_supported_file_format(streamrecorder_h recorder, streamrecorder_supported_file_format_cb foreach_cb, void *user_data)
+{
+ int ret = STREAMRECORDER_ERROR_NONE;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = _streamrecorder_foreach_supported_file_format(recorder, foreach_cb, user_data);
+ return ret;
+
+}
+
+
+int streamrecorder_set_recording_limit(streamrecorder_h recorder, streamrecorder_recording_limit_type_e type, int limit)
+{
+ int ret = STREAMRECORDER_ERROR_NONE;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ if (type == STREAMRECORDER_RECORDING_LIMIT_TYPE_TIME)
+ ret = _streamrecorder_set_size_limit(recorder, limit);
+ else
+ ret = _streamrecorder_set_time_limit(recorder, limit);
+ return ret;
+}
+
+int streamrecorder_get_recording_limit(streamrecorder_h recorder, streamrecorder_recording_limit_type_e type, int *limit)
+{
+ int ret = STREAMRECORDER_ERROR_NONE;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+ if (type == STREAMRECORDER_RECORDING_LIMIT_TYPE_TIME)
+ ret = _streamrecorder_get_size_limit(recorder, limit);
+ else
+ ret = _streamrecorder_get_time_limit(recorder, limit);
+ return ret;
+}
+
+int streamrecorder_set_audio_encoder(streamrecorder_h recorder, streamrecorder_audio_codec_e codec)
+{
+
+ int ret = STREAMRECORDER_ERROR_NONE;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = _streamrecorder_set_audio_encoder(recorder, codec);
+ return ret;
+
+}
+
+
+int streamrecorder_get_audio_encoder(streamrecorder_h recorder, streamrecorder_audio_codec_e *codec)
+{
+
+ int ret = STREAMRECORDER_ERROR_NONE;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = _streamrecorder_get_audio_encoder(recorder, codec);
+ return ret;
+
+}
+
+
+int streamrecorder_set_video_encoder(streamrecorder_h recorder, streamrecorder_video_codec_e codec)
+{
+
+ int ret = STREAMRECORDER_ERROR_NONE;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = _streamrecorder_set_video_encoder(recorder, codec);
+ return ret;
+
+}
+
+
+int streamrecorder_get_video_encoder(streamrecorder_h recorder, streamrecorder_video_codec_e *codec)
+{
+
+ int ret = STREAMRECORDER_ERROR_NONE;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = _streamrecorder_get_video_encoder(recorder, codec);
+ return ret;
+
+}
+
+
+int streamrecorder_set_audio_samplerate(streamrecorder_h recorder, int samplerate)
+{
+
+ int ret = STREAMRECORDER_ERROR_NONE;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = _streamrecorder_set_audio_samplerate(recorder, samplerate);
+ return ret;
+
+}
+
+
+int streamrecorder_set_audio_encoder_bitrate(streamrecorder_h recorder, int bitrate)
+{
+ int ret = STREAMRECORDER_ERROR_NONE;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = _streamrecorder_set_audio_encoder_bitrate(recorder, bitrate);
+ return ret;
+
+}
+
+int streamrecorder_set_video_encoder_bitrate(streamrecorder_h recorder, int bitrate)
+{
+ int ret = STREAMRECORDER_ERROR_NONE;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = _streamrecorder_set_video_encoder_bitrate(recorder, bitrate);
+ return ret;
+}
+
+int streamrecorder_get_audio_samplerate(streamrecorder_h recorder, int *samplerate)
+{
+ int ret = STREAMRECORDER_ERROR_NONE;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = _streamrecorder_get_audio_samplerate(recorder, samplerate);
+ return ret;
+}
+
+int streamrecorder_get_audio_encoder_bitrate(streamrecorder_h recorder, int *bitrate)
+{
+ int ret = STREAMRECORDER_ERROR_NONE;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = _streamrecorder_get_audio_encoder_bitrate(recorder, bitrate);
+ return ret;
+}
+
+
+int streamrecorder_get_video_encoder_bitrate(streamrecorder_h recorder, int *bitrate)
+{
+ int ret = STREAMRECORDER_ERROR_NONE;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = _streamrecorder_get_video_encoder_bitrate(recorder, bitrate);
+ return ret;
+}
+
+
+int streamrecorder_foreach_supported_audio_encoder(streamrecorder_h recorder, streamrecorder_supported_audio_encoder_cb foreach_cb, void *user_data)
+{
+
+ int ret = STREAMRECORDER_ERROR_NONE;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = _streamrecorder_foreach_supported_audio_encoder(recorder, foreach_cb, user_data);
+ return ret;
+
+}
+
+
+int streamrecorder_foreach_supported_video_encoder(streamrecorder_h recorder, streamrecorder_supported_video_encoder_cb foreach_cb, void *user_data)
+{
+
+ int ret = STREAMRECORDER_ERROR_NONE;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = _streamrecorder_foreach_supported_video_encoder(recorder, foreach_cb, user_data);
+ return ret;
+
+}
+
+
+int streamrecorder_set_audio_channel(streamrecorder_h recorder, int channel_count)
+{
+ int ret = STREAMRECORDER_ERROR_NONE;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = _streamrecorder_set_audio_channel(recorder, channel_count);
+ return ret;
+}
+
+
+int streamrecorder_get_audio_channel(streamrecorder_h recorder, int *channel_count)
+{
+ int ret = STREAMRECORDER_ERROR_NONE;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = _streamrecorder_get_audio_channel(recorder, channel_count);
+ return ret;
+
+}
+
+static int __mm_streamrecorder_msg_cb(int message, void *param, void *user_data)
+{
+ streamrecorder_s * handle = (streamrecorder_s *)user_data;
+ MMMessageParamType *m = (MMMessageParamType *)param;
+ streamrecorder_notify_e notification = STREAMRECORDER_NOTIFY_NONE;
+ streamrecorder_state_e previous_state;
+ streamrecorder_recording_limit_type_e type;
+ int streamrecorder_error = 0;
+ switch (message) {
+ case MM_MESSAGE_READY_TO_RESUME:
+ LOGW("not supported message");
+ break;
+ case MM_MESSAGE_STREAMRECORDER_STATE_CHANGED:
+ previous_state = handle->state;
+ notification = STREAMRECORDER_NOTIFY_STATE_CHANGED;
+ if (previous_state != handle->state && handle->user_cb[_STREAMRECORDER_EVENT_TYPE_NOTIFY])
+ ((streamrecorder_notify_cb)handle->user_cb[_STREAMRECORDER_EVENT_TYPE_NOTIFY])(previous_state, handle->state, notification, handle->user_data[_STREAMRECORDER_EVENT_TYPE_NOTIFY]);
+
+ break;
+ case MM_MESSAGE_STREAMRECORDER_MAX_SIZE:
+ case MM_MESSAGE_STREAMRECORDER_NO_FREE_SPACE:
+ case MM_MESSAGE_STREAMRECORDER_TIME_LIMIT:
+ if (MM_MESSAGE_STREAMRECORDER_MAX_SIZE == message) {
+ type = STREAMRECORDER_RECORDING_LIMIT_TYPE_SIZE;
+ } else {
+ type = STREAMRECORDER_RECORDING_LIMIT_TYPE_TIME;
+ }
+ if (handle->user_cb[_STREAMRECORDER_EVENT_TYPE_RECORDING_LIMITED]) {
+ ((streamrecorder_recording_limit_reached_cb)handle->user_cb[_STREAMRECORDER_EVENT_TYPE_RECORDING_LIMITED])(type, handle->user_data[_STREAMRECORDER_EVENT_TYPE_RECORDING_LIMITED]);
+ }
+ break;
+ case MM_MESSAGE_STREAMRECORDER_RECORDING_STATUS:
+ if (handle->user_cb[_STREAMRECORDER_EVENT_TYPE_RECORDING_STATUS]) {
+ ((streamrecorder_recording_status_cb)handle->user_cb[_STREAMRECORDER_EVENT_TYPE_RECORDING_STATUS])(m->recording_status.elapsed, m->recording_status.filesize, handle->user_data[_STREAMRECORDER_EVENT_TYPE_RECORDING_STATUS]);
+ }
+ break;
+
+ case MM_MESSAGE_STREAMRECORDER_VIDEO_CAPTURED:
+ {
+ MMStreamRecordingReport *report = (MMStreamRecordingReport *)m->data;
+ if (report != NULL && report->recording_filename) {
+ free(report->recording_filename);
+ report->recording_filename = NULL;
+ }
+ if (report) {
+ free(report);
+ report = NULL;
+ }
+ } break;
+ case MM_MESSAGE_STREAMRECORDER_CONSUME_COMPLETE:
+ {
+ void *consume = (m->consumed_mediabuffer).consumed_buffer;
+ if (handle->user_cb[_STREAMRECORDER_EVENT_TYPE_CONSUME_COMPLETE]) {
+ ((streamrecorder_consume_completed_cb)handle->user_cb[_STREAMRECORDER_EVENT_TYPE_CONSUME_COMPLETE])(consume, handle->user_data[_STREAMRECORDER_EVENT_TYPE_CONSUME_COMPLETE]);
+ }
+ } break;
+ case MM_MESSAGE_STREAMRECORDER_ERROR:
+ switch (m->code) {
+ case MM_ERROR_STREAMRECORDER_GST_CORE:
+ case MM_ERROR_STREAMRECORDER_GST_LIBRARY:
+ case MM_ERROR_STREAMRECORDER_GST_RESOURCE:
+ case MM_ERROR_STREAMRECORDER_GST_STREAM:
+ case MM_ERROR_STREAMRECORDER_GST_NEGOTIATION:
+ case MM_ERROR_STREAMRECORDER_GST_FLOW_ERROR:
+ case MM_ERROR_STREAMRECORDER_ENCODER:
+ case MM_ERROR_STREAMRECORDER_ENCODER_BUFFER:
+ case MM_ERROR_STREAMRECORDER_ENCODER_WORKING:
+ case MM_ERROR_STREAMRECORDER_INTERNAL:
+ case MM_ERROR_FILE_NOT_FOUND:
+ case MM_ERROR_FILE_READ:
+ streamrecorder_error = STREAMRECORDER_ERROR_INVALID_OPERATION;
+ break;
+ case MM_ERROR_OUT_OF_STORAGE:
+ streamrecorder_error = STREAMRECORDER_ERROR_OUT_OF_STORAGE;
+ break;
+ default:
+ streamrecorder_error = STREAMRECORDER_ERROR_INVALID_OPERATION;
+ break;
+ }
+
+ if (streamrecorder_error != 0 && handle->user_cb[_STREAMRECORDER_EVENT_TYPE_ERROR]) {
+ ((streamrecorder_error_cb)handle->user_cb[_STREAMRECORDER_EVENT_TYPE_ERROR])(streamrecorder_error, handle->state, handle->user_data[_STREAMRECORDER_EVENT_TYPE_ERROR]);
+ }
+ break;
+ default:
+ break;
+ }
+ return 1;
+}
+
--- /dev/null
+/*
+* Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <mm.h>
+#include <mm_types.h>
+#include <mm_streamrecorder.h>
+#include <streamrecorder_private.h>
+#include <dlog.h>
+#include <math.h>
+#include <unistd.h>
+#include <errno.h>
+#include <fcntl.h>
+
+
+#define LOWSET_DECIBEL -300.0
+
+int __convert_streamrecorder_error_code(const char *func, int code)
+{
+ int ret = STREAMRECORDER_ERROR_INVALID_OPERATION;
+ const char *errorstr = NULL;
+
+ switch (code) {
+ case STREAMRECORDER_ERROR_INVALID_PARAMETER:
+ ret = STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ errorstr = "INVALID_PARAMETER";
+ break;
+ case MM_ERROR_NONE:
+ ret = STREAMRECORDER_ERROR_NONE;
+ errorstr = "ERROR_NONE";
+ break;
+ case MM_ERROR_STREAMRECORDER_INVALID_ARGUMENT:
+ case MM_ERROR_COMMON_INVALID_ATTRTYPE:
+ ret = STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ errorstr = "INVALID_PARAMETER";
+ break;
+ case MM_ERROR_COMMON_INVALID_PERMISSION:
+ ret = STREAMRECORDER_ERROR_PERMISSION_DENIED;
+ errorstr = "ERROR_PERMISSION_DENIED";
+ break;
+ case MM_ERROR_STREAMRECORDER_NOT_INITIALIZED:
+ ret = STREAMRECORDER_ERROR_INVALID_STATE;
+ errorstr = "INVALID_STATE";
+ break;
+ case MM_ERROR_STREAMRECORDER_GST_CORE:
+ case MM_ERROR_STREAMRECORDER_GST_LIBRARY:
+ case MM_ERROR_STREAMRECORDER_GST_RESOURCE:
+ case MM_ERROR_STREAMRECORDER_GST_STREAM:
+ case MM_ERROR_STREAMRECORDER_GST_STATECHANGE:
+ case MM_ERROR_STREAMRECORDER_GST_NEGOTIATION:
+ case MM_ERROR_STREAMRECORDER_GST_LINK:
+ case MM_ERROR_STREAMRECORDER_GST_FLOW_ERROR:
+ case MM_ERROR_STREAMRECORDER_ENCODER:
+ case MM_ERROR_STREAMRECORDER_ENCODER_BUFFER:
+ case MM_ERROR_STREAMRECORDER_ENCODER_WRONG_TYPE:
+ case MM_ERROR_STREAMRECORDER_ENCODER_WORKING:
+ case MM_ERROR_STREAMRECORDER_RESPONSE_TIMEOUT:
+ case MM_ERROR_STREAMRECORDER_CMD_IS_RUNNING:
+ ret = STREAMRECORDER_ERROR_INVALID_OPERATION;
+ errorstr = "INVALID_OPERATION";
+ break;
+ case MM_ERROR_STREAMRECORDER_RESOURCE_CREATION:
+ case MM_ERROR_COMMON_OUT_OF_MEMORY:
+ ret = STREAMRECORDER_ERROR_OUT_OF_MEMORY;
+ errorstr = "OUT_OF_MEMORY";
+ break;
+ case MM_ERROR_OUT_OF_STORAGE:
+ ret = STREAMRECORDER_ERROR_OUT_OF_STORAGE;
+ errorstr = "OUT_OF_STORAGE";
+ break;
+ case MM_ERROR_COMMON_OUT_OF_ARRAY:
+ case MM_ERROR_COMMON_OUT_OF_RANGE:
+ case MM_ERROR_COMMON_ATTR_NOT_EXIST:
+ ret = STREAMRECORDER_ERROR_NOT_SUPPORTED;
+ errorstr = "NOT_SUPPORTED";
+ break;
+ default:
+ ret = STREAMRECORDER_ERROR_INVALID_OPERATION;
+ errorstr = "INVALID_OPERATION";
+ break;
+ }
+
+
+ LOGE("[%s] %s(0x%08x) : core frameworks error code(0x%08x)", func, errorstr, ret, code);
+
+ return ret;
+}
+
+static streamrecorder_state_e __streamrecorder_state_convert(void *mm_state)
+{
+ streamrecorder_state_e state = STREAMRECORDER_STATE_NONE;
+ MMStreamRecorderStateType srstate = (MMStreamRecorderStateType)mm_state;
+
+ switch (srstate) {
+ case MM_STREAMRECORDER_STATE_NONE:
+ state = STREAMRECORDER_STATE_NONE;
+ break;
+ case MM_STREAMRECORDER_STATE_CREATED:
+ state = STREAMRECORDER_STATE_CREATED;
+ break;
+ case MM_STREAMRECORDER_STATE_PREPARED:
+ state = STREAMRECORDER_STATE_PREPARED;
+ break;
+ case MM_STREAMRECORDER_STATE_RECORDING:
+ state = STREAMRECORDER_STATE_RECORDING;
+ break;
+ case MM_STREAMRECORDER_STATE_PAUSED:
+ state = STREAMRECORDER_STATE_PAUSED;
+ break;
+ default:
+ state = STREAMRECORDER_STATE_NONE;
+ break;
+ }
+
+ return state;
+}
+
+static int _streamrecorder_check_and_set_attribute(streamrecorder_h recorder, const char *attribute_name, int set_value)
+{
+ int ret = MM_ERROR_NONE;
+
+ MMStreamRecorderStateType mmstate;
+ streamrecorder_s *handle = (streamrecorder_s *)recorder;
+
+ if (recorder == NULL) {
+ LOGE("handle is NULL");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ mm_streamrecorder_get_state(handle->mm_handle, &mmstate);
+ if (mmstate >= MM_STREAMRECORDER_STATE_RECORDING) {
+ LOGE("invalid state %d", mmstate);
+ return STREAMRECORDER_ERROR_INVALID_STATE;
+ }
+
+ ret = mm_streamrecorder_set_attributes(handle->mm_handle, NULL,
+ attribute_name, set_value,
+ NULL);
+
+ if (ret != MM_ERROR_NONE) {
+ LOGE("set [%s] failed 0x%x", attribute_name, ret);
+ }
+
+
+
+ return __convert_streamrecorder_error_code(attribute_name, ret);
+}
+
+
+int _streamrecorder_set_videosource_buffer(streamrecorder_h recorder)
+{
+ int ret = STREAMRECORDER_ERROR_NONE;
+ if (recorder == NULL)
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+
+ streamrecorder_s *handle = (streamrecorder_s *)recorder;
+
+ mm_streamrecorder_set_attributes(handle->mm_handle, NULL,
+ MMSTR_RECORDER_MODE, MM_STREAMRECORDER_MODE_MEDIABUFFER,
+ NULL);
+
+ mm_streamrecorder_set_attributes(handle->mm_handle, NULL,
+ MMSTR_VIDEO_ENABLE, true,
+ NULL);
+
+
+ return ret;
+}
+
+int _streamrecorder_set_audiosource_buffer(streamrecorder_h recorder)
+{
+ int ret = STREAMRECORDER_ERROR_NONE;
+ if (recorder == NULL)
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+
+ streamrecorder_s *handle;
+ handle = (streamrecorder_s *) recorder;
+ mm_streamrecorder_set_attributes(handle->mm_handle, NULL,
+ MMSTR_RECORDER_MODE, MM_STREAMRECORDER_MODE_MEDIABUFFER,
+ NULL);
+
+ mm_streamrecorder_set_attributes(handle->mm_handle, NULL,
+ MMSTR_AUDIO_ENABLE, true,
+ NULL);
+
+ return ret;
+}
+
+int _streamrecorder_get_state(streamrecorder_h recorder, streamrecorder_state_e *state)
+{
+ int ret = STREAMRECORDER_ERROR_NONE;
+ MMStreamRecorderStateType srstate;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+ if (state == NULL) {
+ LOGE("NULL pointer state");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ streamrecorder_s *handle = (streamrecorder_s *)recorder;
+
+
+ ret = mm_streamrecorder_get_state(handle->mm_handle, &srstate);
+ if (ret != MM_ERROR_NONE) {
+ return __convert_streamrecorder_error_code(__func__, ret);
+ }
+ *state = __streamrecorder_state_convert((void *)srstate);
+
+ return STREAMRECORDER_ERROR_NONE;
+}
+
+int _streamrecorder_destroy(streamrecorder_h recorder)
+{
+ streamrecorder_s *handle = NULL;
+ int ret = MM_ERROR_NONE;
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ handle = (streamrecorder_s *)recorder;
+
+ ret = mm_streamrecorder_destroy(handle->mm_handle);
+
+ if (ret == MM_ERROR_NONE) {
+ free(handle);
+ }
+
+ return __convert_streamrecorder_error_code(__func__, ret);
+}
+
+int _streamrecorder_prepare(streamrecorder_h recorder)
+{
+ int ret = MM_ERROR_NONE;
+ streamrecorder_s *handle = (streamrecorder_s *)recorder;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = mm_streamrecorder_realize(handle->mm_handle);
+ if (ret != MM_ERROR_NONE) {
+ LOGE("prepare fail");
+ return __convert_streamrecorder_error_code(__func__, ret);
+ }
+
+ return STREAMRECORDER_ERROR_NONE;
+}
+
+int _streamrecorder_unprepare(streamrecorder_h recorder)
+{
+ int ret = MM_ERROR_NONE;
+ streamrecorder_s *handle = (streamrecorder_s *)recorder;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = mm_streamrecorder_unrealize(handle->mm_handle);
+ if (ret != MM_ERROR_NONE) {
+ LOGE("stramrecorder_unrealize fail");
+ }
+ return __convert_streamrecorder_error_code(__func__, ret);
+}
+
+int _streamrecorder_start(streamrecorder_h recorder)
+{
+ streamrecorder_s *handle = (streamrecorder_s *)recorder;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ return __convert_streamrecorder_error_code(__func__, mm_streamrecorder_record(handle->mm_handle));
+}
+
+int _streamrecorder_pause(streamrecorder_h recorder)
+{
+ streamrecorder_s *handle = (streamrecorder_s *)recorder;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ return __convert_streamrecorder_error_code(__func__, mm_streamrecorder_pause(handle->mm_handle));
+}
+
+int _streamrecorder_commit(streamrecorder_h recorder)
+{
+ streamrecorder_s *handle = (streamrecorder_s *)recorder;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ return __convert_streamrecorder_error_code(__func__, mm_streamrecorder_commit(handle->mm_handle));
+}
+
+int _streamrecorder_cancel(streamrecorder_h recorder)
+{
+ streamrecorder_s *handle = (streamrecorder_s *)recorder;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ return __convert_streamrecorder_error_code(__func__, mm_streamrecorder_cancel(handle->mm_handle));
+}
+
+int _streamrecorder_set_video_framerate(streamrecorder_h recorder , int framerate)
+{
+ int ret = MM_ERROR_NONE;
+ streamrecorder_s *handle = (streamrecorder_s *)recorder;
+
+ ret = mm_streamrecorder_set_attributes(handle->mm_handle, NULL,
+ MMSTR_VIDEO_FRAMERATE, framerate,
+ NULL);
+
+ return __convert_streamrecorder_error_code(__func__, ret);
+
+}
+
+int _streamrecorder_get_video_framerate(streamrecorder_h recorder, int *framerate)
+{
+ int ret = MM_ERROR_NONE;
+ streamrecorder_s *handle = (streamrecorder_s *)recorder;
+
+ ret = mm_streamrecorder_get_attributes(handle->mm_handle, NULL,
+ MMSTR_VIDEO_FRAMERATE, framerate,
+ NULL);
+
+ return __convert_streamrecorder_error_code(__func__, ret);
+}
+
+int _streamrecorder_set_video_source_format(streamrecorder_h recorder , int format)
+{
+ int ret = MM_ERROR_NONE;
+ streamrecorder_s *handle = (streamrecorder_s *)recorder;
+
+ ret = mm_streamrecorder_set_attributes(handle->mm_handle, NULL,
+ MMSTR_VIDEO_SOURCE_FORMAT, format,
+ NULL);
+
+ return __convert_streamrecorder_error_code(__func__, ret);
+}
+
+int _streamrecorder_get_video_source_format(streamrecorder_h recorder, int *format)
+{
+ int ret = MM_ERROR_NONE;
+ streamrecorder_s *handle = (streamrecorder_s *)recorder;
+
+ ret = mm_streamrecorder_get_attributes(handle->mm_handle, NULL,
+ MMSTR_VIDEO_SOURCE_FORMAT, format,
+ NULL);
+
+ return __convert_streamrecorder_error_code(__func__, ret);
+}
+
+int _streamrecorder_set_video_resolution(streamrecorder_h recorder, int width, int height)
+{
+ int ret = MM_ERROR_NONE;
+ streamrecorder_s *handle = (streamrecorder_s *)recorder;
+ streamrecorder_state_e state;
+
+ if (handle == NULL) {
+ LOGE("NULL pointer handle");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+ streamrecorder_get_state(recorder, &state);
+ if (state > STREAMRECORDER_STATE_CREATED) {
+ LOGE("STREAMRECORDER_ERROR_INVALID_STATE (state:%d)", state);
+ return STREAMRECORDER_ERROR_INVALID_STATE;
+ }
+
+
+ ret = mm_streamrecorder_set_attributes(handle->mm_handle, NULL,
+ MMSTR_VIDEO_RESOLUTION_WIDTH, width,
+ MMSTR_VIDEO_RESOLUTION_HEIGHT, height,
+ NULL);
+
+ return __convert_streamrecorder_error_code(__func__, ret);
+}
+
+int _streamrecorder_get_video_resolution(streamrecorder_h recorder, int *width, int *height)
+{
+ int ret = MM_ERROR_NONE;
+ streamrecorder_s *handle = (streamrecorder_s *)recorder;
+
+ if (!handle) {
+ LOGE("NULL pointer handle");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+
+ if (!width || !height) {
+ LOGE("NULL pointer width = [%p], height = [%p]", width, height);
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = mm_streamrecorder_get_attributes(handle->mm_handle, NULL,
+ MMSTR_VIDEO_RESOLUTION_WIDTH , width,
+ MMSTR_VIDEO_RESOLUTION_HEIGHT , height,
+ NULL);
+ return __convert_streamrecorder_error_code(__func__, ret);
+}
+
+int _streamrecorder_foreach_supported_video_resolution(streamrecorder_h recorder, streamrecorder_supported_video_resolution_cb foreach_cb, void *user_data)
+{
+ int i = 0;
+ int ret = MM_ERROR_NONE;
+ streamrecorder_s * handle = (streamrecorder_s *)recorder;
+
+ if (!handle) {
+ LOGE("NULL pointer handle");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+
+ if (!foreach_cb) {
+ LOGE("NULL pointer callback");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ MMStreamRecorderAttrsInfo video_width;
+ MMStreamRecorderAttrsInfo video_height;
+ ret = mm_streamrecorder_get_attribute_info(handle->mm_handle, MMSTR_VIDEO_RESOLUTION_WIDTH, &video_width);
+ ret |= mm_streamrecorder_get_attribute_info(handle->mm_handle, MMSTR_VIDEO_RESOLUTION_HEIGHT, &video_height);
+
+ if (ret != MM_ERROR_NONE) {
+ return __convert_streamrecorder_error_code(__func__, ret);
+ }
+ for (i = 0 ; i < video_width.int_array.count ; i++) {
+ if (!foreach_cb(video_width.int_array.array[i], video_height.int_array.array[i], user_data)) {
+ break;
+ }
+ }
+
+ return STREAMRECORDER_ERROR_NONE;
+}
+
+
+int _streamrecorder_set_filename(streamrecorder_h recorder, const char *filename)
+{
+ int ret = MM_ERROR_NONE;
+ streamrecorder_s *handle = (streamrecorder_s *)recorder;
+
+ if (recorder == NULL) {
+ LOGE("handle is NULL");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ if (filename == NULL) {
+ LOGE("filename is NULL");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ MMStreamRecorderStateType mmstate = MM_STREAMRECORDER_STATE_NONE;
+ mm_streamrecorder_get_state(handle->mm_handle, &mmstate);
+ if (mmstate >= MM_STREAMRECORDER_STATE_RECORDING) {
+ LOGE("invalid state %d", mmstate);
+ return STREAMRECORDER_ERROR_INVALID_STATE;
+ }
+ ret = mm_streamrecorder_set_attributes(handle->mm_handle, NULL,
+ MMSTR_FILENAME, filename, strlen(filename),
+ NULL);
+ return __convert_streamrecorder_error_code(__func__, ret);
+}
+
+int _streamrecorder_get_filename(streamrecorder_h recorder, char **filename)
+{
+ int ret = MM_ERROR_NONE;
+ char *record_filename = NULL;
+ int record_filename_size;
+ streamrecorder_s *handle = (streamrecorder_s *)recorder;
+
+ if (recorder == NULL) {
+ LOGE("handle is NULL");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ if (filename == NULL) {
+ LOGE("filename is NULL");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = mm_streamrecorder_get_attributes(handle->mm_handle, NULL,
+ MMSTR_FILENAME, &record_filename, &record_filename_size,
+ NULL);
+ if (ret == MM_ERROR_NONE && record_filename) {
+ *filename = strdup(record_filename);
+ } else {
+ LOGE("internal return (0x%08x), get filename p:%p", ret, record_filename);
+ *filename = NULL;
+ }
+ return __convert_streamrecorder_error_code(__func__, ret);
+}
+
+int _streamrecorder_set_file_format(streamrecorder_h recorder, streamrecorder_file_format_e format)
+{
+ int format_table[5] = {MM_FILE_FORMAT_3GP, /* STREAMRECORDER_FILE_FORMAT_3GP */
+ MM_FILE_FORMAT_MP4, /* STREAMRECORDER_FILE_FORMAT_MP4 */
+ MM_FILE_FORMAT_AMR, /* STREAMRECORDER_FILE_FORMAT_AMR */
+ MM_FILE_FORMAT_AAC, /* STREAMRECORDER_FILE_FORMAT_ADTS */
+ MM_FILE_FORMAT_WAV, /* STREAMRECORDER_FILE_FORMAT_WAV */
+ };
+
+ if (format < STREAMRECORDER_FILE_FORMAT_3GP || format > STREAMRECORDER_FILE_FORMAT_WAV) {
+ LOGE("invalid format %d", format);
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+ return _streamrecorder_check_and_set_attribute(recorder, MMSTR_FILE_FORMAT, format_table[format]);
+
+}
+
+int _streamrecorder_get_file_format(streamrecorder_h recorder, streamrecorder_file_format_e *format)
+{
+ int ret = MM_ERROR_NONE;
+ streamrecorder_s *handle = (streamrecorder_s *)recorder;
+ int mm_format;
+
+ if (recorder == NULL) {
+ LOGE("handle is NULL");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ if (format == NULL) {
+ LOGE("format is NULL");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = mm_streamrecorder_get_attributes(handle->mm_handle, NULL,
+ MMSTR_FILE_FORMAT, &mm_format,
+ NULL);
+ if (ret == MM_ERROR_NONE) {
+ switch (mm_format) {
+ case MM_FILE_FORMAT_3GP:
+ *format = STREAMRECORDER_FILE_FORMAT_3GP;
+ break;
+ case MM_FILE_FORMAT_MP4:
+ *format = STREAMRECORDER_FILE_FORMAT_MP4;
+ break;
+ case MM_FILE_FORMAT_AMR:
+ *format = STREAMRECORDER_FILE_FORMAT_AMR;
+ break;
+ case MM_FILE_FORMAT_AAC:
+ *format = STREAMRECORDER_FILE_FORMAT_ADTS;
+ break;
+ case MM_FILE_FORMAT_WAV:
+ *format = STREAMRECORDER_FILE_FORMAT_WAV;
+ break;
+ default:
+ ret = MM_ERROR_STREAMRECORDER_INTERNAL;
+ break;
+ }
+ }
+
+ return __convert_streamrecorder_error_code(__func__, ret);
+}
+
+int _streamrecorder_foreach_supported_file_format(streamrecorder_h recorder, streamrecorder_supported_file_format_cb foreach_cb, void *user_data)
+{
+ int i = 0;
+ int ret = MM_ERROR_NONE;
+ streamrecorder_s *handle = (streamrecorder_s *)recorder;
+ int format;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+ if (foreach_cb == NULL) {
+ LOGE("NULL pointer foreach_cb");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ MMStreamRecorderAttrsInfo info;
+ ret = mm_streamrecorder_get_attribute_info(handle->mm_handle, MMSTR_FILE_FORMAT, &info);
+ if (ret != MM_ERROR_NONE) {
+ LOGE("mm_streamrecorder_get_attribute_info failed 0x%x", ret);
+ return __convert_streamrecorder_error_code(__func__, ret);
+ }
+
+ for (i = 0 ; i < info.int_array.count ; i++) {
+ switch (info.int_array.array[i]) {
+ case MM_FILE_FORMAT_3GP:
+ format = STREAMRECORDER_FILE_FORMAT_3GP;
+ break;
+ case MM_FILE_FORMAT_MP4:
+ format = STREAMRECORDER_FILE_FORMAT_MP4;
+ break;
+ case MM_FILE_FORMAT_AMR:
+ format = STREAMRECORDER_FILE_FORMAT_AMR;
+ break;
+ case MM_FILE_FORMAT_AAC:
+ format = STREAMRECORDER_FILE_FORMAT_ADTS;
+ break;
+ case MM_FILE_FORMAT_WAV:
+ format = STREAMRECORDER_FILE_FORMAT_WAV;
+ break;
+ default:
+ format = -1;
+ break;
+ }
+
+ if (format != -1 && !foreach_cb(format, user_data)) {
+ break;
+ }
+ }
+
+ return STREAMRECORDER_ERROR_NONE;
+}
+
+int _streamrecorder_set_size_limit(streamrecorder_h recorder, int kbyte)
+{
+ int ret = MM_ERROR_NONE;
+ streamrecorder_s *handle = (streamrecorder_s *)recorder;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = mm_streamrecorder_set_attributes(handle->mm_handle, NULL,
+ MMSTR_TARGET_MAX_SIZE, kbyte,
+ NULL);
+ return __convert_streamrecorder_error_code(__func__, ret);
+}
+
+int _streamrecorder_set_time_limit(streamrecorder_h recorder, int second)
+{
+ int ret = MM_ERROR_NONE;
+ streamrecorder_s *handle = (streamrecorder_s *)recorder;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = mm_streamrecorder_set_attributes(handle->mm_handle, NULL,
+ MMSTR_TARGET_TIME_LIMIT, second,
+ NULL);
+ return __convert_streamrecorder_error_code(__func__, ret);
+}
+
+int _streamrecorder_set_audio_encoder(streamrecorder_h recorder, streamrecorder_audio_codec_e codec)
+{
+ streamrecorder_s *handle = (streamrecorder_s *)recorder;
+ int audio_table[3] = { MM_AUDIO_CODEC_AMR, /* STREAMRECORDER_AUDIO_CODEC_AMR */
+ MM_AUDIO_CODEC_AAC, /* STREAMRECORDER_AUDIO_CODEC_AAC */
+ MM_AUDIO_CODEC_WAVE /* STREAMRECORDER_AUDIO_CODEC_PCM */
+ };
+
+ if (recorder == NULL) {
+ LOGE("handle is NULL");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ if ((codec < STREAMRECORDER_AUDIO_CODEC_AMR || codec > STREAMRECORDER_AUDIO_CODEC_PCM)) {
+ LOGE("invalid parameter : codec %d", codec);
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ return _streamrecorder_check_and_set_attribute(recorder, MMSTR_AUDIO_ENCODER, audio_table[codec]);
+}
+
+int _streamrecorder_get_audio_encoder(streamrecorder_h recorder, streamrecorder_audio_codec_e *codec)
+{
+ int ret = MM_ERROR_NONE;
+ int mm_codec = 0;
+ int audio_enable = 0;
+ streamrecorder_s *handle = (streamrecorder_s *)recorder;
+
+ if (recorder == NULL) {
+ LOGE("handle is NULL");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ if (codec == NULL) {
+ LOGE("codec is NULL");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = mm_streamrecorder_get_attributes(handle->mm_handle, NULL,
+ MMSTR_AUDIO_ENCODER, &mm_codec,
+ MMSTR_AUDIO_ENABLE, &audio_enable,
+ NULL);
+
+ if (ret == MM_ERROR_NONE && audio_enable != 0) {
+ switch (mm_codec) {
+ case MM_AUDIO_CODEC_AMR:
+ *codec = STREAMRECORDER_AUDIO_CODEC_AMR;
+ break;
+ case MM_AUDIO_CODEC_AAC:
+ *codec = STREAMRECORDER_AUDIO_CODEC_AAC;
+ break;
+ case MM_AUDIO_CODEC_WAVE:
+ *codec = STREAMRECORDER_AUDIO_CODEC_PCM;
+ break;
+ default:
+ ret = MM_ERROR_STREAMRECORDER_INTERNAL;
+ break;
+ }
+ } else {
+ ret = MM_ERROR_STREAMRECORDER_INTERNAL;
+ }
+
+ return __convert_streamrecorder_error_code(__func__, ret);
+}
+
+int _streamrecorder_set_video_encoder(streamrecorder_h recorder, streamrecorder_video_codec_e codec)
+{
+ int ret = MM_ERROR_NONE;
+ int video_table[2] = {MM_VIDEO_CODEC_H263, /* STREAMRECORDER_VIDEO_CODEC_H263 */
+ MM_VIDEO_CODEC_MPEG4, /* STREAMRECORDER_VIDEO_CODEC_MPEG4 */
+ };
+ streamrecorder_s *handle = (streamrecorder_s *)recorder;
+
+ if (handle == NULL) {
+ LOGE("handle is NULL");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+
+ if (codec < STREAMRECORDER_VIDEO_CODEC_H263 || codec > STREAMRECORDER_VIDEO_CODEC_MPEG4) {
+ LOGE("invalid codec %d", codec);
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = mm_streamrecorder_set_attributes(handle->mm_handle, NULL,
+ MMSTR_VIDEO_ENCODER, video_table[codec],
+ NULL);
+ return __convert_streamrecorder_error_code(__func__, ret);
+}
+
+int _streamrecorder_get_video_encoder(streamrecorder_h recorder, streamrecorder_video_codec_e *codec)
+{
+ int ret = MM_ERROR_NONE;
+ int mm_codec = 0;
+ streamrecorder_s *handle = (streamrecorder_s *)recorder;
+
+ if (handle == NULL) {
+ LOGE("handle is NULL");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+ if (codec == NULL) {
+ LOGE("codec is NULL");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = mm_streamrecorder_get_attributes(handle->mm_handle, NULL,
+ MMSTR_VIDEO_ENCODER, &mm_codec,
+ NULL);
+ if (ret == MM_ERROR_NONE) {
+ switch (mm_codec) {
+ case MM_VIDEO_CODEC_H263:
+ *codec = STREAMRECORDER_VIDEO_CODEC_H263;
+ break;
+ case MM_VIDEO_CODEC_MPEG4:
+ *codec = STREAMRECORDER_VIDEO_CODEC_MPEG4;
+ break;
+ default:
+ ret = MM_ERROR_STREAMRECORDER_INTERNAL;
+ break;
+ }
+ }
+
+ return __convert_streamrecorder_error_code(__func__, ret);
+}
+
+
+int _streamrecorder_set_audio_samplerate(streamrecorder_h recorder, int samplerate)
+{
+ if (samplerate < 1) {
+ LOGE("invalid samplerate %d", samplerate);
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ return _streamrecorder_check_and_set_attribute(recorder, MMSTR_AUDIO_SAMPLERATE, samplerate);
+
+}
+
+int _streamrecorder_set_audio_encoder_bitrate(streamrecorder_h recorder, int bitrate)
+{
+ if (bitrate < 1) {
+ LOGE("invalid bitrate %d", bitrate);
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ return _streamrecorder_check_and_set_attribute(recorder, MMSTR_AUDIO_BITRATE, bitrate);
+
+}
+
+int _streamrecorder_set_video_encoder_bitrate(streamrecorder_h recorder, int bitrate)
+{
+ int ret = MM_ERROR_NONE;
+ streamrecorder_s *handle = (streamrecorder_s *)recorder;
+
+ if (handle == NULL) {
+ LOGE("handle is NULL");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = mm_streamrecorder_set_attributes(handle->mm_handle, NULL,
+ MMSTR_VIDEO_BITRATE, bitrate,
+ NULL);
+
+ return __convert_streamrecorder_error_code(__func__, ret);
+}
+
+int _streamrecorder_get_size_limit(streamrecorder_h recorder, int *kbyte)
+{
+ int ret = MM_ERROR_NONE;
+ streamrecorder_s *handle = (streamrecorder_s *)recorder;
+
+ if (recorder == NULL) {
+ LOGE("handle is NULL");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = mm_streamrecorder_get_attributes(handle->mm_handle, NULL,
+ MMSTR_TARGET_MAX_SIZE, kbyte,
+ NULL);
+
+ return __convert_streamrecorder_error_code(__func__, ret);
+}
+
+int _streamrecorder_get_time_limit(streamrecorder_h recorder, int *second)
+{
+ int ret = MM_ERROR_NONE;
+ streamrecorder_s *handle = (streamrecorder_s *)recorder;
+
+ if (recorder == NULL) {
+ LOGE("handle is NULL");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = mm_streamrecorder_get_attributes(handle->mm_handle, NULL,
+ MMSTR_TARGET_TIME_LIMIT, second,
+ NULL);
+
+ return __convert_streamrecorder_error_code(__func__, ret);
+}
+
+
+int _streamrecorder_get_audio_samplerate(streamrecorder_h recorder, int *samplerate)
+{
+ int ret = MM_ERROR_NONE;
+ streamrecorder_s *handle = (streamrecorder_s *)recorder;
+
+ if (recorder == NULL) {
+ LOGE("handle is NULL");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = mm_streamrecorder_get_attributes(handle->mm_handle, NULL,
+ MMSTR_AUDIO_SAMPLERATE, samplerate,
+ NULL);
+
+ return __convert_streamrecorder_error_code(__func__, ret);
+}
+
+int _streamrecorder_get_audio_encoder_bitrate(streamrecorder_h recorder, int *bitrate)
+{
+ int ret = MM_ERROR_NONE;
+ streamrecorder_s *handle = (streamrecorder_s *)recorder;
+
+ if (recorder == NULL) {
+ LOGE("handle is NULL");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = mm_streamrecorder_get_attributes(handle->mm_handle, NULL,
+ MMSTR_AUDIO_BITRATE, bitrate,
+ NULL);
+
+ return __convert_streamrecorder_error_code(__func__, ret);
+}
+
+int _streamrecorder_get_video_encoder_bitrate(streamrecorder_h recorder, int *bitrate)
+{
+ int ret = MM_ERROR_NONE;
+ streamrecorder_s *handle = (streamrecorder_s *)recorder;
+
+ if (handle == NULL) {
+ LOGE("handle is NULL");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+ ret = mm_streamrecorder_get_attributes(handle->mm_handle, NULL,
+ MMSTR_VIDEO_BITRATE, bitrate,
+ NULL);
+ return __convert_streamrecorder_error_code(__func__, ret);
+}
+
+int _streamrecorder_foreach_supported_audio_encoder(streamrecorder_h recorder, streamrecorder_supported_audio_encoder_cb foreach_cb, void *user_data)
+{
+ int i = 0;
+ int ret = MM_ERROR_NONE;
+ int codec;
+ streamrecorder_s *handle = (streamrecorder_s *)recorder;
+
+ if (recorder == NULL) {
+ LOGE("handle is NULL");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+ if (foreach_cb == NULL) {
+ LOGE("foreach_cb is NULL");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ MMStreamRecorderAttrsInfo info;
+ ret = mm_streamrecorder_get_attribute_info(handle->mm_handle, MMSTR_AUDIO_ENCODER, &info);
+ if (ret != MM_ERROR_NONE) {
+ return __convert_streamrecorder_error_code(__func__, ret);
+ }
+
+ for (i = 0 ; i < info.int_array.count ; i++) {
+ switch (info.int_array.array[i]) {
+ case MM_AUDIO_CODEC_AMR:
+ codec = STREAMRECORDER_AUDIO_CODEC_AMR;
+ break;
+ case MM_AUDIO_CODEC_AAC:
+ codec = STREAMRECORDER_AUDIO_CODEC_AAC;
+ break;
+ case MM_AUDIO_CODEC_WAVE:
+ codec = STREAMRECORDER_AUDIO_CODEC_PCM;
+ break;
+ default:
+ codec = -1;
+ break;
+ }
+ if (codec != -1 && !foreach_cb(codec, user_data)) {
+ break;
+ }
+ }
+
+ return STREAMRECORDER_ERROR_NONE;
+}
+
+
+int _streamrecorder_foreach_supported_video_encoder(streamrecorder_h recorder, streamrecorder_supported_video_encoder_cb foreach_cb, void *user_data)
+{
+ int i = 0;
+ int ret = MM_ERROR_NONE;
+ int codec;
+ streamrecorder_s *handle = (streamrecorder_s *)recorder;
+
+ if (handle == NULL) {
+ LOGE("handle is NULL");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+ if (foreach_cb == NULL) {
+ LOGE("foreach_cb is NULL");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ MMStreamRecorderAttrsInfo info;
+ ret = mm_streamrecorder_get_attribute_info(handle->mm_handle, MMSTR_VIDEO_ENCODER, &info);
+ if (ret != MM_ERROR_NONE) {
+ return __convert_streamrecorder_error_code(__func__, ret);
+ }
+
+ for (i = 0 ; i < info.int_array.count ; i++) {
+ switch (info.int_array.array[i]) {
+ case MM_VIDEO_CODEC_H263:
+ codec = STREAMRECORDER_VIDEO_CODEC_H263;
+ break;
+ case MM_VIDEO_CODEC_MPEG4:
+ codec = STREAMRECORDER_VIDEO_CODEC_MPEG4;
+ break;
+ default:
+ codec = -1;
+ break;
+ }
+
+ if (codec != -1 && !foreach_cb(codec, user_data)) {
+ break;
+ }
+ }
+
+ return STREAMRECORDER_ERROR_NONE;
+}
+
+
+
+int _streamrecorder_set_audio_channel(streamrecorder_h recorder, int channel_count)
+{
+ if (channel_count < 1) {
+ LOGE("invalid channel %d", channel_count);
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ return _streamrecorder_check_and_set_attribute(recorder, MMSTR_AUDIO_CHANNEL, channel_count);
+}
+
+int _streamrecorder_get_audio_channel(streamrecorder_h recorder, int *channel_count)
+{
+ int ret = MM_ERROR_NONE;
+ streamrecorder_s *handle = (streamrecorder_s *)recorder;
+
+ if (recorder == NULL) {
+ LOGE("handle is NULL");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+ if (channel_count == NULL) {
+ LOGE("channel_count is NULL");
+ return STREAMRECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = mm_streamrecorder_get_attributes(handle->mm_handle, NULL,
+ MMSTR_AUDIO_CHANNEL, channel_count,
+ NULL);
+
+ return __convert_streamrecorder_error_code(__func__, ret);
+}
+
--- /dev/null
+CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
+SET(fw_test "${fw_name}-test")
+
+#INCLUDE_DIRECTORIES(../include)
+#link_directories(${CMAKE_SOURCE_DIR}/../)
+
+INCLUDE(FindPkgConfig)
+pkg_check_modules(${fw_test} REQUIRED mm-streamrecorder)
+FOREACH(flag ${${fw_test}_CFLAGS})
+ SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}")
+ MESSAGE(${flag})
+ENDFOREACH()
+
+SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS} -fPIC -pie -Wall")
+
+aux_source_directory(. sources)
+FOREACH(src ${sources})
+ GET_FILENAME_COMPONENT(src_name ${src} NAME_WE)
+ MESSAGE("${src_name}")
+ ADD_EXECUTABLE(${src_name} ${src})
+ TARGET_LINK_LIBRARIES(${src_name} ${fw_name} ${${fw_test}_LDFLAGS})
+ INSTALL(TARGETS ${src_name} DESTINATION bin)
+
+ENDFOREACH()
--- /dev/null
+/*
+* recorder_testsuite
+*
+* Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*
+*/
+
+/*=======================================================================================
+| INCLUDE FILES |
+=======================================================================================*/
+#include <stdio.h>
+#include <stdlib.h>
+#include <glib.h>
+#include <gst/gst.h>
+#include <sys/time.h>
+#include <media_format.h>
+#include <streamrecorder.h>
+#include <streamrecorder_private.h>
+
+#define LOGD g_print
+#define LOGE g_print
+#define LOGW g_print
+/*-----------------------------------------------------------------------
+| GLOBAL VARIABLE DEFINITIONS: |
+-----------------------------------------------------------------------*/
+#define EXPORT_API __attribute__((__visibility__("default")))
+
+#define PACKAGE "recorder_testsuite"
+
+GMainLoop *g_loop;
+GIOChannel *stdin_channel;
+int resolution_set;
+int g_current_state;
+int src_w, src_h;
+GstCaps *filtercaps;
+int recorder_state;
+static GTimer *timer = NULL;
+void *display;
+
+/*-----------------------------------------------------------------------
+| GLOBAL CONSTANT DEFINITIONS: |
+-----------------------------------------------------------------------*/
+
+
+/*-----------------------------------------------------------------------
+| IMPORTED VARIABLE DECLARATIONS: |
+-----------------------------------------------------------------------*/
+
+
+/*-----------------------------------------------------------------------
+| IMPORTED FUNCTION DECLARATIONS: |
+-----------------------------------------------------------------------*/
+
+
+/*-----------------------------------------------------------------------
+| LOCAL #defines: |
+-----------------------------------------------------------------------*/
+
+
+#define DISPLAY_W_320 320 /*for direct FB*/
+#define DISPLAY_H_240 240 /*for direct FB*/
+
+
+#define SRC_VIDEO_FRAME_RATE_15 15 /* video input frame rate */
+#define SRC_VIDEO_FRAME_RATE_30 30 /* video input frame rate */
+#define IMAGE_ENC_QUALITY 85 /* quality of jpeg */
+
+#define MAX_FILE_SIZE_FOR_MMS (250 * 1024)
+
+#define EXT_JPEG "jpg"
+#define EXT_MP4 "mp4"
+#define EXT_3GP "3gp"
+#define EXT_AMR "amr"
+#define EXT_MKV "mkv"
+
+#define TARGET_FILENAME_PATH "/opt/usr/media/"
+#define IMAGE_CAPTURE_EXIF_PATH TARGET_FILENAME_PATH"exif.raw"
+#define TARGET_FILENAME_VIDEO TARGET_FILENAME_PATH"test.mp4"
+#define TARGET_FILENAME_AUDIO TARGET_FILENAME_PATH"test_rec_audio.m4a"
+#define CAPTURE_FILENAME_LEN 256
+
+#define AUDIO_SOURCE_SAMPLERATE_AAC 44100
+#define AUDIO_SOURCE_SAMPLERATE_AMR 8000
+#define AUDIO_SOURCE_FORMAT MM_STREAMRECORDER_AUDIO_FORMAT_PCM_S16_LE
+#define AUDIO_SOURCE_CHANNEL_AAC 2
+#define AUDIO_SOURCE_CHANNEL_AMR 1
+#define VIDEO_ENCODE_BITRATE 40000000 /* bps */
+
+#define CHECK_MM_ERROR(expr) \
+do {\
+ int ret = 0; \
+ ret = expr; \
+ if (ret != 0) {\
+ printf("[%s:%d] error code : %x \n", __func__, __LINE__, ret); \
+ return; \
+ } \
+} while (0)
+
+
+#ifndef SAFE_FREE
+#define SAFE_FREE(x) if (x) { g_free(x); x = NULL; }
+#endif
+
+
+GTimeVal previous;
+GTimeVal current;
+GTimeVal result;
+/*temp*/
+
+/**
+* Enumerations for command
+*/
+#define SENSOR_WHITEBALANCE_NUM 10
+#define SENSOR_COLOR_TONE_NUM 31
+#define SENSOR_FLIP_NUM 3
+#define SENSOR_PROGRAM_MODE_NUM 15
+#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: |
+-----------------------------------------------------------------------*/
+enum {
+ MODE_LIVE_BUFFER_I420_VIDEO , /*video capturing mode from live buffer I420 using software encoder*/
+ MODE_LIVE_BUFFER_NV12_VIDEO_SW , /*video capturing mode from live buffer NV12 using software encoder */
+ MODE_LIVE_BUFFER_NV12_VIDEO_HW , /*video capturing mode from live buffer NV12 using hardware encoder*/
+ MODE_NUM,
+};
+
+enum {
+ MENU_STATE_MAIN,
+ MENU_STATE_NUM,
+};
+
+/*-----------------------------------------------------------------------
+| LOCAL DATA TYPE DEFINITIONS: |
+-----------------------------------------------------------------------*/
+typedef struct _mstreamrecorder_handle {
+ streamrecorder_h recorder;
+ int mode; /*video/audio(recording) mode */
+ int menu_state;
+ int fps;
+ bool isMute;
+ unsigned long long elapsed_time;
+} mstreamrecorder_handle_t;
+
+
+/*---------------------------------------------------------------------------
+| LOCAL VARIABLE DEFINITIONS: |
+---------------------------------------------------------------------------*/
+static mstreamrecorder_handle_t *hmstreamrecorder ;
+
+/*---------------------------------------------------------------------------
+| LOCAL FUNCTION PROTOTYPES: |
+---------------------------------------------------------------------------*/
+static void print_menu();
+static gboolean cmd_input(GIOChannel *channel);
+static gboolean init(int type);
+static gboolean mode_change();
+
+
+void _recording_status_cb(unsigned long long elapsed_time, unsigned long long file_size, void *user_data)
+{
+ printf("elapsed time :%d, file_size :%d\n", elapsed_time, file_size);
+}
+
+void _recording_limit_reached_cb(streamrecorder_recording_limit_type_e type, void *user_data)
+{
+ g_print("limited!! %d\n", type);
+ int *ischeck = (int *)user_data;
+ *ischeck = 1;
+}
+static inline void flush_stdin()
+{
+ int ch;
+ while ((ch = getchar()) != EOF && ch != '\n');
+}
+
+
+static void print_menu()
+{
+ switch (hmstreamrecorder->menu_state) {
+ case MENU_STATE_MAIN:
+ if (hmstreamrecorder->mode == MODE_LIVE_BUFFER_I420_VIDEO || hmstreamrecorder->mode == MODE_LIVE_BUFFER_NV12_VIDEO_SW) {
+ g_print("\n\t=======================================\n");
+ if (recorder_state <= STREAMRECORDER_STATE_NONE) {
+ g_print("\t '1' Start Recording\n");
+ g_print("\t 'b' back\n");
+ } else if (recorder_state == STREAMRECORDER_STATE_RECORDING) {
+ g_print("\t 'p' Pause Recording\n");
+ g_print("\t 'c' Cancel\n");
+ g_print("\t 's' Save\n");
+ } else if (recorder_state == STREAMRECORDER_STATE_PAUSED) {
+ g_print("\t 'r' Resume Recording\n");
+ g_print("\t 's' Save\n");
+ }
+ }
+ break;
+
+ default:
+ LOGE("unknow menu state !!\n");
+ break;
+ }
+ return;
+}
+
+media_packet_h streamrecorder_make_media_packet(int video, void *data, int size)
+{
+ guint8 *pkt_data;
+ media_packet_h out_pkt;
+ media_format_h output_fmt;
+ if (media_format_create(&output_fmt)) {
+ g_print("media_format_create failed\n");
+ return NULL;
+ }
+ int i;
+ int bo_num = 0;
+
+ if (video) {
+ if (hmstreamrecorder->mode == MODE_LIVE_BUFFER_NV12_VIDEO_SW) {
+ media_format_set_video_mime(output_fmt, MEDIA_FORMAT_NV12);
+ } else if (hmstreamrecorder->mode == MODE_LIVE_BUFFER_I420_VIDEO) {
+ media_format_set_video_mime(output_fmt, MEDIA_FORMAT_I420);
+ }
+ media_format_set_video_width(output_fmt, 1280);
+ media_format_set_video_height(output_fmt, 720);
+ if (media_format_set_video_frame_rate(output_fmt, 30)) {
+ g_print("media_format_set_video_frame_rate failed\n");
+ return NULL;
+ }
+ } else {
+ media_format_set_audio_mime(output_fmt, MEDIA_FORMAT_PCM);
+ media_format_set_audio_channel(output_fmt, 1);
+ media_format_set_audio_samplerate(output_fmt, 44100);
+ /*media_format_set_audio_bit(core->output_fmt, info->bit);*/
+ }
+ if (media_packet_create(output_fmt, NULL, NULL, &out_pkt)) {
+ g_print("create video media_packet failed\n");
+ return NULL;
+ }
+ if (media_packet_alloc(out_pkt)) {
+ g_print("video media_packet alloc failed\n");
+ return NULL;
+ }
+ media_packet_get_buffer_data_ptr(out_pkt, (void **)&pkt_data);
+ memcpy((char *)pkt_data, data, size);
+ if (media_packet_set_buffer_size(out_pkt, (uint64_t)(size))) {
+ g_print("video set_buffer_size failed\n");
+ return NULL;
+ }
+
+ return out_pkt;
+}
+
+void feed_video_es(GstElement *element, GstBuffer *buffer, GstPad *pad, gpointer data)
+{
+ guint n;
+ GstMemory *mem;
+ GstMapInfo map = GST_MAP_INFO_INIT;
+ media_packet_h out_pkt = NULL;
+ static GstBuffer *buf = NULL;
+ MMVideoBuffer *m_buf;
+
+ MMHandleType handle = (MMHandleType)data;
+
+ gst_buffer_ref(buffer);
+
+ n = gst_buffer_n_memory(buffer);
+
+ mem = gst_buffer_peek_memory(buffer, n-1);
+
+ gst_memory_map(mem, &map, GST_MAP_READ);
+ out_pkt = streamrecorder_make_media_packet(1, map.data, map.size);
+ gst_memory_unmap(mem, &map);
+ if (out_pkt) {
+ media_packet_set_pts(out_pkt, buffer->pts);
+ media_packet_set_extra(out_pkt, buffer);
+ streamrecorder_push_stream_buffer(hmstreamrecorder->recorder, out_pkt);
+ }
+ return;
+}
+
+GstElement *vpipeline, *vconvert, *vsrc, *vfakesink, *vcaps;
+void close_pipeline(void)
+{
+ if (vpipeline)
+ gst_object_unref(vpipeline);
+ if (vsrc)
+ gst_object_unref(vsrc);
+ if (vfakesink)
+ gst_object_unref(vfakesink);
+ if (vcaps)
+ gst_object_unref(vcaps);
+ if (vconvert)
+ gst_object_unref(vconvert);
+}
+
+
+int __feed_buffer_test(MMHandleType handle, int mode)
+{
+
+ GstCaps *caps;
+ g_print("creating __feed_buffer_test pipeline\n");
+ if (!handle)
+ return FALSE;
+ /* create video pipeline */
+ vpipeline = gst_pipeline_new(NULL);
+ if (!vpipeline) {
+ g_print("pipeline create fail\n");
+ return FALSE;
+ }
+ if (mode == MODE_LIVE_BUFFER_NV12_VIDEO_SW) {
+ vsrc = gst_element_factory_make("videotestsrc", NULL);
+ if (!vsrc) {
+ g_print("src element creation failed\n");
+ return FALSE;
+ }
+ } else {
+ vsrc = gst_element_factory_make("videotestsrc", NULL);
+ if (!vsrc) {
+ g_print("src element creation failed\n");
+ return FALSE;
+ }
+ }
+ if (mode == MODE_LIVE_BUFFER_NV12_VIDEO_SW) {
+ vconvert = gst_element_factory_make("videoconvert", NULL);
+ if (!vconvert) {
+ g_print("convert element creation failed\n");
+ return FALSE;
+ }
+ }
+ vcaps = gst_element_factory_make("capsfilter", NULL);
+ if (!vcaps) {
+ g_print("capsfilter element creation failed\n");
+ return FALSE;
+ }
+ if (mode == MODE_LIVE_BUFFER_I420_VIDEO) {
+ caps = gst_caps_new_simple("video/x-raw",
+ "format", G_TYPE_STRING, "I420",
+ "width", G_TYPE_INT, 1280,
+ "height", G_TYPE_INT, 720, NULL);
+ } else if (mode == MODE_LIVE_BUFFER_NV12_VIDEO_SW) {
+ caps = gst_caps_new_simple("video/x-raw",
+ "format", G_TYPE_STRING, "NV12",
+ "width", G_TYPE_INT, 1280,
+ "height", G_TYPE_INT, 720,
+ "framerate", GST_TYPE_FRACTION, 30, 1, NULL);
+ }
+ g_object_set(vcaps, "caps", caps, NULL);
+ gst_caps_unref(caps);
+
+ vfakesink = gst_element_factory_make("fakesink", NULL);
+ if (!vfakesink) {
+ g_print("video fakesink creation failed\n");
+ return FALSE;
+ }
+ g_object_set(GST_OBJECT(vfakesink), "signal-handoffs", TRUE, NULL);
+ g_signal_connect(vfakesink, "handoff", G_CALLBACK(feed_video_es), handle);
+
+ if (mode == MODE_LIVE_BUFFER_I420_VIDEO) {
+ gst_bin_add_many(GST_BIN(vpipeline), vsrc, vcaps, vfakesink, NULL);
+ /* link elements */
+ if (!gst_element_link_many(vsrc, vcaps, vfakesink, NULL)) {
+ GST_WARNING("Can't link elements video pipeline");
+ return FALSE;
+ }
+ } else if (mode == MODE_LIVE_BUFFER_NV12_VIDEO_SW) {
+ gst_bin_add_many(GST_BIN(vpipeline), vsrc, vconvert, vcaps, vfakesink, NULL);
+ /* link elements */
+ if (!gst_element_link_many(vsrc , vconvert, vcaps, vfakesink, NULL)) {
+ GST_WARNING("Can't link elements video pipeline");
+ return FALSE;
+ }
+ }
+ g_print("Linking done video pipeline\n");
+
+#if 0
+ GstElement *a_pipeline, *asrc, *afakesink;
+ /* create common elements */
+ a_pipeline = gst_pipeline_new(NULL);
+ if (v_pipeline) {
+ g_print("pipeline create fail\n");
+ return FALSE;
+ }
+ asrc = gst_element_factory_make("audiotestsrc", NULL);
+ if (!asrc) {
+ g_print("src element creation failed\n");
+ return FALSE;
+ }
+ afakesink = gst_element_factory_make("fakesink", NULL);
+ if (!afakesink) {
+ g_print("audio fakesink creation failed\n");
+ return FALSE;
+ }
+ /* connect handoff */
+ g_object_set(GST_OBJECT(afakesink), "signal-handoffs", TRUE, NULL);
+ g_signal_connect(fakesink, "handoff", G_CALLBACK(feed_audio_es), handle);
+
+ gst_bin_add_many(GST_BIN(v_pipeline), asrc, afakesink, NULL);
+
+ /* link elements */
+ if (!gst_element_link_many(asrc, afakesink, NULL)) {
+ GST_WARNING("Can't link elements audio pipeline");
+ return FALSE;
+ }
+ g_print("Linking done audio pipeline\n");
+ gst_element_set_state(apipeline, GST_STATE_PLAYING);
+#endif
+ gst_element_set_state(vpipeline, GST_STATE_PLAYING);
+ g_print("feed_task pipeline is playing\n");
+
+ return 0;
+}
+
+
+static void main_menu(gchar buf)
+{
+ int err = 0;
+ int current_fps = 0;
+ int average_fps = 0;
+ char *err_attr_name = NULL;
+
+ if (hmstreamrecorder->mode == MODE_LIVE_BUFFER_I420_VIDEO || hmstreamrecorder->mode == MODE_LIVE_BUFFER_NV12_VIDEO_SW) {
+ if (recorder_state == STREAMRECORDER_STATE_NONE) {
+ switch (buf) {
+ case '1': /* Start Recording*/
+ hmstreamrecorder->elapsed_time = 0;
+ err = streamrecorder_start(hmstreamrecorder->recorder);
+ sleep(1);
+ g_timer_reset(timer);
+ err = __feed_buffer_test(hmstreamrecorder->recorder, hmstreamrecorder->mode);
+ if (err != MM_ERROR_NONE)
+
+ g_print("Rec star in live buffer 0x%x", err);
+ if (err == 0)
+ LOGE("Rec start live buffer 0x%x", err);
+
+ recorder_state = STREAMRECORDER_STATE_RECORDING;
+ break;
+
+ case 'b': /* back*/
+ hmstreamrecorder->menu_state = MENU_STATE_MAIN;
+ mode_change();
+ break;
+
+ default:
+ g_print("\t Invalid input \n");
+ break;
+ }
+ } else if (recorder_state == STREAMRECORDER_STATE_RECORDING || recorder_state == STREAMRECORDER_STATE_PAUSED) {
+ switch (buf) {
+ if (recorder_state == STREAMRECORDER_STATE_RECORDING) {
+ case 'p': /* Pause Recording*/
+ g_print("*Pause!\n");
+ err = streamrecorder_pause(hmstreamrecorder->recorder);
+
+ if (err < 0)
+ LOGE("Rec pause streamrecorder_pause = %x", err);
+
+ recorder_state = STREAMRECORDER_STATE_PAUSED;
+ break;
+
+ } else {
+ case 'r': /* Resume Recording*/
+ g_print("*Resume!\n");
+ err = streamrecorder_start(hmstreamrecorder->recorder);
+ if (err < 0)
+ LOGE("Rec start streamrecorder_record = %x", err);
+
+ recorder_state = STREAMRECORDER_STATE_RECORDING;
+ break;
+ }
+
+ case 'c': /* Cancel*/
+ g_print("*Cancel Recording !\n");
+
+ err = streamrecorder_cancel(hmstreamrecorder->recorder);
+
+ if (err < 0)
+ LOGE("Cancel recording streamrecorder_cancel = %x", err);
+
+ recorder_state = STREAMRECORDER_STATE_NONE;
+ break;
+
+ case 's': /* Save*/
+ g_print("*Save Recording!\n");
+ g_timer_reset(timer);
+
+ err = streamrecorder_commit(hmstreamrecorder->recorder);
+
+ if (err < 0)
+ LOGE("Save recording streamrecorder_commit = %x", err);
+
+ recorder_state = STREAMRECORDER_STATE_NONE;
+ break;
+
+ default:
+ g_print("\t Invalid input \n");
+ break;
+ } /*switch*/
+ } else {
+ LOGE("Wrong streamrecorder state, check status!!");
+ }
+ } else {
+ g_print("\t Invalid mode, back to upper menu \n");
+ hmstreamrecorder->menu_state = MENU_STATE_MAIN;
+ mode_change();
+ }
+}
+
+
+/**
+* This function is to execute command.
+*
+* @param channel [in] 1st parameter
+*
+* @return This function returns TRUE/FALSE
+* @remark
+* @see
+*/
+static gboolean cmd_input(GIOChannel *channel)
+{
+ gchar *buf = NULL;
+ gsize read_size;
+ GError *g_error = NULL;
+
+ LOGD("ENTER");
+
+ g_io_channel_read_line(channel, &buf, &read_size, NULL, &g_error);
+ if (g_error) {
+ LOGD("g_io_channel_read_chars error");
+ g_error_free(g_error);
+ g_error = NULL;
+ }
+
+ if (buf) {
+ g_strstrip(buf);
+
+ LOGD("Menu Status : %d", hmstreamrecorder->menu_state);
+ switch (hmstreamrecorder->menu_state) {
+ case MENU_STATE_MAIN:
+ main_menu(buf[0]);
+ break;
+ default:
+ break;
+ }
+
+ g_free(buf);
+ buf = NULL;
+
+ print_menu();
+ } else {
+ LOGD("No read input");
+ }
+
+ return TRUE;
+}
+
+static gboolean init(int type)
+{
+ int err;
+ int size;
+ int support_zero_copy_format = 0;
+ int ischeck = 0;
+ char *err_attr_name = NULL;
+
+ if (!hmstreamrecorder)
+ return FALSE;
+
+ if (!hmstreamrecorder->recorder)
+ return FALSE;
+
+ /*================================================================================
+ Video capture mode
+ *=================================================================================*/
+ if (type == MODE_LIVE_BUFFER_I420_VIDEO || type == MODE_LIVE_BUFFER_NV12_VIDEO_SW) {
+ if (type == MODE_LIVE_BUFFER_I420_VIDEO) {
+ err = streamrecorder_set_video_source_format(hmstreamrecorder->recorder, STREAMRECORDER_VIDEO_SOURCE_FORMAT_I420);
+ if (err < 0) {
+ LOGE("Init fail. (%x)", err);
+ goto ERROR;
+ }
+ } else if (type == MODE_LIVE_BUFFER_NV12_VIDEO_SW) {
+ err = streamrecorder_set_video_source_format(hmstreamrecorder->recorder, STREAMRECORDER_VIDEO_SOURCE_FORMAT_NV12);
+ if (err < 0) {
+ LOGE("Init fail. (%x)", err);
+ goto ERROR;
+ }
+ }
+ err = streamrecorder_set_file_format(hmstreamrecorder->recorder, STREAMRECORDER_FILE_FORMAT_MP4);
+ if (err < 0) {
+ LOGE("aInit fail. (%x)", err);
+ goto ERROR;
+ }
+ err = streamrecorder_set_video_encoder(hmstreamrecorder->recorder, STREAMRECORDER_VIDEO_CODEC_MPEG4);
+ if (err < 0) {
+ LOGE("bInit fail. (%x)", err);
+ goto ERROR;
+ }
+ err = streamrecorder_set_video_resolution(hmstreamrecorder->recorder, 1280, 720);
+ if (err < 0) {
+ LOGE("dInit fail. (%x)", err);
+ goto ERROR;
+ }
+ err = streamrecorder_set_video_framerate(hmstreamrecorder->recorder, 30);
+ if (err < 0) {
+ LOGE("dInit fail. (%x)", err);
+ goto ERROR;
+ }
+ err = streamrecorder_set_filename(hmstreamrecorder->recorder, TARGET_FILENAME_VIDEO);
+ if (err < 0) {
+ LOGE("dInit fail. (%x)", err);
+ goto ERROR;
+ }
+ }
+
+ streamrecorder_set_recording_status_cb(hmstreamrecorder->recorder, _recording_status_cb, NULL);
+ streamrecorder_set_recording_limit_reached_cb(hmstreamrecorder->recorder, _recording_limit_reached_cb, &ischeck);
+
+ LOGD("Init DONE.");
+
+ return TRUE;
+
+ERROR:
+ LOGE("init failed.");
+ return FALSE;
+}
+
+static gboolean init_handle()
+{
+ hmstreamrecorder->mode = 0; /* image(capture)/video(recording) mode */
+ hmstreamrecorder->menu_state = MENU_STATE_MAIN;
+ hmstreamrecorder->isMute = FALSE;
+ hmstreamrecorder->elapsed_time = 0;
+ hmstreamrecorder->fps = SRC_VIDEO_FRAME_RATE_15; /*SRC_VIDEO_FRAME_RATE_30;*/
+
+ return TRUE;
+}
+/**
+* This function is to change streamrecorder mode.
+*
+* @param type [in] image(capture)/video(recording) mode
+*
+* @return This function returns TRUE/FALSE
+* @remark
+* @see other functions
+*/
+static gboolean mode_change()
+{
+ int err = STREAMRECORDER_ERROR_NONE;
+ int state = STREAMRECORDER_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;
+
+ err = streamrecorder_get_state(hmstreamrecorder->recorder, (streamrecorder_state_e *)&state);
+ if (state != STREAMRECORDER_STATE_NONE) {
+ if ((state == STREAMRECORDER_STATE_RECORDING) || (state == STREAMRECORDER_STATE_PAUSED)) {
+ LOGD("streamrecorder_cancel");
+ err = streamrecorder_cancel(hmstreamrecorder->recorder);
+
+ if (err < 0) {
+ LOGE("exit streamrecorder_cancel = %x", err);
+ return FALSE;
+ }
+ }
+
+ err = streamrecorder_get_state(hmstreamrecorder->recorder, (streamrecorder_state_e *)&state);
+ if (state == STREAMRECORDER_STATE_PREPARED) {
+ LOGD("streamrecorder_destroy");
+ streamrecorder_unprepare(hmstreamrecorder->recorder);
+ }
+
+ err = streamrecorder_get_state(hmstreamrecorder->recorder, (streamrecorder_state_e *)&state);
+ if (state == STREAMRECORDER_STATE_CREATED) {
+ LOGD("streamrecorder_destroy");
+ streamrecorder_destroy(hmstreamrecorder->recorder);
+ }
+ }
+
+ init_handle();
+ streamrecorder_create(&hmstreamrecorder->recorder);
+ g_get_current_time(&previous);
+ g_timer_reset(timer);
+ while (!check) {
+ g_print("\n\t=======================================\n");
+ g_print("\t RECORDER_TESTSUIT\n");
+ g_print("\t=======================================\n");
+ g_print("\t '1' i420 sw buffer - Video\n");
+ g_print("\t '2' nv12 sw buffer - Video\n");
+ g_print("\t 'q' Exit\n");
+ g_print("\t=======================================\n");
+
+ g_print("\t Enter the media type:\n\t");
+
+ err = scanf("%c", &media_type);
+ if (err == EOF) {
+ g_print("\t!!!read input error!!!\n");
+ continue;
+ }
+
+ switch (media_type) {
+ case '1':
+ hmstreamrecorder->mode = MODE_LIVE_BUFFER_I420_VIDEO;
+ streamrecorder_enable_source_buffer(hmstreamrecorder->recorder, STREAMRECORDER_SOURCE_VIDEO);
+ check = TRUE;
+ break;
+ case '2':
+ hmstreamrecorder->mode = MODE_LIVE_BUFFER_NV12_VIDEO_SW;
+ streamrecorder_enable_source_buffer(hmstreamrecorder->recorder, STREAMRECORDER_SOURCE_VIDEO);
+ check = TRUE;
+ break;
+ case 'q':
+ g_print("\t Quit Streamrecorder Testsuite!!\n");
+ hmstreamrecorder->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;
+ }
+ }
+
+ g_timer_reset(timer);
+
+ if (!init(hmstreamrecorder->mode)) {
+ g_print("hmstreamrecorder->mode = %d\n", hmstreamrecorder->mode);
+ LOGE("testsuite init() failed.");
+ return -1;
+ }
+
+ g_timer_reset(timer);
+
+ err = streamrecorder_prepare(hmstreamrecorder->recorder);
+ LOGD("streamrecorder_start() : %12.6lfs", g_timer_elapsed(timer, NULL));
+
+ if (err != 0) {
+ LOGE("streamrecorder_prepare = %x", err);
+ return -1;
+ }
+
+ g_get_current_time(¤t);
+ timersub(¤t, &previous, &result);
+ LOGD("Streamrecorder Starting Time : %ld.%lds", result.tv_sec, result.tv_usec);
+
+ return TRUE;
+}
+
+
+/**
+* This function is the example main function for recorder API.
+*
+* @param
+*
+* @return This function returns 0.
+* @remark
+* @see other functions
+*/
+int main(int argc, char **argv)
+{
+ int bret;
+
+ timer = g_timer_new();
+
+ gst_init(&argc, &argv);
+
+ LOGD("gst_init() : %12.6lfs", g_timer_elapsed(timer, NULL));
+
+ hmstreamrecorder = (mstreamrecorder_handle_t *) g_malloc0(sizeof(mstreamrecorder_handle_t));
+
+ recorder_state = STREAMRECORDER_STATE_NONE;
+
+ g_timer_reset(timer);
+
+ bret = mode_change();
+ if (!bret)
+ return bret;
+
+ print_menu();
+
+ g_loop = g_main_loop_new(NULL, FALSE);
+
+ stdin_channel = g_io_channel_unix_new(fileno(stdin));/* read from stdin */
+ g_io_add_watch(stdin_channel, G_IO_IN, (GIOFunc)cmd_input, NULL);
+
+ LOGD("RUN main loop");
+
+ g_main_loop_run(g_loop);
+
+ LOGD("STOP main loop");
+
+ if (timer) {
+ g_timer_stop(timer);
+ g_timer_destroy(timer);
+ timer = NULL;
+ }
+
+ g_free(hmstreamrecorder);
+ g_main_loop_unref(g_loop);
+ g_io_channel_unref(stdin_channel);
+
+ return bret;
+}
+
+/*EOF*/
projects / platform / core / api / mediastreamrecorder.git / commitdiff
