--- /dev/null
+Kangho Hur <kanho.hur@samsung.com>
+Seungkeun Lee <sngn.lee@samsung.com>
--- /dev/null
+
+CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
+SET(fw_name "capi-media-tool")
+
+PROJECT(${fw_name})
+
+SET(CMAKE_INSTALL_PREFIX /usr)
+SET(PREFIX ${CMAKE_INSTALL_PREFIX})
+
+SET(INC_DIR include)
+INCLUDE_DIRECTORIES(${INC_DIR})
+
+SET(dependents "dlog glib-2.0")
+SET(pc_dependents "dlog capi-base-common libtbm")
+
+INCLUDE(FindPkgConfig)
+pkg_check_modules(${fw_name} REQUIRED ${dependents})
+FOREACH(flag ${${fw_name}_CFLAGS})
+ SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}")
+ENDFOREACH(flag)
+
+SET(CMAKE_C_FLAGS "-I./include -I./include/headers ${CMAKE_C_FLAGS} ${EXTRA_CFLAGS} -fPIC -Wall -w")
+SET(CMAKE_C_FLAGS_DEBUG "-O0 -g")
+
+IF("${ARCH}" STREQUAL "arm")
+ ADD_DEFINITIONS("-DTARGET")
+ENDIF("${ARCH}" STREQUAL "arm")
+
+ADD_DEFINITIONS("-DPREFIX=\"${CMAKE_INSTALL_PREFIX}\"")
+ADD_DEFINITIONS("-DTIZEN_DEBUG")
+
+SET(CMAKE_EXE_LINKER_FLAGS "-Wl,--as-needed -Wl,--rpath=/usr/lib")
+
+aux_source_directory(src SOURCES)
+ADD_LIBRARY(${fw_name} SHARED ${SOURCES})
+
+TARGET_LINK_LIBRARIES(${fw_name} ${${fw_name}_LDFLAGS})
+
+SET_TARGET_PROPERTIES(${fw_name}
+ PROPERTIES
+ VERSION ${FULLVER}
+ SOVERSION ${MAJORVER}
+ CLEAN_DIRECT_OUTPUT 1
+)
+
+INSTALL(TARGETS ${fw_name} DESTINATION lib)
+INSTALL(
+ DIRECTORY ${INC_DIR}/ DESTINATION include/media
+ FILES_MATCHING
+ PATTERN "*_private.h" EXCLUDE
+ PATTERN "${INC_DIR}/*.h"
+ )
+
+SET(PC_NAME ${fw_name})
+SET(PC_REQUIRED ${pc_dependents})
+SET(PC_LDFLAGS -l${fw_name})
+SET(PC_CFLAGS -I\${includedir}/media)
+
+CONFIGURE_FILE(
+ ${fw_name}.pc.in
+ ${CMAKE_CURRENT_SOURCE_DIR}/${fw_name}.pc
+ @ONLY
+)
+INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/${fw_name}.pc DESTINATION lib/pkgconfig)
+
+ADD_SUBDIRECTORY(test)
+
+IF(UNIX)
+
+ADD_CUSTOM_TARGET (distclean @echo cleaning for source distribution)
+ADD_CUSTOM_COMMAND(
+ DEPENDS clean
+ COMMENT "distribution clean"
+ COMMAND find
+ ARGS .
+ -not -name config.cmake -and \(
+ -name tester.c -or
+ -name Testing -or
+ -name CMakeFiles -or
+ -name cmake.depends -or
+ -name cmake.check_depends -or
+ -name CMakeCache.txt -or
+ -name cmake.check_cache -or
+ -name *.cmake -or
+ -name Makefile -or
+ -name core -or
+ -name core.* -or
+ -name gmon.out -or
+ -name install_manifest.txt -or
+ -name *.pc -or
+ -name *~ \)
+ | grep -v TC | xargs rm -rf
+ TARGET distclean
+ VERBATIM
+)
+
+ENDIF(UNIX)
+
--- /dev/null
+Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "[]"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+ Copyright [yyyy] [name of copyright owner]
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+
+
+
--- /dev/null
+Copyright (c) Samsung Electronics Co., Ltd. All rights reserved.
+Except as noted, this software is licensed under Apache License, Version 2.
+Please, see the LICENSE file for Apache License terms and conditions.
--- /dev/null
+<manifest>
+ <request>
+ <domain name="_" />
+ </request>
+ <assign>
+ <filesystem path="/usr/bin/media_packet_test" label="_" exec_label="none" />
+ </assign>
+</manifest>
--- /dev/null
+
+# Package Information for pkg-config
+
+prefix=@PREFIX@
+exec_prefix=/usr
+libdir=/usr/lib
+includedir=/usr/include/media
+
+Name: @PC_NAME@
+Description: @PACKAGE_DESCRIPTION@
+Version: @VERSION@
+Requires: @PC_REQUIRED@
+Libs: -L${libdir} @PC_LDFLAGS@
+Cflags: -I${includedir}
+
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+#ifndef __TIZEN_MEDIA_TOOL_DOC_H__
+#define __TIZEN_MEDIA_TOOL_DOC_H__
+
+
+/**
+ * @file capi_media_tool_doc.h
+ * @brief This file contains high level documentation of the CAPI MEDIA TOOL API.
+ */
+
+/**
+ * @defgroup CAPI_MEDIA_TOOL_MODULE Media Tool
+ * @brief The @ref CAPI_MEDIA_TOOL_MODULE APIs provides functions for AV packet buffer for interworking between mutimedia framework module .
+ * @ingroup CAPI_MEDIA_FRAMEWORK
+ *
+ * @section CAPI_MEDIA_TOOL_MODULE_HEADER Required Header
+ * \#include <media_packet.h>
+ *
+ * @section CAPI_MEDIA_TOOL_MODULE_OVERVIEW Overview
+ *
+ * MEDIA TOOL API allows :
+ *- Create media_packet handle and Allocate buffer to heap or tbm_surface
+ *- Set and Get metadata of media packet
+ *
+ * The media packet handle is created by caller.
+ * After creating media_packet_h handle, the caller can set & get other meta datas.
+ *
+ */
+
+/**
+ * @defgroup CAPI_MEDIA_TOOL_MEDIA_FORMAT_MODULE Media Format
+ * @brief The @ref CAPI_MEDIA_TOOL_MEDIA_FORMAT_MODULE APIs provides functions for specify video or audio information.
+ * @ingroup CAPI_MEDIA_TOOL_MODULE
+ *
+ * @section CAPI_MEDIA_TOOL_MEDIA_FORMAT_MODULE_HEADER Required Header
+ * \#include <media_format.h>
+ */
+
+#endif // __TIZEN_MEDIA_TOOL_DOC_H__
--- /dev/null
+/*
+* Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+#ifndef __TIZEN_MEDIA_FORMAT_H__
+#define __TIZEN_MEDIA_FORMAT_H__
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <tizen.h>
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @file media_format.h
+ * @brief This file contains the capi media tool API.
+ */
+
+/**
+ * @addtogroup CAPI_MEDIA_TOOL_MEDIA_FORMAT_MODULE
+ * @{
+ */
+
+/**
+ * @brief Media Format handle type.
+ * @since_tizen 2.3
+ */
+typedef struct media_format_s* media_format_h;
+
+
+/**
+ * @brief Enumerations of media format error
+ * @since_tizen 2.3
+ */
+typedef enum
+{
+ MEDIA_FORMAT_ERROR_NONE = TIZEN_ERROR_NONE, /**< Successful */
+ MEDIA_FORMAT_ERROR_OUT_OF_MEMORY = TIZEN_ERROR_OUT_OF_MEMORY, /**< Out of memory */
+ MEDIA_FORMAT_ERROR_INVALID_PARAMETER = TIZEN_ERROR_INVALID_PARAMETER, /**< Invalid parameter */
+ MEDIA_FORMAT_ERROR_INVALID_OPERATION = TIZEN_ERROR_INVALID_OPERATION, /**< Invalid operation */
+ MEDIA_FORMAT_ERROR_FILE_NO_SPACE_ON_DEVICE = TIZEN_ERROR_FILE_NO_SPACE_ON_DEVICE, /**< No space left on device */
+} media_format_error_e;
+
+
+/**
+ * @brief Enumeration for media format type.
+ * @since_tizen 2.3
+ */
+typedef enum {
+ MEDIA_FORMAT_NONE = 0x00000000, /**< media format type is NONE */
+ MEDIA_FORMAT_AUDIO = 0x01000000, /**< media format type is AUDIO */
+ MEDIA_FORMAT_VIDEO = 0x02000000, /**< media format type is VIDEO */
+ MEDIA_FORMAT_TEXT = 0x03000000, /**< media format type is TEXT */
+ MEDIA_FORMAT_UNKNOWN = 0x0a000000, /**< media format type is UNKNOWN */
+} media_format_type_e;
+
+/**
+ * @brief Enumeration for media format data type.
+ * @since_tizen 2.3
+ */
+typedef enum {
+ MEDIA_FORMAT_ENCODED = 0x10000000, /**< media format data type is encoded type */
+ MEDIA_FORMAT_RAW = 0x20000000, /**< media format data type is raw type */
+} media_format_data_type_e;
+
+/**
+ * @brief Enumeration for media format MIME type.
+ * @since_tizen 2.3
+ */
+
+/* TODO : More an more audio/video types are needed !!!! */
+/* TODO : consider to make those enumerations into a combination of bitwised structure
+ * Then we can check just few bits rather than compare all items.
+*/
+typedef enum {
+ /* Audio */
+ MEDIA_FORMAT_L16 = (MEDIA_FORMAT_AUDIO | MEDIA_FORMAT_ENCODED | 0x1010), /**< media format mime type is L16, AUDIO*/
+ MEDIA_FORMAT_ALAW = (MEDIA_FORMAT_AUDIO | MEDIA_FORMAT_ENCODED | 0x1020), /**< media format mime type is ALAW, AUDIO*/
+ MEDIA_FORMAT_ULAW = (MEDIA_FORMAT_AUDIO | MEDIA_FORMAT_ENCODED | 0x1030), /**< media format mime type is ULAW, AUDIO */
+ MEDIA_FORMAT_AMR = (MEDIA_FORMAT_AUDIO | MEDIA_FORMAT_ENCODED | 0x1040), /**< media format mime type is AMR, AUDIO */
+ MEDIA_FORMAT_G729 = (MEDIA_FORMAT_AUDIO | MEDIA_FORMAT_ENCODED | 0x1050), /**< media format mime type is G729, AUDIO*/
+ MEDIA_FORMAT_AAC = (MEDIA_FORMAT_AUDIO | MEDIA_FORMAT_ENCODED | 0x1060), /**< media format mime type is AAC, AUDIO*/
+ MEDIA_FORMAT_MP3 = (MEDIA_FORMAT_AUDIO | MEDIA_FORMAT_ENCODED | 0x1070), /**< media format mime type is MP3, AUDIO*/
+
+ MEDIA_FORMAT_PCM = (MEDIA_FORMAT_AUDIO | MEDIA_FORMAT_RAW | 0x1510), /**< media format mime type is PCM, AUDIO*/
+ MEDIA_FORMAT_PCMA = (MEDIA_FORMAT_AUDIO | MEDIA_FORMAT_RAW | 0x1520), /**< media format mime type is PCM A-law, AUDIO*/
+ MEDIA_FORMAT_PCMU = (MEDIA_FORMAT_AUDIO | MEDIA_FORMAT_RAW | 0x1530), /**< media format mime type is PCM U-law, AUDIO */
+
+ /* Video */
+ MEDIA_FORMAT_H261 = (MEDIA_FORMAT_VIDEO | MEDIA_FORMAT_ENCODED | 0x2010), /**< media format mime type is H261, VIDEO */
+ MEDIA_FORMAT_H263 = (MEDIA_FORMAT_VIDEO | MEDIA_FORMAT_ENCODED | 0x2020), /**< media format mime type is H263, VIDEO */
+ MEDIA_FORMAT_H263P = (MEDIA_FORMAT_VIDEO | MEDIA_FORMAT_ENCODED | 0x2021), /**< media format mime type is H263P, VIDEO */
+ MEDIA_FORMAT_H264_SP = (MEDIA_FORMAT_VIDEO | MEDIA_FORMAT_ENCODED | 0x2030), /**< media format mime type is H264_SP, VIDEO */
+ MEDIA_FORMAT_H264_MP = (MEDIA_FORMAT_VIDEO | MEDIA_FORMAT_ENCODED | 0x2031), /**< media format mime type is H264_MP, VIDEO */
+ MEDIA_FORMAT_H264_HP = (MEDIA_FORMAT_VIDEO | MEDIA_FORMAT_ENCODED | 0x2032), /**< media format mime type is H264_HP, VIDEO */
+ MEDIA_FORMAT_MJPEG = (MEDIA_FORMAT_VIDEO | MEDIA_FORMAT_ENCODED | 0x2040), /**< media format mime type is MJPEG, VIDEO */
+ MEDIA_FORMAT_MPEG1 = (MEDIA_FORMAT_VIDEO | MEDIA_FORMAT_ENCODED | 0x2050), /**< media format mime type is MPEG1, VIDEO */
+ MEDIA_FORMAT_MPEG2_SP = (MEDIA_FORMAT_VIDEO | MEDIA_FORMAT_ENCODED | 0x2060), /**< media format mime type is MPEG2_SP, VIDEO */
+ MEDIA_FORMAT_MPEG2_MP = (MEDIA_FORMAT_VIDEO | MEDIA_FORMAT_ENCODED | 0x2061), /**< media format mime type is MPEG2_MP, VIDEO */
+ MEDIA_FORMAT_MPEG2_HP = (MEDIA_FORMAT_VIDEO | MEDIA_FORMAT_ENCODED | 0x2062), /**< media format mime type is MPEG2_HP, VIDEO */
+ MEDIA_FORMAT_MPEG4_SP = (MEDIA_FORMAT_VIDEO | MEDIA_FORMAT_ENCODED | 0x2070), /**< media format mime type is MPEG4_SP, VIDEO */
+ MEDIA_FORMAT_MPEG4_ASP = (MEDIA_FORMAT_VIDEO | MEDIA_FORMAT_ENCODED | 0x2071), /**< media format mime type is MPEG4_ASP, VIDEO */
+
+ MEDIA_FORMAT_I420 = (MEDIA_FORMAT_VIDEO | MEDIA_FORMAT_RAW | 0x2510), /**< media format mime type is I420, VIDEO */
+ MEDIA_FORMAT_NV12 = (MEDIA_FORMAT_VIDEO | MEDIA_FORMAT_RAW | 0x2520), /**< media format mime type is NV12, VIDEO */
+ MEDIA_FORMAT_NV12T = (MEDIA_FORMAT_VIDEO | MEDIA_FORMAT_RAW | 0x2530), /**< media format mime type is NV12T, VIDEO */
+ MEDIA_FORMAT_YV12 = (MEDIA_FORMAT_VIDEO | MEDIA_FORMAT_RAW | 0x2540), /**< media format mime type is YV12, VIDEO */
+ MEDIA_FORMAT_NV21 = (MEDIA_FORMAT_VIDEO | MEDIA_FORMAT_RAW | 0x2550), /**< media format mime type is NV21, VIDEO */
+ MEDIA_FORMAT_NV16 = (MEDIA_FORMAT_VIDEO | MEDIA_FORMAT_RAW | 0x2560), /**< media format mime type is NV16, VIDEO */
+ MEDIA_FORMAT_YUYV = (MEDIA_FORMAT_VIDEO | MEDIA_FORMAT_RAW | 0x2570), /**< media format mime type is YUYV, VIDEO */
+ MEDIA_FORMAT_UYVY = (MEDIA_FORMAT_VIDEO | MEDIA_FORMAT_RAW | 0x2580), /**< media format mime type is UYVY, VIDEO */
+ MEDIA_FORMAT_422P = (MEDIA_FORMAT_VIDEO | MEDIA_FORMAT_RAW | 0x2590), /**< media format mime type is 422P, VIDEO */
+ MEDIA_FORMAT_RGB565 = (MEDIA_FORMAT_VIDEO | MEDIA_FORMAT_RAW | 0x25a0), /**< media format mime type is RGB565, VIDEO */
+ MEDIA_FORMAT_RGB888 = (MEDIA_FORMAT_VIDEO | MEDIA_FORMAT_RAW | 0x25b0), /**< media format mime type is RGB888, VIDEO */
+ MEDIA_FORMAT_RGBA = (MEDIA_FORMAT_VIDEO | MEDIA_FORMAT_RAW | 0x25c0), /**< media format mime type is RGBA, VIDEO */
+ MEDIA_FORMAT_ARGB = (MEDIA_FORMAT_VIDEO | MEDIA_FORMAT_RAW | 0x25d0), /**< media format mime type is ARGB, VIDEO */
+
+ MEDIA_FORMAT_MAX /**< media format mime type is MEDIA_FORMAT_MAX, Do not use */
+} media_format_mimetype_e;
+
+/**
+ * @brief Enumeration for media color model.
+ * @since_tizen 2.3
+ */
+typedef enum {
+ MEDIA_COLOR_MODEL_NONE, /**< media format color model is NONE */
+ MEDIA_COLOR_MODEL_RGB, /**< media format color model is RGB */
+ MEDIA_COLOR_MODEL_YUV /**< media format color model is YUV */
+} media_format_color_model_e;
+
+
+/**
+ * @brief Creates a media format
+ * @since_tizen 2.3
+ * @details It creates media format. and reference count will be set to 1
+ For destroying media_format_h handle, use media_format_unref()
+ * @param[out] fmt allocated media_format_h
+ * @retval #MEDIA_FORMAT_ERROR_NONE Successful
+ * @retval #MEDIA_FORMAT_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #MEDIA_FORMAT_ERROR_OUT_OF_MEMORY Out of memory
+ * @retval #MEDIA_FORMAT_ERROR_INVALID_OPERATION Invalid operation
+ * @see media_format_ref()
+ * @see media_format_unref()
+ */
+int media_format_create(media_format_h* fmt);
+
+/**
+ * @brief Gets video information of media format
+ * @since_tizen 2.3
+ * @details returns mimetype, width, height, average bps, max bps of this media format
+ * @param[in] fmt media_format_h to get video information
+ * @param[out] mimetype media_format_mimetype_e , ex) MEDIA_FORMAT_H264_HP
+ * @param[out] width width of the video
+ * @param[out] height height of the video
+ * @param[out] avg_bps average bps of the video
+ * @param[out] max_bps max bps of the video
+ * @retval #MEDIA_FORMAT_ERROR_NONE Successful
+ * @retval #MEDIA_FORMAT_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #MEDIA_FORMAT_ERROR_INVALID_OPERATION Invalid operation
+ * @see media_format_set_video_mime()
+ * @see media_format_set_video_width()
+ * @see media_format_set_video_height()
+ * @see media_format_set_video_avg_bps()
+ * @see media_format_set_video_max_bps()
+ */
+int media_format_get_video_info(media_format_h fmt, media_format_mimetype_e* mimetype, int* width, int* height, int* avg_bps, int* max_bps);
+
+/**
+ * @brief Gets audio information of media format
+ * @since_tizen 2.3
+ * @details returns mimetype, channels, height, samplerate bps, max bps of this media format
+ * @param[in] fmt media_format_h to get audio information
+ * @param[out] mimetype media_format_mimetype_e , ex) MEDIA_FORMAT_PCM
+ * @param[out] channel channel of the audio
+ * @param[out] samplerate sampling rate of the audio
+ * @param[out] bit bit resolution of the audio
+ * @param[out] avg_bps average bps of the audio
+ * @retval #MEDIA_FORMAT_ERROR_NONE Successful
+ * @retval #MEDIA_FORMAT_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #MEDIA_FORMAT_ERROR_INVALID_OPERATION Invalid operation
+ * @see media_format_set_audio_mime()
+ * @see media_format_set_audio_channel()
+ * @see media_format_set_audio_samplerate()
+ * @see media_format_set_audio_bit()
+ * @see media_format_set_audio_avg_bps()
+ */
+int media_format_get_audio_info(media_format_h fmt, media_format_mimetype_e* mimetype, int* channel, int* samplerate, int* bit, int* avg_bps);
+
+/**
+ * @brief Sets video MIME type of media format
+ * @since_tizen 2.3
+ * @details Sets MIME type
+ * @param[in] fmt media_format_h to set
+ * @param[in] mimetype media_format_mimetype_e , ex) MEDIA_FORMAT_H264_HP
+ * @retval #MEDIA_FORMAT_ERROR_NONE Successful
+ * @retval #MEDIA_FORMAT_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #MEDIA_FORMAT_ERROR_INVALID_OPERATION Invalid operation
+ * @see media_format_get_video()
+ */
+int media_format_set_video_mime(media_format_h fmt, media_format_mimetype_e mimetype);
+
+/**
+ * @brief Sets video width of media format
+ * @since_tizen 2.3
+ * @details Sets video width
+ * @param[in] fmt media_format_h to set
+ * @param[in] width width of the video
+ * @pre must set video MIME type by media_format_set_video_mime()
+ * @retval #MEDIA_FORMAT_ERROR_NONE Successful
+ * @retval #MEDIA_FORMAT_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #MEDIA_FORMAT_ERROR_INVALID_OPERATION Invalid operation
+ * @see media_format_get_video()
+ */
+int media_format_set_video_width(media_format_h fmt, int width);
+
+
+/**
+ * @brief Sets video height of media format
+ * @since_tizen 2.3
+ * @details Sets video height
+ * @param[in] fmt media_format_h to set
+ * @param[in] height height of the video
+ * @pre must set video MIME type by media_format_set_video_mime()
+ * @retval #MEDIA_FORMAT_ERROR_NONE Successful
+ * @retval #MEDIA_FORMAT_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #MEDIA_FORMAT_ERROR_INVALID_OPERATION Invalid operation
+ * @see media_format_get_video()
+ */
+int media_format_set_video_height(media_format_h fmt, int height);
+
+/**
+ * @brief Sets video avg_bps of media format
+ * @since_tizen 2.3
+ * @details Sets avg_bps
+ * @param[in] fmt media_format_h to set
+ * @param[in] avg_bps average bps of the video
+ * @pre must set video MIME type by media_format_set_video_mime()
+ * @retval #MEDIA_FORMAT_ERROR_NONE Successful
+ * @retval #MEDIA_FORMAT_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #MEDIA_FORMAT_ERROR_INVALID_OPERATION Invalid operation
+ * @see media_format_get_video()
+ */
+int media_format_set_video_avg_bps(media_format_h fmt, int avg_bps);
+
+/**
+ * @brief Sets video max_bps of media format
+ * @since_tizen 2.3
+ * @details Sets max_bps
+ * @param[in] fmt media_format_h to set
+ * @param[in] max_bps max bps of the video
+ * @pre must set video MIME type by media_format_set_video_mime()
+ * @retval #MEDIA_FORMAT_ERROR_NONE Successful
+ * @retval #MEDIA_FORMAT_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #MEDIA_FORMAT_ERROR_INVALID_OPERATION Invalid operation
+ * @see media_format_get_video()
+ */
+int media_format_set_video_max_bps(media_format_h fmt, int max_bps);
+
+/**
+ * @brief Sets audio MIME type of media format
+ * @since_tizen 2.3
+ * @details Sets MIME type
+ * @param[in] fmt media_format_h to set audio information
+ * @param[in] mimetype media_format_mimetype_e , ex) MEDIA_FORMAT_PCM
+ * @retval #MEDIA_FORMAT_ERROR_NONE Successful
+ * @retval #MEDIA_FORMAT_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #MEDIA_FORMAT_ERROR_INVALID_OPERATION Invalid operation
+ * @see media_format_get_audio()
+ */
+int media_format_set_audio_mime(media_format_h fmt, media_format_mimetype_e mimetype);
+
+/**
+ * @brief Sets audio channel of media format
+ * @since_tizen 2.3
+ * @details Sets audio channel
+ * @param[in] fmt media_format_h to set audio information
+ * @param[in] channel channel of the audio
+ * @pre must set audio MIME type by media_format_set_audio_mime()
+ * @retval #MEDIA_FORMAT_ERROR_NONE Successful
+ * @retval #MEDIA_FORMAT_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #MEDIA_FORMAT_ERROR_INVALID_OPERATION Invalid operation
+ * @see media_format_get_audio()
+ */
+int media_format_set_audio_channel(media_format_h fmt, int channel);
+
+/**
+ * @brief Sets audio samplerate of media format
+ * @since_tizen 2.3
+ * @details Sets audio samplerate of this media format
+ * @param[in] fmt media_format_h to set
+ * @param[in] samplerate sampling rate of the audio
+ * @pre must set audio MIME type by media_format_set_audio_mime()
+ * @retval #MEDIA_FORMAT_ERROR_NONE Successful
+ * @retval #MEDIA_FORMAT_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #MEDIA_FORMAT_ERROR_INVALID_OPERATION Invalid operation
+ * @see media_format_get_audio()
+ */
+int media_format_set_audio_samplerate(media_format_h fmt, int samplerate);
+
+ /**
+ * @brief Sets audio bit of media format
+ * @since_tizen 2.3
+ * @details Sets audio bit resolution of this media format
+ * @param[in] fmt media_format_h to set
+ * @param[in] bit bit of the audio
+ * @pre must set audio MIME type by media_format_set_audio_mime()
+ * @retval #MEDIA_FORMAT_ERROR_NONE Successful
+ * @retval #MEDIA_FORMAT_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #MEDIA_FORMAT_ERROR_INVALID_OPERATION Invalid operation
+ * @see media_format_get_audio()
+ */
+int media_format_set_audio_bit(media_format_h fmt, int bit);
+
+ /**
+ * @brief Sets audio avg_bps of media format
+ * @since_tizen 2.3
+ * @details Sets audio avg_bps of this media format
+ * @param[in] fmt media_format_h to set
+ * @param[in] avg_bps avg_bps of the audio
+ * @pre must set audio MIME type by media_format_set_audio_mime()
+ * @retval #MEDIA_FORMAT_ERROR_NONE Successful
+ * @retval #MEDIA_FORMAT_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #MEDIA_FORMAT_ERROR_INVALID_OPERATION Invalid operation
+ * @see media_format_get_audio()
+ */
+int media_format_set_audio_avg_bps(media_format_h fmt, int avg_bps);
+
+/**
+ * @brief Increase reference count of media_format_h object
+ * @since_tizen 2.3
+ * @details increase ref_count of media_format_h
+ * @param[in] fmt exist media_format_h
+ * @retval #MEDIA_FORMAT_ERROR_NONE Successful
+ * @retval #MEDIA_FORMAT_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #MEDIA_FORMAT_ERROR_OUT_OF_MEMORY Out of memory
+ * @retval #MEDIA_FORMAT_ERROR_INVALID_OPERATION Invalid operation
+ * @see media_format_unref()
+ */
+int media_format_ref(media_format_h fmt);
+
+/**
+ * @brief Decrease reference count of media_format_h object
+ * @since_tizen 2.3
+ * @details decrease ref_count of media_format_h
+ * @param[in] fmt exist media_format_h
+ * @retval #MEDIA_FORMAT_ERROR_NONE Successful
+ * @retval #MEDIA_FORMAT_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #MEDIA_FORMAT_ERROR_OUT_OF_MEMORY Out of memory
+ * @retval #MEDIA_FORMAT_ERROR_INVALID_OPERATION Invalid operation
+ * @see media_format_ref()
+ */
+int media_format_unref(media_format_h fmt);
+
+/**
+ * @brief Check whether the media_format_h is writable or not.
+ * @since_tizen 2.3
+ * @details Check the number of media_format's ref_count
+ * @param[in] fmt exist media_format_h
+ * @param[out] is_writable if ref_count is 1, return true. if not, return false
+ * @retval #MEDIA_FORMAT_ERROR_NONE Successful
+ * @retval #MEDIA_FORMAT_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #MEDIA_FORMAT_ERROR_OUT_OF_MEMORY Out of memory
+ * @retval #MEDIA_FORMAT_ERROR_INVALID_OPERATION Invalid operation
+ */
+int media_format_is_writable(media_format_h fmt, bool* is_writable);
+
+ /**
+ * @brief Returns a writable copy of media_format_h
+ * @since_tizen 2.3
+ * @details If there is only one reference count on fmt, the caller must be the owner,
+ * and so this function will return the object unchanged.
+ * while, if there is more than one reference count on the object, a new object will be returned.
+ * The caller will own a reference to the returned object.
+ * In a nutshell, this function unrefs the fmt and refs the out_fmt returned.
+ * Don't access fmt after calling this function.
+ * @param[in] fmt exist media_format_h , don't access it after calling this function.
+ * @param[out] out_fmt new copied media_format_h, the caller is owner of this object.
+ * @retval #MEDIA_FORMAT_ERROR_NONE Successful
+ * @retval #MEDIA_FORMAT_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #MEDIA_FORMAT_ERROR_OUT_OF_MEMORY Out of memory
+ * @retval #MEDIA_FORMAT_ERROR_INVALID_OPERATION Invalid operation
+ */
+int media_format_make_writable(media_format_h fmt, media_format_h* out_fmt);
+
+
+/**
+ * @}
+ */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __TIZEN_MEDIA_AV_PACKET_BUFFER_H__ */
--- /dev/null
+/*
+* Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+#ifndef __TIZEN_MEDIA_FORMAT_PRIVATE_H__
+#define __TIZEN_MEDIA_FORMAT_PRIVATE_H__
+
+#include <media_format.h>
+#include <glib.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef LOG_TAG
+#undef LOG_TAG
+#endif
+#define LOG_TAG "TIZEN_MEDIA_TOOL"
+
+#define MEDIA_FORMAT_CHECK_CONDITION(condition,error,msg) \
+ if(condition) {} else \
+ { LOGE("[%s] %s(0x%08x)", __FUNCTION__, msg,error); return error;}; \
+
+#define MEDIA_FORMAT_INSTANCE_CHECK(media_format) \
+ MEDIA_FORMAT_CHECK_CONDITION(media_format != NULL, MEDIA_FORMAT_ERROR_INVALID_PARAMETER, "MEDIA_FORMAT_ERROR_INVALID_PARAMETER")
+
+#define MEDIA_FORMAT_NULL_ARG_CHECK(arg) \
+ MEDIA_FORMAT_CHECK_CONDITION(arg != NULL, MEDIA_FORMAT_ERROR_INVALID_PARAMETER, "MEDIA_FORMAT_ERROR_INVALID_PARAMETER")
+
+#if 0
+#define atomic_int_inc(atomic) \
+ (__extension__({ \
+ STATIC_ASSERT (sizeof *(atomic) == sizeof (int)); \
+ (void) (0 ? *(atomic) ^ *(atomic) : 0); \
+ (void) __sync_fetch_and_add ((atomic), 1); \
+ }))
+#endif
+
+
+#define MEDIA_FORMAT_CAST(obj) ((media_format_s*)(obj))
+
+/**
+ * @brief Check whether given media format is for audio or not
+ * @since_tizen 2.3
+ */
+#define MEDIA_FORMAT_IS_AUDIO(x_fmt) (MEDIA_FORMAT_CAST(x_fmt)->mimetype & MEDIA_FORMAT_AUDIO)
+
+/**
+ * @brief Check whether given media format is for video or not
+ * @since_tizen 2.3
+ */
+#define MEDIA_FORMAT_IS_VIDEO(x_fmt) (MEDIA_FORMAT_CAST(x_fmt)->mimetype & MEDIA_FORMAT_VIDEO)
+
+/**
+ * @brief Check whether given media format is for text or not
+ * @since_tizen 2.3
+ */
+#define MEDIA_FORMAT_IS_TEXT(x_fmt) (false)
+
+/**
+ * @brief Check whether given media format is for raw type or not
+ * @since_tizen 2.3
+ */
+#define MEDIA_FORMAT_IS_RAW(x_fmt) (MEDIA_FORMAT_CAST(x_fmt)->mimetype & MEDIA_FORMAT_RAW)
+
+/**
+ * @brief Check whether given media format is for encoded type or not
+ * @since_tizen 2.3
+ */
+#define MEDIA_FORMAT_IS_ENCODED(x_fmt) (MEDIA_FORMAT_CAST(x_fmt)->mimetype & MEDIA_FORMAT_ENCODED)
+
+/**
+ * @brief Gets the number of media format ref_count
+ * @since_tizen 2.3
+ */
+#define MEDIA_FORMAT_GET_REFCOUNT(x_fmt) (g_atomic_int_get(&(MEDIA_FORMAT_CAST(x_fmt))->ref_count))
+
+/**
+ * @brief Check whether given media format is writable or not
+ * @since_tizen 2.3
+ */
+#define MEDIA_FORMAT_IS_WRITABLE(x_fmt) (MEDIA_FORMAT_GET_REFCOUNT(x_fmt) == 1)
+
+/**
+ * @brief increase the media format's ref_count
+ * @since_tizen 2.3
+ */
+#define MEDIA_FORMAT_INC_REFCOUNT(x_fmt) (g_atomic_int_inc(&(MEDIA_FORMAT_CAST(x_fmt))->ref_count))
+
+/**
+ * @brief decrease the media format's ref_count and return true if ref_count become zero.
+ * @since_tizen 2.3
+ */
+#define MEDIA_FORMAT_DEC_REFCOUNT_TEST(x_fmt) (g_atomic_int_dec_and_test(&(MEDIA_FORMAT_CAST(x_fmt))->ref_count))
+
+/**
+ * @brief Media format for configuring video codec.
+ * @since_tizen 2.3
+ */
+typedef struct _media_format_video_spec_s {
+ int width; /**< media format video width */
+ int height; /**< media format video height */
+ int avg_bps; /**< media format video average bps */
+ int max_bps; /**< media format video max bps */
+} media_format_video_spec_s;
+
+/**
+ * @brief Media format for configuring audio codec.
+ * @since_tizen 2.3
+ */
+typedef struct _media_fomat_audio_spec_s {
+ int channel; /**< media format audio's the number of channels */
+ int samplerate; /**< media format audio sampling rate */
+ int bit; /**< media format audio's the bit resolution */
+ int avg_bps; /**< media format audio max bps */
+} media_format_audio_spec_s;
+
+/**
+ * @brief Structure of media format.
+ * @since_tizen 2.3
+ */
+typedef struct _media_format_s
+{
+ int ref_count; /**< media format struct reference count */
+ media_format_mimetype_e mimetype; /**< media format struct mimetype of media_format_mimetype_e */
+
+ union {
+ media_format_audio_spec_s audio; /**< media format struct audio of media_format_audio_spec_s */
+ media_format_video_spec_s video; /**< media format struct video of media_format_video_spec_s */
+ }detail;
+
+} media_format_s;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __TIZEN_MEDIA_FORMAT_PRIVATE_H__ */
+
--- /dev/null
+/*
+* Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+#ifndef __TIZEN_MEDIA_PACKET_H__
+#define __TIZEN_MEDIA_PACKET_H__
+
+#include <tizen.h>
+#include <stdint.h>
+
+#include <media_format.h>
+
+#include <tbm_type.h>
+#include <tbm_surface.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @file media_packet.h
+ * @brief This file contains the capi media tool API.
+ */
+
+/**
+ * @addtogroup CAPI_MEDIA_TOOL_MODULE
+ * @{
+ */
+
+/**
+ * @brief The Media Packet handle.
+ * @since_tizen 2.3
+ */
+typedef struct media_packet_s *media_packet_h;
+
+/**
+ * @brief Enumeration for media packet error.
+ * @since_tizen 2.3
+ */
+typedef enum
+{
+ MEDIA_PACKET_ERROR_NONE = TIZEN_ERROR_NONE, /**< Successful */
+ MEDIA_PACKET_ERROR_OUT_OF_MEMORY = TIZEN_ERROR_OUT_OF_MEMORY, /**< Out of memory */
+ MEDIA_PACKET_ERROR_INVALID_PARAMETER = TIZEN_ERROR_INVALID_PARAMETER, /**< Invalid parameter */
+ MEDIA_PACKET_ERROR_INVALID_OPERATION = TIZEN_ERROR_INVALID_OPERATION, /**< Invalid operation */
+ MEDIA_PACKET_ERROR_FILE_NO_SPACE_ON_DEVICE = TIZEN_ERROR_FILE_NO_SPACE_ON_DEVICE, /**< No space left on device */
+} media_packet_error_e;
+
+/**
+ * @brief Enumeration for media buffer flag.
+ * @since_tizen 2.3
+ */
+typedef enum
+{
+ MEDIA_PACKET_CODEC_CONFIG = 0x1, /**< The buffer marked as such contains codec initialization/codec specific data instead of media data */
+ MEDIA_PACKET_END_OF_STREAM = 0x2, /**< The end of stream */
+ MEDIA_PACKET_SYNC_FRAME = 0x4, /**< The buffer marked as such contains the data for a sync frame */
+} media_buffer_flags_e;
+
+/**
+ * @brief Enumeration for the return values of media packet finalize call back functions.
+ * @since_tizen 2.3
+ * @see media_packet_finalize_cb()
+ */
+typedef enum _finalize_cb_ret
+{
+ MEDIA_PACKET_REUSE = 0, /**< Packet handle is not destroyed */
+ MEDIA_PACKET_FINALIZE, /**< Destroy packet handle */
+} media_packet_finalize_cb_ret_t;
+
+/**
+ * @brief Called when the media packet is destroyed.
+ * @details It will be invoked when media_packet_destroy() is called.
+ *
+ * @since_tizen 2.3
+ *
+ * @param[in] packet The media packet handle
+ * @param[in] error_code The error code of #media_packet_error_e
+ * @param[in] user_data The user data passed from the callback registration function
+ *
+ * @pre It will be invoked when media packet is destroyed.
+ *
+ * @retval #MEDIA_PACKET_REUSE Packet handle is not destroyed, the handle will be reused.
+ * @retval #MEDIA_PACKET_FINALIZE Destroy media packet handle, the handle will not be reused.
+ *
+ * @see media_packet_destroy()
+ * @see media_packet_create_alloc()
+ * @see media_packet_create()
+ * @see media_packet_copy()
+ * @see media_packet_create_from_tbm_surface()
+ */
+typedef int (*media_packet_finalize_cb)(media_packet_h packet, int error_code, void *user_data);
+
+/**
+ * @brief Creates a media packet handle and allocates buffer.
+ * @details The buffer will be allocated to heap or tbm_surface.
+ *
+ * @since_tizen 2.3
+ *
+ * @param[in] fmt The allocated #media_format_h by caller
+ * @param[in] fcb The media_packet_finalize_cb() to register
+ * @param[in] fcb_data The user data to be passed to the media_packet_finalize_cb() function
+ * @param[out] packet A new handle for media packet
+ *
+ * @retval #MEDIA_PACKET_ERROR_NONE Successful
+ * @retval #MEDIA_PACKET_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #MEDIA_PACKET_ERROR_OUT_OF_MEMORY Out of memory
+ * @retval #MEDIA_PACKET_ERROR_INVALID_OPERATION Invalid operation
+ *
+ * @pre must have media_format_h instance by media_format_create()
+ * @post must do media_format_unref()
+ *
+ * @see media_packet_destroy()
+ * @see media_packet_finalize_cb()
+ * @see media_format_unref()
+ * @par Example
+ @code
+ #include <media_packet.h>
+
+ {
+ media_format_h fmt;
+ media_packet_h packet;
+
+ media_format_create(&fmt);
+ media_format_set_video_info(fmt, MEDIA_FORMAT_H264_HP, 480, 640, 10000000, 15000000);
+
+ media_packet_create_alloc (fmt, _finalize_callback, fcb_data, &packet);
+ media_format_unref(fmt);
+
+ ...
+ }
+
+ int _finalize_callback(media_packet_h packet, int err, void* userdata)
+ {
+ ...
+ return MEDIA_PACKET_FINALIZE;
+ }
+
+ @endcode
+ */
+int media_packet_create_alloc(media_format_h fmt, media_packet_finalize_cb fcb, void *fcb_data, media_packet_h *packet);
+
+/**
+ * @brief Creates a media packet handle.
+ * @details It creates only media packet handle without allocated buffer.
+ *
+ * @since_tizen 2.3
+ *
+ * @param[in] fmt The allocated #media_format_h by caller
+ * @param[in] fcb The media_packet_finalize_cb() to register
+ * @param[in] fcb_data The user data to be passed to the media_packet_finalize_cb() function
+ * @param[out] packet A new handle for media packet
+ *
+ * @retval #MEDIA_PACKET_ERROR_NONE Successful
+ * @retval #MEDIA_PACKET_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #MEDIA_PACKET_ERROR_OUT_OF_MEMORY Out of memory
+ * @retval #MEDIA_PACKET_ERROR_INVALID_OPERATION Invalid operation
+ *
+ * @pre must have media_format_h instance by media_format_create()
+ * @post must do media_format_unref()
+ *
+ * @see media_packet_destroy()
+ * @see media_packet_finalize_cb()
+ * @see media_format_unref()
+ * @par Example
+ @code
+ #include <media_packet.h>
+
+ {
+ media_format_h fmt;
+ media_packet_h packet;
+
+ media_format_create(&fmt);
+ media_format_set_video_info(fmt, MEDIA_FORMAT_H264_HP, 480, 640, 10000000, 15000000);
+
+ media_packet_create (fmt, _finalize_callback, fcb_data, &packet);
+ media_format_unref(fmt);
+
+ ...
+ }
+
+ int _finalize_callback(media_packet_h packet, int err, void* userdata)
+ {
+ ...
+ return MEDIA_PACKET_FINALIZE;
+ }
+
+ @endcode
+ */
+int media_packet_create(media_format_h fmt, media_packet_finalize_cb fcb, void *fcb_data, media_packet_h *packet);
+
+/**
+ * @brief Copies a media packet handle.
+ * @details It re-creates only media packet handle with exist media packet handle.
+ *
+ * @since_tizen 2.3
+ *
+ * @param[in] org_packet The existing media packet handle
+ * @param[in] fcb The media_packet_finalize_cb() to register
+ * @param[in] fcb_data The user data to be passed to the media_packet_finalize_cb() function
+ * @param[out] new_packet A new handle for media packet
+ *
+ * @retval #MEDIA_PACKET_ERROR_NONE Successful
+ * @retval #MEDIA_PACKET_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #MEDIA_PACKET_ERROR_OUT_OF_MEMORY Out of memory
+ * @retval #MEDIA_PACKET_ERROR_INVALID_OPERATION Invalid operation
+ *
+ * @see media_packet_destroy()
+ * @see media_packet_finalize_cb()
+ */
+int media_packet_copy(media_packet_h org_packet, media_packet_finalize_cb fcb, void *fcb_data, media_packet_h* new_packet);
+
+/**
+ * @brief Allocates buffer with media packet handle.
+ * @details Before using media_packet_alloc(), media packet handle must be exist.
+ *
+ * @since_tizen 2.3
+ *
+ * @param[in] packet The existing media packet handle
+ *
+ * @retval #MEDIA_PACKET_ERROR_NONE Successful
+ * @retval #MEDIA_PACKET_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #MEDIA_PACKET_ERROR_OUT_OF_MEMORY Out of memory
+ * @retval #MEDIA_PACKET_ERROR_INVALID_OPERATION Invalid operation
+ *
+ * @see media_packet_create()
+ * @see media_packet_destroy()
+ */
+int media_packet_alloc(media_packet_h packet);
+
+/**
+ * @brief Creates media packet handle and allocates buffer with #tbm_surface_h.
+ *
+ * @since_tizen 2.3
+ *
+ * @param[in] fmt The allocated #media_format_h by caller
+ * @param[in] surface The #tbm_surface_h by caller
+ * @param[in] fcb The media_packet_finalize_cb() to register
+ * @param[in] fcb_data The user data to be passed to the media_packet_finalize_cb() function
+ * @param[out] packet A new handle for media packet
+ * @retval #MEDIA_PACKET_ERROR_NONE Successful
+ * @retval #MEDIA_PACKET_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #MEDIA_PACKET_ERROR_OUT_OF_MEMORY Out of memory
+ * @retval #MEDIA_PACKET_ERROR_INVALID_OPERATION Invalid operation
+ *
+ * @pre must have media_format_h instance by media_format_create()
+ * @post must do media_format_unref()
+ *
+ * @see media_packet_destroy()
+ * @see media_packet_finalize_cb()
+ * @see media_format_unref()
+ * @par Example
+ @code
+ #include <media_packet.h>
+
+ {
+ media_format_h fmt;
+ media_packet_h packet;
+
+ media_format_create(&fmt);
+ media_format_set_video_info(fmt, MEDIA_FORMAT_RGBA, 128, 128, 2000000, 15000000);
+
+ media_packet_create_from_tbm_surface (fmt, surface, _finalize_callback, fcb_data, &packet);
+ media_format_unref(fmt);
+
+ ...
+ }
+
+ int _finalize_callback(media_packet_h packet, int err, void* userdata)
+ {
+ ...
+ return MEDIA_PACKET_FINALIZE;
+ }
+
+ @endcode
+ */
+int media_packet_create_from_tbm_surface(media_format_h fmt, tbm_surface_h surface, media_packet_finalize_cb fcb, void *fcb_data, media_packet_h *packet);
+
+/**
+ * @brief Gets #media_format_h of media packet
+ * @since_tizen 2.3
+ *
+ * @param[in] packet The media packet handle
+ * @param[out] fmt The media format of media packet
+ *
+ * @retval #MEDIA_PACKET_ERROR_NONE Successful
+ * @retval #MEDIA_PACKET_ERROR_INVALID_PARAMETER Invalid parameter
+ *
+ * @see media_format_unref()
+ * @par Example
+ @code
+ #include <media_packet.h>
+
+ {
+ media_format_h* fmt;
+
+ media_packet_get_format (pakcet, &fmt);
+ ..
+
+ media_format_unref(fmt);
+ ...
+ }
+
+ @endcode
+ */
+int media_packet_get_format(media_packet_h packet, media_format_h *fmt);
+
+/**
+ * @brief Sets #media_format_h of media packet
+ * @since_tizen 2.3
+ *
+ * @param[in] packet The media packet handle
+ * @param[in] fmt The #media_format_h to set
+ *
+ * @retval #MEDIA_PACKET_ERROR_NONE Successful
+ * @retval #MEDIA_PACKET_ERROR_INVALID_PARAMETER Invalid parameter
+ *
+ * @see media_format_unref()
+ * @par Example
+ @code
+ #include <media_packet.h>
+
+ {
+ media_format_h fmt;
+
+ media_packet_set_format (pakcet, fmt);
+ ..
+
+ media_format_unref(fmt);
+ ...
+ }
+
+ @endcode
+ */
+int media_packet_set_format(media_packet_h packet, media_format_h fmt);
+
+/**
+ * @brief Sets PTS of media packet.
+ * @since_tizen 2.3
+ *
+ * @param[in] packet The media packet handle
+ * @param[in] pts The PTS value to set
+ *
+ * @retval #MEDIA_PACKET_ERROR_NONE Successful
+ * @retval #MEDIA_PACKET_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #MEDIA_PACKET_ERROR_INVALID_OPERATION Invalid operation
+ */
+int media_packet_set_pts(media_packet_h packet, uint64_t pts);
+
+/**
+ * @brief Sets DTS of media packet handle.
+ * @since_tizen 2.3
+ *
+ * @param[in] packet The media packet handle
+ * @param[in] dts The DTS value to set
+ *
+ * @retval #MEDIA_PACKET_ERROR_NONE Successful
+ * @retval #MEDIA_PACKET_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #MEDIA_PACKET_ERROR_INVALID_OPERATION Invalid operation
+ */
+int media_packet_set_dts(media_packet_h packet, uint64_t dts);
+
+/**
+ * @brief Sets PTS of media packet.
+ * @since_tizen 2.3
+ *
+ * @param[in] packet The media packet handle
+ * @param[in] duration The duration value to set
+ *
+ * @retval #MEDIA_PACKET_ERROR_NONE Successful
+ * @retval #MEDIA_PACKET_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #MEDIA_PACKET_ERROR_INVALID_OPERATION Invalid operation
+ */
+int media_packet_set_duration(media_packet_h packet, uint64_t duration);
+
+/**
+ * @brief Sets buffer size of media packet.
+ * @since_tizen 2.3
+ *
+ * @param[in] packet The media packet handle
+ * @param[out] size The buffer size value to set
+ *
+ * @retval #MEDIA_PACKET_ERROR_NONE Successful
+ * @retval #MEDIA_PACKET_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #MEDIA_PACKET_ERROR_INVALID_OPERATION Invalid operation
+ */
+int media_packet_set_buffer_size(media_packet_h packet, uint64_t size);
+
+/**
+ * @brief Gets PTS of media packet.
+ * @since_tizen 2.3
+ *
+ * @param[in] packet The media packet handle
+ * @param[out] pts The PTS value to get
+ *
+ * @retval #MEDIA_PACKET_ERROR_NONE Successful
+ * @retval #MEDIA_PACKET_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #MEDIA_PACKET_ERROR_INVALID_PARAMETER Invalid parameter
+ */
+int media_packet_get_pts(media_packet_h packet, uint64_t *pts);
+
+/**
+ * @brief Gets DTS of media packet
+ * @since_tizen 2.3
+ *
+ * @param[in] packet The media packet handle
+ * @param[out] dts The DTS value to get
+ *
+ * @retval #MEDIA_PACKET_ERROR_NONE Successful
+ * @retval #MEDIA_PACKET_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #MEDIA_PACKET_ERROR_INVALID_OPERATION Invalid operation
+ */
+int media_packet_get_dts(media_packet_h packet, uint64_t *dts);
+
+/**
+ * @brief Gets duration of media packet.
+ * @since_tizen 2.3
+ *
+ * @param[in] packet The media packet handle
+ * @param[out] duration The duration value to get
+ *
+ * @retval #MEDIA_PACKET_ERROR_NONE Successful
+ * @retval #MEDIA_PACKET_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #MEDIA_PACKET_ERROR_INVALID_OPERATION Invalid operation
+ */
+int media_packet_get_duration(media_packet_h packet, uint64_t *duration);
+
+/**
+ * @brief Gets buffer size of media packet.
+ * @since_tizen 2.3
+ *
+ * @param[in] packet The media packet handle
+ * @param[out] size The buffer size value to get
+ *
+ * @retval #MEDIA_PACKET_ERROR_NONE Successful
+ * @retval #MEDIA_PACKET_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #MEDIA_PACKET_ERROR_INVALID_OPERATION Invalid operation
+ */
+int media_packet_get_buffer_size(media_packet_h packet, uint64_t *size);
+
+/**
+ * @brief Gets buffer data pointer of media packet.
+ * @since_tizen 2.3
+ *
+ * @param[in] packet The media packet handle
+ * @param[out] data The allocated buffer data pointer
+ *
+ * @retval #MEDIA_PACKET_ERROR_NONE Successful
+ * @retval #MEDIA_PACKET_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #MEDIA_PACKET_ERROR_INVALID_OPERATION Invalid operation
+ */
+int media_packet_get_buffer_data_ptr(media_packet_h packet, void **data);
+
+/**
+ * @brief Gets TBM surface data of media packet.
+ * @since_tizen 2.3
+ *
+ * @param[in] packet The media packet handle
+ * @param[out] surface The tbm_surface data pointer
+ *
+ * @retval #MEDIA_PACKET_ERROR_NONE Successful
+ * @retval #MEDIA_PACKET_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #MEDIA_PACKET_ERROR_INVALID_OPERATION Invalid operation
+ */
+int media_packet_get_tbm_surface(media_packet_h packet, tbm_surface_h *surface);
+
+/**
+ * @brief Sets extra data of media packet.
+ * @since_tizen 2.3
+ *
+ * @param[in] packet The media packet handle
+ * @param[in] extra The extra data to set
+ *
+ * @retval #MEDIA_PACKET_ERROR_NONE Successful
+ * @retval #MEDIA_PACKET_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #MEDIA_PACKET_ERROR_INVALID_OPERATION Invalid operation
+ */
+int media_packet_set_extra(media_packet_h packet, void *extra);
+
+/**
+ * @brief Gets extra data of media packet.
+ * @since_tizen 2.3
+ *
+ * @param[in] packet The media packet handle
+ * @param[out] extra The extra data to get
+ *
+ * @retval #MEDIA_PACKET_ERROR_NONE Successful
+ * @retval #MEDIA_PACKET_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #MEDIA_PACKET_ERROR_INVALID_OPERATION Invalid operation
+ */
+int media_packet_get_extra(media_packet_h packet, void **extra);
+
+/**
+ * @brief Checks whether the given media packet is for video.
+ * @since_tizen 2.3
+ *
+ * @param[in] packet The media packet handle
+ * @param[out] is_video @c true if the given media packet is for video,
+ * otherwise @c false if the given media packet is not for video
+ *
+ * @retval #MEDIA_PACKET_ERROR_NONE Successful
+ * @retval #MEDIA_PACKET_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #MEDIA_PACKET_ERROR_INVALID_OPERATION Invalid operation
+ *
+ * @see media_format_mimetype_e
+ * @see media_format_type_e
+ */
+int media_packet_is_video(media_packet_h packet, bool *is_video);
+
+/**
+ * @brief Checks whether the given media packet is for audio.
+ * @since_tizen 2.3
+ *
+ * @param[in] packet The media packet handle
+ * @param[out] is_audio @c true if the given media packet is for audio,
+ * otherwise @c false if the given media packet is not for audio
+ *
+ * @retval #MEDIA_PACKET_ERROR_NONE Successful
+ * @retval #MEDIA_PACKET_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #MEDIA_PACKET_ERROR_INVALID_OPERATION Invalid operation
+ * @see media_format_mimetype_e
+ * @see media_format_type_e
+ */
+int media_packet_is_audio(media_packet_h packet, bool *is_audio);
+
+/**
+ * @brief Checks whether the given media packet is encoded type.
+ * @since_tizen 2.3
+ *
+ * @param[in] packet The media packet handle
+ * @param[out] is_encoded @c true if the given media packet is encoded,
+ * otherwise @c false if the given media packet is not encoded
+ *
+ * @retval #MEDIA_PACKET_ERROR_NONE Successful
+ * @retval #MEDIA_PACKET_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #MEDIA_PACKET_ERROR_INVALID_OPERATION Invalid operation
+ *
+ * @see media_format_mimetype_e
+ * @see media_format_data_type_e
+ */
+int media_packet_is_encoded(media_packet_h packet, bool *is_encoded);
+
+/**
+ * @brief Checks whether the given media packet is raw type.
+ * @since_tizen 2.3
+ *
+ * @param[in] packet The media packet handle
+ * @param[out] is_raw @c true if the given media packet is for raw video,
+ * otherwise @c false if the given media packet is not for raw video
+ *
+ * @retval #MEDIA_PACKET_ERROR_NONE Successful
+ * @retval #MEDIA_PACKET_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #MEDIA_PACKET_ERROR_INVALID_OPERATION Invalid operation
+ *
+ * @see media_format_mimetype_e
+ * @see media_format_data_type_e
+ */
+int media_packet_is_raw(media_packet_h packet, bool *is_raw);
+
+/**
+ * @brief Sets #media_buffer_flags_e of media packet.
+ * @since_tizen 2.3
+ *
+ * @param[in] packet The media packet handle
+ * @param[in] flags The media_buffer_flags_e of media packet to set
+ *
+ * @retval #MEDIA_PACKET_ERROR_NONE Successful
+ * @retval #MEDIA_PACKET_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #MEDIA_PACKET_ERROR_INVALID_OPERATION Invalid operation
+ *
+ * @see media_buffer_flags_e
+ * @see media_packet_unset_flags()
+ */
+int media_packet_set_flags(media_packet_h packet, media_buffer_flags_e flags);
+
+/**
+ * @brief Unsets media_buffer_flags_e of media packet
+ * @since_tizen 2.3
+ *
+ * @param[in] packet The media packet handle
+ * @param[in] flags The media_buffer_flags_e of media packet to unset
+ *
+ * @retval #MEDIA_PACKET_ERROR_NONE Successful
+ * @retval #MEDIA_PACKET_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #MEDIA_PACKET_ERROR_INVALID_OPERATION Invalid operation
+ *
+ * @see media_buffer_flags_e
+ * @see media_packet_set_flags()
+ * */
+int media_packet_unset_flags(media_packet_h packet, media_buffer_flags_e flags);
+
+/**
+ * @brief Checks whether the given media packet is codec data.
+ * @since_tizen 2.3
+ *
+ * @param[in] packet The media packet handle
+ * @param[out] is_codec_config @c true if the given media packet is for codec data,
+ * otherwise @c false if the given media packet is not for codec data
+ *
+ * @retval #MEDIA_PACKET_ERROR_NONE Successful
+ * @retval #MEDIA_PACKET_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #MEDIA_PACKET_ERROR_INVALID_OPERATION Invalid operation
+ *
+ * @see media_format_mimetype_e
+ * @see media_format_data_type_e
+ */
+int media_packet_is_codec_config(media_packet_h packet, bool *is_codec_config);
+
+/**
+ * @brief Checks whether the given media packet is eos.
+ * @since_tizen 2.3
+ *
+ * @param[in] packet The media packet handle
+ * @param[out] is_eos @c true if the given media packet is for eos,
+ * otherwise @c false if the given media packet is not for eos
+ *
+ * @retval #MEDIA_PACKET_ERROR_NONE Successful
+ * @retval #MEDIA_PACKET_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #MEDIA_PACKET_ERROR_INVALID_OPERATION Invalid operation
+ *
+ * @see media_format_mimetype_e
+ * @see media_format_data_type_e
+ */
+int media_packet_is_end_of_stream(media_packet_h packet, bool *is_eos);
+
+/**
+ * @brief Checks whether the given media packet is sync frame.
+ * @since_tizen 2.3
+ *
+ * @param[in] packet The media packet handle
+ * @param[out] is_sync @c true if the given media packet is for sync frame,
+ * otherwise @c false if the given media packet is not for sync frame
+ *
+ * @retval #MEDIA_PACKET_ERROR_NONE Successful
+ * @retval #MEDIA_PACKET_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #MEDIA_PACKET_ERROR_INVALID_OPERATION Invalid operation
+ *
+ * @see media_format_mimetype_e
+ * @see media_format_data_type_e
+ */
+int media_packet_is_sync_frame(media_packet_h packet, bool *is_sync);
+
+/**
+ * @brief Checks whether the allocated buffer is tbm surface or not.
+ * @since_tizen 2.3
+ *
+ * @param[in] packet The media packet handle
+ * @param[out] has_tbm_surface @c true if the given media packet's allocated buffer is tbm surface,
+ * otherwise @c false if the given media packet's allocated buffer is not tbm surface
+ *
+ * @retval #MEDIA_PACKET_ERROR_NONE Successful
+ * @retval #MEDIA_PACKET_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #MEDIA_PACKET_ERROR_INVALID_OPERATION Invalid operation
+ */
+int media_packet_has_tbm_surface_buffer(media_packet_h packet, bool* has_tbm_surface);
+
+/**
+ * @brief Destroys the media packet handle.
+ * @details The registered finalize_callback() function will be invoked to destroy the media packet handle.
+ * @since_tizen 2.3
+ *
+ * @param[in] packet The handle to media packet to be destroyed
+ *
+ * @retval #MEDIA_PACKET_ERROR_NONE Successful
+ * @retval #MEDIA_PACKET_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #MEDIA_PACKET_ERROR_INVALID_OPERATION Invalid operation
+ *
+ * @see media_packet_create_alloc()
+ * @see media_packet_create()
+ * @see media_packet_copy()
+ * @see media_packet_create_from_tbm_surface()
+ */
+int media_packet_destroy(media_packet_h packet);
+
+/**
+ * @}
+ */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __TIZEN_MEDIA_AV_PACKET_BUFFER_H__ */
--- /dev/null
+/*
+* Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+#ifndef __TIZEN_MEDIA_PACKET_PRIVATE_H__
+#define __TIZEN_MEDIA_PACKET_PRIVATE_H__
+
+#include <media_packet.h>
+#include <media_format_private.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef LOG_TAG
+#undef LOG_TAG
+#endif
+#define LOG_TAG "TIZEN_MEDIA_TOOL"
+
+#define MEDIA_PACKET_CHECK_CONDITION(condition,error,msg) \
+ if(condition) {} else \
+ { LOGE("[%s] %s(0x%08x)", __FUNCTION__, msg,error); return error;}; \
+
+#define MEDIA_PACKET_INSTANCE_CHECK(media_packet) \
+ MEDIA_PACKET_CHECK_CONDITION(media_packet != NULL, MEDIA_PACKET_ERROR_INVALID_PARAMETER, "MEDIA_PACKET_ERROR_INVALID_PARAMETER")
+
+#define MEDIA_PACKET_NULL_ARG_CHECK(arg) \
+ MEDIA_PACKET_CHECK_CONDITION(arg != NULL, MEDIA_PACKET_ERROR_INVALID_PARAMETER, "MEDIA_PACKET_ERROR_INVALID_PARAMETER")
+
+/**
+ * @brief Gets pts of media_packet_h
+ * @since_tizen 2.3
+ */
+#define MEDIA_PACKET_PTS(arg) (MEDIA_PACKET_CAST(arg)->pts)
+
+/**
+ * @brief Gets dts of media_packet_h
+ * @since_tizen 2.3
+ */
+#define MEDIA_PACKET_DTS(arg) (MEDIA_PACKET_CAST(arg)->dts)
+
+/**
+ * @brief Gets duration of media_packet_h
+ * @since_tizen 2.3
+ */
+#define MEDIA_PACKET_DURATION(arg) (MEDIA_PACKET_CAST(arg)->duration)
+
+/**
+ * @brief Gets size of media_packet_h
+ * @since_tizen 2.3
+ */
+#define MEDIA_PACKET_SIZE(arg) (MEDIA_PACKET_CAST(arg)->size)
+
+/**
+ * @brief Gets data of media_packet_h
+ * @since_tizen 2.3
+ */
+#define MEDIA_PACKET_DATA(arg) (MEDIA_PACKET_CAST(arg)->data)
+
+/**
+ * @brief Gets the buffer flags of media_packet_h
+ * @since_tizen 2.3
+ */
+#define MEDIA_PACKET_FLAGS(arg) (MEDIA_PACKET_CAST(arg)->flags)
+
+/**
+ * @brief Gets the buffer config flag of media_packet_h
+ * @since_tizen 2.3
+ */
+#define MEDIA_PACKET_CODEC_CONFIG_DATA(arg) (((MEDIA_PACKET_CAST(arg)->flags) >> 0) & 0x001)
+
+/**
+ * @brief Gets the buffer eos flag of media_packet_h
+ * @since_tizen 2.3
+ */
+#define MEDIA_PACKET_CODEC_END_OF_STREAM(arg) (((MEDIA_PACKET_CAST(arg)->flags) >> 1) & 0x001)
+
+/**
+ * @brief Gets the buffer sync flag of media_packet_h
+ * @since_tizen 2.3
+ */
+#define MEDIA_PACKET_CODEC_SYNC_FRAME(arg) (((MEDIA_PACKET_CAST(arg)->flags) >> 2) & 0x001)
+
+/**
+ * @brief Casting to media_packet_s
+ * @since_tizen 2.3
+ */
+#define MEDIA_PACKET_CAST(obj) ((media_packet_s*)(obj))
+
+
+typedef enum {
+ MEDIA_BUFFER_TYPE_TBM_SURFACE,
+ MEDIA_BUFFER_TYPE_EXTERNAL_TBM_SURFACE,
+ MEDIA_BUFFER_TYPE_NORMAL,
+ MEDIA_BUFFER_TYPE_AUTO,
+ MEDIA_BUFFER_TYPE_MAX
+} media_buffer_type_e;
+
+typedef struct _media_packet_s{
+
+ uint64_t pts;
+ uint64_t dts;
+ uint64_t duration;
+ uint64_t size;
+ void* data;
+ void* surface_data;
+ media_packet_finalize_cb finalizecb_func;
+ void* userdata;
+ bool is_allocated;
+ void *extradata;
+
+ media_format_s* format;
+ media_buffer_type_e type;
+ media_buffer_flags_e flags;
+
+} media_packet_s;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __TIZEN_MEDIA_PACKET_PRIVATE_H__ */
+
--- /dev/null
+Name: capi-media-tool
+Summary: A Core API media tool library in Tizen Native API
+Version: 0.1.1
+Release: 0
+Group: Multimedia/API
+License: Apache-2.0
+Source0: %{name}-%{version}.tar.gz
+BuildRequires: cmake
+BuildRequires: pkgconfig(dlog)
+BuildRequires: pkgconfig(glib-2.0)
+BuildRequires: pkgconfig(capi-base-common)
+BuildRequires: pkgconfig(appcore-efl)
+BuildRequires: pkgconfig(libtbm)
+
+Requires(post): /sbin/ldconfig
+Requires(post): libprivilege-control
+Requires(postun): /sbin/ldconfig
+
+%description
+A Core API media tool library in Tizen Native API
+
+%package devel
+Summary: A Core API media tool library in Tizen Native API (Development)
+Group: Multimedia/API
+Requires: %{name} = %{version}-%{release}
+Requires: pkgconfig(libtbm)
+
+%description devel
+%devel_desc
+%prep
+%setup -q
+
+
+%build
+%if 0%{?sec_build_binary_debug_enable}
+export CFLAGS="$CFLAGS -DTIZEN_DEBUG_ENABLE"
+export CXXFLAGS="$CXXFLAGS -DTIZEN_DEBUG_ENABLE"
+export FFLAGS="$FFLAGS -DTIZEN_DEBUG_ENABLE"
+%endif
+MAJORVER=`echo %{version} | awk 'BEGIN {FS="."}{print $1}'`
+cmake . -DCMAKE_INSTALL_PREFIX=/usr -DFULLVER=%{version} -DMAJORVER=${MAJORVER}
+
+
+make %{?jobs:-j%jobs}
+
+%install
+rm -rf %{buildroot}
+mkdir -p %{buildroot}/usr/share/license
+mkdir -p %{buildroot}/usr/bin
+mkdir -p %{buildroot}/opt/usr/devel
+cp test/media_packet_test %{buildroot}/opt/usr/devel
+cp LICENSE.APLv2 %{buildroot}/usr/share/license/%{name}
+
+%make_install
+
+%post
+/sbin/ldconfig
+
+%postun -p /sbin/ldconfig
+
+
+%files
+%manifest capi-media-tool.manifest
+%{_libdir}/libcapi-media-tool.so.*
+%{_datadir}/license/%{name}
+/opt/usr/devel/*
+#%{_bindir}/*
+
+%files devel
+%{_includedir}/media/*.h
+%{_libdir}/pkgconfig/*.pc
+%{_libdir}/libcapi-media-tool.so
+
+
--- /dev/null
+/*
+* Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <dlog.h>
+#include <media_format.h>
+#include <media_format_private.h>
+
+static void _media_format_destroy(media_format_s* fmt);
+
+int media_format_create(media_format_h* fmt)
+{
+ MEDIA_FORMAT_NULL_ARG_CHECK(fmt);
+ int ret = MEDIA_FORMAT_ERROR_NONE;
+
+ media_format_s* fmt_handle;
+ fmt_handle = (media_format_s*)malloc(sizeof(media_format_s));
+ if (fmt_handle)
+ {
+ memset(fmt_handle, 0, sizeof(media_format_s));
+ }
+ else
+ {
+ return MEDIA_FORMAT_ERROR_OUT_OF_MEMORY;
+ }
+
+ fmt_handle->ref_count = 1;
+
+ *fmt = (media_format_h)fmt_handle;
+
+ return ret;
+}
+
+static void _media_format_destroy(media_format_s* fmt)
+{
+ MEDIA_FORMAT_INSTANCE_CHECK(fmt);
+
+ free(fmt);
+ fmt = NULL;
+}
+
+int media_format_get_video_info(media_format_h fmt, media_format_mimetype_e* mimetype, int* width, int* height, int* avg_bps, int* max_bps)
+{
+ int ret = MEDIA_FORMAT_ERROR_NONE;
+ MEDIA_FORMAT_INSTANCE_CHECK(fmt);
+
+ media_format_s* fmt_handle;
+ fmt_handle = (media_format_s*)fmt;
+
+ if (!(fmt_handle->mimetype & MEDIA_FORMAT_VIDEO))
+ {
+ return MEDIA_FORMAT_ERROR_INVALID_OPERATION;
+ }
+
+ if (mimetype)
+ *mimetype = fmt_handle->mimetype;
+ if (width)
+ *width = fmt_handle->detail.video.width;
+ if (height)
+ *height = fmt_handle->detail.video.height;
+ if (avg_bps)
+ *avg_bps = fmt_handle->detail.video.avg_bps;
+ if (max_bps)
+ *max_bps = fmt_handle->detail.video.max_bps;
+
+ return ret;
+}
+
+int media_format_get_audio_info(media_format_h fmt, media_format_mimetype_e* mimetype, int* channel, int* samplerate, int* bit, int* avg_bps)
+{
+ int ret = MEDIA_FORMAT_ERROR_NONE;
+ MEDIA_FORMAT_INSTANCE_CHECK(fmt);
+
+ media_format_s* fmt_handle;
+ fmt_handle = (media_format_s*)fmt;
+
+ if (!(fmt_handle->mimetype & MEDIA_FORMAT_AUDIO))
+ {
+ return MEDIA_FORMAT_ERROR_INVALID_OPERATION;
+ }
+
+ *mimetype = fmt_handle->mimetype;
+ *channel = fmt_handle->detail.audio.channel;
+ *samplerate = fmt_handle->detail.audio.samplerate;
+ *bit = fmt_handle->detail.audio.bit;
+ *avg_bps = fmt_handle->detail.audio.avg_bps;
+
+ return ret;
+}
+
+int media_format_set_video_mime(media_format_h fmt, media_format_mimetype_e mimetype)
+{
+ int ret = MEDIA_FORMAT_ERROR_NONE;
+ MEDIA_FORMAT_INSTANCE_CHECK(fmt);
+
+ if (!MEDIA_FORMAT_IS_WRITABLE(fmt))
+ {
+ LOGE("the format can not be changed..", __FUNCTION__);
+ return MEDIA_FORMAT_ERROR_INVALID_OPERATION;
+ }
+
+ media_format_s* fmt_handle;
+ fmt_handle = (media_format_s*)fmt;
+
+ if (!(mimetype & MEDIA_FORMAT_VIDEO))
+ {
+ return MEDIA_FORMAT_ERROR_INVALID_PARAMETER;
+ }
+
+ fmt_handle->mimetype = mimetype;
+
+ return ret;
+}
+
+int media_format_set_video_width(media_format_h fmt, int width)
+{
+ int ret = MEDIA_FORMAT_ERROR_NONE;
+ MEDIA_FORMAT_INSTANCE_CHECK(fmt);
+
+ if (!MEDIA_FORMAT_IS_WRITABLE(fmt))
+ {
+ LOGE("the format can not be changed..", __FUNCTION__);
+ return MEDIA_FORMAT_ERROR_INVALID_OPERATION;
+ }
+
+ media_format_s* fmt_handle;
+ fmt_handle = (media_format_s*)fmt;
+
+ if (!(fmt_handle->mimetype & MEDIA_FORMAT_VIDEO))
+ {
+ return MEDIA_FORMAT_ERROR_INVALID_PARAMETER;
+ }
+
+ fmt_handle->detail.video.width = width;
+
+ return ret;
+}
+
+int media_format_set_video_height(media_format_h fmt, int height)
+{
+ int ret = MEDIA_FORMAT_ERROR_NONE;
+ MEDIA_FORMAT_INSTANCE_CHECK(fmt);
+
+ if (!MEDIA_FORMAT_IS_WRITABLE(fmt))
+ {
+ LOGE("the format can not be changed..", __FUNCTION__);
+ return MEDIA_FORMAT_ERROR_INVALID_OPERATION;
+ }
+
+ media_format_s* fmt_handle;
+ fmt_handle = (media_format_s*)fmt;
+
+ if (!(fmt_handle->mimetype & MEDIA_FORMAT_VIDEO))
+ {
+ return MEDIA_FORMAT_ERROR_INVALID_PARAMETER;
+ }
+
+ fmt_handle->detail.video.height = height;
+
+ return ret;
+}
+
+int media_format_set_video_avg_bps(media_format_h fmt, int avg_bps)
+{
+ int ret = MEDIA_FORMAT_ERROR_NONE;
+ MEDIA_FORMAT_INSTANCE_CHECK(fmt);
+
+ if (!MEDIA_FORMAT_IS_WRITABLE(fmt))
+ {
+ LOGE("the format can not be changed..", __FUNCTION__);
+ return MEDIA_FORMAT_ERROR_INVALID_OPERATION;
+ }
+
+ media_format_s* fmt_handle;
+ fmt_handle = (media_format_s*)fmt;
+
+ if (!(fmt_handle->mimetype & MEDIA_FORMAT_VIDEO))
+ {
+ return MEDIA_FORMAT_ERROR_INVALID_PARAMETER;
+ }
+
+ fmt_handle->detail.video.avg_bps = avg_bps;
+
+ return ret;
+}
+
+int media_format_set_video_max_bps(media_format_h fmt, int max_bps)
+{
+ int ret = MEDIA_FORMAT_ERROR_NONE;
+ MEDIA_FORMAT_INSTANCE_CHECK(fmt);
+
+ if (!MEDIA_FORMAT_IS_WRITABLE(fmt))
+ {
+ LOGE("the format can not be changed..", __FUNCTION__);
+ return MEDIA_FORMAT_ERROR_INVALID_OPERATION;
+ }
+
+ media_format_s* fmt_handle;
+ fmt_handle = (media_format_s*)fmt;
+
+ if (!(fmt_handle->mimetype & MEDIA_FORMAT_VIDEO))
+ {
+ return MEDIA_FORMAT_ERROR_INVALID_PARAMETER;
+ }
+
+ fmt_handle->detail.video.max_bps = max_bps;
+
+ return ret;
+}
+
+
+int media_format_set_audio_mime(media_format_h fmt, media_format_mimetype_e mimetype)
+{
+
+ int ret = MEDIA_FORMAT_ERROR_NONE;
+ MEDIA_FORMAT_INSTANCE_CHECK(fmt);
+
+ if (!MEDIA_FORMAT_IS_WRITABLE(fmt))
+ {
+ LOGE("the format can not be changed..", __FUNCTION__);
+ return MEDIA_FORMAT_ERROR_INVALID_OPERATION;
+ }
+
+ media_format_s* fmt_handle;
+ fmt_handle = (media_format_s*)fmt;
+
+ if (!(mimetype & MEDIA_FORMAT_AUDIO))
+ {
+ return MEDIA_FORMAT_ERROR_INVALID_PARAMETER;
+ }
+
+ fmt_handle->mimetype = mimetype;
+
+ return ret;
+}
+
+int media_format_set_audio_channel(media_format_h fmt, int channel)
+{
+
+ int ret = MEDIA_FORMAT_ERROR_NONE;
+ MEDIA_FORMAT_INSTANCE_CHECK(fmt);
+
+ if (!MEDIA_FORMAT_IS_WRITABLE(fmt))
+ {
+ LOGE("the format can not be changed..", __FUNCTION__);
+ return MEDIA_FORMAT_ERROR_INVALID_OPERATION;
+ }
+
+ media_format_s* fmt_handle;
+ fmt_handle = (media_format_s*)fmt;
+
+ if (!(fmt_handle->mimetype & MEDIA_FORMAT_AUDIO))
+ {
+ return MEDIA_FORMAT_ERROR_INVALID_PARAMETER;
+ }
+
+ fmt_handle->detail.audio.channel = channel;
+
+ return ret;
+}
+
+int media_format_set_audio_samplerate(media_format_h fmt, int samplerate)
+{
+
+ int ret = MEDIA_FORMAT_ERROR_NONE;
+ MEDIA_FORMAT_INSTANCE_CHECK(fmt);
+
+ if (!MEDIA_FORMAT_IS_WRITABLE(fmt))
+ {
+ LOGE("the format can not be changed..", __FUNCTION__);
+ return MEDIA_FORMAT_ERROR_INVALID_OPERATION;
+ }
+
+ media_format_s* fmt_handle;
+ fmt_handle = (media_format_s*)fmt;
+
+ if (!(fmt_handle->mimetype & MEDIA_FORMAT_AUDIO))
+ {
+ return MEDIA_FORMAT_ERROR_INVALID_PARAMETER;
+ }
+
+ fmt_handle->detail.audio.samplerate = samplerate;
+
+ return ret;
+}
+
+int media_format_set_audio_bit(media_format_h fmt, int bit)
+{
+
+ int ret = MEDIA_FORMAT_ERROR_NONE;
+ MEDIA_FORMAT_INSTANCE_CHECK(fmt);
+
+ if (!MEDIA_FORMAT_IS_WRITABLE(fmt))
+ {
+ LOGE("the format can not be changed..", __FUNCTION__);
+ return MEDIA_FORMAT_ERROR_INVALID_OPERATION;
+ }
+
+ media_format_s* fmt_handle;
+ fmt_handle = (media_format_s*)fmt;
+
+ if (!(fmt_handle->mimetype & MEDIA_FORMAT_AUDIO))
+ {
+ return MEDIA_FORMAT_ERROR_INVALID_PARAMETER;
+ }
+
+ fmt_handle->detail.audio.bit = bit;
+
+ return ret;
+}
+
+int media_format_set_audio_avg_bps(media_format_h fmt, int avg_bps)
+{
+
+ int ret = MEDIA_FORMAT_ERROR_NONE;
+ MEDIA_FORMAT_INSTANCE_CHECK(fmt);
+
+ if (!MEDIA_FORMAT_IS_WRITABLE(fmt))
+ {
+ LOGE("the format can not be changed..", __FUNCTION__);
+ return MEDIA_FORMAT_ERROR_INVALID_OPERATION;
+ }
+
+ media_format_s* fmt_handle;
+ fmt_handle = (media_format_s*)fmt;
+
+ if (!(fmt_handle->mimetype & MEDIA_FORMAT_AUDIO))
+ {
+ return MEDIA_FORMAT_ERROR_INVALID_PARAMETER;
+ }
+
+ fmt_handle->detail.audio.avg_bps = avg_bps;
+
+ return ret;
+}
+
+int media_format_ref(media_format_h fmt)
+{
+ int ret = MEDIA_FORMAT_ERROR_NONE;
+ MEDIA_FORMAT_INSTANCE_CHECK(fmt);
+
+ media_format_s* fmt_handle;
+ fmt_handle = (media_format_s*)fmt;
+
+ if (MEDIA_FORMAT_GET_REFCOUNT(fmt) <= 0)
+ {
+ return MEDIA_FORMAT_ERROR_INVALID_OPERATION;
+ }
+
+ g_atomic_int_inc(&fmt_handle->ref_count);
+
+ return ret;
+}
+
+int media_format_unref(media_format_h fmt)
+{
+ int ret = MEDIA_FORMAT_ERROR_NONE;
+ MEDIA_FORMAT_INSTANCE_CHECK(fmt);
+ bool is_zero;
+
+ media_format_s* fmt_handle;
+ fmt_handle = (media_format_s*)fmt;
+
+ if (MEDIA_FORMAT_GET_REFCOUNT(fmt) <= 0)
+ return MEDIA_FORMAT_ERROR_INVALID_OPERATION;
+
+ is_zero = g_atomic_int_dec_and_test(&fmt_handle->ref_count);
+ if (is_zero)
+ {
+ /* if reference count become 0 , free fmt. */
+ _media_format_destroy(fmt_handle);
+ }
+
+ return ret;
+}
+
+int media_format_is_writable(media_format_h fmt, bool* is_writable)
+{
+ int ret = MEDIA_FORMAT_ERROR_NONE;
+ MEDIA_FORMAT_INSTANCE_CHECK(fmt);
+
+ media_format_s* fmt_handle;
+ fmt_handle = (media_format_s*)fmt;
+
+ if (g_atomic_int_get(&fmt_handle->ref_count) <= 0)
+ {
+ return MEDIA_FORMAT_ERROR_INVALID_OPERATION;
+ }
+
+ if (g_atomic_int_get(&fmt_handle->ref_count) == 1)
+ {
+ /* if reference count is 1, the caller must be owner. */
+ *is_writable = true;
+ }
+ else
+ {
+ *is_writable = false;
+ }
+
+ return ret;
+}
+
+int media_format_make_writable(media_format_h fmt, media_format_h* out_fmt)
+{
+ int ret = MEDIA_FORMAT_ERROR_NONE;
+ MEDIA_FORMAT_INSTANCE_CHECK(fmt);
+
+ media_format_s* fmt_handle;
+ fmt_handle = (media_format_s*)fmt;
+
+ if (MEDIA_FORMAT_IS_WRITABLE(fmt))
+ {
+ /* If there is only one reference count on @fmt, the caller must be the owner */
+ *out_fmt = fmt;
+ }
+ else
+ {
+ /* If there is more than one reference on the object, a new media_format_h object will be returned.
+ The caller's reference on @fmt will be removed, and instead the caller will own a reference to the returned object.*/
+ media_format_s* copy;
+ copy = (media_format_s*)malloc(sizeof(media_format_s));
+ if (copy)
+ {
+ memset(copy, 0, sizeof(media_format_s));
+ }
+ else
+ {
+ return MEDIA_FORMAT_ERROR_OUT_OF_MEMORY;
+ }
+
+ memcpy(copy, fmt_handle, sizeof(media_format_s));
+ copy->ref_count = 1;
+
+ if (media_format_unref(fmt) != MEDIA_FORMAT_ERROR_NONE)
+ {
+ free(copy);
+ return MEDIA_FORMAT_ERROR_INVALID_OPERATION;
+ }
+
+ *out_fmt = (media_format_h)copy;
+
+ }
+
+ return ret;
+}
+
+
--- /dev/null
+/*
+* Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <dlog.h>
+#include <media_format.h>
+#include <media_packet.h>
+#include <media_packet_private.h>
+#include <media_format_private.h>
+
+/* NOTE : static internal functions does not check anything on incomming parameters
+ * Caller should takecare it
+ */
+static int _pkt_alloc_buffer(media_packet_s* pkt);
+static uint64_t _pkt_calculate_video_buffer_size(media_packet_s* pkt);
+static uint64_t _pkt_calculate_audio_buffer_size(media_packet_s* pkt);
+static uint32_t _convert_to_tbm_surface_format(media_format_mimetype_e format_type);
+
+int media_packet_create_alloc(media_format_h fmt, media_packet_finalize_cb fcb, void *fcb_data, media_packet_h *packet)
+{
+ media_packet_s* handle;
+ int ret = MEDIA_PACKET_ERROR_NONE;
+
+ MEDIA_PACKET_INSTANCE_CHECK(fmt);
+ MEDIA_PACKET_NULL_ARG_CHECK(packet);
+ /* TODO : need more validation on fmt */
+
+ handle = (media_packet_s*)malloc(sizeof(media_packet_s));
+ if (handle != NULL)
+ memset(handle, 0, sizeof(media_packet_s));
+ else
+ {
+ LOGE("[%s] MEDIA_PACKET_ERROR_OUT_OF_MEMORY(0x%08x)" ,__FUNCTION__, MEDIA_PACKET_ERROR_OUT_OF_MEMORY);
+ return MEDIA_PACKET_ERROR_OUT_OF_MEMORY;
+ }
+
+ /* TODO : need to consider to give application to select buffer type(tbm or heap) */
+
+ /* check if tbm surface is needed.
+ * This time, Only raw video format is considered to be allocated in TBM
+ */
+ if (MEDIA_FORMAT_IS_VIDEO(fmt) && MEDIA_FORMAT_IS_RAW(fmt))
+ {
+ handle->type = MEDIA_BUFFER_TYPE_TBM_SURFACE;
+ }
+ else
+ {
+ handle->type = MEDIA_BUFFER_TYPE_NORMAL;
+ }
+
+ /* take fmt */
+ handle->format = MEDIA_FORMAT_CAST(fmt);
+
+ /* alloc buffer */
+ int err = _pkt_alloc_buffer(handle);
+ if (err != MEDIA_PACKET_ERROR_NONE)
+ {
+ LOGE("[%s] MEDIA_PACKET_ERROR_OUT_OF_MEMORY(0x%08x)", __FUNCTION__, MEDIA_PACKET_ERROR_OUT_OF_MEMORY);
+ ret = err;
+ goto fail;
+ }
+
+ /* allocated buffer */
+ handle->is_allocated = true;
+
+ /* set finalized callback and user data */
+ handle->finalizecb_func = fcb;
+ handle->userdata = fcb_data;
+
+ /* increase format reference count */
+ media_format_ref((media_format_h)handle->format);
+
+ /* take handle */
+ *packet = (media_packet_h)handle;
+ LOGI("[%s] new handle : %p", __FUNCTION__, *packet);
+ return ret;
+
+fail:
+
+ if (handle)
+ {
+ free(handle);
+ handle = NULL;
+ }
+
+ *packet = NULL;
+ return ret;
+}
+
+int media_packet_create(media_format_h fmt, media_packet_finalize_cb fcb, void *fcb_data, media_packet_h *packet)
+{
+ media_packet_s* handle;
+ int ret = MEDIA_PACKET_ERROR_NONE;
+
+ MEDIA_PACKET_INSTANCE_CHECK(fmt);
+ MEDIA_PACKET_NULL_ARG_CHECK(packet);
+ /* TODO : need more validation on fmt */
+
+ handle = (media_packet_s*)malloc(sizeof(media_packet_s));
+ if (handle != NULL)
+ memset(handle, 0, sizeof(media_packet_s));
+ else
+ {
+ LOGE("[%s] MEDIA_PACKET_ERROR_OUT_OF_MEMORY(0x%08x)" ,__FUNCTION__, MEDIA_PACKET_ERROR_OUT_OF_MEMORY);
+ return MEDIA_PACKET_ERROR_OUT_OF_MEMORY;
+ }
+
+ /* TODO : need to consider to give application to select buffer type(tbm or heap) */
+
+ /* check if tbm surface is needed.
+ * This time, Only raw video format is considered to be allocated in TBM
+ */
+ if (MEDIA_FORMAT_IS_VIDEO(fmt) && MEDIA_FORMAT_IS_RAW(fmt))
+ {
+ handle->type = MEDIA_BUFFER_TYPE_TBM_SURFACE;
+ }
+ else
+ {
+ handle->type = MEDIA_BUFFER_TYPE_NORMAL;
+ }
+
+ /* take fmt */
+ handle->format = MEDIA_FORMAT_CAST(fmt);
+
+ /* NOT allocated buffer */
+ handle->is_allocated = false;
+
+ /* set finalized callback and user data */
+ handle->finalizecb_func = fcb;
+ handle->userdata = fcb_data;
+
+ /* increase format reference count */
+ media_format_ref((media_format_h)handle->format);
+
+ /* take handle */
+ *packet = (media_packet_h)handle;
+ LOGI("[%s] new handle : %p", __FUNCTION__, *packet);
+ return ret;
+
+}
+
+int media_packet_copy(media_packet_h org_packet, media_packet_finalize_cb fcb, void *fcb_data, media_packet_h* new_packet)
+{
+ media_packet_s* handle;
+ media_packet_s* org_handle;
+
+ int ret = MEDIA_PACKET_ERROR_NONE;
+
+ MEDIA_PACKET_INSTANCE_CHECK(org_packet);
+ MEDIA_PACKET_NULL_ARG_CHECK(new_packet);
+
+ org_handle = (media_packet_s*)org_packet;
+
+ handle = (media_packet_s*)malloc(sizeof(media_packet_s));
+ if (handle != NULL)
+ memset(handle, 0, sizeof(media_packet_s));
+ else
+ {
+ LOGE("[%s] MEDIA_PACKET_ERROR_OUT_OF_MEMORY(0x%08x)" ,__FUNCTION__, MEDIA_PACKET_ERROR_OUT_OF_MEMORY);
+ return MEDIA_PACKET_ERROR_OUT_OF_MEMORY;
+ }
+
+ /* copy handle*/
+ memcpy(handle, org_handle, sizeof(media_packet_s));
+
+ /* the caller can not get exist allocated buffer pointer */
+ handle->data = NULL;
+ handle->surface_data = NULL;
+ handle->is_allocated = false;
+ handle->size = 0;
+
+ /* set finalized callback and user data */
+ handle->finalizecb_func = fcb;
+ handle->userdata = fcb_data;
+
+ /* increase format reference count */
+ media_format_ref((media_format_h)handle->format);
+
+ /* take handle */
+ *new_packet = (media_packet_h)handle;
+ LOGI("[%s] new handle : %p", __FUNCTION__, *new_packet);
+ return ret;
+
+}
+
+int media_packet_alloc(media_packet_h packet)
+{
+ LOGI("[%s] start", __FUNCTION__);
+ media_packet_s* handle;
+ int ret = MEDIA_PACKET_ERROR_NONE;
+
+ MEDIA_PACKET_INSTANCE_CHECK(packet);
+
+ handle = (media_packet_s*) packet;
+
+ /* alloc buffer */
+ int err = _pkt_alloc_buffer(handle);
+ if (err != MEDIA_PACKET_ERROR_NONE)
+ {
+ LOGE("[%s] MEDIA_PACKET_ERROR_OUT_OF_MEMORY(0x%08x)", __FUNCTION__, MEDIA_PACKET_ERROR_OUT_OF_MEMORY);
+ ret = err;
+ goto fail;
+ }
+
+ /* allocated buffer */
+ handle->is_allocated = true;
+
+ LOGI("[%s] end", __FUNCTION__);
+ return ret;
+
+fail:
+ if(handle)
+ {
+ free(handle);
+ handle = NULL;
+ }
+ return ret;
+
+}
+
+
+int _pkt_alloc_buffer(media_packet_s* pkt)
+{
+ /* skip validating pkt */
+ uint64_t buffersize = 0;
+
+ /* need to use format,width,height to get buffer size for raw video frame */
+ if (pkt->type == MEDIA_BUFFER_TYPE_TBM_SURFACE)
+ {
+ buffersize = _pkt_calculate_video_buffer_size(pkt);
+ pkt->size = buffersize;
+ /* NOTE : size of buffer may not equal to w*h*bpp. Not sure we need to
+ * do some verifying between given size and calculated size.
+ */
+ }
+ else
+ {
+ buffersize = pkt->size;
+ }
+
+ if (pkt->type == MEDIA_BUFFER_TYPE_NORMAL)
+ {
+ /* need to use format,width,height to get buffer size */
+ if (MEDIA_FORMAT_IS_VIDEO(pkt->format))
+ {
+ buffersize = _pkt_calculate_video_buffer_size(pkt);
+ pkt->data = (void*)malloc(buffersize);
+ if (!pkt->data)
+ {
+ return MEDIA_PACKET_ERROR_OUT_OF_MEMORY;
+ }
+ }
+ else
+ {
+ buffersize = _pkt_calculate_audio_buffer_size(pkt);
+ pkt->data = (void*)malloc(buffersize);
+ if (!pkt->data)
+ {
+ return MEDIA_PACKET_ERROR_OUT_OF_MEMORY;
+ }
+ }
+ pkt->size = buffersize;
+ }
+ else if (pkt->type == MEDIA_BUFFER_TYPE_TBM_SURFACE)
+ {
+
+ /* convert to tbm_format*/
+ uint32_t tbm_format;
+ tbm_format = _convert_to_tbm_surface_format(pkt->format->mimetype);
+
+#if 0
+ /*check whether given tbm_format is supported or not*/
+ uint32_t *supported_formats;
+ uint32_t supported_format_num;
+ bool is_supported_format;
+ int i;
+
+ if (tbm_surface_query_formats(&supported_formats, &supported_format_num))
+ {
+ is_supported_format = false;
+ for (i = 0 ; i < supported_format_num ; i++)
+ {
+ if (supported_formats[i] == tbm_format)
+ {
+ is_supported_format = true;
+ break;
+ }
+ }
+
+ free (supported_formats);
+ }
+ else
+ {
+ /* tbm_surface_query_format returns error */
+ LOGE("tbm_surface_query_format is failed..");
+ return MEDIA_PACKET_ERROR_INVALID_OPERATION;
+ }
+
+ /* if not supported tbm_format by backend, don't need to do tbm_surface_create() */
+ if (!is_supported_format)
+ {
+ LOGE("the backend doesn't support 0x%x mimetype", pkt->format->mimetype);
+ return MEDIA_PACKET_ERROR_INVALID_OPERATION;
+ }
+#endif
+ /*create tbm_surface*/
+ pkt->surface_data = (void*)tbm_surface_create(pkt->format->detail.video.width, pkt->format->detail.video.height, tbm_format);
+ if (pkt->surface_data != NULL)
+ {
+
+ /* get tbm_surface_info */
+ tbm_surface_info_s surface_info;
+ int err = tbm_surface_get_info((tbm_surface_h)pkt->surface_data, &surface_info);
+ if (err == TBM_SURFACE_ERROR_NONE)
+ {
+ pkt->data = surface_info.planes[0].ptr;
+ pkt->size = (uint64_t)surface_info.size;
+ }
+ else
+ {
+ tbm_surface_destroy((tbm_surface_h)pkt->surface_data);
+ return MEDIA_PACKET_ERROR_INVALID_OPERATION;
+ }
+ }
+ else
+ {
+ LOGE("\n tbm_surface_create() is failed!! \n");
+ return MEDIA_PACKET_ERROR_INVALID_OPERATION;
+ }
+
+ }
+ return MEDIA_PACKET_ERROR_NONE;
+}
+
+/* TODO : contact Kim Young Hun to make below api as a common */
+static uint64_t _pkt_calculate_video_buffer_size(media_packet_s* pkt)
+{
+/* TODO : rename below macro or make it able to use original from mm_transform */
+#define _ROUND_UP_4(num) (((num)+3)&~3)
+#define _GEN_MASK(x) ((1<<(x))-1)
+#define _ROUND_UP_X(v,x) (((v) + _GEN_MASK(x)) & ~_GEN_MASK(x))
+#define _DIV_ROUND_UP_X(v,x) (((v) + _GEN_MASK(x)) >> (x))
+#define MAX(a, b) (((a) > (b)) ? (a) : (b))
+
+ unsigned char x_chroma_shift = 0;
+ unsigned char y_chroma_shift = 0;
+ int size, w2, h2, size2;
+ int stride, stride2;
+ int width = 0;
+ int height = 0;
+ uint64_t buffersize = 0;
+
+ if (MEDIA_FORMAT_IS_VIDEO(pkt->format)) {
+ width = pkt->format->detail.video.width;
+ height = pkt->format->detail.video.height;
+ }
+
+ /* TODO : need to check type mapping again with mm_transform */
+ switch (pkt->format->mimetype)
+ {
+
+ case MEDIA_FORMAT_I420:
+ //case MM_UTIL_IMG_FMT_YUV420:
+ x_chroma_shift = 1;
+ y_chroma_shift = 1;
+ stride = _ROUND_UP_4 (width);
+ h2 = _ROUND_UP_X (height, x_chroma_shift);
+ size = stride * h2;
+ w2 = _DIV_ROUND_UP_X (width, x_chroma_shift);
+ stride2 = _ROUND_UP_4 (w2);
+ h2 = _DIV_ROUND_UP_X (height, y_chroma_shift);
+ size2 = stride2 * h2;
+ buffersize = size + 2 * size2;
+ break;
+
+ //case MM_UTIL_IMG_FMT_YUV422:
+ case MEDIA_FORMAT_YUYV:
+ case MEDIA_FORMAT_UYVY:
+ case MEDIA_FORMAT_NV16:
+ //case MM_UTIL_IMG_FMT_NV61:
+ stride = _ROUND_UP_4 (width * 2);
+ size = stride * height;
+ buffersize = size;
+ break;
+
+ case MEDIA_FORMAT_RGB565:
+ stride = _ROUND_UP_4 (width * 2);
+ size = stride * height;
+ buffersize = size;
+ break;
+
+ case MEDIA_FORMAT_RGB888:
+ stride = _ROUND_UP_4 (width * 3);
+ size = stride * height;
+ buffersize = size;
+ break;
+
+ case MEDIA_FORMAT_ARGB:
+ //case MM_UTIL_IMG_FMT_BGRA8888:
+ case MEDIA_FORMAT_RGBA:
+ //case MM_UTIL_IMG_FMT_BGRX8888:
+ stride = width * 4;
+ size = stride * height;
+ buffersize = size;
+ break;
+
+ case MEDIA_FORMAT_NV12:
+ case MEDIA_FORMAT_NV12T:
+ case MEDIA_FORMAT_H261:
+ case MEDIA_FORMAT_H263:
+ case MEDIA_FORMAT_H263P:
+ case MEDIA_FORMAT_H264_SP:
+ case MEDIA_FORMAT_H264_MP:
+ case MEDIA_FORMAT_H264_HP:
+ case MEDIA_FORMAT_MJPEG:
+ case MEDIA_FORMAT_MPEG1:
+ case MEDIA_FORMAT_MPEG2_SP:
+ case MEDIA_FORMAT_MPEG2_MP:
+ case MEDIA_FORMAT_MPEG2_HP:
+ case MEDIA_FORMAT_MPEG4_SP:
+ case MEDIA_FORMAT_MPEG4_ASP:
+ x_chroma_shift = 1;
+ y_chroma_shift = 1;
+ stride = _ROUND_UP_4 (width);
+ h2 = _ROUND_UP_X (height, y_chroma_shift);
+ size = stride * h2;
+ w2 = 2 * _DIV_ROUND_UP_X (width, x_chroma_shift);
+ stride2 = _ROUND_UP_4 (w2);
+ h2 = _DIV_ROUND_UP_X (height, y_chroma_shift);
+ size2 = stride2 * h2;
+ buffersize = size + size2;
+ break;
+ default:
+ LOGE("Not supported format\n");
+ return 0;
+ }
+
+ LOGD("format 0x%x, buffersize %llu\n", pkt->format->mimetype, buffersize);
+
+ return buffersize;
+}
+
+/* TODO : written by joungkook seo for audio */
+static uint64_t _pkt_calculate_audio_buffer_size(media_packet_s* pkt)
+{
+/* TODO : rename below macro or make it able to use original from mm_transform */
+#define PCM_MIN_FRM_SIZE (1024)
+#define AAC_MIN_FRM_SIZE (1024)
+#define AAC_MIN_NCH (2)
+
+ int channel = 0;
+ int bit = 0;
+ uint64_t buffersize = 0;
+
+ if (!MEDIA_FORMAT_IS_VIDEO(pkt->format)) {
+ channel = pkt->format->detail.audio.channel;
+ bit = pkt->format->detail.audio.bit;
+ }
+
+ /* TODO : need to check type mapping again with mm_transform */
+ switch (pkt->format->mimetype)
+ {
+ case MEDIA_FORMAT_PCM:
+ buffersize = (PCM_MIN_FRM_SIZE * channel) * (uint64_t)(bit /8);
+ break;
+ case MEDIA_FORMAT_AAC:
+ buffersize = (AAC_MIN_FRM_SIZE * AAC_MIN_NCH) * (uint64_t)(2); /* 2 = (16bit/8)*/
+ break;
+ default:
+ LOGE("Not supported format\n");
+ return 0;
+ }
+
+ LOGD("format 0x%x, buffersize %llu\n", pkt->format->mimetype, buffersize);
+
+ return buffersize;
+}
+
+int media_packet_create_from_tbm_surface(media_format_h fmt, tbm_surface_h surface, media_packet_finalize_cb fcb, void *fcb_data, media_packet_h *packet)
+{
+ media_packet_s* handle;
+ int ret = MEDIA_PACKET_ERROR_NONE;
+
+ if (surface == NULL)
+ return MEDIA_PACKET_ERROR_INVALID_PARAMETER;
+
+ MEDIA_PACKET_INSTANCE_CHECK(fmt);
+ MEDIA_PACKET_INSTANCE_CHECK(surface);
+ MEDIA_PACKET_NULL_ARG_CHECK(packet);
+ /* TODO : need more validation on fmt */
+
+ handle = (media_packet_s*)malloc( sizeof(media_packet_s));
+ if (handle != NULL)
+ {
+ memset(handle, 0 , sizeof(media_packet_s));
+ }
+ else
+ {
+ LOGE("[%s] MEDIA_PACKET_ERROR_OUT_OF_MEMORY(0x%08x)" ,__FUNCTION__,MEDIA_PACKET_ERROR_OUT_OF_MEMORY);
+ return MEDIA_PACKET_ERROR_OUT_OF_MEMORY;
+ }
+
+ handle->type = MEDIA_BUFFER_TYPE_EXTERNAL_TBM_SURFACE;
+ handle->surface_data = (void*)surface;
+
+ /* alloc handle->format */
+ handle->format = MEDIA_FORMAT_CAST(fmt);
+
+ /* get tbm_surface_info */
+ tbm_surface_info_s surface_info;
+ int err = tbm_surface_get_info((tbm_surface_h)handle->surface_data, &surface_info);
+ if (err == TBM_SURFACE_ERROR_NONE)
+ {
+ handle->data = surface_info.planes[0].ptr;
+ handle->size = (uint64_t)surface_info.size;
+ }
+ else
+ {
+ ret = MEDIA_PACKET_ERROR_INVALID_OPERATION;
+ goto fail;
+ }
+
+ /* allocated buffer */
+ handle->is_allocated = true;
+
+ /* set finalized callback and user data */
+ handle->finalizecb_func = fcb;
+ handle->userdata = fcb_data;
+
+ /* increase format reference count */
+ ret = media_format_ref((media_format_h)handle->format);
+
+ /* take handle */
+ *packet = (media_packet_h)handle;
+ LOGI("[%s] new handle : %p", __FUNCTION__, *packet);
+ return ret;
+
+fail:
+
+ if (handle)
+ {
+ free(handle);
+ handle = NULL;
+ }
+
+ *packet = NULL;
+ return ret;
+}
+
+int media_packet_get_buffer_data_ptr(media_packet_h packet, void **data)
+{
+ media_packet_s* handle;
+ int ret = MEDIA_PACKET_ERROR_NONE;
+
+ MEDIA_PACKET_INSTANCE_CHECK(packet);
+ MEDIA_PACKET_NULL_ARG_CHECK(data);
+
+ handle = (media_packet_s*) packet;
+
+ *data = handle->data;
+
+ return ret;
+
+}
+
+int media_packet_get_tbm_surface(media_packet_h packet, tbm_surface_h *surface)
+{
+ media_packet_s* handle;
+ int ret = MEDIA_PACKET_ERROR_NONE;
+
+ MEDIA_PACKET_INSTANCE_CHECK(packet);
+ MEDIA_PACKET_NULL_ARG_CHECK(surface);
+
+ handle = (media_packet_s*) packet;
+
+ *surface = (tbm_surface_h)handle->surface_data;
+
+ return ret;
+}
+
+int media_packet_get_format(media_packet_h packet, media_format_h *fmt)
+{
+ media_packet_s* handle;
+ int ret = MEDIA_PACKET_ERROR_NONE;
+
+ MEDIA_PACKET_INSTANCE_CHECK(packet);
+ MEDIA_PACKET_NULL_ARG_CHECK(fmt);
+
+ handle = (media_packet_s*) packet;
+
+ /* ref exist format */
+ media_format_ref((media_format_h)handle->format);
+
+ *fmt = (media_format_h)handle->format;
+
+ return ret;
+}
+
+int media_packet_set_format(media_packet_h packet, media_format_h fmt)
+{
+ media_packet_s* handle;
+ int ret = MEDIA_PACKET_ERROR_NONE;
+
+ MEDIA_PACKET_INSTANCE_CHECK(packet);
+ MEDIA_PACKET_NULL_ARG_CHECK(fmt);
+
+ handle = (media_packet_s*) packet;
+
+ /* if trying to set same format, return*/
+ if (handle->format == MEDIA_FORMAT_CAST(fmt))
+ {
+ return MEDIA_PACKET_ERROR_INVALID_OPERATION;
+ }
+
+ /* unref exist format */
+ media_format_unref((media_format_h)handle->format);
+
+ /* set as new format to packet */
+ handle->format = MEDIA_FORMAT_CAST(fmt);
+
+ /* ref new format */
+ media_format_ref(fmt);
+
+ return ret;
+}
+
+int media_packet_set_pts(media_packet_h packet, uint64_t pts)
+{
+ media_packet_s* handle;
+ int ret = MEDIA_PACKET_ERROR_NONE;
+
+ MEDIA_PACKET_INSTANCE_CHECK(packet);
+
+ handle = (media_packet_s*) packet;
+
+ handle->pts = pts;
+
+ return ret;
+}
+
+int media_packet_set_dts(media_packet_h packet, uint64_t dts)
+{
+ media_packet_s* handle;
+ int ret = MEDIA_PACKET_ERROR_NONE;
+
+ MEDIA_PACKET_INSTANCE_CHECK(packet);
+
+ handle = (media_packet_s*) packet;
+
+ handle->dts = dts;
+
+ return ret;
+}
+
+int media_packet_set_duration(media_packet_h packet, uint64_t duration)
+{
+ media_packet_s* handle;
+ int ret = MEDIA_PACKET_ERROR_NONE;
+
+ MEDIA_PACKET_INSTANCE_CHECK(packet);
+
+ handle = (media_packet_s*) packet;
+
+ handle->duration = duration;
+
+ return ret;
+}
+
+int media_packet_set_buffer_size(media_packet_h packet, uint64_t size)
+{
+ media_packet_s* handle;
+ int ret = MEDIA_PACKET_ERROR_NONE;
+
+ MEDIA_PACKET_INSTANCE_CHECK(packet);
+
+ handle = (media_packet_s*) packet;
+
+ handle->size = size;
+
+ return ret;
+}
+
+int media_packet_get_pts(media_packet_h packet, uint64_t *pts)
+{
+ media_packet_s* handle;
+ int ret = MEDIA_PACKET_ERROR_NONE;
+
+ MEDIA_PACKET_INSTANCE_CHECK(packet);
+ MEDIA_PACKET_NULL_ARG_CHECK(pts);
+
+ handle = (media_packet_s*) packet;
+
+ *pts = handle->pts;
+
+ return ret;
+}
+
+int media_packet_get_dts(media_packet_h packet, uint64_t *dts)
+{
+ media_packet_s* handle;
+ int ret = MEDIA_PACKET_ERROR_NONE;
+
+ MEDIA_PACKET_INSTANCE_CHECK(packet);
+ MEDIA_PACKET_NULL_ARG_CHECK(dts);
+
+ handle = (media_packet_s*) packet;
+
+ *dts = handle->dts;
+
+ return ret;
+}
+
+int media_packet_get_duration(media_packet_h packet, uint64_t *duration)
+{
+ media_packet_s* handle;
+ int ret = MEDIA_PACKET_ERROR_NONE;
+
+ MEDIA_PACKET_INSTANCE_CHECK(packet);
+ MEDIA_PACKET_NULL_ARG_CHECK(duration);
+
+ handle = (media_packet_s*) packet;
+
+ *duration = handle->duration;
+
+ return ret;
+}
+
+int media_packet_get_buffer_size(media_packet_h packet, uint64_t *size)
+{
+ media_packet_s* handle;
+ int ret = MEDIA_PACKET_ERROR_NONE;
+
+ MEDIA_PACKET_INSTANCE_CHECK(packet);
+ MEDIA_PACKET_NULL_ARG_CHECK(size);
+
+ handle = (media_packet_s*) packet;
+
+ *size = handle->size;
+
+ return ret;
+}
+
+int media_packet_set_extra(media_packet_h packet, void *extra)
+{
+ media_packet_s* handle;
+ int ret = MEDIA_PACKET_ERROR_NONE;
+
+ MEDIA_PACKET_INSTANCE_CHECK(packet);
+ MEDIA_PACKET_NULL_ARG_CHECK(extra);
+
+ handle = (media_packet_s*) packet;
+
+ handle->extradata = extra;
+
+ return ret;
+}
+
+int media_packet_get_extra(media_packet_h packet, void **extra)
+{
+ media_packet_s* handle;
+ int ret = MEDIA_PACKET_ERROR_NONE;
+
+ MEDIA_PACKET_INSTANCE_CHECK(packet);
+ MEDIA_PACKET_NULL_ARG_CHECK(extra);
+
+ handle = (media_packet_s*) packet;
+
+ *extra = handle->extradata;
+
+ return ret;
+}
+
+int media_packet_is_video(media_packet_h packet, bool *is_video)
+{
+ media_packet_s* handle;
+ int ret = MEDIA_PACKET_ERROR_NONE;
+
+ MEDIA_PACKET_INSTANCE_CHECK(packet);
+ MEDIA_PACKET_NULL_ARG_CHECK(is_video);
+
+ handle = (media_packet_s*) packet;
+
+ if (MEDIA_FORMAT_IS_VIDEO(handle->format))
+ *is_video = true;
+ else
+ *is_video = false;
+
+ return ret;
+}
+
+int media_packet_is_audio(media_packet_h packet, bool *is_audio)
+{
+ media_packet_s* handle;
+ int ret = MEDIA_PACKET_ERROR_NONE;
+
+ MEDIA_PACKET_INSTANCE_CHECK(packet);
+ MEDIA_PACKET_NULL_ARG_CHECK(is_audio);
+
+ handle = (media_packet_s*) packet;
+
+ if (MEDIA_FORMAT_IS_AUDIO(handle->format))
+ *is_audio = true;
+ else
+ *is_audio = false;
+
+ return ret;
+}
+
+int media_packet_is_encoded(media_packet_h packet, bool *is_encoded)
+{
+ media_packet_s* handle;
+ int ret = MEDIA_PACKET_ERROR_NONE;
+
+ MEDIA_PACKET_INSTANCE_CHECK(packet);
+ MEDIA_PACKET_NULL_ARG_CHECK(is_encoded);
+
+ handle = (media_packet_s*) packet;
+
+ if (MEDIA_FORMAT_IS_ENCODED(handle->format))
+ *is_encoded = true;
+ else
+ *is_encoded = false;
+
+ return ret;
+}
+
+int media_packet_is_raw(media_packet_h packet, bool *is_raw)
+{
+ media_packet_s* handle;
+ int ret = MEDIA_PACKET_ERROR_NONE;
+
+ MEDIA_PACKET_INSTANCE_CHECK(packet);
+ MEDIA_PACKET_NULL_ARG_CHECK(is_raw);
+
+ handle = (media_packet_s*) packet;
+
+ if (MEDIA_FORMAT_IS_RAW(handle->format))
+ *is_raw = true;
+ else
+ *is_raw = false;
+
+ return ret;
+}
+
+int media_packet_set_flags(media_packet_h packet, media_buffer_flags_e flags)
+{
+ media_packet_s* handle;
+ int ret = MEDIA_PACKET_ERROR_NONE;
+
+ MEDIA_PACKET_INSTANCE_CHECK(packet);
+
+ handle = (media_packet_s*) packet;
+
+ handle->flags |= flags;
+
+ return ret;
+}
+
+int media_packet_unset_flags(media_packet_h packet, media_buffer_flags_e flags)
+{
+ media_packet_s* handle;
+ int ret = MEDIA_PACKET_ERROR_NONE;
+
+ MEDIA_PACKET_INSTANCE_CHECK(packet);
+
+ handle = (media_packet_s*) packet;
+
+ handle->flags &= ~flags;
+
+ return ret;
+}
+
+int media_packet_is_codec_config(media_packet_h packet, bool *is_codec_config)
+{
+ media_packet_s* handle;
+ int ret = MEDIA_PACKET_ERROR_NONE;
+
+ MEDIA_PACKET_INSTANCE_CHECK(packet);
+ MEDIA_PACKET_NULL_ARG_CHECK(is_codec_config);
+
+ handle = (media_packet_s*) packet;
+
+ if (MEDIA_PACKET_CODEC_CONFIG_DATA(packet))
+ *is_codec_config = true;
+ else
+ *is_codec_config = false;
+
+ return ret;
+}
+
+int media_packet_is_end_of_stream(media_packet_h packet, bool *is_eos)
+{
+ media_packet_s* handle;
+ int ret = MEDIA_PACKET_ERROR_NONE;
+
+ MEDIA_PACKET_INSTANCE_CHECK(packet);
+ MEDIA_PACKET_NULL_ARG_CHECK(is_eos);
+
+ handle = (media_packet_s*) packet;
+
+ if (MEDIA_PACKET_CODEC_END_OF_STREAM(packet))
+ *is_eos = true;
+ else
+ *is_eos = false;
+
+ return ret;
+}
+
+int media_packet_is_sync_frame(media_packet_h packet, bool *is_sync)
+{
+ media_packet_s* handle;
+ int ret = MEDIA_PACKET_ERROR_NONE;
+
+ MEDIA_PACKET_INSTANCE_CHECK(packet);
+ MEDIA_PACKET_NULL_ARG_CHECK(is_sync);
+
+ handle = (media_packet_s*) packet;
+
+ if (MEDIA_PACKET_CODEC_SYNC_FRAME(packet))
+ *is_sync = true;
+ else
+ *is_sync = false;
+
+ return ret;
+}
+
+int media_packet_has_tbm_surface_buffer(media_packet_h packet, bool* has_tbm_surface)
+{
+ media_packet_s* handle;
+ int ret = MEDIA_PACKET_ERROR_NONE;
+
+ MEDIA_PACKET_INSTANCE_CHECK(packet);
+ MEDIA_PACKET_NULL_ARG_CHECK(has_tbm_surface);
+
+ handle = (media_packet_s*) packet;
+
+ if ((handle->type == MEDIA_BUFFER_TYPE_TBM_SURFACE || handle->type == MEDIA_BUFFER_TYPE_EXTERNAL_TBM_SURFACE) && handle->surface_data)
+ {
+ *has_tbm_surface = true;
+ }
+ else
+ {
+ *has_tbm_surface = false;
+ }
+ return ret;
+}
+
+int media_packet_destroy(media_packet_h packet)
+{
+ media_packet_s* handle;
+ int ret = MEDIA_PACKET_ERROR_NONE;
+
+ MEDIA_PACKET_INSTANCE_CHECK(packet);
+
+ handle = (media_packet_s*) packet;
+
+ /* finailize callback */
+ if (handle->finalizecb_func)
+ {
+ int finalize_cb_ret;
+ finalize_cb_ret = handle->finalizecb_func((media_packet_h)handle, MEDIA_PACKET_ERROR_NONE, handle->userdata);
+
+ /* creator do not want to destroy media packet handle*/
+ if(finalize_cb_ret == MEDIA_PACKET_REUSE)
+ {
+ LOGI("the media packet handle will be reused.");
+ return MEDIA_PACKET_ERROR_NONE;
+ }
+ }
+
+ if(handle->type == MEDIA_BUFFER_TYPE_TBM_SURFACE)
+ {
+ if(handle->surface_data)
+ {
+ tbm_surface_destroy((tbm_surface_h)handle->surface_data);
+ }
+ }
+ else if (handle->type == MEDIA_BUFFER_TYPE_NORMAL)
+ {
+ if(handle->data)
+ {
+ free(handle->data);
+ handle->data = NULL;
+ }
+ }
+ else if (handle->type == MEDIA_BUFFER_TYPE_EXTERNAL_TBM_SURFACE)
+ {
+ // there is nothing to do
+ }
+
+ /* unreference media_format */
+ media_format_unref(handle->format);
+
+ free(handle);
+ handle = NULL;
+
+ return ret;
+}
+
+static uint32_t _convert_to_tbm_surface_format(media_format_mimetype_e format_type)
+{
+ uint32_t tbm_format;
+
+ switch(format_type) {
+ case MEDIA_FORMAT_NV12:
+ case MEDIA_FORMAT_NV12T:
+ tbm_format = TBM_FORMAT_NV12;
+ break;
+ case MEDIA_FORMAT_NV16:
+ tbm_format = TBM_FORMAT_NV16;
+ break;
+ case MEDIA_FORMAT_NV21:
+ tbm_format = TBM_FORMAT_NV21;
+ break;
+ case MEDIA_FORMAT_YUYV:
+ tbm_format = TBM_FORMAT_YUYV;
+ break;
+ case MEDIA_FORMAT_UYVY:
+ tbm_format = TBM_FORMAT_UYVY;
+ break;
+ case MEDIA_FORMAT_422P:
+ tbm_format = TBM_FORMAT_YUV422;
+ break;
+ case MEDIA_FORMAT_I420:
+ tbm_format = TBM_FORMAT_YUV420;
+ break;
+ case MEDIA_FORMAT_YV12:
+ tbm_format = TBM_FORMAT_YVU420;
+ break;
+ case MEDIA_FORMAT_RGB565:
+ tbm_format = TBM_FORMAT_RGB565;
+ break;
+ case MEDIA_FORMAT_RGB888:
+ tbm_format = TBM_FORMAT_RGB888;
+ break;
+ case MEDIA_FORMAT_RGBA:
+ tbm_format = TBM_FORMAT_RGBA8888;
+ break;
+ case MEDIA_FORMAT_ARGB:
+ tbm_format = TBM_FORMAT_ARGB8888;
+ break;
+ default:
+ LOGE("Invalid format mime type!");
+ tbm_format = 0;
+ break;
+ }
+
+ return tbm_format;
+}
+
+
+#if 0
+int media_tool_create(mediatool_h *mediatool)
+{
+ MediaTool_s *handle;
+ int ret;
+ handle = (MediaTool_s*)malloc(sizeof(MediaTool_s));
+
+ if (handle != NULL)
+ memset(handle, 0, sizeof(MediaTool_s));
+ else
+ return MEDIA_TOOL_ERROR_OUT_OF_MEMORY;
+
+ //TODO : make _media_tool_create function
+ //ret = _media_tool_create(&handle->mediatool_handle);
+ if(ret != MEDIA_TOOL_ERROR_NONE)
+ {
+ free(handle);
+ handle = NULL;
+ return MEDIA_TOOL_ERROR_INVALID_OPERATION;
+ }
+ else
+ {
+ *mediatool = (mediatool_h*)handle;
+ handle->refcount = 1;
+ return MEDIA_TOOL_ERROR_NONE;
+ }
+}
+
+int media_tool_destroy(mediatool_h mediatool)
+{
+ MediaTool_s* handle = (MediaTool_s *) mediatool;
+ int ret;
+
+ if (handle == NULL)
+ return MEDIA_TOOL_ERROR_INVALID_PARAMETER;
+
+ //TODO : make _media_tool_create function
+ ret = _media_tool_destroy(handle->mediatool_handle);
+ if (ret != MEDIA_TOOL_ERROR_NONE)
+ {
+ return MEDIA_TOOL_ERROR_INVALID_OPERATION;
+ }
+ else
+ {
+ free(handle);
+ handle = NULL;
+ return MEDIA_TOOL_ERROR_NONE;
+ }
+}
+
+int media_tool_is_Iframe(mediatool_h mediatool, bool *isIFrame)
+{
+ MediaTool_s *handle = (MediaTool_s *) mediatool;
+ int ret;
+ if (handle == NULL)
+ return MEDIA_TOOL_ERROR_INVALID_PARAMETER;
+
+ *isIFrame = handle->videocodecformat->isIFrame;
+
+ return MEDIA_TOOL_ERROR_NONE;
+}
+
+int media_tool_set_buffer(mediatool_h mediatool, MediaToolBufferPrivate_s* privBuffer)
+{
+ MediaTool_s *handle = (MediaTool_s *) mediatool;
+ int ret;
+ handle->bufferpriv = (MediaToolBufferPrivate_s *)malloc(sizeof(MediaToolBufferPrivate_s));
+
+ if (handle->bufferpriv != NULL)
+ memset(handle->bufferpriv, 0, sizeof(MediaToolBufferPrivate_s));
+ else
+ return MEDIA_TOOL_ERROR_OUT_OF_MEMORY;
+
+ return MEDIA_TOOL_ERROR_NONE;
+}
+
+int media_tool_get_buffer(mediatool_h mediatool, MediaToolBufferPrivate_s** privBuffer)
+{
+ MediaTool_s *handle = (MediaTool_s *) mediatool;
+ int ret;
+ if (handle->bufferpriv == NULL)
+ return MEDIA_TOOL_ERROR_INVALID_OPERATION;
+
+ memcpy(*privBuffer, handle->bufferpriv, sizeof(handle->bufferpriv));
+
+ return MEDIA_TOOL_ERROR_NONE;
+}
+
+int media_tool_set_video_codec_format(mediatool_h mediatool, VideoCodecFormat_s* videoCodecFormat)
+{
+ MediaTool_s *handle = (MediaTool_s *) mediatool;
+ int ret;
+ handle->videocodecformat = (VideoCodecFormat_s *)malloc(sizeof(VideoCodecFormat_s));
+
+ if (handle->videocodecformat != NULL)
+ memset(handle->videocodecformat, 0, sizeof(VideoCodecFormat_s));
+ else
+ return MEDIA_TOOL_ERROR_OUT_OF_MEMORY;
+
+ return MEDIA_TOOL_ERROR_NONE;
+}
+
+int media_tool_get_video_codec_format(mediatool_h mediatool, VideoCodecFormat_s** videoCodecFormat)
+{
+ MediaTool_s *handle = (MediaTool_s *) mediatool;
+ int ret;
+ if (handle->videocodecformat == NULL)
+ return MEDIA_TOOL_ERROR_INVALID_OPERATION;
+
+ memcpy(*videoCodecFormat, handle->videocodecformat, sizeof(handle->videocodecformat));
+
+ return MEDIA_TOOL_ERROR_NONE;
+}
+
+int media_tool_set_audio_codec_format(mediatool_h mediatool, AudioCodecFormat_s* audioCodecFormat)
+{
+ MediaTool_s *handle = (MediaTool_s *) mediatool;
+ int ret;
+ handle->audiocodecformat = (AudioCodecFormat_s *)malloc(sizeof(AudioCodecFormat_s));
+
+ if (handle->audiocodecformat != NULL)
+ memset(handle->audiocodecformat, 0, sizeof(AudioCodecFormat_s));
+ else
+ return MEDIA_TOOL_ERROR_OUT_OF_MEMORY;
+
+ return MEDIA_TOOL_ERROR_NONE;
+}
+
+int media_tool_get_audio_codec_format(mediatool_h mediatool, AudioCodecFormat_s** audioCodecFormat)
+{
+ MediaTool_s *handle = (MediaTool_s *) mediatool;
+ int ret;
+ if (handle->audiocodecformat == NULL)
+ return MEDIA_TOOL_ERROR_INVALID_OPERATION;
+
+ memcpy(*audioCodecFormat, handle->audiocodecformat, sizeof(handle->audiocodecformat));
+
+ return MEDIA_TOOL_ERROR_NONE;
+}
+
+int media_tool_ref(mediatool_h mediatool)
+{
+ MediaTool_s *handle = (MediaTool_s *) mediatool;
+
+ if (handle == NULL)
+ return MEDIA_TOOL_ERROR_INVALID_PARAMETER;
+
+ if (!(handle->refcount> 0))
+ return MEDIA_TOOL_ERROR_INVALID_OPERATION;
+
+ g_atomic_int_inc (&handle->refcount);
+
+ return MEDIA_TOOL_ERROR_NONE;
+}
+
+int media_tool_unref(mediatool_h mediatool)
+{
+ MediaTool_s *handle = (MediaTool_s *) mediatool;
+
+ if (handle == NULL)
+ return MEDIA_TOOL_ERROR_INVALID_PARAMETER;
+
+ if (!(handle->refcount> 0))
+ return MEDIA_TOOL_ERROR_INVALID_OPERATION;
+
+ int zero;
+
+ zero = g_atomic_int_dec_and_test (&handle->refcount);
+ if (zero)
+ {
+ free(handle);
+ handle = NULL;
+ }
+ return MEDIA_TOOL_ERROR_NONE;
+}
+
+#endif
+
--- /dev/null
+/*
+* Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+#include <glib.h>
+#include <media_packet_private.h>
+
+
--- /dev/null
+CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
+SET(fw_test "${fw_name}-test")
+
+INCLUDE_DIRECTORIES(../include)
+link_directories(${CMAKE_SOURCE_DIR}/../)
+
+INCLUDE(FindPkgConfig)
+pkg_check_modules(${fw_test} REQUIRED libtbm appcore-efl)
+FOREACH(flag ${${fw_test}_CFLAGS})
+ SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}")
+ENDFOREACH(flag)
+
+SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS}")
+
+aux_source_directory(. sources)
+FOREACH(src ${sources})
+ GET_FILENAME_COMPONENT(src_name ${src} NAME_WE)
+ MESSAGE("${src_name}")
+ ADD_EXECUTABLE(${src_name} ${src})
+ TARGET_LINK_LIBRARIES(${src_name} capi-media-tool ${${fw_test}_LDFLAGS})
+ENDFOREACH()
+
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <glib.h>
+
+#include <media_packet_private.h>
+#include <media_format.h>
+#include <media_format_private.h>
+
+
+#include <appcore-efl.h>
+
+#define PACKAGE "media_tool_test"
+#define MAX_STRING_LEN 2048
+#define MAX_HANDLE 20
+
+
+enum
+{
+ CURRENT_STATUS_MAINMENU,
+ CURRENT_STATUS_SET_FORMAT,
+ CURRENT_STATUS_DURATION,
+};
+
+
+char g_uri[MAX_STRING_LEN];
+int g_menu_state = CURRENT_STATUS_MAINMENU;
+int g_handle_num = 1;
+static media_packet_h g_media_packet[MAX_HANDLE] = {0};
+static media_format_h format[3] = {0};
+bool is_only_created_handle;
+bool is_excute_create;
+
+/***********************************************/
+/*** Test API part
+/***********************************************/
+static void _create_format_480_640_es(void)
+{
+
+ if (media_format_create(&format[0]) == MEDIA_FORMAT_ERROR_NONE)
+ {
+ g_print("media_format_create success! \n");
+
+ int ret = MEDIA_FORMAT_ERROR_NONE;
+ ret = media_format_set_video_mime(format[0], MEDIA_FORMAT_H264_HP);
+ ret = media_format_set_video_width(format[0], 480);
+ ret = media_format_set_video_height(format[0], 640);
+ ret = media_format_set_video_avg_bps(format[0], 10000000);
+ ret = media_format_set_video_max_bps(format[0], 15000000);
+ if (ret == MEDIA_FORMAT_ERROR_NONE)
+ {
+ g_print("media_format_set_video_xxx success! w: 480, h: 640, MEDIA_FORMAT_H264_HP \n");
+ g_print("\t\t\t\t ====>> ref_count = %d", MEDIA_FORMAT_GET_REFCOUNT(format[0]));
+ }
+ else
+ g_print("media_format_set_video_xxx failed..\n");
+ }
+ else
+ {
+ g_print("media_format_create failed..\n");
+ }
+
+}
+
+static void _create_format_320_240_es(void)
+{
+
+ if (media_format_create(&format[1]) == MEDIA_FORMAT_ERROR_NONE)
+ {
+ g_print("media_format_create success! \n");
+ int ret = MEDIA_FORMAT_ERROR_NONE;
+ ret = media_format_set_video_mime(format[1], MEDIA_FORMAT_H264_HP);
+ ret = media_format_set_video_width(format[1], 320);
+ ret = media_format_set_video_height(format[1], 240);
+ ret = media_format_set_video_avg_bps(format[1], 3000000);
+ ret = media_format_set_video_max_bps(format[1], 15000000);
+ if (ret == MEDIA_FORMAT_ERROR_NONE)
+ {
+ g_print("media_format_set_video_xxx success! w: 320, h: 240, MEDIA_FORMAT_H264_HP \n");
+ g_print("\t\t\t\t ====>> ref_count = %d", MEDIA_FORMAT_GET_REFCOUNT(format[1]));
+ }
+ else
+ g_print("media_format_set_video_xxx failed..\n");
+ }
+ else
+ {
+ g_print("media_format_create failed..\n");
+ }
+
+}
+
+
+static void _create_format_raw(void)
+{
+
+ if (media_format_create(&format[2]) == MEDIA_FORMAT_ERROR_NONE)
+ {
+ g_print("media_format_create success! \n");
+ int ret = MEDIA_FORMAT_ERROR_NONE;
+ ret = media_format_set_video_mime(format[2], MEDIA_FORMAT_RGB888);
+ ret = media_format_set_video_width(format[2], 128);
+ ret = media_format_set_video_height(format[2], 128);
+ ret = media_format_set_video_avg_bps(format[2], 2000000);
+ ret = media_format_set_video_max_bps(format[2], 15000000);
+ if (ret == MEDIA_FORMAT_ERROR_NONE)
+ {
+ g_print("media_format_set_video_xxx success! w:128, h:128, MEDIA_FORMAT_RGB888\n");
+ g_print("\t\t\t\t ====>> ref_count = %d", MEDIA_FORMAT_GET_REFCOUNT(format[2]));
+ }
+ else
+ g_print("media_format_set_video_xxx failed..\n");
+ }
+ else
+ {
+ g_print("media_format_create failed..\n");
+ }
+
+
+}
+
+static int _finalize_callback(media_packet_h packet, int err, void* userdata)
+{
+ g_print("==> finalize callback func is called\n");
+ return MEDIA_PACKET_FINALIZE;
+}
+
+static void _create_and_alloc(void)
+{
+ g_print("=== create_and_alloc!!\n");
+ int i;
+
+ for(i = 0; i < g_handle_num; i++)
+ {
+ if(g_media_packet[i] != NULL)
+ {
+ media_packet_destroy(g_media_packet[i]);
+ g_media_packet[i] = NULL;
+ }
+
+ if(format[0] == NULL)
+ {
+ g_print("media_format_h is NULL!! create media_format_h handle \n");
+ break;
+ }
+ /* only ES format , if you want to another format, see _create_format_es() */
+ if (media_packet_create_alloc(format[0], _finalize_callback, NULL, &g_media_packet[i]) != MEDIA_PACKET_ERROR_NONE)
+ {
+ g_print("media_packet create is failed\n");
+ media_format_unref(format[0]);
+ }
+ else
+ {
+ g_print("media_packet_create_alloc is sucess!!\n");
+ media_format_unref(format[0]);
+ is_excute_create = true;
+ }
+
+ }
+}
+
+static void _create(void)
+{
+ g_print("=== create!!\n");
+ is_only_created_handle = true;
+ int i;
+
+ for(i = 0; i < g_handle_num; i++)
+ {
+ if(g_media_packet[i] != NULL)
+ {
+ media_packet_destroy(g_media_packet[i]);
+ g_media_packet[i] = NULL;
+ }
+
+ if(format[0] == NULL)
+ {
+ g_print("media_format_h is NULL!! create media_format_h handle \n");
+ break;
+ }
+
+ /* only ES format , if you want to another format, see _create_format_es() */
+ if (media_packet_create(format[0], _finalize_callback, NULL, &g_media_packet[i]) != MEDIA_PACKET_ERROR_NONE)
+ {
+ g_print("media_packet create is failed\n");
+ media_format_unref(format[0]);
+ }
+ else
+ {
+ g_print("media_packet_create is sucess!!\n");
+ is_excute_create = true;
+ }
+ }
+}
+
+static void _alloc(void)
+{
+ g_print("=== alloc!!\n");
+ if (is_only_created_handle)
+ {
+ if (media_packet_alloc(g_media_packet[0]) == MEDIA_PACKET_ERROR_NONE)
+ g_print("media_packet_alloc is sucess\n");
+ else
+ g_print("media_packet_alloc is failed\n");
+ }
+ else
+ {
+ g_print("*** can not excute!! fisrt excute media_packet_create() before this alloc. \n");
+ }
+}
+
+static void _create_from_tbm_surface(void)
+{
+ g_print("=== create_from_tbm_surface!!\n");
+
+ tbm_surface_h surface;
+ surface = tbm_surface_create(128, 128, TBM_FORMAT_RGB888);
+
+ if (surface)
+ {
+ int i;
+
+ for(i = 0; i < g_handle_num; i++)
+ {
+ if(g_media_packet[i] != NULL)
+ {
+ media_packet_destroy(g_media_packet[i]);
+ g_media_packet[i] = NULL;
+ }
+
+ if(format[2] == NULL)
+ {
+ g_print("media_format_h is NULL!! create media_format_h handle \n");
+ break;
+ }
+
+ /* only RAW format , if you want to another format, see _create_format_raw() */
+ if (media_packet_create_from_tbm_surface(format[2], surface, _finalize_callback, NULL, &g_media_packet[i]) != MEDIA_PACKET_ERROR_NONE)
+ {
+ g_print("media_packet_create_from_tbm_surface is failed\n");
+ media_format_unref(format[2]);
+ }
+ else
+ {
+ g_print("media_packet_create_from_tbm_surface is sucess!!\n");
+ is_excute_create = true;
+ }
+ }
+
+ }
+ else
+ {
+ g_print("tbm_surface_create failed...\n");
+ }
+}
+
+static void _copy(void)
+{
+ g_print("=== copy!!\n");
+
+ if (is_excute_create)
+ {
+ if (media_packet_copy(g_media_packet[0], _finalize_callback, NULL, &g_media_packet[1]) == MEDIA_PACKET_ERROR_NONE)
+ {
+ g_print("media_packet_copy sucess !!");
+ is_only_created_handle = true;
+ memset (g_media_packet[0], 0, sizeof(media_packet_s));
+ memcpy (g_media_packet[0], g_media_packet[1], sizeof(media_packet_s));
+ if(g_media_packet[1])
+ {
+ free(g_media_packet[1]);
+ g_media_packet[1] = NULL;
+ }
+
+ }
+ else
+ {
+ g_print("media_packet_copy failed");
+ }
+ }
+ else
+ {
+ g_print("denied... excute create or create_alloc or create_from_surface");
+ }
+
+}
+
+static void _destroy()
+{
+ g_print("=== destroy!!\n");
+ int i;
+ int ret;
+ for (i = 0; i < g_handle_num ; i++)
+ {
+ if(g_media_packet[i]!=NULL)
+ {
+ ret = media_packet_destroy(g_media_packet[i]);
+ g_media_packet[i] = 0;
+ if (ret == MEDIA_PACKET_ERROR_NONE)
+ g_print("media_packet_destroy is sucess!!\n");
+ else
+ g_print("media_packet_destroy is failed...\n");
+ }
+ }
+}
+
+static void _get_size(void)
+{
+ uint64_t size;
+ if (media_packet_get_buffer_size(g_media_packet[0],&size) == MEDIA_PACKET_ERROR_NONE)
+ {
+ g_print("media_packet_get_buffer_size is sucess!!");
+ g_print("\t\t[media_packet]===> size = %llu", size);
+ }
+ else
+ {
+ g_print("media_packet_get_buffer_size is failed...");
+ }
+}
+
+static void _get_duration(void)
+{
+ uint64_t duration;
+
+ if (media_packet_get_duration(g_media_packet[0], &duration) == MEDIA_PACKET_ERROR_NONE)
+ {
+ g_print("media_packet_get_duration is sucess!!");
+ g_print("\t\t[media_packet]===> duration = %llu", duration);
+ }
+ else
+ {
+ g_print("media_packet_get_duration is failed...");
+ }
+}
+
+static void _get_buffer_ptr(void)
+{
+ void* ptr;
+ media_packet_s* packet = g_media_packet[0];
+ ptr = (void*)malloc(sizeof(packet->size));
+
+ if (ptr)
+ memset(packet, 0, sizeof(packet->size));
+ else
+ g_print("_get_buffer_ptr , malloc failed...");
+
+ if (media_packet_get_buffer_data_ptr(g_media_packet[0], &ptr) == MEDIA_PACKET_ERROR_NONE)
+ {
+ g_print("media_packet_get_buffer_data_ptr is sucess!!");
+ g_print("\t\t[media_packet]===> buffer_data_ptr = %p", ptr);
+ }
+ else
+ {
+ g_print("media_packet_get_buffer_data_ptr is failed...");
+ }
+
+}
+
+static void _get_tbm_surface()
+{
+ tbm_surface_h tbm_surface;
+
+ if (media_packet_get_tbm_surface(g_media_packet[0], &tbm_surface) == MEDIA_PACKET_ERROR_NONE)
+ {
+ g_print("media_packet_get_tbm_surface is sucess!!");
+ g_print("\t\t[media_packet]===> tbm_surface = %p", (void*)tbm_surface);
+ }
+ else
+ {
+ g_print("media_packet_get_duration is failed...");
+ }
+}
+
+static void _set_duration(uint64_t duration)
+{
+ if (media_packet_set_duration(g_media_packet[0], duration) == MEDIA_PACKET_ERROR_NONE)
+ {
+ g_print("media_packet_set_duration is sucess!!\n");
+ }
+ else
+ {
+ g_print("media_packet_set_duration is failed..\n");
+ }
+}
+
+static void _is_video(void)
+{
+ bool is_video;
+ if (media_packet_is_video(g_media_packet[0], &is_video) == MEDIA_PACKET_ERROR_NONE)
+ {
+ g_print("media_packet_is_video is sucess!!\n");
+ g_print("\t\t[media_packet]===> is_video = %d", is_video);
+ }
+ else
+ {
+ g_print("media_packet_is_video is failed...");
+ }
+}
+
+static void _is_audio(void)
+{
+ bool is_audio;
+ if (media_packet_is_audio(g_media_packet[0], &is_audio) == MEDIA_PACKET_ERROR_NONE)
+ {
+ g_print("media_packet_is_audio is sucess!!\n");
+ g_print("\t\t[media_packet]===> is_audio = %d", is_audio);
+ }
+ else
+ {
+ g_print("media_packet_is_audio is failed...");
+ }
+}
+
+static void _is_encoded(void)
+{
+ bool is_encoded;
+ if (media_packet_is_encoded(g_media_packet[0], &is_encoded) == MEDIA_PACKET_ERROR_NONE)
+ {
+ g_print("media_packet_is_encoded is sucess!!\n");
+ g_print("\t\t[media_packet]===> is_encoded = %d", is_encoded);
+ }
+ else
+ {
+ g_print("media_packet_is_encoded is failed...");
+ }
+
+}
+static void _is_raw(void)
+{
+ bool is_raw;
+ if (media_packet_is_raw(g_media_packet[0], &is_raw) == MEDIA_PACKET_ERROR_NONE)
+ {
+ g_print("media_packet_is_raw is sucess!!\n");
+ g_print("\t\t[media_packet]===> is_raw = %d", is_raw);
+ }
+ else
+ {
+ g_print("media_packet_is_raw is failed...");
+ }
+
+}
+
+static void _get_format(void)
+{
+ media_format_h fmt;
+ if (media_packet_get_format(g_media_packet[0], &fmt) == MEDIA_PACKET_ERROR_NONE)
+ {
+ int w;
+ int h;
+
+ g_print("media_packet_get_format is sucess!\n");
+ if (media_format_get_video_info(fmt, NULL, &w, &h, NULL, NULL) == MEDIA_PACKET_ERROR_NONE)
+ {
+ g_print("\t\t [media_format] width = %d, height =%d", w, h);
+ }
+ else
+ {
+ g_print("media_format_get_video is failed...");
+ }
+ }
+ else
+ {
+ g_print("media_packet_get_format is failed...");
+ }
+
+}
+
+
+static void _set_format(media_format_h fmt)
+{
+ if (media_packet_set_format(g_media_packet[0], fmt) == MEDIA_PACKET_ERROR_NONE)
+ {
+ g_print("media_packet_set_format is sucess!\n");
+ }
+ else
+ {
+ g_print("media_packet_get_format is failed...");
+ }
+
+}
+
+static void _set_extra(void)
+{
+ char* extra = "extra";
+
+ if (media_packet_set_extra(g_media_packet[0], (void*)extra) == MEDIA_PACKET_ERROR_NONE)
+ {
+ g_print("media_packet_set_extra is sucess!\n");
+ }
+ else
+ {
+ g_print("media_packet_set_extra is failed...");
+ }
+
+}
+
+static void _get_extra(void)
+{
+ void* extra;
+
+ if (media_packet_get_extra(g_media_packet[0], &extra) == MEDIA_PACKET_ERROR_NONE)
+ {
+ g_print("media_packet_get_extra is sucess!\n");
+ g_print("\t\t extra = %s\n", (char*)extra);
+ }
+ else
+ {
+ g_print("media_packet_get_extra is failed...");
+ }
+
+}
+
+static void _has_tbm_surface_buffer(void)
+{
+ bool has_tbm;
+
+ if (media_packet_has_tbm_surface_buffer(g_media_packet[0], &has_tbm) == MEDIA_PACKET_ERROR_NONE)
+ {
+ g_print("media_packet_has_tbm_surface_buffer is sucess! \n");
+ g_print("\t\t has_tbm_surface_buffer = %d \n", has_tbm);
+ }
+ else
+ {
+ g_print("media_packet_has_tbm_surface_buffer is failed! \n");
+ }
+}
+
+static void _format_get_video(void)
+{
+ media_format_mimetype_e mime;
+ int w;
+ int h;
+
+ media_packet_s* packet;
+ packet = (media_packet_s*)g_media_packet[0];
+
+ if (media_format_get_video_info(packet->format, &mime, &w, &h, NULL, NULL) == MEDIA_FORMAT_ERROR_NONE)
+ {
+ g_print("media_format_get_video is sucess!\n");
+ g_print("\t\t[media_format_get_video]mime:0x%x, width :%d, height :%d\n", mime, w, h);
+ g_print("packet format ref_count: %d", MEDIA_FORMAT_GET_REFCOUNT(packet->format));
+ }
+ else
+ {
+ g_print("media_format_get_video is failed..");
+ }
+}
+
+static void _format_get_audio(void)
+{
+ media_format_mimetype_e mime;
+ int channel;
+ int samplerate;
+ int bit;
+ int avg_bps;
+
+ media_packet_s* packet;
+ packet = (media_packet_s*)g_media_packet[0];
+
+ if (media_format_get_audio_info(packet->format, &mime, &channel, &samplerate, &bit, &avg_bps)== MEDIA_FORMAT_ERROR_NONE)
+ {
+ g_print("media_format_get_audio_info is sucess!\n");
+ g_print("\t\t[media_format_get_audio_info]mime:0x%x, channel :%d, samplerate :%d, bit: %d, avg_bps:%d \n", mime, channel, samplerate, bit, avg_bps);
+ g_print("packet format ref_count: %d", MEDIA_FORMAT_GET_REFCOUNT(packet->format));
+ }
+ else
+ {
+ g_print("media_format_get_audio_info is failed..");
+ }
+}
+
+
+/***********************************************/
+/*** Test suit frame API part
+/***********************************************/
+static int _create_app(void *data)
+{
+ printf("media_packet_test is started!\n");
+ return 0;
+}
+
+static int _terminate_app(void *data)
+{
+ printf("media_packet_test is terminated!\n");
+ return 0;
+}
+
+
+struct appcore_ops ops = {
+ .create = _create_app,
+ .terminate = _terminate_app,
+};
+
+void reset_menu_state()
+{
+ g_menu_state = CURRENT_STATUS_MAINMENU;
+}
+
+void quit_program(void)
+{
+ int i = 0;
+
+ for (i = 0; i < g_handle_num; i++)
+ {
+ if(g_media_packet[i]!=NULL)
+ {
+ media_packet_destroy(g_media_packet[i]);
+ g_media_packet[i] = NULL;
+ }
+ }
+ elm_exit();
+}
+
+void _interpret_main_menu(char *cmd)
+{
+ int len = strlen(cmd);
+ if (len == 1)
+ {
+ if (strncmp(cmd, "a", 1) == 0)
+ {
+ _create_and_alloc();
+ }
+ else if (strncmp(cmd, "d", 1) == 0)
+ {
+ _destroy();
+ }
+ else if (strncmp(cmd, "b", 1) == 0)
+ {
+ _create_from_tbm_surface();
+ }
+ else if (strncmp(cmd, "c", 1) == 0)
+ {
+ _copy();
+ }
+ else if (strncmp(cmd, "q", 1) == 0)
+ {
+ quit_program();
+ }
+ }
+ else if (len == 2)
+ {
+ if (strncmp(cmd, "aa", 2) == 0)
+ {
+ _create();
+ }
+ else if (strncmp(cmd, "ab", 2) == 0)
+ {
+ _alloc();
+ }
+ else if (strncmp(cmd, "iv", 2) == 0)
+ {
+ _is_video();
+ }
+ else if (strncmp(cmd, "ia", 2) == 0)
+ {
+ _is_audio();
+ }
+ else if (strncmp(cmd, "ie", 2) == 0)
+ {
+ _is_encoded();
+ }
+ else if (strncmp(cmd, "ir", 2) == 0)
+ {
+ _is_raw();
+ }
+ else if (strncmp(cmd, "gd", 2) == 0)
+ {
+ _get_duration();
+ }
+ else if (strncmp(cmd, "sd", 2) == 0)
+ {
+ g_menu_state = CURRENT_STATUS_DURATION;
+ }
+ else if (strncmp(cmd, "gf", 2) == 0)
+ {
+ _get_format();
+ }
+ else if (strncmp(cmd, "gs", 2) == 0)
+ {
+ _get_size();
+ }
+ else if (strncmp(cmd, "sf", 2) == 0)
+ {
+ g_menu_state = CURRENT_STATUS_SET_FORMAT;
+ }
+ else if (strncmp(cmd, "se", 2) == 0)
+ {
+ _set_extra();
+ }
+ else if (strncmp(cmd, "ge", 2) == 0)
+ {
+ _get_extra();
+ }
+ else if (strncmp(cmd, "ht", 2) == 0)
+ {
+ _has_tbm_surface_buffer();
+ }
+
+ }
+ else if (len == 3)
+ {
+ if (strncmp(cmd, "gbp", 3) == 0)
+ {
+ _get_buffer_ptr();
+ }
+ else if (strncmp(cmd, "gts", 3) == 0)
+ {
+ _get_tbm_surface();
+ }
+ else if (strncmp(cmd, "fes", 3) == 0)
+ {
+ _create_format_480_640_es();
+ }
+ else if (strncmp(cmd, "fgv", 3) == 0)
+ {
+ _format_get_video();
+ }
+ }
+ else if (len == 4)
+ {
+ if (strncmp(cmd, "fraw", 4) == 0)
+ {
+ _create_format_raw();
+ }
+ else if (strncmp(cmd, "fes2", 4) == 0)
+ {
+ _create_format_320_240_es();
+ }
+ }
+
+
+}
+
+static void displaymenu(void)
+{
+ if (g_menu_state == CURRENT_STATUS_MAINMENU)
+ {
+ display_sub_basic();
+ }
+ else if (g_menu_state == CURRENT_STATUS_SET_FORMAT)
+ {
+ g_print("*** choose format.\n");
+ g_print("0. 640x480 , MEDIA_FORMAT_H264_HP\n");
+ g_print("1. 320x240 , MEDIA_FORMAT_H264_HP\n");
+ g_print("2. 128x128 , MEDIA_FORMAT_RGB888\n");
+ }
+ else if (g_menu_state == CURRENT_STATUS_DURATION)
+ {
+ g_print("*** input duration \n");
+ }
+ else
+ {
+ g_print("*** unknown status.\n");
+ quit_program();
+ }
+ g_print(" >>> ");
+}
+
+
+gboolean timeout_menu_display(void* data)
+{
+ displaymenu();
+ return FALSE;
+}
+
+static void interpret (char *cmd)
+{
+ switch (g_menu_state)
+ {
+ case CURRENT_STATUS_MAINMENU:
+ {
+ _interpret_main_menu(cmd);
+ }
+ break;
+ case CURRENT_STATUS_SET_FORMAT:
+ {
+ int num = atoi(cmd);
+ switch (num)
+ {
+ case 0:
+ if (format[0])
+ {
+ _set_format(format[0]);
+ }
+ else
+ {
+ _create_format_480_640_es();
+ _set_format(format[0]);
+ }
+ break;
+ case 1:
+ if(format[1])
+ {
+ _set_format(format[1]);
+ }
+ else
+ {
+ _create_format_320_240_es();
+ _set_format(format[1]);
+ }
+ break;
+ case 2:
+ if(format[2])
+ {
+ _set_format(format[2]);
+ }
+ else
+ {
+ _create_format_raw();
+ _set_format(format[2]);
+ }
+ break;
+ default:
+ g_print("invalid number..");
+
+
+ }
+ reset_menu_state();
+ }
+ break;
+ case CURRENT_STATUS_DURATION:
+ {
+ uint64_t duration = atoi(cmd);
+ _set_duration(duration);
+ reset_menu_state();
+ }
+ }
+
+ g_timeout_add(100, timeout_menu_display, 0);
+}
+
+void display_sub_basic()
+{
+ g_print("\n");
+ g_print("=========================================================================================\n");
+ g_print(" media tool test\n");
+ g_print("-----------------------------------------------------------------------------------------\n");
+ g_print("fes. create format for es 480x640\t\t");
+ g_print("fes2. create format for es 320x240\t\t");
+ g_print("fraw. create format for raw 128x128 \t\t");
+ g_print("\n");
+ g_print("a. Create_and _Alloc \t");
+ g_print("aa. Create \t");
+ g_print("ab. Alloc \t");
+ g_print("c. Copy \t");
+ g_print("b. Create from tbm_surface \n");
+ g_print("iv. is_video \t\t");
+ g_print("ia. is_audio \t\t");
+ g_print("ie. is_encoded \t\t");
+ g_print("ir. is_raw \t\t");
+ g_print("ht. has_tbm_surface \t\t");
+ g_print("\n");
+ g_print("sd. set duration \t\t");
+ g_print("sf. set format \t\t");
+ g_print("se. set extra \t\t");
+ g_print("\n");
+ g_print("gd. get duration \t\t");
+ g_print("gbp. get buffer data ptr \t\t");
+ g_print("gts. get tbm surface \t\t");
+ g_print("gf. get format \t\t");
+ g_print("ge. get extra \t\t");
+ g_print("\n");
+ g_print("fgv. media_format_get_video_info \t\t");
+ g_print("fga. media_format_get_audio_info \t\t");
+ g_print("\n");
+ g_print("gs. get size\t\t");
+ g_print("\n");
+ g_print("d. Destroy \n");
+ g_print("q. quit test suite");
+ g_print("\n");
+ g_print("=========================================================================================\n");
+}
+
+
+gboolean input (GIOChannel *channel)
+{
+ gchar buf[MAX_STRING_LEN];
+ gsize read;
+ GError *error = NULL;
+
+ g_io_channel_read_chars(channel, buf, MAX_STRING_LEN, &read, &error);
+ buf[read] = '\0';
+ g_strstrip(buf);
+ interpret (buf);
+
+ return TRUE;
+}
+
+int main(int argc, char *argv[])
+{
+ GIOChannel *stdin_channel;
+ stdin_channel = g_io_channel_unix_new(0);
+ g_io_channel_set_flags (stdin_channel, G_IO_FLAG_NONBLOCK, NULL);
+ g_io_add_watch (stdin_channel, G_IO_IN, (GIOFunc)input, NULL);
+
+ displaymenu();
+
+ ops.data = NULL;
+
+ return appcore_efl_main(PACKAGE, &argc, &argv, &ops);
+
+}
+
projects / platform / core / api / mediatool.git / commitdiff