* 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.
+* limitations under the License.
*/
#ifndef __TIZEN_MULTIMEDIA_RECORDER_H__
/**
* @file recorder.h
* @brief This file contains the Recorder API.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
*/
/**
/**
* @brief The Media recorder handle.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
*/
typedef struct recorder_s *recorder_h;
/**
* @brief Enumeration for error code of the media recorder.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
*/
typedef enum
{
- RECORDER_ERROR_NONE = TIZEN_ERROR_NONE, /**< Successful */
- RECORDER_ERROR_INVALID_PARAMETER = TIZEN_ERROR_INVALID_PARAMETER, /**< Invalid parameter */
- RECORDER_ERROR_INVALID_STATE = RECORDER_ERROR_CLASS | 0x02, /**< Invalid state */
- RECORDER_ERROR_OUT_OF_MEMORY = TIZEN_ERROR_OUT_OF_MEMORY , /**< Out of memory */
- RECORDER_ERROR_DEVICE = RECORDER_ERROR_CLASS | 0x04, /**< Device error */
- RECORDER_ERROR_INVALID_OPERATION = TIZEN_ERROR_INVALID_OPERATION, /**< Internal error */
- RECORDER_ERROR_SOUND_POLICY = RECORDER_ERROR_CLASS | 0x06, /**< Blocked by Audio Session Manager */
- RECORDER_ERROR_SECURITY_RESTRICTED = RECORDER_ERROR_CLASS | 0x07, /**< Restricted by security system policy */
- RECORDER_ERROR_SOUND_POLICY_BY_CALL = RECORDER_ERROR_CLASS | 0x08, /**< Blocked by Audio Session Manager - CALL */
+ RECORDER_ERROR_NONE = TIZEN_ERROR_NONE, /**< Successful */
+ RECORDER_ERROR_INVALID_PARAMETER = TIZEN_ERROR_INVALID_PARAMETER, /**< Invalid parameter */
+ RECORDER_ERROR_INVALID_STATE = RECORDER_ERROR_CLASS | 0x02, /**< Invalid state */
+ RECORDER_ERROR_OUT_OF_MEMORY = TIZEN_ERROR_OUT_OF_MEMORY , /**< Out of memory */
+ RECORDER_ERROR_DEVICE = RECORDER_ERROR_CLASS | 0x04, /**< Device error */
+ RECORDER_ERROR_INVALID_OPERATION = TIZEN_ERROR_INVALID_OPERATION, /**< Internal error */
+ RECORDER_ERROR_SOUND_POLICY = RECORDER_ERROR_CLASS | 0x06, /**< Blocked by Audio Session Manager */
+ RECORDER_ERROR_SECURITY_RESTRICTED = RECORDER_ERROR_CLASS | 0x07, /**< Restricted by security system policy */
+ RECORDER_ERROR_SOUND_POLICY_BY_CALL = RECORDER_ERROR_CLASS | 0x08, /**< Blocked by Audio Session Manager - CALL */
RECORDER_ERROR_SOUND_POLICY_BY_ALARM = RECORDER_ERROR_CLASS | 0x09, /**< Blocked by Audio Session Manager - ALARM */
- RECORDER_ERROR_ESD = RECORDER_ERROR_CLASS | 0x0a, /**< ESD situation */
- RECORDER_ERROR_OUT_OF_STORAGE = RECORDER_ERROR_CLASS | 0x0b, /**< Out of storage */
- RECORDER_ERROR_PERMISSION_DENIED = TIZEN_ERROR_PERMISSION_DENIED, /**< The access to the resources can not be granted */
+ RECORDER_ERROR_ESD = RECORDER_ERROR_CLASS | 0x0a, /**< ESD situation */
+ RECORDER_ERROR_OUT_OF_STORAGE = RECORDER_ERROR_CLASS | 0x0b, /**< Out of storage */
+ RECORDER_ERROR_PERMISSION_DENIED = TIZEN_ERROR_PERMISSION_DENIED, /**< The access to the resources can not be granted */
RECORDER_ERROR_NOT_SUPPORTED = TIZEN_ERROR_NOT_SUPPORTED, /**< The feature is not supported */
} recorder_error_e;
/**
* @brief Enumeration for recorder states.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
*/
typedef enum
{
/**
* @brief Enumeration for the recording limit.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
*/
typedef enum
{
/**
* @brief Enumeration for the file container format.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
*/
typedef enum
{
/**
* @brief Enumeration for the audio codec.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
*/
typedef enum
{
/**
* @brief Enumeration for the video codec.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
*/
typedef enum
{
/**
* @brief Enumeration for audio capture devices.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
*/
typedef enum
{
/**
* @brief Enumeration for the recorder rotation type.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
*/
typedef enum
{
} recorder_rotation_e;
/**
- * @brief Enumerations for the recorder flip type.
- */
-typedef enum
-{
- RECORDER_FLIP_NONE, /**< No Flip */
- RECORDER_FLIP_HORIZONTAL, /**< Horizontal flip */
- RECORDER_FLIP_VERTICAL, /**< Vertical flip */
- RECORDER_FLIP_BOTH /**< Horizontal and vertical flip */
-} recorder_flip_e;
-
-
-/**
* @brief Enumeration for the recorder policy.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
*/
typedef enum
{
/**
* @brief Called when limitation error occurs while recording.
* @details The callback function is possible to receive three types of limits: time, size and no-space.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @remarks After being called, recording data is discarded and not written in the recording file. Also the state of recorder is not changed.
* @param[in] type The imitation type
* @param[in] user_data The user data passed from the callback registration function
/**
* @brief Called to indicate the recording status.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @remarks This callback function is repeatedly invoked during the #RECORDER_STATE_RECORDING state.
* @param[in] elapsed_time The time of the recording (milliseconds)
* @param[in] file_size The size of the recording file (KB)
/**
* @brief Called when the record state is changed.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @param[in] previous The previous state of the recorder
* @param[in] current The current state of the recorder
* @param[in] by_policy @c true if the state is changed by policy, otherwise @c false if the state is not changed
/**
* @brief Called when the recorder is interrupted by a policy.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @param[in] policy The policy that is interrupting the recorder
* @param[in] previous The previous state of the recorder
* @param[in] current The current state of the recorder
/**
* @brief Called when audio stream data was being delivered just before storing in the recorded file.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @remarks The callback function holds the same buffer that will be recorded. \n
* So if the user changes the buffer, the result file will contain the buffer.
* @remarks The callback is called via internal thread of Frameworks, therefore do not invoke UI API, recorder_unprepare(), recorder_commit() and recorder_cancel() in callback.
/**
* @brief Called once for each supported video resolution.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @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
/**
* @brief Called when the error occurred.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @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.
/**
* @brief Called iteratively to notify about the supported file formats.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @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
/**
* @brief Called iteratively to notify about the supported audio encoders.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @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
/**
* @brief Called iteratively to notify about the supported video encoders.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @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
/**
* @brief Creates a recorder handle to record a video.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @privlevel public
* @privilege %http://tizen.org/privilege/recorder
* @remarks You must release @a recorder using recorder_destroy(). \n
/**
* @brief Creates a recorder handle to record an audio.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @privlevel public
* @privilege %http://tizen.org/privilege/recorder
* @remarks You must release @a recorder using recorder_destroy().
/**
* @brief Destroys the recorder handle.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @privlevel public
* @privilege %http://tizen.org/privilege/recorder
* @remarks The video recorder's camera handle is not released by this function.
/**
* @brief Prepares the media recorder for recording.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @privlevel public
* @privilege %http://tizen.org/privilege/recorder
* @remarks Before calling the function, it is required to properly set audio encoder (recorder_set_audio_encoder()),
/**
* @brief Resets the media recorder.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @privlevel public
* @privilege %http://tizen.org/privilege/recorder
* @param[in] recorder The handle to the media recorder
/**
* @brief Starts the recording.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @privlevel public
* @privilege %http://tizen.org/privilege/recorder
* @remarks If file path has been set to an existing file, this file is removed automatically and updated by new one. \n
/**
* @brief Pauses the recording.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @privlevel public
* @privilege %http://tizen.org/privilege/recorder
* @remarks Recording can be resumed with recorder_start().
/**
* @brief Stops recording and saves the result.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @privlevel public
* @privilege %http://tizen.org/privilege/recorder
* @remarks When you want to record audio or video file, you need to add privilege according to rules below additionally. \n
/**
* @brief Cancels the recording.
* @details The recording data is discarded and not written in the recording file.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @privlevel public
* @privilege %http://tizen.org/privilege/recorder
* @remarks When you want to record audio or video file, you need to add privilege according to rules below additionally. \n
/**
* @brief Gets the recorder's current state.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @param[in] recorder The handle to the media recorder
* @param[out] state The current state of the recorder
* @return @c 0 on success, otherwise a negative error value
/**
* @brief Gets the peak audio input level that was sampled since the last call to this function.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @remarks @c 0 dB indicates maximum input level, @c -300 dB indicates minimum input level.
* @param[in] recorder The handle to the media recorder
* @param[out] dB The audio input level in dB
/**
* @brief Sets the file path to record.
* @details This function sets file path which defines where newly recorded data should be stored.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @remarks If the same file already exists in the file system, then old file will be overwritten.
* @param[in] recorder The handle to the media recorder
* @param[in] path The recording file path
* @retval #RECORDER_ERROR_INVALID_STATE Invalid state
* @retval #RECORDER_ERROR_PERMISSION_DENIED The access to the resources can not be granted
* @retval #RECORDER_ERROR_NOT_SUPPORTED The feature is not supported
- * @pre The recorder state must be #RECORDER_STATE_CREATED by recorder_create() or recorder_unprepare().
+ * @pre The recorder state must be #RECORDER_STATE_CREATED or #RECORDER_STATE_READY.
* @see recorder_get_filename()
*/
int recorder_set_filename(recorder_h recorder, const char *path);
/**
* @brief Gets the file path to record.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @remarks You must release @a path using free().
* @param[in] recorder The handle to the media recorder
* @param[out] path The recording file path
/**
* @brief Sets the file format for recording media stream.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
+ * @remarks Since 2.3.1, it could be returned #RECORDER_ERROR_INVALID_OPERATION \n
+ * when it's audio recorder and its state is #RECORDER_STATE_READY \n
+ * because of checking codec compatibility with current encoder.
* @param[in] recorder The handle to the media recorder
* @param[in] format The media file format
* @return @c 0 on success, otherwise a negative error value
* @retval #RECORDER_ERROR_INVALID_STATE Invalid state
* @retval #RECORDER_ERROR_PERMISSION_DENIED The access to the resources can not be granted
* @retval #RECORDER_ERROR_NOT_SUPPORTED The feature is not supported
- * @pre The recorder state must be #RECORDER_STATE_CREATED.
+ * @retval #RECORDER_ERROR_INVALID_OPERATION Invalid operation (Since 2.3.1)
+ * @pre The recorder state must be #RECORDER_STATE_CREATED or #RECORDER_STATE_READY (for video recorder only).\n
+ * Since 2.3.1, this API also works for audio recorder when its state is #RECORDER_STATE_READY.
* @see recorder_get_file_format()
* @see recorder_foreach_supported_file_format()
*/
/**
* @brief Gets the file format for recording media stream.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @param[in] recorder The handle to the media recorder
* @param[out] format The media file format
* @return @c 0 on success, otherwise a negative error value
/**
* @brief Retrieves all supported file formats by invoking a specific callback for each supported file format.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @param[in] recorder The handle to the media recorder
* @param[in] callback The iteration callback
* @param[in] user_data The user data to be passed to the callback function
/**
* @brief Sets the audio codec for encoding an audio stream.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @remarks You can get available audio encoders by using recorder_foreach_supported_audio_encoder(). \n
- * If set to #RECORDER_AUDIO_CODEC_DISABLE, the audio track is not created in recording files.
+ * If set to #RECORDER_AUDIO_CODEC_DISABLE, the audio track is not created in recording files.\n
+ * Since 2.3.1, it could be returned #RECORDER_ERROR_INVALID_OPERATION \n
+ * when it's audio recorder and its state is #RECORDER_STATE_READY \n
+ * because of checking codec compatibility with current file format.
* @param[in] recorder The handle to the media recorder
* @param[in] codec The audio codec
* @return @c 0 on success, otherwise a negative error value
* @retval #RECORDER_ERROR_INVALID_STATE Invalid state
* @retval #RECORDER_ERROR_PERMISSION_DENIED The access to the resources can not be granted
* @retval #RECORDER_ERROR_NOT_SUPPORTED The feature is not supported
+ * @retval #RECORDER_ERROR_INVALID_OPERATION Invalid operation (Since 2.3.1)
* @pre The recorder state must be #RECORDER_STATE_CREATED or #RECORDER_STATE_READY.
* @see recorder_get_audio_encoder()
* @see recorder_foreach_supported_audio_encoder()
/**
* @brief Gets the audio codec for encoding an audio stream.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @param[in] recorder The handle to the media recorder
* @param[out] codec The audio codec
* @return @c 0 on success, otherwise a negative error value
/**
* @brief Retrieves all supported audio encoders by invoking a specific callback for each supported audio encoder.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @param[in] recorder The handle to the media recorder
* @param[in] callback The iteration callback
* @param[in] user_data The user data to be passed to the callback function
/**
* @brief Sets the resolution of the video recording.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @remarks This function should be called before recording (recorder_start()).
* @param[in] recorder The handle to the media recorder
* @param[in] width The preview width
/**
* @brief Gets the resolution of the video recording.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @param[in] recorder The handle to the media recorder
* @param[out] width The video width
* @param[out] height The video height
- * @return 0 on success, otherwise a negative error value
+ * @return @c 0 on success, otherwise a negative error value
* @retval #RECORDER_ERROR_NONE Successful
* @retval #RECORDER_ERROR_INVALID_PARAMETER Invalid parameter
* @retval #RECORDER_ERROR_PERMISSION_DENIED The access to the resources can not be granted
int recorder_get_video_resolution(recorder_h recorder, int *width, int *height);
/**
+ * @}
+*/
+
+/**
+ * @addtogroup CAPI_MEDIA_RECORDER_CAPABILITY_MODULE
+ * @{
+ */
+
+/**
+ * @brief Retrieves all supported video resolutions by invoking callback function once for each supported video resolution.
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
+ * @param[in] recorder The handle to the media recorder
+ * @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 #RECORDER_ERROR_NONE Successful
+ * @retval #RECORDER_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #RECORDER_ERROR_PERMISSION_DENIED The access to the resources can not be granted
+ * @retval #RECORDER_ERROR_NOT_SUPPORTED The feature is not supported
+ * @post This function invokes recorder_supported_video_resolution_cb() repeatedly to retrieve each supported video resolution.
+ * @see recorder_set_video_resolution()
+ * @see recorder_get_video_resolution()
+ * @see recorder_supported_video_resolution_cb()
+ */
+int recorder_foreach_supported_video_resolution(recorder_h recorder,
+ recorder_supported_video_resolution_cb foreach_cb, void *user_data);
+
+/**
+ * @}
+*/
+
+/**
+ * @addtogroup CAPI_MEDIA_RECORDER_MODULE
+ * @{
+ */
+
+/**
* @brief Sets the video codec for encoding video stream.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @remarks You can get available video encoders by using recorder_foreach_supported_video_encoder().
* @param[in] recorder The handle to the media recorder
* @param[in] codec The video codec
/**
* @brief Gets the video codec for encoding video stream.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @param[in] recorder The handle to the media recorder
* @param[out] codec The video codec
* @return @c 0 on success, otherwise a negative error value
*/
/**
- * @brief Retrieves all supported video resolutions by invoking callback function once for each supported video resolution.
- * @since_tizen 2.3
- * @param[in] recorder The handle to the media recorder
- * @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 #RECORDER_ERROR_NONE Successful
- * @retval #RECORDER_ERROR_INVALID_PARAMETER Invalid parameter
- * @retval #RECORDER_ERROR_PERMISSION_DENIED The access to the resources can not be granted
- * @retval #RECORDER_ERROR_NOT_SUPPORTED The feature is not supported
- * @post This function invokes recorder_supported_video_resolution_cb() repeatedly to retrieve each supported video resolution.
- * @see recorder_set_video_resolution()
- * @see recorder_get_video_resolution()
- * @see recorder_supported_video_resolution_cb()
- */
-int recorder_foreach_supported_video_resolution(recorder_h recorder,
- recorder_supported_video_resolution_cb foreach_cb, void *user_data);
-
-/**
* @brief Retrieves all supported video encoders by invoking a specific callback for each supported video encoder.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @param[in] recorder The handle to the media recorder
* @param[in] callback The iteration callback
* @param[in] user_data The user data to be passed to the callback function
/**
* @brief Registers the callback function that will be invoked when the recorder state changes.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @param[in] recorder The handle to the media recorder
* @param[in] callback The function pointer of user callback
* @param[in] user_data The user data to be passed to the callback function
/**
* @brief Unregisters the callback function.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @param[in] recorder The handle to the media recorder
* @return @c 0 on success, otherwise a negative error value
* @retval #RECORDER_ERROR_NONE Successful
/**
* @brief Registers a callback function to be called when the media recorder is interrupted according to a policy.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @param[in] recorder The handle to the media recorder
* @param[in] callback The callback function to register
* @param[in] user_data The user data to be passed to the callback function
/**
* @brief Unregisters the callback function.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @param[in] recorder The handle to the media recorder
* @return @c 0 on success, otherwise a negative error value
* @retval #RECORDER_ERROR_NONE Successful
/**
* @brief Registers a callback function to be called when audio stream data is being delivered.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @remarks This callback function holds the same buffer that will be recorded. \n
* Therefore if an user changes the buffer, the result file will have the buffer. \n
* @remarks The callback is called via internal thread of Frameworks. Therefore do not invoke UI API, recorder_unprepare(), recorder_commit() and recorder_cancel() in callback.\n
/**
* @brief Unregisters the callback function.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @param[in] recorder The handle to the media recorder
* @return @c 0 on success, otherwise a negative error value
* @retval #RECORDER_ERROR_NONE Successful
* @retval #RECORDER_ERROR_INVALID_PARAMETER Invalid parameter
* @retval #RECORDER_ERROR_PERMISSION_DENIED The access to the resources can not be granted
* @retval #RECORDER_ERROR_NOT_SUPPORTED The feature is not supported
- * @see recorder_set_audio_stream_cb()
+ * @see recorder_set_audio_stream_cb()
*/
int recorder_unset_audio_stream_cb(recorder_h recorder);
/**
* @brief Registers a callback function to be invoked when the recording information changes.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @param[in] recorder The handle to the media recorder
* @param[in] callback The function pointer of user callback
* @param[in] user_data The user data to be passed to the callback function
/**
* @brief Unregisters the callback function.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @param[in] recorder The handle to the media recorder
* @return @c 0 on success, otherwise a negative error value
* @retval #RECORDER_ERROR_NONE Successful
/**
* @brief Registers the callback function to be run when reached the recording limit.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @param[in] recorder The handle to media recorder
* @param[in] callback The function pointer of user callback
* @param[in] user_data The user data to be passed to the callback function
/**
* @brief Unregisters the callback function.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @param[in] recorder The handle to the media recorder
* @return @c 0 on success, otherwise a negative error value
* @retval #RECORDER_ERROR_NONE Successful
/**
* @brief Registers a callback function to be called when an asynchronous operation error occurred.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @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
/**
* @brief Unregisters the callback function.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @param[in] recorder The handle to the recorder
* @return @c on success, otherwise a negative error value
* @retval #RECORDER_ERROR_NONE Successful
/**
* @brief Sets the maximum size of a recording file.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @remarks After reaching the limitation, the recording data is discarded and not written in the recording file.
* @param[in] recorder The handle to the media recorder
* @param[in] kbyte The maximum size of the recording file(KB) \n
/**
* @brief Gets the maximum size of a recording file.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @param[in] recorder The handle to the media recorder
* @param[out] kbyte The maximum size of recording file (KB) \n
* @c 0 means unlimited recording size.
/**
* @brief Sets the time limit of a recording file.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @remarks After reaching the limitation, the recording data is discarded and not written in the recording file.
* @param[in] recorder The handle to the media recorder
* @param[in] second The time limit of the recording file (in seconds) \n
/**
* @brief Gets the time limit of a recording file.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @param[in] recorder The handle to the media recorder
* @param[out] second The time limit of the recording file (in seconds) \n
* @c 0 means unlimited recording time.
/**
* @brief Sets the audio device for recording.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @param[in] recorder The handle to the media recorder
* @param[in] device The type of an audio device
* @return @c 0 on success, otherwise a negative error value
* @retval #RECORDER_ERROR_INVALID_STATE Invalid state
* @retval #RECORDER_ERROR_PERMISSION_DENIED The access to the resources can not be granted
* @retval #RECORDER_ERROR_NOT_SUPPORTED The feature is not supported
- * @pre The recorder state must be #RECORDER_STATE_CREATED.
+ * @pre The recorder state must be #RECORDER_STATE_CREATED or #RECORDER_STATE_READY (for video recorder only).\n
+ * Since 2.3.1, this API also works for audio recorder when its state is #RECORDER_STATE_READY.
* @see recorder_attr_get_audio_device()
*/
int recorder_attr_set_audio_device(recorder_h recorder, recorder_audio_device_e device);
/**
* @brief Gets the audio device for recording.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @param[in] recorder The handle to the media recorder
* @param[out] device The type of an audio device
* @return @c 0 on success, otherwise a negative error value
/**
* @brief Sets the sampling rate of an audio stream.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @param[in] recorder The handle to the media recorder
* @param[in] samplerate The sample rate in Hertz
* @return @c 0 on success, otherwise a negative error value
* @retval #RECORDER_ERROR_INVALID_STATE Invalid state
* @retval #RECORDER_ERROR_PERMISSION_DENIED The access to the resources can not be granted
* @retval #RECORDER_ERROR_NOT_SUPPORTED The feature is not supported
- * @pre The recorder state must be #RECORDER_STATE_CREATED.
+ * @pre The recorder state must be #RECORDER_STATE_CREATED or #RECORDER_STATE_READY (for video recorder only).\n
+ * Since 2.3.1, this API also works for audio recorder when its state is #RECORDER_STATE_READY.
* @see recorder_attr_get_audio_samplerate()
*/
int recorder_attr_set_audio_samplerate(recorder_h recorder, int samplerate);
/**
* @brief Gets the sampling rate of an audio stream.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @param[in] recorder The handle to the media recorder
* @param[out] samplerate The sample rate in Hertz
* @return @c 0 on success, otherwise a negative error value
/**
* @brief Sets the bitrate of an audio encoder.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @param[in] recorder The handle to the media recorder
* @param[in] bitrate The bitrate (for mms : 12200[bps], normal : 288000[bps])
* @return @c 0 on success, otherwise a negative error value
/**
* @brief Sets the bitrate of a video encoder.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @param[in] recorder The handle to the media recorder
* @param[in] bitrate The bitrate in bits per second
* @return @c 0 on success, otherwise a negative error value
/**
* @brief Gets the bitrate of an audio encoder.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @param[in] recorder The handle to the media recorder
* @param[out] bitrate The bitrate in bits per second
* @return @c 0 on success, otherwise a negative error value
/**
* @brief Gets the bitrate of a video encoder.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @param[in] recorder The handle to the media recorder
* @param[out] bitrate The bitrate in bits per second
* @return @c 0 on success, otherwise a negative error value
/**
* @brief Sets the mute state of a recorder.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @param[in] recorder The handle to the media recorder
* @param[in] enable The mute state
* @return @c 0 on success, otherwise a negative error value
/**
* @brief Gets the mute state of a recorder.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @param[in] recorder The handle to the media recorder
* @remarks The specific error code can be obtained using the get_last_result() method. Error codes are described in Exception section.
* @return @c true if the recorder is not recording any sound,
/**
* @brief Sets the recording motion rate.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @remarks This attribute is valid only in a video recorder. \n
* If the rate bigger than @c 0 and smaller than @c 1, video is recorded in a slow motion mode. \n
* If the rate bigger than @c 1, video is recorded in a fast motion mode (time lapse recording).
/**
* @brief Gets the recording motion rate.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @remarks This attribute is valid only in a video recorder. \n
* If the rate bigger than @c 0 and smaller than @c 1, video is recorded in a slow motion mode. \n
* If the rate bigger than @c 1, video is recorded in a fast motion mode (time lapse recording).
*/
int recorder_attr_get_recording_motion_rate(recorder_h recorder , double *rate);
-__attribute__ ((deprecated)) int recorder_attr_set_slow_motion_rate(recorder_h recorder , double rate);
-__attribute__ ((deprecated)) int recorder_attr_get_slow_motion_rate(recorder_h recorder , double *rate);
-
/**
* @brief Sets the number of the audio channel.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @remarks This attribute is applied only in RECORDER_STATE_CREATED state. \n
* For mono recording, setting channel to @c 1. \n
* For stereo recording, setting channel to @c 2.
* @retval #RECORDER_ERROR_INVALID_PARAMETER Invalid parameter
* @retval #RECORDER_ERROR_PERMISSION_DENIED The access to the resources can not be granted
* @retval #RECORDER_ERROR_NOT_SUPPORTED The feature is not supported
- * @pre The recorder state must be #RECORDER_STATE_CREATED.
+ * @pre The recorder state must be #RECORDER_STATE_CREATED or #RECORDER_STATE_READY (for video recorder only).\n
+ * Since 2.3.1, this API also works for audio recorder when its state is #RECORDER_STATE_READY.
* @see recorder_attr_get_audio_channel()
*/
int recorder_attr_set_audio_channel(recorder_h recorder, int channel_count);
/**
* @brief Gets the number of the audio channel.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @param[in] recorder The handle to the media recorder
* @param[out] channel_count The number of the audio channel
* @return @c 0 on success, otherwise a negative error value
*/
int recorder_attr_get_audio_channel(recorder_h recorder, int *channel_count);
-/**
- * @brief Sets the orientation of video recording data
- * @remarks
- * This attribute is valid only in video recorder.\n
- * This attribute is applied in video encoding.
- * @param[in] recorder The handle to media recorder
- * @param[in] orientation The orientation of video recording data
- * @return 0 on success, otherwise a negative error value.
- * @retval #RECORDER_ERROR_NONE Successful
- * @retval #RECORDER_ERROR_INVALID_PARAMETER Invalid parameter
- * @see recorder_attr_get_recording_orientation()
- */
-__attribute__ ((deprecated)) int recorder_attr_set_recording_orientation(recorder_h recorder, recorder_rotation_e orientation);
-
-/**
- * @brief Gets the orientation of video recording data
- * @remarks
- * This attribute is valid only in video recorder.\n
- * @param[in] recorder The handle to media recorder
- * @param[out] orientation The orientation of video recording data
- * @return 0 on success, otherwise a negative error value.
- * @retval #RECORDER_ERROR_NONE Successful
- * @retval #RECORDER_ERROR_INVALID_PARAMETER Invalid parameter
- * @see recorder_attr_set_recording_orientation()
- */
-__attribute__ ((deprecated)) int recorder_attr_get_recording_orientation(recorder_h recorder, recorder_rotation_e *orientation);
-
-/**
- * @brief Sets the flip of video recording data
- * @remarks
- * This attribute is valid only in video recorder.\n
- * This attribute is applied in video encoding.
- * @param[in] recorder The handle to media recorder
- * @param[in] flip The flip of video recording data
- * @return 0 on success, otherwise a negative error value.
- * @retval #RECORDER_ERROR_NONE Successful
- * @retval #RECORDER_ERROR_INVALID_PARAMETER Invalid parameter
- * @see recorder_attr_get_recording_flip()
- */
-__attribute__ ((deprecated)) int recorder_attr_set_recording_flip(recorder_h recorder, recorder_flip_e flip);
-
-/**
- * @brief Gets the flip of video recording data
- * @remarks
- * This attribute is valid only in video recorder.\n
- * This attribute is applied in video encoding.
- * @param[in] recorder The handle to media recorder
- * @param[out] flip The flip of video recording data
- * @return 0 on success, otherwise a negative error value.
- * @retval #RECORDER_ERROR_NONE Successful
- * @retval #RECORDER_ERROR_INVALID_PARAMETER Invalid parameter
- * @see recorder_attr_set_recording_flip()
- */
-__attribute__ ((deprecated)) int recorder_attr_get_recording_flip(recorder_h recorder, recorder_flip_e *flip);
/**
* @brief Sets the video orientation in a video metadata tag.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @param[in] recorder The handle to a media recorder
* @param[in] orientation The information of the video orientation
- * @return 0 on success, otherwise a negative error value
+ * @return @c 0 on success, otherwise a negative error value
* @retval #RECORDER_ERROR_NONE Successful
* @retval #RECORDER_ERROR_INVALID_PARAMETER Invalid parameter
* @retval #RECORDER_ERROR_PERMISSION_DENIED The access to the resources can not be granted
/**
* @brief Gets the video orientation in a video metadata tag.
- * @since_tizen 2.3
+ * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
* @param[in] recorder The handle to a media recorder
* @param[out] orientation The information of the video orientation
-* @return @c 0 on success, otherwise a negative error value
+ * @return @c 0 on success, otherwise a negative error value
* @retval #RECORDER_ERROR_NONE Successful
* @retval #RECORDER_ERROR_INVALID_PARAMETER Invalid parameter
* @retval #RECORDER_ERROR_PERMISSION_DENIED The access to the resources can not be granted
#include <mm_types.h>
#include <math.h>
#include <camera.h>
-#include <recorder.h>
#include <recorder_private.h>
#include <dlog.h>
#include <unistd.h>
/*
- * camera_private function
+ * camera_private function
*/
int _camera_get_mm_handle(camera_h camera , MMHandleType *handle);
int _camera_set_relay_mm_message_callback(camera_h camera, MMMessageCallback callback, void *user_data);
static int __mm_recorder_msg_cb(int message, void *param, void *user_data);
-static int __convert_error_code_camera_to_recorder(int code){
+static int __convert_error_code_camera_to_recorder(int code)
+{
int new_code = code;
- switch(code)
- {
- case CAMERA_ERROR_INVALID_STATE :
- new_code = RECORDER_ERROR_INVALID_STATE;
- break;
- case CAMERA_ERROR_DEVICE:
- new_code = RECORDER_ERROR_DEVICE;
- break;
- case CAMERA_ERROR_SOUND_POLICY:
- new_code = RECORDER_ERROR_SOUND_POLICY;
- break;
- case CAMERA_ERROR_SECURITY_RESTRICTED:
- new_code = RECORDER_ERROR_SECURITY_RESTRICTED;
- break;
- default:
- break;
+
+ switch (code) {
+ case CAMERA_ERROR_INVALID_STATE :
+ new_code = RECORDER_ERROR_INVALID_STATE;
+ break;
+ case CAMERA_ERROR_DEVICE:
+ new_code = RECORDER_ERROR_DEVICE;
+ break;
+ case CAMERA_ERROR_SOUND_POLICY:
+ new_code = RECORDER_ERROR_SOUND_POLICY;
+ break;
+ case CAMERA_ERROR_SECURITY_RESTRICTED:
+ new_code = RECORDER_ERROR_SECURITY_RESTRICTED;
+ break;
+ default:
+ break;
}
+
return new_code;
}
-static int __convert_recorder_error_code(const char *func, int code){
+
+int __convert_recorder_error_code(const char *func, int code)
+{
int ret = RECORDER_ERROR_INVALID_OPERATION;
const char *errorstr = NULL;
- switch(code)
- {
- case RECORDER_ERROR_INVALID_PARAMETER:
- ret = RECORDER_ERROR_INVALID_PARAMETER;
- errorstr = "INVALID_PARAMETER";
- break;
- case MM_ERROR_NONE:
- ret = RECORDER_ERROR_NONE;
- errorstr = "ERROR_NONE";
- break;
- case MM_ERROR_CAMCORDER_INVALID_ARGUMENT :
- case MM_ERROR_COMMON_INVALID_ATTRTYPE :
- case MM_ERROR_COMMON_OUT_OF_ARRAY :
- case MM_ERROR_COMMON_OUT_OF_RANGE :
- case MM_ERROR_COMMON_ATTR_NOT_EXIST :
- ret = RECORDER_ERROR_INVALID_PARAMETER;
- errorstr = "INVALID_PARAMETER";
- break;
- case MM_ERROR_COMMON_INVALID_PERMISSION :
- ret = RECORDER_ERROR_PERMISSION_DENIED;
- errorstr = "ERROR_PERMISSION_DENIED";
- break;
- case MM_ERROR_CAMCORDER_NOT_INITIALIZED :
- case MM_ERROR_CAMCORDER_INVALID_STATE :
- ret = RECORDER_ERROR_INVALID_STATE;
- errorstr = "INVALID_STATE";
- break;
-
- case MM_ERROR_CAMCORDER_DEVICE :
- case MM_ERROR_CAMCORDER_DEVICE_NOT_FOUND :
- case MM_ERROR_CAMCORDER_DEVICE_BUSY :
- case MM_ERROR_CAMCORDER_DEVICE_OPEN :
- case MM_ERROR_CAMCORDER_DEVICE_IO :
- case MM_ERROR_CAMCORDER_DEVICE_TIMEOUT :
- case MM_ERROR_CAMCORDER_DEVICE_WRONG_JPEG :
- case MM_ERROR_CAMCORDER_DEVICE_LACK_BUFFER :
- ret = RECORDER_ERROR_DEVICE;
- errorstr = "ERROR_DEVICE";
- break;
-
- case MM_ERROR_CAMCORDER_GST_CORE :
- case MM_ERROR_CAMCORDER_GST_LIBRARY :
- case MM_ERROR_CAMCORDER_GST_RESOURCE :
- case MM_ERROR_CAMCORDER_GST_STREAM :
- case MM_ERROR_CAMCORDER_GST_STATECHANGE :
- case MM_ERROR_CAMCORDER_GST_NEGOTIATION :
- case MM_ERROR_CAMCORDER_GST_LINK :
- case MM_ERROR_CAMCORDER_GST_FLOW_ERROR :
- case MM_ERROR_CAMCORDER_ENCODER :
- case MM_ERROR_CAMCORDER_ENCODER_BUFFER :
- case MM_ERROR_CAMCORDER_ENCODER_WRONG_TYPE :
- case MM_ERROR_CAMCORDER_ENCODER_WORKING :
- case MM_ERROR_CAMCORDER_INTERNAL :
- case MM_ERROR_CAMCORDER_NOT_SUPPORTED :
- case MM_ERROR_CAMCORDER_RESPONSE_TIMEOUT :
- case MM_ERROR_CAMCORDER_CMD_IS_RUNNING :
- case MM_ERROR_CAMCORDER_DSP_FAIL :
- case MM_ERROR_CAMCORDER_AUDIO_EMPTY :
- case MM_ERROR_CAMCORDER_CREATE_CONFIGURE :
- case MM_ERROR_CAMCORDER_FILE_SIZE_OVER :
- case MM_ERROR_CAMCORDER_DISPLAY_DEVICE_OFF :
- case MM_ERROR_CAMCORDER_INVALID_CONDITION :
- ret = RECORDER_ERROR_INVALID_OPERATION;
- errorstr = "INVALID_OPERATION";
- break;
- case MM_ERROR_CAMCORDER_RESOURCE_CREATION :
- case MM_ERROR_COMMON_OUT_OF_MEMORY:
- ret = RECORDER_ERROR_OUT_OF_MEMORY;
- errorstr = "OUT_OF_MEMORY";
- break;
-
- case MM_ERROR_POLICY_BLOCKED:
- ret = RECORDER_ERROR_SOUND_POLICY;
- errorstr = "ERROR_SOUND_POLICY";
- break;
-
- case MM_ERROR_POLICY_BLOCKED_BY_CALL:
- ret = RECORDER_ERROR_SOUND_POLICY_BY_CALL;
- errorstr = "ERROR_SOUND_POLICY_BY_CALL";
- break;
-
- case MM_ERROR_POLICY_BLOCKED_BY_ALARM:
- ret = RECORDER_ERROR_SOUND_POLICY_BY_ALARM;
- errorstr = "ERROR_SOUND_POLICY_BY_ALARM";
- break;
-
- case MM_ERROR_POLICY_RESTRICTED:
- ret = RECORDER_ERROR_SECURITY_RESTRICTED;
- errorstr = "ERROR_RESTRICTED";
- break;
-
- case MM_ERROR_CAMCORDER_DEVICE_REG_TROUBLE:
- ret = RECORDER_ERROR_ESD;
- errorstr = "ERROR_ESD";
- break;
-
- case MM_ERROR_OUT_OF_STORAGE:
- ret = RECORDER_ERROR_OUT_OF_STORAGE;
- errorstr = "OUT_OF_STORAGE";
- break;
-
- default:
- ret = RECORDER_ERROR_INVALID_OPERATION;
- errorstr = "INVALID_OPERATION";
-
+ switch (code) {
+ case RECORDER_ERROR_INVALID_PARAMETER:
+ ret = RECORDER_ERROR_INVALID_PARAMETER;
+ errorstr = "INVALID_PARAMETER";
+ break;
+ case MM_ERROR_NONE:
+ ret = RECORDER_ERROR_NONE;
+ errorstr = "ERROR_NONE";
+ break;
+ case MM_ERROR_CAMCORDER_INVALID_ARGUMENT :
+ case MM_ERROR_COMMON_INVALID_ATTRTYPE :
+ ret = RECORDER_ERROR_INVALID_PARAMETER;
+ errorstr = "INVALID_PARAMETER";
+ break;
+ case MM_ERROR_COMMON_INVALID_PERMISSION :
+ ret = RECORDER_ERROR_PERMISSION_DENIED;
+ errorstr = "ERROR_PERMISSION_DENIED";
+ break;
+ case MM_ERROR_CAMCORDER_NOT_INITIALIZED :
+ case MM_ERROR_CAMCORDER_INVALID_STATE :
+ ret = RECORDER_ERROR_INVALID_STATE;
+ errorstr = "INVALID_STATE";
+ break;
+ case MM_ERROR_CAMCORDER_DEVICE :
+ case MM_ERROR_CAMCORDER_DEVICE_NOT_FOUND :
+ case MM_ERROR_CAMCORDER_DEVICE_BUSY :
+ case MM_ERROR_CAMCORDER_DEVICE_OPEN :
+ case MM_ERROR_CAMCORDER_DEVICE_IO :
+ case MM_ERROR_CAMCORDER_DEVICE_TIMEOUT :
+ case MM_ERROR_CAMCORDER_DEVICE_WRONG_JPEG :
+ case MM_ERROR_CAMCORDER_DEVICE_LACK_BUFFER :
+ ret = RECORDER_ERROR_DEVICE;
+ errorstr = "ERROR_DEVICE";
+ break;
+ case MM_ERROR_CAMCORDER_GST_CORE :
+ case MM_ERROR_CAMCORDER_GST_LIBRARY :
+ case MM_ERROR_CAMCORDER_GST_RESOURCE :
+ case MM_ERROR_CAMCORDER_GST_STREAM :
+ case MM_ERROR_CAMCORDER_GST_STATECHANGE :
+ case MM_ERROR_CAMCORDER_GST_NEGOTIATION :
+ case MM_ERROR_CAMCORDER_GST_LINK :
+ case MM_ERROR_CAMCORDER_GST_FLOW_ERROR :
+ case MM_ERROR_CAMCORDER_ENCODER :
+ case MM_ERROR_CAMCORDER_ENCODER_BUFFER :
+ case MM_ERROR_CAMCORDER_ENCODER_WRONG_TYPE :
+ case MM_ERROR_CAMCORDER_ENCODER_WORKING :
+ case MM_ERROR_CAMCORDER_INTERNAL :
+ case MM_ERROR_CAMCORDER_RESPONSE_TIMEOUT :
+ case MM_ERROR_CAMCORDER_CMD_IS_RUNNING :
+ case MM_ERROR_CAMCORDER_DSP_FAIL :
+ case MM_ERROR_CAMCORDER_AUDIO_EMPTY :
+ case MM_ERROR_CAMCORDER_CREATE_CONFIGURE :
+ case MM_ERROR_CAMCORDER_FILE_SIZE_OVER :
+ case MM_ERROR_CAMCORDER_DISPLAY_DEVICE_OFF :
+ case MM_ERROR_CAMCORDER_INVALID_CONDITION :
+ ret = RECORDER_ERROR_INVALID_OPERATION;
+ errorstr = "INVALID_OPERATION";
+ break;
+ case MM_ERROR_CAMCORDER_RESOURCE_CREATION :
+ case MM_ERROR_COMMON_OUT_OF_MEMORY:
+ ret = RECORDER_ERROR_OUT_OF_MEMORY;
+ errorstr = "OUT_OF_MEMORY";
+ break;
+ case MM_ERROR_POLICY_BLOCKED:
+ ret = RECORDER_ERROR_SOUND_POLICY;
+ errorstr = "ERROR_SOUND_POLICY";
+ break;
+ case MM_ERROR_POLICY_BLOCKED_BY_CALL:
+ ret = RECORDER_ERROR_SOUND_POLICY_BY_CALL;
+ errorstr = "ERROR_SOUND_POLICY_BY_CALL";
+ break;
+ case MM_ERROR_POLICY_BLOCKED_BY_ALARM:
+ ret = RECORDER_ERROR_SOUND_POLICY_BY_ALARM;
+ errorstr = "ERROR_SOUND_POLICY_BY_ALARM";
+ break;
+ case MM_ERROR_POLICY_RESTRICTED:
+ ret = RECORDER_ERROR_SECURITY_RESTRICTED;
+ errorstr = "ERROR_RESTRICTED";
+ break;
+ case MM_ERROR_CAMCORDER_DEVICE_REG_TROUBLE:
+ ret = RECORDER_ERROR_ESD;
+ errorstr = "ERROR_ESD";
+ break;
+ case MM_ERROR_OUT_OF_STORAGE:
+ ret = RECORDER_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:
+ case MM_ERROR_CAMCORDER_NOT_SUPPORTED:
+ ret = RECORDER_ERROR_NOT_SUPPORTED;
+ errorstr = "NOT_SUPPORTED";
+ break;
+ default:
+ ret = RECORDER_ERROR_INVALID_OPERATION;
+ errorstr = "INVALID_OPERATION";
+ break;
}
- LOGE( "[%s] %s(0x%08x) : core frameworks error code(0x%08x)",func, errorstr, ret, code);
-
+ LOGE("[%s] %s(0x%08x) : core frameworks error code(0x%08x)", func, errorstr, ret, code);
return ret;
}
-static recorder_state_e __recorder_state_convert(MMCamcorderStateType mm_state )
+
+static recorder_state_e __recorder_state_convert(MMCamcorderStateType mm_state)
{
recorder_state_e state = RECORDER_STATE_NONE;
- switch( mm_state ){
- case MM_CAMCORDER_STATE_NONE:
- state = RECORDER_STATE_NONE;
- break;
- case MM_CAMCORDER_STATE_NULL:
- state = RECORDER_STATE_CREATED;
- break;
- case MM_CAMCORDER_STATE_READY:
- state = RECORDER_STATE_CREATED;
- break;
- case MM_CAMCORDER_STATE_PREPARE:
- state = RECORDER_STATE_READY;
- break;
- case MM_CAMCORDER_STATE_CAPTURING:
- state = RECORDER_STATE_READY;
- break;
- case MM_CAMCORDER_STATE_RECORDING:
- state = RECORDER_STATE_RECORDING;
- break;
- case MM_CAMCORDER_STATE_PAUSED:
- state = RECORDER_STATE_PAUSED;
- break;
- default:
- state = RECORDER_STATE_NONE;
- break;
+ switch (mm_state) {
+ case MM_CAMCORDER_STATE_NONE:
+ state = RECORDER_STATE_NONE;
+ break;
+ case MM_CAMCORDER_STATE_NULL:
+ state = RECORDER_STATE_CREATED;
+ break;
+ case MM_CAMCORDER_STATE_READY:
+ state = RECORDER_STATE_CREATED;
+ break;
+ case MM_CAMCORDER_STATE_PREPARE:
+ state = RECORDER_STATE_READY;
+ break;
+ case MM_CAMCORDER_STATE_CAPTURING:
+ state = RECORDER_STATE_READY;
+ break;
+ case MM_CAMCORDER_STATE_RECORDING:
+ state = RECORDER_STATE_RECORDING;
+ break;
+ case MM_CAMCORDER_STATE_PAUSED:
+ state = RECORDER_STATE_PAUSED;
+ break;
+ default:
+ state = RECORDER_STATE_NONE;
+ break;
}
return state;
}
-static int __mm_recorder_msg_cb(int message, void *param, void *user_data){
- recorder_s * handle = (recorder_s*)user_data;
- MMMessageParamType *m = (MMMessageParamType*)param;
- recorder_state_e previous_state;
-
- switch(message){
- case MM_MESSAGE_CAMCORDER_STATE_CHANGED:
- case MM_MESSAGE_CAMCORDER_STATE_CHANGED_BY_ASM:
- case MM_MESSAGE_CAMCORDER_STATE_CHANGED_BY_SECURITY:
- previous_state = handle->state;
- handle->state = __recorder_state_convert(m->state.current);
- recorder_policy_e policy = RECORDER_POLICY_NONE;
- if (message == MM_MESSAGE_CAMCORDER_STATE_CHANGED_BY_ASM) {
- switch (m->state.code) {
- case ASM_EVENT_SOURCE_CALL_START:
- policy = RECORDER_POLICY_SOUND_BY_CALL;
- LOGE("RECORDER_POLICY_SOUND_BY_CALL");
- break;
- case ASM_EVENT_SOURCE_ALARM_START:
- case ASM_EVENT_SOURCE_ALARM_END:
- policy = RECORDER_POLICY_SOUND_BY_ALARM;
- LOGE("RECORDER_POLICY_SOUND_BY_ALARM");
- break;
- default:
- policy = RECORDER_POLICY_SOUND;
- LOGE("RECORDER_POLICY_SOUND");
- break;
- }
- } else if (message == MM_MESSAGE_CAMCORDER_STATE_CHANGED_BY_SECURITY) {
- policy = RECORDER_POLICY_SECURITY;
- LOGE("RECORDER_POLICY_SECURITY");
- }
-
- if( previous_state != handle->state && handle->user_cb[_RECORDER_EVENT_TYPE_STATE_CHANGE] ){
- ((recorder_state_changed_cb)handle->user_cb[_RECORDER_EVENT_TYPE_STATE_CHANGE])(previous_state, handle->state, policy , handle->user_data[_RECORDER_EVENT_TYPE_STATE_CHANGE]);
- }
- // should change intermediate state MM_CAMCORDER_STATE_READY is not valid in capi , change to NULL state
- if (policy != RECORDER_POLICY_NONE &&
- (m->state.current == MM_CAMCORDER_STATE_PAUSED || m->state.current == MM_CAMCORDER_STATE_NULL)) {
- if (handle->user_cb[_RECORDER_EVENT_TYPE_INTERRUPTED]) {
- ((recorder_interrupted_cb)handle->user_cb[_RECORDER_EVENT_TYPE_INTERRUPTED])(policy, previous_state, handle->state, handle->user_data[_RECORDER_EVENT_TYPE_INTERRUPTED]);
- } else {
- LOGW("_RECORDER_EVENT_TYPE_INTERRUPTED cb is NULL");
- }
- }
+static int __mm_recorder_msg_cb(int message, void *param, void *user_data)
+{
+ recorder_s * handle = (recorder_s *)user_data;
+ MMMessageParamType *m = (MMMessageParamType *)param;
+ recorder_state_e previous_state;
+ recorder_recording_limit_type_e type;
+ int recorder_error = 0;
+
+ switch (message) {
+ case MM_MESSAGE_READY_TO_RESUME:
+ LOGW("not supported message");
+ break;
+ case MM_MESSAGE_CAMCORDER_STATE_CHANGED:
+ case MM_MESSAGE_CAMCORDER_STATE_CHANGED_BY_ASM:
+ case MM_MESSAGE_CAMCORDER_STATE_CHANGED_BY_SECURITY:
+ previous_state = handle->state;
+ handle->state = __recorder_state_convert(m->state.current);
+ recorder_policy_e policy = RECORDER_POLICY_NONE;
+ if (message == MM_MESSAGE_CAMCORDER_STATE_CHANGED_BY_ASM) {
+ switch (m->state.code) {
+ case ASM_EVENT_SOURCE_CALL_START:
+ case ASM_EVENT_SOURCE_CALL_END:
+ policy = RECORDER_POLICY_SOUND_BY_CALL;
+ LOGE("RECORDER_POLICY_SOUND_BY_CALL");
+ break;
+ case ASM_EVENT_SOURCE_ALARM_START:
+ case ASM_EVENT_SOURCE_ALARM_END:
+ policy = RECORDER_POLICY_SOUND_BY_ALARM;
+ LOGE("RECORDER_POLICY_SOUND_BY_ALARM");
+ break;
+ default:
+ policy = RECORDER_POLICY_SOUND;
+ LOGE("RECORDER_POLICY_SOUND");
break;
- case MM_MESSAGE_CAMCORDER_MAX_SIZE:
- case MM_MESSAGE_CAMCORDER_NO_FREE_SPACE:
- case MM_MESSAGE_CAMCORDER_TIME_LIMIT:
- {
- recorder_recording_limit_type_e type ;
- if( MM_MESSAGE_CAMCORDER_MAX_SIZE == message )
- type = RECORDER_RECORDING_LIMIT_SIZE;
- else if( MM_MESSAGE_CAMCORDER_NO_FREE_SPACE == message)
- type = RECORDER_RECORDING_LIMIT_FREE_SPACE;
- else
- type = RECORDER_RECORDING_LIMIT_TIME;
- if( handle->user_cb[_RECORDER_EVENT_TYPE_RECORDING_LIMITED] ){
- ((recorder_recording_limit_reached_cb)handle->user_cb[_RECORDER_EVENT_TYPE_RECORDING_LIMITED])(type, handle->user_data[_RECORDER_EVENT_TYPE_RECORDING_LIMITED]);
- }
- }
- break;
- case MM_MESSAGE_CAMCORDER_RECORDING_STATUS:
- if( handle->user_cb[_RECORDER_EVENT_TYPE_RECORDING_STATUS] ){
- ((recorder_recording_status_cb)handle->user_cb[_RECORDER_EVENT_TYPE_RECORDING_STATUS])( m->recording_status.elapsed, m->recording_status.filesize, handle->user_data[_RECORDER_EVENT_TYPE_RECORDING_STATUS]);
}
- break;
- case MM_MESSAGE_CAMCORDER_VIDEO_CAPTURED:
- case MM_MESSAGE_CAMCORDER_AUDIO_CAPTURED:
- {
- if( handle->type == _RECORDER_TYPE_AUDIO ){
- MMCamRecordingReport *report = (MMCamRecordingReport *)m ->data;
- if( report != NULL && report->recording_filename ){
- free(report->recording_filename );
- report->recording_filename = NULL;
- }
- if( report ){
- free(report);
- report = NULL;
- }
+ } else if (message == MM_MESSAGE_CAMCORDER_STATE_CHANGED_BY_SECURITY) {
+ policy = RECORDER_POLICY_SECURITY;
+ LOGE("RECORDER_POLICY_SECURITY");
+ }
+
+ if (previous_state != handle->state && handle->user_cb[_RECORDER_EVENT_TYPE_STATE_CHANGE]) {
+ ((recorder_state_changed_cb)handle->user_cb[_RECORDER_EVENT_TYPE_STATE_CHANGE])(previous_state, handle->state, policy, handle->user_data[_RECORDER_EVENT_TYPE_STATE_CHANGE]);
+ }
+
+ /* should change intermediate state MM_CAMCORDER_STATE_READY is not valid in capi , change to NULL state */
+ if (policy != RECORDER_POLICY_NONE &&
+ (m->state.current == MM_CAMCORDER_STATE_PAUSED || m->state.current == MM_CAMCORDER_STATE_NULL)) {
+ if (handle->user_cb[_RECORDER_EVENT_TYPE_INTERRUPTED]) {
+ ((recorder_interrupted_cb)handle->user_cb[_RECORDER_EVENT_TYPE_INTERRUPTED])(policy, previous_state, handle->state, handle->user_data[_RECORDER_EVENT_TYPE_INTERRUPTED]);
+ } else {
+ LOGW("_RECORDER_EVENT_TYPE_INTERRUPTED cb is NULL");
}
- break;
}
- case MM_MESSAGE_CAMCORDER_ERROR:
- {
- int errorcode = m->code;
- int recorder_error = 0;
- switch( errorcode ){
- case MM_ERROR_CAMCORDER_DEVICE :
- case MM_ERROR_CAMCORDER_DEVICE_TIMEOUT :
- case MM_ERROR_CAMCORDER_DEVICE_WRONG_JPEG :
- recorder_error = RECORDER_ERROR_DEVICE;
- break;
- case MM_ERROR_CAMCORDER_GST_CORE :
- case MM_ERROR_CAMCORDER_GST_LIBRARY :
- case MM_ERROR_CAMCORDER_GST_RESOURCE :
- case MM_ERROR_CAMCORDER_GST_STREAM :
- case MM_ERROR_CAMCORDER_GST_NEGOTIATION :
- case MM_ERROR_CAMCORDER_GST_FLOW_ERROR :
- case MM_ERROR_CAMCORDER_ENCODER :
- case MM_ERROR_CAMCORDER_ENCODER_BUFFER :
- case MM_ERROR_CAMCORDER_ENCODER_WORKING :
- case MM_ERROR_CAMCORDER_MNOTE_CREATION :
- case MM_ERROR_CAMCORDER_MNOTE_ADD_ENTRY :
- case MM_ERROR_CAMCORDER_INTERNAL :
- case MM_ERROR_FILE_NOT_FOUND:
- case MM_ERROR_FILE_READ:
- recorder_error = RECORDER_ERROR_INVALID_OPERATION;
- break;
- case MM_ERROR_CAMCORDER_LOW_MEMORY :
- case MM_ERROR_CAMCORDER_MNOTE_MALLOC :
- recorder_error = RECORDER_ERROR_OUT_OF_MEMORY;
- break;
- case MM_ERROR_CAMCORDER_DEVICE_REG_TROUBLE:
- recorder_error = RECORDER_ERROR_ESD;
- break;
- case MM_ERROR_OUT_OF_STORAGE:
- recorder_error = RECORDER_ERROR_OUT_OF_STORAGE;
- break;
- default:
- recorder_error = RECORDER_ERROR_INVALID_OPERATION;
- break;
+ break;
+ case MM_MESSAGE_CAMCORDER_MAX_SIZE:
+ case MM_MESSAGE_CAMCORDER_NO_FREE_SPACE:
+ case MM_MESSAGE_CAMCORDER_TIME_LIMIT:
+ if (MM_MESSAGE_CAMCORDER_MAX_SIZE == message) {
+ type = RECORDER_RECORDING_LIMIT_SIZE;
+ } else if (MM_MESSAGE_CAMCORDER_NO_FREE_SPACE == message) {
+ type = RECORDER_RECORDING_LIMIT_FREE_SPACE;
+ } else {
+ type = RECORDER_RECORDING_LIMIT_TIME;
+ }
+ if (handle->user_cb[_RECORDER_EVENT_TYPE_RECORDING_LIMITED]) {
+ ((recorder_recording_limit_reached_cb)handle->user_cb[_RECORDER_EVENT_TYPE_RECORDING_LIMITED])(type, handle->user_data[_RECORDER_EVENT_TYPE_RECORDING_LIMITED]);
+ }
+ break;
+ case MM_MESSAGE_CAMCORDER_RECORDING_STATUS:
+ if (handle->user_cb[_RECORDER_EVENT_TYPE_RECORDING_STATUS]) {
+ ((recorder_recording_status_cb)handle->user_cb[_RECORDER_EVENT_TYPE_RECORDING_STATUS])(m->recording_status.elapsed, m->recording_status.filesize, handle->user_data[_RECORDER_EVENT_TYPE_RECORDING_STATUS]);
+ }
+ break;
+ case MM_MESSAGE_CAMCORDER_VIDEO_CAPTURED:
+ case MM_MESSAGE_CAMCORDER_AUDIO_CAPTURED:
+ if (handle->type == _RECORDER_TYPE_AUDIO) {
+ MMCamRecordingReport *report = (MMCamRecordingReport *)m->data;
+ if (report != NULL && report->recording_filename) {
+ free(report->recording_filename);
+ report->recording_filename = NULL;
+ }
+ if (report) {
+ free(report);
+ report = NULL;
}
- if( recorder_error != 0 && handle->user_cb[_RECORDER_EVENT_TYPE_ERROR] )
- ((recorder_error_cb)handle->user_cb[_RECORDER_EVENT_TYPE_ERROR])(errorcode, handle->state , handle->user_data[_RECORDER_EVENT_TYPE_ERROR]);
- break;
}
- case MM_MESSAGE_CAMCORDER_CURRENT_VOLUME:
- if( handle->last_max_input_level < m->rec_volume_dB )
- handle->last_max_input_level = m->rec_volume_dB;
+ break;
+ case MM_MESSAGE_CAMCORDER_ERROR:
+ switch (m->code) {
+ case MM_ERROR_CAMCORDER_DEVICE:
+ case MM_ERROR_CAMCORDER_DEVICE_TIMEOUT:
+ case MM_ERROR_CAMCORDER_DEVICE_WRONG_JPEG:
+ recorder_error = RECORDER_ERROR_DEVICE;
+ break;
+ case MM_ERROR_CAMCORDER_GST_CORE:
+ case MM_ERROR_CAMCORDER_GST_LIBRARY:
+ case MM_ERROR_CAMCORDER_GST_RESOURCE:
+ case MM_ERROR_CAMCORDER_GST_STREAM:
+ case MM_ERROR_CAMCORDER_GST_NEGOTIATION:
+ case MM_ERROR_CAMCORDER_GST_FLOW_ERROR:
+ case MM_ERROR_CAMCORDER_ENCODER:
+ case MM_ERROR_CAMCORDER_ENCODER_BUFFER:
+ case MM_ERROR_CAMCORDER_ENCODER_WORKING:
+ case MM_ERROR_CAMCORDER_MNOTE_CREATION:
+ case MM_ERROR_CAMCORDER_MNOTE_ADD_ENTRY:
+ case MM_ERROR_CAMCORDER_INTERNAL:
+ case MM_ERROR_FILE_NOT_FOUND:
+ case MM_ERROR_FILE_READ:
+ recorder_error = RECORDER_ERROR_INVALID_OPERATION;
+ break;
+ case MM_ERROR_CAMCORDER_LOW_MEMORY:
+ case MM_ERROR_CAMCORDER_MNOTE_MALLOC:
+ recorder_error = RECORDER_ERROR_OUT_OF_MEMORY;
+ break;
+ case MM_ERROR_CAMCORDER_DEVICE_REG_TROUBLE:
+ recorder_error = RECORDER_ERROR_ESD;
+ break;
+ case MM_ERROR_OUT_OF_STORAGE:
+ recorder_error = RECORDER_ERROR_OUT_OF_STORAGE;
break;
default:
+ recorder_error = RECORDER_ERROR_INVALID_OPERATION;
break;
+ }
+
+ if (recorder_error != 0 && handle->user_cb[_RECORDER_EVENT_TYPE_ERROR]) {
+ ((recorder_error_cb)handle->user_cb[_RECORDER_EVENT_TYPE_ERROR])(recorder_error, handle->state, handle->user_data[_RECORDER_EVENT_TYPE_ERROR]);
+ }
+ break;
+ case MM_MESSAGE_CAMCORDER_CURRENT_VOLUME:
+ if (handle->last_max_input_level < m->rec_volume_dB) {
+ handle->last_max_input_level = m->rec_volume_dB;
+ }
+ break;
+ default:
+ break;
}
return 1;
}
-static int __mm_audio_stream_cb(MMCamcorderAudioStreamDataType *stream, void *user_param){
- if( user_param == NULL || stream == NULL)
+
+static int __mm_audio_stream_cb(MMCamcorderAudioStreamDataType *stream, void *user_param)
+{
+ if (user_param == NULL || stream == NULL) {
return 0;
+ }
- recorder_s * handle = (recorder_s*)user_param;
+ recorder_s *handle = (recorder_s *)user_param;
audio_sample_type_e format = AUDIO_SAMPLE_TYPE_U8;
- if( stream->format == MM_CAMCORDER_AUDIO_FORMAT_PCM_S16_LE)
+
+ if (stream->format == MM_CAMCORDER_AUDIO_FORMAT_PCM_S16_LE) {
format = AUDIO_SAMPLE_TYPE_S16_LE;
+ }
if( handle->user_cb[_RECORDER_EVENT_TYPE_AUDIO_STREAM] ){
- ((recorder_audio_stream_cb)(handle->user_cb[_RECORDER_EVENT_TYPE_AUDIO_STREAM]))(stream->data,
- stream->length,
- format,
- stream->channel,
- stream->timestamp,
- handle->user_data[_RECORDER_EVENT_TYPE_AUDIO_STREAM]);
+ ((recorder_audio_stream_cb)(handle->user_cb[_RECORDER_EVENT_TYPE_AUDIO_STREAM]))(stream->data, stream->length, format,
+ stream->channel, stream->timestamp,
+ handle->user_data[_RECORDER_EVENT_TYPE_AUDIO_STREAM]);
}
+
return 1;
}
-int recorder_create_videorecorder(camera_h camera, recorder_h* recorder)
+static int _recorder_check_and_set_attribute(recorder_h recorder, const char *attribute_name, int set_value)
+{
+ bool reset_pipeline = false;
+ bool restore_set = false;
+ int ret = MM_ERROR_NONE;
+ int ret2 = MM_ERROR_NONE;
+ int current_value = -1;
+ int current_audio_disable = 0;
+
+ recorder_s *handle = (recorder_s *)recorder;
+ MMCamcorderStateType mmstate = MM_CAMCORDER_STATE_NONE;
+
+ if (recorder == NULL) {
+ LOGE("handle is NULL");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ mm_camcorder_get_state(handle->mm_handle, &mmstate);
+ if (mmstate >= MM_CAMCORDER_STATE_RECORDING) {
+ LOGE("invalid state %d", mmstate);
+ return RECORDER_ERROR_INVALID_STATE;
+ }
+
+ if (handle->type == _RECORDER_TYPE_AUDIO && mmstate == MM_CAMCORDER_STATE_PREPARE) {
+ mm_camcorder_get_attributes(handle->mm_handle, NULL,
+ MMCAM_AUDIO_DISABLE, ¤t_audio_disable,
+ attribute_name, ¤t_value,
+ NULL);
+
+ if (current_value != set_value) {
+ LOGD("try to reset pipeline");
+
+ ret = mm_camcorder_stop(handle->mm_handle);
+ if (ret != MM_ERROR_NONE) {
+ LOGE("mm_camcorder_stop failed 0x%x", ret);
+ return __convert_recorder_error_code(attribute_name, ret);
+ }
+
+ ret = mm_camcorder_unrealize(handle->mm_handle);
+ if (ret != MM_ERROR_NONE) {
+ LOGE("mm_camcorder_unrealize failed 0x%x", ret);
+ mm_camcorder_start(handle->mm_handle);
+ return __convert_recorder_error_code(attribute_name, ret);
+ }
+
+ reset_pipeline = true;
+ }
+ }
+
+ if (!strcmp(attribute_name, MMCAM_AUDIO_ENCODER)) {
+ if (set_value == RECORDER_AUDIO_CODEC_DISABLE) {
+ ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
+ MMCAM_AUDIO_DISABLE, true,
+ NULL);
+ } else {
+ ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
+ MMCAM_AUDIO_DISABLE, false,
+ MMCAM_AUDIO_ENCODER, set_value,
+ NULL);
+ }
+ } else {
+ ret = mm_camcorder_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);
+ }
+
+ if (reset_pipeline) {
+ ret2 = mm_camcorder_realize(handle->mm_handle);
+ if (ret2 == MM_ERROR_NONE) {
+ ret2 = mm_camcorder_start(handle->mm_handle);
+ if (ret2 == MM_ERROR_NONE) {
+ LOGW("restart pipeline done.");
+ } else {
+ LOGE("mm_camcorder_start failed 0x%x", ret2);
+ mm_camcorder_unrealize(handle->mm_handle);
+ }
+ } else {
+ LOGE("mm_camcorder_realize failed 0x%x", ret2);
+ }
+
+ if (ret2 != MM_ERROR_NONE) {
+ restore_set = true;
+ /* determine return value */
+ if (ret == MM_ERROR_NONE) {
+ ret = ret2;
+ }
+ }
+ }
+
+ if (restore_set) {
+ ret2 = mm_camcorder_set_attributes(handle->mm_handle, NULL,
+ MMCAM_AUDIO_DISABLE, current_audio_disable,
+ attribute_name, current_value,
+ NULL);
+ LOGW("restore attribute set : 0x%x", ret2);
+
+ ret2 = mm_camcorder_realize(handle->mm_handle);
+ LOGW("restore mm_camcorder_realize : 0x%x", ret2);
+
+ ret2 = mm_camcorder_start(handle->mm_handle);
+ LOGW("restore mm_camcorder_realize : 0x%x", ret2);
+ if (ret2 != MM_ERROR_NONE) {
+ ret2 = mm_camcorder_unrealize(handle->mm_handle);
+ LOGW("restore mm_camcorder_unrealize : 0x%x", ret2);
+ }
+ }
+
+ return __convert_recorder_error_code(attribute_name, ret);
+}
+
+
+int recorder_create_videorecorder(camera_h camera, recorder_h *recorder)
{
+ int ret = MM_ERROR_NONE;
int resource_fd = -1;
- recorder_s * handle = NULL;
+ recorder_s *handle = NULL;
int preview_format = MM_PIXEL_FORMAT_NV12;
+ int camera_device_count = 0;
- if( camera == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
- if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
+ if (camera == NULL) {
+ LOGE("NULL pointer camera handle");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+ if (recorder == NULL) {
+ LOGE("NULL pointer recorder handle");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
- //Check already used in another recorder
- if( _camera_is_used(camera)){
+ /* Check already used in another recorder */
+ if (_camera_is_used(camera)) {
LOGE("[%s] camera is using in another recorder.", __func__);
return RECORDER_ERROR_INVALID_PARAMETER;
}
}
memset(handle, 0 , sizeof(recorder_s));
+ handle->src_type = _RECORDER_SOURCE_TYPE_CAMERA;
handle->last_max_input_level = LOWSET_DECIBEL;
handle->changed_preview_format = -1;
handle->mm_source.camera = camera;
- _camera_set_use(camera, true);
_camera_get_mm_handle(camera, &handle->mm_handle);
_camera_set_relay_mm_message_callback(camera, __mm_recorder_msg_cb , (void*)handle);
handle->type = _RECORDER_TYPE_VIDEO;
recorder_get_state((recorder_h)handle, (recorder_state_e*)&handle->state);
- *recorder = (recorder_h)handle;
- mm_camcorder_get_attributes(handle->mm_handle, NULL, MMCAM_CAMERA_FORMAT, &preview_format, NULL);
+ mm_camcorder_get_attributes(handle->mm_handle, NULL,
+ MMCAM_CAMERA_FORMAT, &preview_format,
+ NULL);
handle->origin_preview_format = preview_format;
- mm_camcorder_get_attributes(handle->mm_handle, NULL, MMCAM_RECOMMEND_PREVIEW_FORMAT_FOR_RECORDING, &preview_format, NULL);
+ mm_camcorder_get_attributes(handle->mm_handle, NULL,
+ MMCAM_RECOMMEND_PREVIEW_FORMAT_FOR_RECORDING, &preview_format,
+ NULL);
+ ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL,
+ MMCAM_CAMERA_DEVICE_COUNT, &camera_device_count,
+ NULL);
+ if (ret != MM_ERROR_NONE) {
+ free(handle);
+ handle = NULL;
+ LOGE("get device count error");
+ return __convert_recorder_error_code(__func__, ret);
+ }
+ if (camera_device_count == 0) {
+ free(handle);
+ handle = NULL;
+ LOGE("RECORDER_ERROR_NOT_SUPPORTED");
+ return RECORDER_ERROR_NOT_SUPPORTED;
+ } else {
+ handle->camera_device_count = camera_device_count;
+ }
- if( handle->state == RECORDER_STATE_CREATED ){
- int ret;
- ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,MMCAM_CAMERA_FORMAT, preview_format,(void*)NULL);
- if( ret ==0 )
+ _camera_set_use(camera, true);
+ if (handle->state == RECORDER_STATE_CREATED) {
+ ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
+ MMCAM_CAMERA_FORMAT, preview_format,
+ NULL);
+ if (ret == MM_ERROR_NONE) {
handle->changed_preview_format = preview_format;
+ }
}
+ *recorder = (recorder_h)handle;
+
return RECORDER_ERROR_NONE;
}
-int recorder_create_audiorecorder( recorder_h* recorder){
-
- if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
- int ret = MM_ERROR_NONE;
- recorder_s * handle;
+int recorder_create_audiorecorder(recorder_h *recorder)
+{
+ int ret = MM_ERROR_NONE;
+ recorder_s *handle = NULL;
MMCamPreset info;
- info.videodev_type= MM_VIDEO_DEVICE_NONE;
+ int camera_device_count = 0;
- handle = (recorder_s*)malloc( sizeof(recorder_s) );
- if(handle==NULL){
- LOGE( "[%s] OUT_OF_MEMORY(0x%08x)", __func__, RECORDER_ERROR_OUT_OF_MEMORY);
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ info.videodev_type = MM_VIDEO_DEVICE_NONE;
+
+ handle = (recorder_s *)malloc(sizeof(recorder_s));
+ if (handle == NULL) {
+ LOGE("OUT_OF_MEMORY(0x%08x)", RECORDER_ERROR_OUT_OF_MEMORY);
return RECORDER_ERROR_OUT_OF_MEMORY;
}
- memset(handle, 0 , sizeof(recorder_s));
+ memset(handle, 0, sizeof(recorder_s));
+
handle->last_max_input_level = LOWSET_DECIBEL;
ret = mm_camcorder_create(&handle->mm_handle, &info);
- if( ret != MM_ERROR_NONE){
+ if (ret != MM_ERROR_NONE) {
free(handle);
- LOGE("[%s] mm_camcorder_create fail", __func__);
+ handle = NULL;
+ LOGE("mm_camcorder_create fail");
return __convert_recorder_error_code(__func__, ret);
}
+
ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
- MMCAM_MODE , MM_CAMCORDER_MODE_AUDIO,
- (void*)NULL);
+ MMCAM_MODE, MM_CAMCORDER_MODE_AUDIO,
+ NULL);
- if( ret != MM_ERROR_NONE){
+ if (ret != MM_ERROR_NONE) {
mm_camcorder_destroy(handle->mm_handle);
free(handle);
- LOGE("[%s] AUDIO mode setting fail", __func__);
+ handle = NULL;
+ LOGE("AUDIO mode setting fail");
return __convert_recorder_error_code(__func__, ret);
}
-
-
+ ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL,
+ MMCAM_CAMERA_DEVICE_COUNT, &camera_device_count, NULL);
+ if (ret != MM_ERROR_NONE) {
+ mm_camcorder_destroy(handle->mm_handle);
+ free(handle);
+ handle = NULL;
+ LOGE("get device count error");
+ return __convert_recorder_error_code(__func__, ret);
+ } else {
+ handle->camera_device_count = camera_device_count;
+ }
handle->state = RECORDER_STATE_CREATED;
- mm_camcorder_set_message_callback(handle->mm_handle, __mm_recorder_msg_cb, (void*)handle);
handle->mm_source.camera = NULL;
handle->type = _RECORDER_TYPE_AUDIO;
+ mm_camcorder_set_message_callback(handle->mm_handle, __mm_recorder_msg_cb, (void*)handle);
+
*recorder = (recorder_h)handle;
return RECORDER_ERROR_NONE;
-
}
-int recorder_get_state(recorder_h recorder, recorder_state_e * state){
- if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
- if( state == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
+int recorder_get_state(recorder_h recorder, recorder_state_e *state)
+{
+ int ret = MM_ERROR_NONE;
+ MMCamcorderStateType mmstate;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+ if (state == NULL) {
+ LOGE("NULL pointer state");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
recorder_s *handle = (recorder_s*)recorder;
- MMCamcorderStateType mmstate ;
- recorder_state_e capi_state;
- mm_camcorder_get_state(handle->mm_handle, &mmstate);
- capi_state = __recorder_state_convert(mmstate);
+ ret = mm_camcorder_get_state(handle->mm_handle, &mmstate);
+ if (ret != MM_ERROR_NONE) {
+ return __convert_recorder_error_code(__func__, ret);
+ }
+
+ *state = __recorder_state_convert(mmstate);
- *state = capi_state;
return RECORDER_ERROR_NONE;
}
-int recorder_destroy( recorder_h recorder){
- if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
- recorder_s * handle;
+
+int recorder_destroy(recorder_h recorder)
+{
+ recorder_s *handle = NULL;
int ret = MM_ERROR_NONE;
+ int preview_format;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
- handle = (recorder_s *) recorder;
- if( handle->type == _RECORDER_TYPE_VIDEO ){
- //set to unsed
+ handle = (recorder_s *)recorder;
+
+ if (handle->type == _RECORDER_TYPE_VIDEO) {
+ /* set to unsed */
_camera_set_use(handle->mm_source.camera, false);
- int preview_format;
- mm_camcorder_get_attributes(handle->mm_handle, NULL, MMCAM_CAMERA_FORMAT, &preview_format, NULL);
- // preview format was changed?
- if( preview_format == handle->changed_preview_format ){
- mm_camcorder_set_attributes(handle->mm_handle, NULL, MMCAM_CAMERA_FORMAT, handle->origin_preview_format,(void*)NULL);
+ ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
+ MMCAM_CAMERA_FORMAT, &preview_format,
+ NULL);
+
+ /* preview format was changed? */
+ if (ret == MM_ERROR_NONE && preview_format == handle->changed_preview_format) {
+ ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
+ MMCAM_CAMERA_FORMAT, handle->origin_preview_format,
+ NULL);
+ }
+
+ if (ret == MM_ERROR_NONE) {
+ _camera_set_relay_mm_message_callback(handle->mm_source.camera, NULL, NULL);
}
- _camera_set_relay_mm_message_callback(handle->mm_source.camera , NULL, NULL);
- }else{
+ } else {
ret = mm_camcorder_destroy(handle->mm_handle);
}
- if(ret == MM_ERROR_NONE)
+ if (ret == MM_ERROR_NONE) {
free(handle);
+ }
return __convert_recorder_error_code(__func__, ret);
-
}
-int recorder_prepare( recorder_h recorder){
- if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
- int ret = MM_ERROR_NONE;
- recorder_s *handle = (recorder_s*)recorder;
- if( handle->type == _RECORDER_TYPE_VIDEO ){
+int recorder_prepare(recorder_h recorder)
+{
+ int ret = MM_ERROR_NONE;
+ recorder_s *handle = (recorder_s *)recorder;
+ MMCamcorderStateType mmstate;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ if (handle->type == _RECORDER_TYPE_VIDEO) {
return __convert_error_code_camera_to_recorder(camera_start_preview(handle->mm_source.camera));
}
- MMCamcorderStateType mmstate ;
- mm_camcorder_get_state(handle->mm_handle, &mmstate);
+ ret = mm_camcorder_get_state(handle->mm_handle, &mmstate);
- if( mmstate != MM_CAMCORDER_STATE_READY){
+ if (ret == MM_ERROR_NONE && mmstate < MM_CAMCORDER_STATE_READY) {
ret = mm_camcorder_realize(handle->mm_handle);
- if( ret != MM_ERROR_NONE){
- LOGE("[%s] mm_camcorder_realize fail", __func__);
+ if (ret != MM_ERROR_NONE) {
+ LOGE("mm_camcorder_realize fail");
return __convert_recorder_error_code(__func__, ret);
}
}
ret = mm_camcorder_start(handle->mm_handle);
-
- if( ret != MM_ERROR_NONE){
- LOGE("[%s] mm_camcorder_start fail", __func__);
+ if (ret != MM_ERROR_NONE) {
+ LOGE("mm_camcorder_start fail");
mm_camcorder_unrealize(handle->mm_handle);
return __convert_recorder_error_code(__func__, ret);
}
return RECORDER_ERROR_NONE;
}
-int recorder_unprepare( recorder_h recorder){
- if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
- int ret = MM_ERROR_NONE;
- recorder_s *handle = (recorder_s*)recorder;
- MMCamcorderStateType mmstate ;
- mm_camcorder_get_state(handle->mm_handle, &mmstate);
+int recorder_unprepare(recorder_h recorder)
+{
+ int ret = MM_ERROR_NONE;
+ recorder_s *handle = (recorder_s *)recorder;
+ MMCamcorderStateType mmstate;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
- if( mmstate == MM_CAMCORDER_STATE_PREPARE){
+ ret = mm_camcorder_get_state(handle->mm_handle, &mmstate);
+ if (ret == MM_ERROR_NONE && mmstate == MM_CAMCORDER_STATE_PREPARE) {
ret = mm_camcorder_stop(handle->mm_handle);
if( ret != MM_ERROR_NONE){
- LOGE("[%s] mm_camcorder_stop fail", __func__);
- return __convert_recorder_error_code(__func__, ret);
+ LOGE("mm_camcorder_stop fail");
+ }
+ }
+
+ if (ret == MM_ERROR_NONE) {
+ ret = mm_camcorder_unrealize(handle->mm_handle);
+ if (ret != MM_ERROR_NONE) {
+ LOGE("mm_camcorder_unrealize fail");
+ mm_camcorder_start(handle->mm_handle);
}
}
- ret = mm_camcorder_unrealize(handle->mm_handle);
+
return __convert_recorder_error_code(__func__, ret);
}
-int recorder_start( recorder_h recorder){
- if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
- int ret = MM_ERROR_NONE;
- recorder_s *handle = (recorder_s*)recorder;
- ret = mm_camcorder_record(handle->mm_handle);
- return __convert_recorder_error_code(__func__, ret);
+
+int recorder_start(recorder_h recorder)
+{
+ recorder_s *handle = (recorder_s *)recorder;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ return __convert_recorder_error_code(__func__, mm_camcorder_record(handle->mm_handle));
}
-int recorder_pause( recorder_h recorder){
- if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
- int ret = MM_ERROR_NONE;
- recorder_s *handle = (recorder_s*)recorder;
- ret = mm_camcorder_pause(handle->mm_handle);
- return __convert_recorder_error_code(__func__, ret);
+int recorder_pause(recorder_h recorder)
+{
+ recorder_s *handle = (recorder_s *)recorder;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ return __convert_recorder_error_code(__func__, mm_camcorder_pause(handle->mm_handle));
}
-int recorder_commit( recorder_h recorder){
- if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
- int ret = MM_ERROR_NONE;
- recorder_s *handle = (recorder_s*)recorder;
- ret = mm_camcorder_commit(handle->mm_handle);
- return __convert_recorder_error_code(__func__, ret);
+
+int recorder_commit(recorder_h recorder)
+{
+ recorder_s *handle = (recorder_s *)recorder;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ return __convert_recorder_error_code(__func__, mm_camcorder_commit(handle->mm_handle));
}
-int recorder_cancel( recorder_h recorder){
- if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
- int ret = MM_ERROR_NONE;
- recorder_s *handle = (recorder_s*)recorder;
- ret = mm_camcorder_cancel(handle->mm_handle);
- return __convert_recorder_error_code(__func__, ret);
+
+int recorder_cancel(recorder_h recorder)
+{
+ recorder_s *handle = (recorder_s *)recorder;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ return __convert_recorder_error_code(__func__, mm_camcorder_cancel(handle->mm_handle));
}
recorder_s *handle = (recorder_s*)recorder;
recorder_state_e state;
- if (!handle || !width || !height) {
- LOGE("NULL pointer %p %p %p", handle, width, height);
- return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
+ if (handle == NULL) {
+ LOGE("NULL pointer handle");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+ if (handle->camera_device_count == 0) {
+ LOGE("RECORDER_ERROR_NOT_SUPPORTED");
+ return RECORDER_ERROR_NOT_SUPPORTED;
}
-
recorder_get_state(recorder, &state);
if (state > RECORDER_STATE_READY) {
LOGE("RECORDER_ERROR_INVALID_STATE (state:%d)", state);
}
ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
- MMCAM_VIDEO_WIDTH, width,
- MMCAM_VIDEO_HEIGHT, height,
- NULL);
+ MMCAM_VIDEO_WIDTH, width,
+ MMCAM_VIDEO_HEIGHT, height,
+ NULL);
return __convert_recorder_error_code(__func__, ret);
}
int ret = MM_ERROR_NONE;
recorder_s *handle = (recorder_s*)recorder;
- if (!handle || !width || !height) {
- LOGE("NULL pointer %p %p %p", handle, width, height);
- return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
+ if (!handle) {
+ LOGE("NULL pointer handle");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ if (handle->camera_device_count == 0) {
+ LOGE("RECORDER_ERROR_NOT_SUPPORTED");
+ return RECORDER_ERROR_NOT_SUPPORTED;
+ }
+
+ if (!width || !height) {
+ LOGE("NULL pointer width = [%p], height = [%p]", width, height);
+ return RECORDER_ERROR_INVALID_PARAMETER;
}
ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
- MMCAM_VIDEO_WIDTH, width,
- MMCAM_VIDEO_HEIGHT, height,
- NULL);
+ MMCAM_VIDEO_WIDTH, width,
+ MMCAM_VIDEO_HEIGHT, height,
+ NULL);
return __convert_recorder_error_code(__func__, ret);
}
MMCamAttrsInfo video_width;
MMCamAttrsInfo video_height;
- if (!handle || !foreach_cb) {
- LOGE("NULL pointer %p %p", handle, foreach_cb);
+ if (!handle) {
+ LOGE("NULL pointer handle");
return RECORDER_ERROR_INVALID_PARAMETER;
}
- ret = mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_VIDEO_WIDTH , &video_width);
- ret |= mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_VIDEO_HEIGHT , &video_height);
+ if (handle->camera_device_count == 0) {
+ LOGE("RECORDER_ERROR_NOT_SUPPORTED");
+ return RECORDER_ERROR_NOT_SUPPORTED;
+ }
+
+ if (!foreach_cb) {
+ LOGE("NULL pointer callback");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_VIDEO_WIDTH, &video_width);
+ ret |= mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_VIDEO_HEIGHT, &video_height);
if (ret != MM_ERROR_NONE ) {
return __convert_recorder_error_code(__func__, ret);
}
-int recorder_get_audio_level(recorder_h recorder, double *level){
- if( recorder == NULL || level == NULL ) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
- recorder_s *handle = (recorder_s*)recorder;
-
+int recorder_get_audio_level(recorder_h recorder, double *level)
+{
+ recorder_s *handle = (recorder_s *)recorder;
recorder_state_e state;
+
+ if (recorder == NULL || level == NULL) {
+ LOGE("NULL pointer %p %p", recorder, level);
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+
recorder_get_state(recorder, &state);
- if( state < RECORDER_STATE_RECORDING ){
- LOGE("[%s]RECORDER_ERROR_INVALID_STATE(0x%08x) ",__func__, RECORDER_ERROR_INVALID_STATE);
+ if (state < RECORDER_STATE_RECORDING) {
+ LOGE("RECORDER_ERROR_INVALID_STATE(0x%08x)", RECORDER_ERROR_INVALID_STATE);
return RECORDER_ERROR_INVALID_STATE;
}
- *level = handle->last_max_input_level ;
+ *level = handle->last_max_input_level;
handle->last_max_input_level = LOWSET_DECIBEL;
+
return RECORDER_ERROR_NONE;
}
-int recorder_set_filename(recorder_h recorder, const char *filename){
- if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
- g_return_val_if_fail(filename != NULL, RECORDER_ERROR_INVALID_PARAMETER);
+
+int recorder_set_filename(recorder_h recorder, const char *filename)
+{
int ret = MM_ERROR_NONE;
- recorder_s * handle = (recorder_s*)recorder;
- ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_TARGET_FILENAME , filename , strlen(filename), NULL);
- return __convert_recorder_error_code(__func__, ret);
+ recorder_s *handle = (recorder_s *)recorder;
+ MMCamcorderStateType mmstate = MM_CAMCORDER_STATE_NONE;
+
+ if (recorder == NULL) {
+ LOGE("handle is NULL");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ if (filename == NULL) {
+ LOGE("filename is NULL");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ mm_camcorder_get_state(handle->mm_handle, &mmstate);
+ if (mmstate >= MM_CAMCORDER_STATE_RECORDING) {
+ LOGE("invalid state %d", mmstate);
+ return RECORDER_ERROR_INVALID_STATE;
+ }
+
+ ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
+ MMCAM_TARGET_FILENAME, filename, strlen(filename),
+ NULL);
+ return __convert_recorder_error_code(__func__, ret);
}
-int recorder_get_filename(recorder_h recorder, char **filename){
- if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
- g_return_val_if_fail(filename != NULL, RECORDER_ERROR_INVALID_PARAMETER);
- int ret = MM_ERROR_NONE;
- recorder_s * handle = (recorder_s*)recorder;
+int recorder_get_filename(recorder_h recorder, char **filename)
+{
+ int ret = MM_ERROR_NONE;
char *record_filename = NULL;
int record_filename_size;
- ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_TARGET_FILENAME , &record_filename, &record_filename_size, NULL);
+ recorder_s *handle = (recorder_s *)recorder;
+
+ if (recorder == NULL) {
+ LOGE("handle is NULL");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
- if( ret == MM_ERROR_NONE && record_filename) {
+ if (filename == NULL) {
+ LOGE("filename is NULL");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
+ MMCAM_TARGET_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);
int recorder_set_file_format(recorder_h recorder, recorder_file_format_e format)
{
- int ret = MM_ERROR_NONE;
- int format_table[6] = { MM_FILE_FORMAT_3GP, //RECORDER_FILE_FORMAT_3GP
- MM_FILE_FORMAT_MP4, //RECORDER_FILE_FORMAT_MP4
- MM_FILE_FORMAT_AMR, //RECORDER_FILE_FORMAT_AMR
- MM_FILE_FORMAT_AAC, //RECORDER_FILE_FORMAT_ADTS
- MM_FILE_FORMAT_WAV, //RECORDER_FILE_FORMAT_WAV
- MM_FILE_FORMAT_OGG //RECORDER_FILE_FORMAT_OGG
+ int format_table[6] = { MM_FILE_FORMAT_3GP, /* RECORDER_FILE_FORMAT_3GP */
+ MM_FILE_FORMAT_MP4, /* RECORDER_FILE_FORMAT_MP4 */
+ MM_FILE_FORMAT_AMR, /* RECORDER_FILE_FORMAT_AMR */
+ MM_FILE_FORMAT_AAC, /* RECORDER_FILE_FORMAT_ADTS */
+ MM_FILE_FORMAT_WAV, /* RECORDER_FILE_FORMAT_WAV */
+ MM_FILE_FORMAT_OGG /* RECORDER_FILE_FORMAT_OGG */
};
- recorder_s *handle = (recorder_s *)recorder;
-
- if (handle == NULL) {
- return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
- }
if (format < RECORDER_FILE_FORMAT_3GP || format > RECORDER_FILE_FORMAT_OGG) {
+ LOGE("invalid format %d", format);
return RECORDER_ERROR_INVALID_PARAMETER;
}
- ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
- MMCAM_FILE_FORMAT, format_table[format],
- NULL);
-
- return __convert_recorder_error_code(__func__, ret);
+ return _recorder_check_and_set_attribute(recorder, MMCAM_FILE_FORMAT, format_table[format]);
}
-int recorder_get_file_format(recorder_h recorder, recorder_file_format_e *format){
- if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
- g_return_val_if_fail(format != NULL, RECORDER_ERROR_INVALID_PARAMETER);
+
+int recorder_get_file_format(recorder_h recorder, recorder_file_format_e *format)
+{
int ret = MM_ERROR_NONE;
- recorder_s * handle = (recorder_s*)recorder;
+ recorder_s *handle = (recorder_s *)recorder;
int mm_format;
- ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_FILE_FORMAT , &mm_format, NULL);
- if( ret == 0 ){
- switch( mm_format ){
- case MM_FILE_FORMAT_3GP:
- *format = RECORDER_FILE_FORMAT_3GP;
- break;
- case MM_FILE_FORMAT_MP4 :
- *format = RECORDER_FILE_FORMAT_MP4;
- break;
- case MM_FILE_FORMAT_AMR :
- *format = RECORDER_FILE_FORMAT_AMR;
- break;
- case MM_FILE_FORMAT_AAC :
- *format = RECORDER_FILE_FORMAT_ADTS;
- break;
- case MM_FILE_FORMAT_WAV:
- *format = RECORDER_FILE_FORMAT_WAV;
- break;
- case MM_FILE_FORMAT_OGG:
- *format = RECORDER_FILE_FORMAT_OGG;
- break;
- default :
- ret = MM_ERROR_CAMCORDER_INTERNAL;
- break;
+ if (recorder == NULL) {
+ LOGE("handle is NULL");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ if (format == NULL) {
+ LOGE("format is NULL");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
+ MMCAM_FILE_FORMAT, &mm_format,
+ NULL);
+ if (ret == MM_ERROR_NONE) {
+ switch (mm_format) {
+ case MM_FILE_FORMAT_3GP:
+ *format = RECORDER_FILE_FORMAT_3GP;
+ break;
+ case MM_FILE_FORMAT_MP4 :
+ *format = RECORDER_FILE_FORMAT_MP4;
+ break;
+ case MM_FILE_FORMAT_AMR :
+ *format = RECORDER_FILE_FORMAT_AMR;
+ break;
+ case MM_FILE_FORMAT_AAC :
+ *format = RECORDER_FILE_FORMAT_ADTS;
+ break;
+ case MM_FILE_FORMAT_WAV:
+ *format = RECORDER_FILE_FORMAT_WAV;
+ break;
+ case MM_FILE_FORMAT_OGG:
+ *format = RECORDER_FILE_FORMAT_OGG;
+ break;
+ default :
+ ret = MM_ERROR_CAMCORDER_INTERNAL;
+ break;
}
}
+
return __convert_recorder_error_code(__func__, ret);
}
-int recorder_set_state_changed_cb(recorder_h recorder, recorder_state_changed_cb callback, void* user_data){
- if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
- recorder_s *handle = (recorder_s*)recorder;
- if( callback == NULL )
+
+int recorder_set_state_changed_cb(recorder_h recorder, recorder_state_changed_cb callback, void* user_data)
+{
+ recorder_s *handle = (recorder_s *)recorder;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ if (callback == NULL) {
+ LOGE("NULL pointer callback");
return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+
handle->user_cb[_RECORDER_EVENT_TYPE_STATE_CHANGE] = callback;
handle->user_data[_RECORDER_EVENT_TYPE_STATE_CHANGE] = user_data;
return RECORDER_ERROR_NONE;
}
-int recorder_unset_state_changed_cb(recorder_h recorder){
- if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
- recorder_s *handle = (recorder_s*)recorder;
+
+int recorder_unset_state_changed_cb(recorder_h recorder)
+{
+ recorder_s *handle = (recorder_s *)recorder;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
handle->user_cb[_RECORDER_EVENT_TYPE_STATE_CHANGE] = NULL;
handle->user_data[_RECORDER_EVENT_TYPE_STATE_CHANGE] = NULL;
return RECORDER_ERROR_NONE;
}
-int recorder_set_interrupted_cb(recorder_h recorder, recorder_interrupted_cb callback, void *user_data){
- if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
- recorder_s *handle = (recorder_s*)recorder;
- if( callback == NULL )
+
+int recorder_set_interrupted_cb(recorder_h recorder, recorder_interrupted_cb callback, void *user_data)
+{
+ recorder_s *handle = (recorder_s *)recorder;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+ if (callback == NULL) {
+ LOGE("NULL pointer callback");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
handle->user_cb[_RECORDER_EVENT_TYPE_INTERRUPTED] = callback;
handle->user_data[_RECORDER_EVENT_TYPE_INTERRUPTED] = user_data;
return RECORDER_ERROR_NONE;
}
-int recorder_unset_interrupted_cb(recorder_h recorder){
- if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
- recorder_s *handle = (recorder_s*)recorder;
+
+
+int recorder_unset_interrupted_cb(recorder_h recorder)
+{
+ recorder_s *handle = (recorder_s *)recorder;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
handle->user_cb[_RECORDER_EVENT_TYPE_INTERRUPTED] = NULL;
handle->user_data[_RECORDER_EVENT_TYPE_INTERRUPTED] = NULL;
return RECORDER_ERROR_NONE;
}
-int recorder_set_audio_stream_cb(recorder_h recorder, recorder_audio_stream_cb callback, void* user_data){
- if( recorder == NULL || callback == NULL ) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
- int ret;
- recorder_s *handle = (recorder_s*)recorder;
- ret = mm_camcorder_set_audio_stream_callback( handle->mm_handle, __mm_audio_stream_cb, handle);
- if( ret == 0 ){
+
+int recorder_set_audio_stream_cb(recorder_h recorder, recorder_audio_stream_cb callback, void* user_data)
+{
+ int ret = MM_ERROR_NONE;
+ recorder_s *handle = (recorder_s *)recorder;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+ if (callback == NULL) {
+ LOGE("NULL pointer callback");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = mm_camcorder_set_audio_stream_callback(handle->mm_handle, __mm_audio_stream_cb, handle);
+ if (ret == MM_ERROR_NONE){
handle->user_cb[_RECORDER_EVENT_TYPE_AUDIO_STREAM] = callback;
handle->user_data[_RECORDER_EVENT_TYPE_AUDIO_STREAM] = user_data;
}
+
return __convert_recorder_error_code(__func__, ret);
}
-int recorder_unset_audio_stream_cb(recorder_h recorder){
- if( recorder == NULL ) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
- int ret;
- recorder_s *handle = (recorder_s*)recorder;
+
+int recorder_unset_audio_stream_cb(recorder_h recorder)
+{
+ int ret = MM_ERROR_NONE;
+ recorder_s *handle = (recorder_s *)recorder;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+
handle->user_cb[_RECORDER_EVENT_TYPE_AUDIO_STREAM] = NULL;
handle->user_data[_RECORDER_EVENT_TYPE_AUDIO_STREAM] = NULL;
- ret = mm_camcorder_set_audio_stream_callback( handle->mm_handle, NULL, NULL);
+
+ ret = mm_camcorder_set_audio_stream_callback(handle->mm_handle, NULL, NULL);
+
return __convert_recorder_error_code(__func__, ret);
}
-int recorder_set_error_cb(recorder_h recorder, recorder_error_cb callback, void *user_data){
- if( recorder == NULL || callback == NULL ) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
- recorder_s *handle = (recorder_s*)recorder;
+
+int recorder_set_error_cb(recorder_h recorder, recorder_error_cb callback, void *user_data)
+{
+ recorder_s *handle = (recorder_s *)recorder;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+ if (callback == NULL) {
+ LOGE("NULL pointer callback");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+
handle->user_cb[_RECORDER_EVENT_TYPE_ERROR] = callback;
handle->user_data[_RECORDER_EVENT_TYPE_ERROR] = user_data;
+
return RECORDER_ERROR_NONE;
}
-int recorder_unset_error_cb(recorder_h recorder){
- if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
- recorder_s *handle = (recorder_s*)recorder;
+
+int recorder_unset_error_cb(recorder_h recorder)
+{
+ recorder_s *handle = (recorder_s *)recorder;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+
handle->user_cb[_RECORDER_EVENT_TYPE_ERROR] = NULL;
handle->user_data[_RECORDER_EVENT_TYPE_ERROR] = NULL;
+
return RECORDER_ERROR_NONE;
}
-int recorder_set_recording_status_cb(recorder_h recorder, recorder_recording_status_cb callback, void* user_data){
-
- if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
- recorder_s *handle = (recorder_s*)recorder;
- if( callback == NULL )
+
+int recorder_set_recording_status_cb(recorder_h recorder, recorder_recording_status_cb callback, void* user_data)
+{
+ recorder_s *handle = (recorder_s *)recorder;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+ if (callback == NULL) {
+ LOGE("NULL pointer callback");
return RECORDER_ERROR_INVALID_PARAMETER;
-
+ }
+
handle->user_cb[_RECORDER_EVENT_TYPE_RECORDING_STATUS] = callback;
handle->user_data[_RECORDER_EVENT_TYPE_RECORDING_STATUS] = user_data;
return RECORDER_ERROR_NONE;
}
-int recorder_unset_recording_status_cb(recorder_h recorder){
-
- if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
- recorder_s *handle = (recorder_s*)recorder;
+
+int recorder_unset_recording_status_cb(recorder_h recorder)
+{
+ recorder_s *handle = (recorder_s *)recorder;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+
handle->user_cb[_RECORDER_EVENT_TYPE_RECORDING_STATUS] = NULL;
handle->user_data[_RECORDER_EVENT_TYPE_RECORDING_STATUS] = NULL;
-
+
return RECORDER_ERROR_NONE;
-
}
-int recorder_set_recording_limit_reached_cb(recorder_h recorder, recorder_recording_limit_reached_cb callback, void* user_data){
-
- if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
- recorder_s *handle = (recorder_s*)recorder;
- if( callback == NULL )
+
+int recorder_set_recording_limit_reached_cb(recorder_h recorder, recorder_recording_limit_reached_cb callback, void* user_data)
+{
+ recorder_s *handle = (recorder_s *)recorder;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
return RECORDER_ERROR_INVALID_PARAMETER;
-
+ }
+ if (callback == NULL) {
+ LOGE("NULL pointer callback");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+
handle->user_cb[_RECORDER_EVENT_TYPE_RECORDING_LIMITED] = callback;
handle->user_data[_RECORDER_EVENT_TYPE_RECORDING_LIMITED] = user_data;
return RECORDER_ERROR_NONE;
-
}
-int recorder_unset_recording_limit_reached_cb(recorder_h recorder){
-
- if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
- recorder_s *handle = (recorder_s*)recorder;
+
+int recorder_unset_recording_limit_reached_cb(recorder_h recorder)
+{
+ recorder_s *handle = (recorder_s *)recorder;
+
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+
handle->user_cb[_RECORDER_EVENT_TYPE_RECORDING_LIMITED] = NULL;
handle->user_data[_RECORDER_EVENT_TYPE_RECORDING_LIMITED] = NULL;
- return RECORDER_ERROR_NONE;
+ return RECORDER_ERROR_NONE;
}
-int recorder_foreach_supported_file_format(recorder_h recorder, recorder_supported_file_format_cb foreach_cb , void *user_data){
- if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
- if( foreach_cb == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
- int ret;
- recorder_s * handle = (recorder_s*)recorder;
+
+int recorder_foreach_supported_file_format(recorder_h recorder, recorder_supported_file_format_cb foreach_cb, void *user_data)
+{
+ int i = 0;
+ int ret = MM_ERROR_NONE;
+ recorder_s *handle = (recorder_s *)recorder;
MMCamAttrsInfo info;
- ret = mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_FILE_FORMAT , &info);
- if( ret != MM_ERROR_NONE )
- return ret;
- int i;
- for( i=0 ; i < info.int_array.count ; i++)
- {
-
- int format;
-
- switch( info.int_array.array[i] ){
- case MM_FILE_FORMAT_3GP:
- format = RECORDER_FILE_FORMAT_3GP;
- break;
- case MM_FILE_FORMAT_MP4 :
- format = RECORDER_FILE_FORMAT_MP4;
- break;
- case MM_FILE_FORMAT_AMR :
- format = RECORDER_FILE_FORMAT_AMR;
- break;
- case MM_FILE_FORMAT_AAC:
- format = RECORDER_FILE_FORMAT_ADTS;
- break;
- case MM_FILE_FORMAT_WAV:
- format = RECORDER_FILE_FORMAT_WAV;
- break;
- default :
- format = -1;
- }
+ int format;
- if ( format != -1 && !foreach_cb(format,user_data) )
- break;
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+ if (foreach_cb == NULL) {
+ LOGE("NULL pointer foreach_cb");
+ return RECORDER_ERROR_INVALID_PARAMETER;
}
- return RECORDER_ERROR_NONE;
-
-}
+ ret = mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_FILE_FORMAT, &info);
+ if (ret != MM_ERROR_NONE) {
+ LOGE("mm_camcorder_get_attribute_info failed 0x%x", ret);
+ return __convert_recorder_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 = RECORDER_FILE_FORMAT_3GP;
+ break;
+ case MM_FILE_FORMAT_MP4 :
+ format = RECORDER_FILE_FORMAT_MP4;
+ break;
+ case MM_FILE_FORMAT_AMR :
+ format = RECORDER_FILE_FORMAT_AMR;
+ break;
+ case MM_FILE_FORMAT_AAC:
+ format = RECORDER_FILE_FORMAT_ADTS;
+ break;
+ case MM_FILE_FORMAT_WAV:
+ format = RECORDER_FILE_FORMAT_WAV;
+ break;
+ default :
+ format = -1;
+ break;
+ }
-int recorder_attr_set_size_limit(recorder_h recorder, int kbyte){
- if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
- int ret;
- recorder_s * handle = (recorder_s*)recorder;
- ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, "target-max-size" , kbyte, NULL);
- return __convert_recorder_error_code(__func__, ret);
-}
+ if (format != -1 && !foreach_cb(format,user_data)) {
+ break;
+ }
+ }
-int recorder_attr_set_time_limit(recorder_h recorder, int second){
- if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
- int ret;
- recorder_s * handle = (recorder_s*)recorder;
- ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_TARGET_TIME_LIMIT , second, NULL);
- return __convert_recorder_error_code(__func__, ret);
+ return RECORDER_ERROR_NONE;
}
-int recorder_attr_set_audio_device(recorder_h recorder , recorder_audio_device_e device){
- if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
- int ret;
- recorder_s * handle = (recorder_s*)recorder;
- ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_AUDIO_DEVICE , device, NULL);
- return __convert_recorder_error_code(__func__, ret);
-}
-int recorder_set_audio_encoder(recorder_h recorder, recorder_audio_codec_e codec){
- if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
+int recorder_attr_set_size_limit(recorder_h recorder, int kbyte)
+{
+ int ret = MM_ERROR_NONE;
+ recorder_s *handle = (recorder_s *)recorder;
- if( codec != RECORDER_AUDIO_CODEC_DISABLE && ( codec < RECORDER_AUDIO_CODEC_AMR || codec > RECORDER_AUDIO_CODEC_PCM) )
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
return RECORDER_ERROR_INVALID_PARAMETER;
+ }
- int audio_table[4] = { MM_AUDIO_CODEC_AMR, //RECORDER_AUDIO_CODEC_AMR
- MM_AUDIO_CODEC_AAC, //RECORDER_AUDIO_CODEC_AAC
- MM_AUDIO_CODEC_VORBIS, //RECORDER_AUDIO_CODEC_VORBIS
- MM_AUDIO_CODEC_WAVE //RECORDER_AUDIO_CODEC_PCM
- };
- int ret = MM_ERROR_NONE;
- recorder_s * handle = (recorder_s*)recorder;
- if( codec == RECORDER_AUDIO_CODEC_DISABLE )
- ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_AUDIO_DISABLE , 1, NULL);
- else
- ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_AUDIO_ENCODER , audio_table[codec], MMCAM_AUDIO_DISABLE, 0, NULL);
+ ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
+ MMCAM_TARGET_MAX_SIZE, kbyte,
+ NULL);
return __convert_recorder_error_code(__func__, ret);
}
-int recorder_get_audio_encoder(recorder_h recorder, recorder_audio_codec_e *codec){
- if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
- g_return_val_if_fail(codec != NULL, RECORDER_ERROR_INVALID_PARAMETER);
+
+int recorder_attr_set_time_limit(recorder_h recorder, int second)
+{
int ret = MM_ERROR_NONE;
- int mm_codec = 0;
- int audio_disable = 0;
+ recorder_s *handle = (recorder_s *)recorder;
- recorder_s * handle = (recorder_s*)recorder;
- ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_AUDIO_ENCODER , &mm_codec , MMCAM_AUDIO_DISABLE, &audio_disable, NULL);
- if( ret == 0 && audio_disable == 0 ){
- switch( mm_codec ){
- case MM_AUDIO_CODEC_AMR :
- *codec = RECORDER_AUDIO_CODEC_AMR;
- break;
- case MM_AUDIO_CODEC_AAC :
- *codec = RECORDER_AUDIO_CODEC_AAC;
- break;
- case MM_AUDIO_CODEC_VORBIS:
- *codec = RECORDER_AUDIO_CODEC_VORBIS;
- break;
- case MM_AUDIO_CODEC_WAVE:
- *codec = RECORDER_AUDIO_CODEC_PCM;
- break;
- default :
- ret = MM_ERROR_CAMCORDER_INTERNAL;
- break;
- }
- }else if( ret == 0 && audio_disable ){
- *codec = RECORDER_AUDIO_CODEC_DISABLE;
+ if (recorder == NULL) {
+ LOGE("NULL pointer handle");
+ return RECORDER_ERROR_INVALID_PARAMETER;
}
+ ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
+ MMCAM_TARGET_TIME_LIMIT, second,
+ NULL);
+
return __convert_recorder_error_code(__func__, ret);
}
-int recorder_set_video_encoder(recorder_h recorder, recorder_video_codec_e codec){
- if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
- int ret = MM_ERROR_NONE;
- int video_table[4] = { MM_VIDEO_CODEC_H263, //RECORDER_VIDEO_CODEC_H263, /**< H263 codec */
- MM_VIDEO_CODEC_H264, //RECORDER_VIDEO_CODEC_H264, /**< H264 codec */
- MM_VIDEO_CODEC_MPEG4, //RECORDER_VIDEO_CODEC_MPEG4, /**< MPEG4 codec */
- MM_VIDEO_CODEC_THEORA //RECORDER_VIDEO_CODEC_THEORA
- };
- if( codec < RECORDER_VIDEO_CODEC_H263 || codec > RECORDER_VIDEO_CODEC_THEORA )
+int recorder_attr_set_audio_device(recorder_h recorder, recorder_audio_device_e device)
+{
+ if (device < RECORDER_AUDIO_DEVICE_MIC || device > RECORDER_AUDIO_DEVICE_MODEM) {
+ LOGE("invalid device %d", device);
return RECORDER_ERROR_INVALID_PARAMETER;
- recorder_s * handle = (recorder_s*)recorder;
+ }
- ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_VIDEO_ENCODER , video_table[codec], NULL);
- return __convert_recorder_error_code(__func__, ret);
+ return _recorder_check_and_set_attribute(recorder, MMCAM_AUDIO_DEVICE, device);
}
-int recorder_get_video_encoder(recorder_h recorder, recorder_video_codec_e *codec){
- if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
- if( codec == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
- int ret;
+int recorder_set_audio_encoder(recorder_h recorder, recorder_audio_codec_e codec)
+{
+ recorder_s *handle = (recorder_s *)recorder;
+ int audio_table[4] = { MM_AUDIO_CODEC_AMR, /* RECORDER_AUDIO_CODEC_AMR */
+ MM_AUDIO_CODEC_AAC, /* RECORDER_AUDIO_CODEC_AAC */
+ MM_AUDIO_CODEC_VORBIS, /* RECORDER_AUDIO_CODEC_VORBIS */
+ MM_AUDIO_CODEC_WAVE /* RECORDER_AUDIO_CODEC_PCM */
+ };
+
+ if (recorder == NULL) {
+ LOGE("handle is NULL");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ if (codec != RECORDER_AUDIO_CODEC_DISABLE &&
+ (codec < RECORDER_AUDIO_CODEC_AMR || codec > RECORDER_AUDIO_CODEC_PCM)) {
+ LOGE("invalid parameter : codec %d", codec);
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ if (handle->type == _RECORDER_TYPE_AUDIO && codec == RECORDER_AUDIO_CODEC_DISABLE) {
+ LOGE("AUDIO_CODEC_DISABLE is not supported in audio mode");
+ return RECORDER_ERROR_NOT_SUPPORTED;
+ }
+
+ return _recorder_check_and_set_attribute(recorder, MMCAM_AUDIO_ENCODER, codec == RECORDER_AUDIO_CODEC_DISABLE ? RECORDER_AUDIO_CODEC_DISABLE : audio_table[codec]);
+}
+
+
+int recorder_get_audio_encoder(recorder_h recorder, recorder_audio_codec_e *codec)
+{
+ int ret = MM_ERROR_NONE;
int mm_codec = 0;
+ int audio_disable = 0;
+ recorder_s *handle = (recorder_s *)recorder;
- recorder_s * handle = (recorder_s*)recorder;
- ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_VIDEO_ENCODER , &mm_codec, NULL);
- if( ret == 0 ){
- switch( mm_codec ){
- case MM_VIDEO_CODEC_H263 :
- *codec = RECORDER_VIDEO_CODEC_H263;
- break;
- case MM_VIDEO_CODEC_H264 :
- *codec = RECORDER_VIDEO_CODEC_H264;
- break;
- case MM_VIDEO_CODEC_MPEG4 :
- *codec = RECORDER_VIDEO_CODEC_MPEG4;
- break;
- case MM_VIDEO_CODEC_THEORA:
- *codec = RECORDER_VIDEO_CODEC_THEORA;
- break;
- default :
- ret = MM_ERROR_CAMCORDER_INTERNAL;
- break;
+ if (recorder == NULL) {
+ LOGE("handle is NULL");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ if (codec == NULL) {
+ LOGE("codec is NULL");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
+ MMCAM_AUDIO_ENCODER, &mm_codec,
+ MMCAM_AUDIO_DISABLE, &audio_disable,
+ NULL);
+
+ if (ret == MM_ERROR_NONE && audio_disable == 0) {
+ switch (mm_codec) {
+ case MM_AUDIO_CODEC_AMR :
+ *codec = RECORDER_AUDIO_CODEC_AMR;
+ break;
+ case MM_AUDIO_CODEC_AAC :
+ *codec = RECORDER_AUDIO_CODEC_AAC;
+ break;
+ case MM_AUDIO_CODEC_VORBIS:
+ *codec = RECORDER_AUDIO_CODEC_VORBIS;
+ break;
+ case MM_AUDIO_CODEC_WAVE:
+ *codec = RECORDER_AUDIO_CODEC_PCM;
+ break;
+ default :
+ ret = MM_ERROR_CAMCORDER_INTERNAL;
+ break;
}
+ } else if (ret == MM_ERROR_NONE && audio_disable) {
+ *codec = RECORDER_AUDIO_CODEC_DISABLE;
}
-
+
return __convert_recorder_error_code(__func__, ret);
}
-int recorder_attr_set_audio_samplerate(recorder_h recorder, int samplerate){
- if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
+
+int recorder_set_video_encoder(recorder_h recorder, recorder_video_codec_e codec)
+{
int ret = MM_ERROR_NONE;
- recorder_s * handle = (recorder_s*)recorder;
- ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_AUDIO_SAMPLERATE , samplerate, NULL);
+ int video_table[4] = { MM_VIDEO_CODEC_H263, /* RECORDER_VIDEO_CODEC_H263 */
+ MM_VIDEO_CODEC_H264, /* RECORDER_VIDEO_CODEC_H264 */
+ MM_VIDEO_CODEC_MPEG4, /* RECORDER_VIDEO_CODEC_MPEG4 */
+ MM_VIDEO_CODEC_THEORA /* RECORDER_VIDEO_CODEC_THEORA */
+ };
+ recorder_s *handle = (recorder_s *)recorder;
+
+ if (handle == NULL) {
+ LOGE("handle is NULL");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ if (handle->camera_device_count == 0) {
+ LOGE("RECORDER_ERROR_NOT_SUPPORTED");
+ return RECORDER_ERROR_NOT_SUPPORTED;
+ }
+
+ if (codec < RECORDER_VIDEO_CODEC_H263 || codec > RECORDER_VIDEO_CODEC_THEORA) {
+ LOGE("invalid codec %d", codec);
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
+ MMCAM_VIDEO_ENCODER, video_table[codec],
+ NULL);
+
return __convert_recorder_error_code(__func__, ret);
}
-int recorder_attr_set_audio_encoder_bitrate(recorder_h recorder, int bitrate){
- if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
+
+int recorder_get_video_encoder(recorder_h recorder, recorder_video_codec_e *codec)
+{
int ret = MM_ERROR_NONE;
- recorder_s * handle = (recorder_s*)recorder;
- ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_AUDIO_ENCODER_BITRATE , bitrate, NULL);
+ int mm_codec = 0;
+ recorder_s *handle = (recorder_s *)recorder;
+
+ if (handle == NULL) {
+ LOGE("handle is NULL");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+ if (handle->camera_device_count == 0) {
+ LOGE("RECORDER_ERROR_NOT_SUPPORTED");
+ return RECORDER_ERROR_NOT_SUPPORTED;
+ }
+ if (codec == NULL) {
+ LOGE("codec is NULL");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
+ MMCAM_VIDEO_ENCODER, &mm_codec,
+ NULL);
+ if (ret == MM_ERROR_NONE) {
+ switch(mm_codec) {
+ case MM_VIDEO_CODEC_H263 :
+ *codec = RECORDER_VIDEO_CODEC_H263;
+ break;
+ case MM_VIDEO_CODEC_H264 :
+ *codec = RECORDER_VIDEO_CODEC_H264;
+ break;
+ case MM_VIDEO_CODEC_MPEG4 :
+ *codec = RECORDER_VIDEO_CODEC_MPEG4;
+ break;
+ case MM_VIDEO_CODEC_THEORA:
+ *codec = RECORDER_VIDEO_CODEC_THEORA;
+ break;
+ default :
+ ret = MM_ERROR_CAMCORDER_INTERNAL;
+ break;
+ }
+ }
+
return __convert_recorder_error_code(__func__, ret);
}
-int recorder_attr_set_video_encoder_bitrate(recorder_h recorder, int bitrate){
- if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
+
+int recorder_attr_set_audio_samplerate(recorder_h recorder, int samplerate)
+{
+ if (samplerate < 1) {
+ LOGE("invalid samplerate %d", samplerate);
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ return _recorder_check_and_set_attribute(recorder, MMCAM_AUDIO_SAMPLERATE, samplerate);
+}
+
+
+int recorder_attr_set_audio_encoder_bitrate(recorder_h recorder, int bitrate)
+{
+ if (bitrate < 1) {
+ LOGE("invalid bitrate %d", bitrate);
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ return _recorder_check_and_set_attribute(recorder, MMCAM_AUDIO_ENCODER_BITRATE, bitrate);
+}
+
+
+int recorder_attr_set_video_encoder_bitrate(recorder_h recorder, int bitrate)
+{
int ret = MM_ERROR_NONE;
- recorder_s * handle = (recorder_s*)recorder;
- ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_VIDEO_ENCODER_BITRATE , bitrate, NULL);
+ recorder_s *handle = (recorder_s *)recorder;
+
+ if (handle == NULL) {
+ LOGE("handle is NULL");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+ if (handle->camera_device_count == 0) {
+ LOGE("RECORDER_ERROR_NOT_SUPPORTED");
+ return RECORDER_ERROR_NOT_SUPPORTED;
+ }
+
+ ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
+ MMCAM_VIDEO_ENCODER_BITRATE, bitrate,
+ NULL);
+
return __convert_recorder_error_code(__func__, ret);
}
-int recorder_attr_get_size_limit(recorder_h recorder, int *kbyte){
- if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
- int ret;
- recorder_s * handle = (recorder_s*)recorder;
- ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, "target-max-size" , kbyte, NULL);
+
+int recorder_attr_get_size_limit(recorder_h recorder, int *kbyte)
+{
+ int ret = MM_ERROR_NONE;
+ recorder_s *handle = (recorder_s *)recorder;
+
+ if (recorder == NULL) {
+ LOGE("handle is NULL");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
+ MMCAM_TARGET_MAX_SIZE, kbyte,
+ NULL);
+
return __convert_recorder_error_code(__func__, ret);
}
-int recorder_attr_get_time_limit(recorder_h recorder, int *second){
- if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
- int ret;
- recorder_s * handle = (recorder_s*)recorder;
- ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_TARGET_TIME_LIMIT , second, NULL);
+
+int recorder_attr_get_time_limit(recorder_h recorder, int *second)
+{
+ int ret = MM_ERROR_NONE;
+ recorder_s *handle = (recorder_s *)recorder;
+
+ if (recorder == NULL) {
+ LOGE("handle is NULL");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
+ MMCAM_TARGET_TIME_LIMIT, second,
+ NULL);
+
return __convert_recorder_error_code(__func__, ret);
}
-int recorder_attr_get_audio_device(recorder_h recorder , recorder_audio_device_e *device){
- if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
- int ret;
- recorder_s * handle = (recorder_s*)recorder;
- ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_AUDIO_DEVICE , device, NULL);
+
+int recorder_attr_get_audio_device(recorder_h recorder, recorder_audio_device_e *device)
+{
+ int ret = MM_ERROR_NONE;
+ recorder_s *handle = (recorder_s *)recorder;
+
+ if (recorder == NULL) {
+ LOGE("handle is NULL");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
+ MMCAM_AUDIO_DEVICE, device,
+ NULL);
+
return __convert_recorder_error_code(__func__, ret);
}
-int recorder_attr_get_audio_samplerate(recorder_h recorder, int *samplerate){
- if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
+
+int recorder_attr_get_audio_samplerate(recorder_h recorder, int *samplerate)
+{
int ret = MM_ERROR_NONE;
- recorder_s * handle = (recorder_s*)recorder;
- ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_AUDIO_SAMPLERATE , samplerate, NULL);
+ recorder_s *handle = (recorder_s *)recorder;
+
+ if (recorder == NULL) {
+ LOGE("handle is NULL");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
+ MMCAM_AUDIO_SAMPLERATE, samplerate,
+ NULL);
+
return __convert_recorder_error_code(__func__, ret);
}
-int recorder_attr_get_audio_encoder_bitrate(recorder_h recorder, int *bitrate){
- if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
+
+int recorder_attr_get_audio_encoder_bitrate(recorder_h recorder, int *bitrate)
+{
int ret = MM_ERROR_NONE;
- recorder_s * handle = (recorder_s*)recorder;
- ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_AUDIO_ENCODER_BITRATE , bitrate, NULL);
+ recorder_s *handle = (recorder_s *)recorder;
+
+ if (recorder == NULL) {
+ LOGE("handle is NULL");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
+ MMCAM_AUDIO_ENCODER_BITRATE, bitrate,
+ NULL);
+
return __convert_recorder_error_code(__func__, ret);
}
-int recorder_attr_get_video_encoder_bitrate(recorder_h recorder, int *bitrate){
- if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
+
+int recorder_attr_get_video_encoder_bitrate(recorder_h recorder, int *bitrate)
+{
int ret = MM_ERROR_NONE;
- recorder_s * handle = (recorder_s*)recorder;
- ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_VIDEO_ENCODER_BITRATE , bitrate, NULL);
+ recorder_s *handle = (recorder_s *)recorder;
+
+ if (handle == NULL) {
+ LOGE("handle is NULL");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+ if (handle->camera_device_count == 0) {
+ LOGE("RECORDER_ERROR_NOT_SUPPORTED");
+ return RECORDER_ERROR_NOT_SUPPORTED;
+ }
+ ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
+ MMCAM_VIDEO_ENCODER_BITRATE, bitrate,
+ NULL);
+
return __convert_recorder_error_code(__func__, ret);
}
-int recorder_foreach_supported_audio_encoder(recorder_h recorder, recorder_supported_audio_encoder_cb foreach_cb , void *user_data){
- if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
- if( foreach_cb == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
- int ret;
- recorder_s * handle = (recorder_s*)recorder;
+
+int recorder_foreach_supported_audio_encoder(recorder_h recorder, recorder_supported_audio_encoder_cb foreach_cb, void *user_data)
+{
+ int i = 0;
+ int ret = MM_ERROR_NONE;
+ int codec;
+ recorder_s *handle = (recorder_s *)recorder;
MMCamAttrsInfo info;
- ret = mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_AUDIO_ENCODER , &info);
- if( ret != MM_ERROR_NONE )
+
+ if (recorder == NULL) {
+ LOGE("handle is NULL");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+ if (foreach_cb == NULL) {
+ LOGE("foreach_cb is NULL");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_AUDIO_ENCODER, &info);
+ if (ret != MM_ERROR_NONE) {
return __convert_recorder_error_code(__func__, ret);
-
- int i;
- for( i=0 ; i < info.int_array.count ; i++)
- {
- int codec;
-
- switch( info.int_array.array[i] ){
- case MM_AUDIO_CODEC_AMR:
- codec = RECORDER_AUDIO_CODEC_AMR;
- break;
- case MM_AUDIO_CODEC_AAC :
- codec = RECORDER_AUDIO_CODEC_AAC;
- break;
- case MM_AUDIO_CODEC_VORBIS:
- codec = RECORDER_AUDIO_CODEC_VORBIS;
- break;
- case MM_AUDIO_CODEC_WAVE:
- codec = RECORDER_AUDIO_CODEC_PCM;
- break;
- default :
- codec = -1;
- }
- if( codec != -1 && !foreach_cb(codec,user_data) )
+ }
+
+ for (i = 0 ; i < info.int_array.count ; i++) {
+ switch (info.int_array.array[i]) {
+ case MM_AUDIO_CODEC_AMR:
+ codec = RECORDER_AUDIO_CODEC_AMR;
+ break;
+ case MM_AUDIO_CODEC_AAC :
+ codec = RECORDER_AUDIO_CODEC_AAC;
+ break;
+ case MM_AUDIO_CODEC_VORBIS:
+ codec = RECORDER_AUDIO_CODEC_VORBIS;
+ break;
+ case MM_AUDIO_CODEC_WAVE:
+ codec = RECORDER_AUDIO_CODEC_PCM;
+ break;
+ default :
+ codec = -1;
break;
+ }
+ if (codec != -1 && !foreach_cb(codec,user_data)) {
+ break;
+ }
}
- return RECORDER_ERROR_NONE;
+
+ return RECORDER_ERROR_NONE;
}
-int recorder_foreach_supported_video_encoder(recorder_h recorder, recorder_supported_video_encoder_cb foreach_cb , void *user_data){
-
- if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
- if( foreach_cb == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
- int ret;
- recorder_s * handle = (recorder_s*)recorder;
+
+
+int recorder_foreach_supported_video_encoder(recorder_h recorder, recorder_supported_video_encoder_cb foreach_cb, void *user_data)
+{
+ int i = 0;
+ int ret = MM_ERROR_NONE;
+ int codec;
+ recorder_s *handle = (recorder_s *)recorder;
MMCamAttrsInfo info;
- ret = mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_VIDEO_ENCODER , &info);
- if( ret != MM_ERROR_NONE )
+
+ if (handle == NULL) {
+ LOGE("handle is NULL");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+ if (handle->camera_device_count == 0) {
+ LOGE("RECORDER_ERROR_NOT_SUPPORTED");
+ return RECORDER_ERROR_NOT_SUPPORTED;
+ }
+ if (foreach_cb == NULL) {
+ LOGE("foreach_cb is NULL");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = mm_camcorder_get_attribute_info(handle->mm_handle, MMCAM_VIDEO_ENCODER, &info);
+ if (ret != MM_ERROR_NONE) {
return __convert_recorder_error_code(__func__, ret);
-
- int i;
- for( i=0 ; i < info.int_array.count ; i++)
- {
- int codec;
-
- switch( info.int_array.array[i] ){
- case MM_VIDEO_CODEC_H263 :
- codec = RECORDER_VIDEO_CODEC_H263;
- break;
- case MM_VIDEO_CODEC_H264 :
- codec = RECORDER_VIDEO_CODEC_H264;
- break;
- case MM_VIDEO_CODEC_MPEG4 :
- codec = RECORDER_VIDEO_CODEC_MPEG4;
- break;
- case MM_VIDEO_CODEC_THEORA :
- codec = RECORDER_VIDEO_CODEC_THEORA;
- break;
- default :
- codec = -1;
- }
-
- if ( codec != -1 && !foreach_cb(codec,user_data) )
+ }
+
+ for (i = 0 ; i < info.int_array.count ; i++) {
+ switch (info.int_array.array[i]){
+ case MM_VIDEO_CODEC_H263 :
+ codec = RECORDER_VIDEO_CODEC_H263;
break;
+ case MM_VIDEO_CODEC_H264 :
+ codec = RECORDER_VIDEO_CODEC_H264;
+ break;
+ case MM_VIDEO_CODEC_MPEG4 :
+ codec = RECORDER_VIDEO_CODEC_MPEG4;
+ break;
+ case MM_VIDEO_CODEC_THEORA :
+ codec = RECORDER_VIDEO_CODEC_THEORA;
+ break;
+ default :
+ codec = -1;
+ break;
+ }
+
+ if (codec != -1 && !foreach_cb(codec,user_data)) {
+ break;
+ }
}
+
return RECORDER_ERROR_NONE;
-
}
-int recorder_attr_set_mute(recorder_h recorder, bool enable){
- if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
- recorder_s * handle = (recorder_s*)recorder;
- int ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_AUDIO_VOLUME , enable ? 0.0 : 1.0 , NULL);
+int recorder_attr_set_mute(recorder_h recorder, bool enable)
+{
+ int ret = MM_ERROR_NONE;
+ recorder_s *handle = (recorder_s *)recorder;
+
+ if (recorder == NULL) {
+ LOGE("handle is NULL");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
+ MMCAM_AUDIO_VOLUME, enable ? 0.0 : 1.0,
+ NULL);
+
return __convert_recorder_error_code(__func__, ret);
}
-bool recorder_attr_is_muted(recorder_h recorder){
- if( recorder == NULL){
- __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
+
+bool recorder_attr_is_muted(recorder_h recorder)
+{
+ int ret = MM_ERROR_NONE;
+ double volume = 1.0;
+ recorder_s *handle = (recorder_s *)recorder;
+
+ if (recorder == NULL) {
+ LOGE("handle is NULL");
return false;
}
- recorder_s * handle = (recorder_s*)recorder;
- double volume = 1.0;
- int ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_AUDIO_VOLUME , &volume , NULL);
+
+ ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
+ MMCAM_AUDIO_VOLUME, &volume,
+ NULL);
set_last_result(__convert_recorder_error_code(__func__, ret));
- if( volume == 0.0 )
+
+ if (volume == 0.0) {
return true;
- else
+ } else {
return false;
+ }
}
-int recorder_attr_set_recording_motion_rate(recorder_h recorder , double rate){
- if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
- recorder_s * handle = (recorder_s*)recorder;
- int ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, "camera-recording-motion-rate" , rate, NULL);
+
+int recorder_attr_set_recording_motion_rate(recorder_h recorder, double rate)
+{
+ int ret = MM_ERROR_NONE;
+ recorder_s *handle = (recorder_s *)recorder;
+
+ if (handle == NULL) {
+ LOGE("handle is NULL");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+ if (handle->camera_device_count == 0) {
+ LOGE("RECORDER_ERROR_NOT_SUPPORTED");
+ return RECORDER_ERROR_NOT_SUPPORTED;
+ }
+ ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
+ MMCAM_CAMERA_RECORDING_MOTION_RATE, rate,
+ NULL);
+
return __convert_recorder_error_code(__func__, ret);
}
-int recorder_attr_get_recording_motion_rate(recorder_h recorder , double *rate){
- if( recorder == NULL || rate == NULL )
- return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
- recorder_s * handle = (recorder_s*)recorder;
- int ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, "camera-recording-motion-rate" , rate , NULL);
+int recorder_attr_get_recording_motion_rate(recorder_h recorder, double *rate)
+{
+ int ret = MM_ERROR_NONE;
+ recorder_s *handle = (recorder_s *)recorder;
+
+ if (handle == NULL) {
+ LOGE("handle is NULL");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+ if (handle->camera_device_count == 0) {
+ LOGE("RECORDER_ERROR_NOT_SUPPORTED");
+ return RECORDER_ERROR_NOT_SUPPORTED;
+ }
+ if (rate == NULL) {
+ LOGE("rate is NULL");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
+ MMCAM_CAMERA_RECORDING_MOTION_RATE, rate,
+ NULL);
+
return __convert_recorder_error_code(__func__, ret);
}
+int recorder_attr_set_audio_channel(recorder_h recorder, int channel_count)
+{
+ if (channel_count < 1) {
+ LOGE("invalid channel %d", channel_count);
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
-int recorder_attr_set_slow_motion_rate(recorder_h recorder , double rate){
- return recorder_attr_set_recording_motion_rate(recorder, rate);
+ return _recorder_check_and_set_attribute(recorder, MMCAM_AUDIO_CHANNEL, channel_count);
}
-int recorder_attr_get_slow_motion_rate(recorder_h recorder , double *rate){
- return recorder_attr_get_recording_motion_rate(recorder, rate);
-}
+int recorder_attr_get_audio_channel(recorder_h recorder, int *channel_count)
+{
+ int ret = MM_ERROR_NONE;
+ recorder_s *handle = (recorder_s *)recorder;
-int recorder_attr_set_audio_channel(recorder_h recorder, int channel_count){
- if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
- recorder_s * handle = (recorder_s*)recorder;
- int ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_AUDIO_CHANNEL, channel_count, NULL);
- return __convert_recorder_error_code(__func__, ret);
-}
+ if (recorder == NULL) {
+ LOGE("handle is NULL");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+ if (channel_count == NULL) {
+ LOGE("channel_count is NULL");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
-int recorder_attr_get_audio_channel(recorder_h recorder, int *channel_count){
- if( recorder == NULL || channel_count == NULL )
- return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
+ ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
+ MMCAM_AUDIO_CHANNEL, channel_count,
+ NULL);
- recorder_s * handle = (recorder_s*)recorder;
- int ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_AUDIO_CHANNEL , channel_count, NULL);
return __convert_recorder_error_code(__func__, ret);
}
-int recorder_attr_set_recording_orientation(recorder_h recorder, recorder_rotation_e orientation){
- if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
- recorder_s * handle = (recorder_s*)recorder;
- int ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, "camcorder-rotation", orientation, NULL);
- return __convert_recorder_error_code(__func__, ret);
-}
-int recorder_attr_get_recording_orientation(recorder_h recorder, recorder_rotation_e *orientation){
- if( recorder == NULL || orientation == NULL ) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
- recorder_s * handle = (recorder_s*)recorder;
- int ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, "camcorder-rotation" , orientation, NULL);
- return __convert_recorder_error_code(__func__, ret);
-}
+int recorder_attr_set_orientation_tag(recorder_h recorder, recorder_rotation_e orientation)
+{
+ int ret = MM_ERROR_NONE;
+ recorder_s *handle = (recorder_s *)recorder;
-int recorder_attr_set_recording_flip(recorder_h recorder, recorder_flip_e flip){
- if( recorder == NULL) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
- recorder_s * handle = (recorder_s*)recorder;
- int ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, "camcorder-flip", flip, NULL);
- return __convert_recorder_error_code(__func__, ret);
-}
+ if (handle == NULL) {
+ LOGE("handle is NULL");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+ if (handle->camera_device_count == 0) {
+ LOGE("RECORDER_ERROR_NOT_SUPPORTED");
+ return RECORDER_ERROR_NOT_SUPPORTED;
+ }
+ if (orientation > RECORDER_ROTATION_270) {
+ LOGE("invalid orientation %d", orientation);
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
-int recorder_attr_get_recording_flip(recorder_h recorder, recorder_flip_e *flip){
- if( recorder == NULL || flip == NULL ) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
- recorder_s * handle = (recorder_s*)recorder;
- int ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, "camcorder-flip" , flip, NULL);
- return __convert_recorder_error_code(__func__, ret);
-}
+ ret = mm_camcorder_set_attributes(handle->mm_handle, NULL,
+ MMCAM_RECORDER_TAG_ENABLE, true,
+ MMCAM_TAG_VIDEO_ORIENTATION, orientation,
+ NULL);
-int recorder_attr_set_orientation_tag(recorder_h recorder, recorder_rotation_e orientation){
- if( recorder == NULL ) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
- if((orientation < RECORDER_ROTATION_NONE) || ( orientation > RECORDER_ROTATION_270)) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
- recorder_s * handle = (recorder_s*)recorder;
- int ret = mm_camcorder_set_attributes(handle->mm_handle ,NULL, MMCAM_TAG_VIDEO_ORIENTATION , orientation, NULL);
return __convert_recorder_error_code(__func__, ret);
}
-int recorder_attr_get_orientation_tag(recorder_h recorder, recorder_rotation_e *orientation){
- if( recorder == NULL || orientation == NULL ) return __convert_recorder_error_code(__func__, RECORDER_ERROR_INVALID_PARAMETER);
- recorder_s * handle = (recorder_s*)recorder;
- int ret = mm_camcorder_get_attributes(handle->mm_handle ,NULL, MMCAM_TAG_VIDEO_ORIENTATION , orientation, NULL);
+
+int recorder_attr_get_orientation_tag(recorder_h recorder, recorder_rotation_e *orientation)
+{
+ int ret = MM_ERROR_NONE;
+ recorder_s *handle = (recorder_s *)recorder;
+
+ if (handle == NULL) {
+ LOGE("handle is NULL");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+ if (handle->camera_device_count == 0) {
+ LOGE("RECORDER_ERROR_NOT_SUPPORTED");
+ return RECORDER_ERROR_NOT_SUPPORTED;
+ }
+ if (orientation == NULL) {
+ LOGE("orientation is NULL");
+ return RECORDER_ERROR_INVALID_PARAMETER;
+ }
+
+ ret = mm_camcorder_get_attributes(handle->mm_handle, NULL,
+ MMCAM_TAG_VIDEO_ORIENTATION, orientation,
+ NULL);
+
return __convert_recorder_error_code(__func__, ret);
}
projects / platform / core / api / recorder.git / commitdiff