From: Hyongtaek Lim Date: Wed, 29 Jul 2015 04:39:40 +0000 (+0900) Subject: Initial release X-Git-Tag: accepted/tizen/mobile/20150731.102626^0 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=87e10bc4bc8b1a7fd01027415e0f5955c76b97e4;p=platform%2Fcore%2Fmultimedia%2Fmmsvc-player.git Initial release Signed-off-by: Hyongtaek Lim Change-Id: Ie0cd653203ad84a7720ccae8ebd44e85ed859ee9 --- diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..73837b8 --- /dev/null +++ b/.gitignore @@ -0,0 +1,29 @@ +CMakeCache.txt +*/CMakeFiles/* +*.cmake +CMakeFiles* +*.a +*.so +Testing +cmake.depends +cmake.check_depends +cmake.check_cache +core +core.* +gmon.out +install_manifest.txt +*~ +.kdev_include_paths +src.kdev4 +.cproject +.project +tet_captured +tet_lock +*.pc +Makefile +*-test +*-test_* +*tester.c +.gitattributes +*.swp +tags diff --git a/AUTHORS b/AUTHORS new file mode 100644 index 0000000..cb87b0c --- /dev/null +++ b/AUTHORS @@ -0,0 +1 @@ +JongHyuk Choi diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..59af094 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,105 @@ + +CMAKE_MINIMUM_REQUIRED(VERSION 2.6) +SET(fw_name "mused-player") + +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 libtbm mused capi-media-player mm-common") +SET(pc_dependents "dlog") + +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./${INC_DIR} ${CMAKE_C_FLAGS} ${EXTRA_CFLAGS} -fPIC -Wall -Werror -Wno-error=deprecated-declarations") +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") +ADD_DEFINITIONS("-DUSE_ASM") +IF(WAYLAND_SUPPORT) + ADD_DEFINITIONS("-DHAVE_WAYLAND") +ENDIF(WAYLAND_SUPPORT) +IF(X11_SUPPORT) + ADD_DEFINITIONS("-DHAVE_X11") +ENDIF(X11_SUPPORT) + +SET(CMAKE_EXE_LINKER_FLAGS "-Wl,--as-needed -Wl,--rpath=${LIB_INSTALL_DIR}") + +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_DIR}) +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_INSTALL_DIR}/pkgconfig) + +ADD_SUBDIRECTORY(client) + +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) + diff --git a/LICENSE.APLv2 b/LICENSE.APLv2 new file mode 100644 index 0000000..a06208b --- /dev/null +++ b/LICENSE.APLv2 @@ -0,0 +1,204 @@ +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. + diff --git a/NOTICE b/NOTICE new file mode 100644 index 0000000..ccdad52 --- /dev/null +++ b/NOTICE @@ -0,0 +1,3 @@ +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. diff --git a/client/AUTHORS b/client/AUTHORS new file mode 100644 index 0000000..cb87b0c --- /dev/null +++ b/client/AUTHORS @@ -0,0 +1 @@ +JongHyuk Choi diff --git a/client/CMakeLists.txt b/client/CMakeLists.txt new file mode 100644 index 0000000..106eb2b --- /dev/null +++ b/client/CMakeLists.txt @@ -0,0 +1,74 @@ + +CMAKE_MINIMUM_REQUIRED(VERSION 2.6) +SET(fw_name "capi-media-player2") + +PROJECT(${fw_name}) + +SET(CMAKE_INSTALL_PREFIX /usr) +SET(PREFIX ${CMAKE_INSTALL_PREFIX}) + +SET(INC_DIR include) +INCLUDE_DIRECTORIES(${INC_DIR}) + +SET(dependents "dlog elementary evas libtbm mm-common mm-player capi-base-common capi-media-tool capi-media-sound-manager eom") +SET(pc_dependents "dlog") + +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 ${CMAKE_C_FLAGS} ${EXTRA_CFLAGS} -fPIC -Wall -DGST_EXT_TIME_ANALYSIS") +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") +IF(WAYLAND_SUPPORT) + ADD_DEFINITIONS("-DHAVE_WAYLAND") +ENDIF(WAYLAND_SUPPORT) +IF(X11_SUPPORT) + ADD_DEFINITIONS("-DHAVE_X11") +ENDIF(X11_SUPPORT) + +SET(CMAKE_EXE_LINKER_FLAGS "-Wl,--as-needed -Wl,--rpath=${LIB_INSTALL_DIR}") + + +aux_source_directory(src CLI_SOURCES) +ADD_LIBRARY(${fw_name} SHARED ${CLI_SOURCES}) + +TARGET_LINK_LIBRARIES(${fw_name} mused ${${fw_name}_LDFLAGS}) + +SET_TARGET_PROPERTIES(${fw_name} + PROPERTIES + VERSION ${FULLVER} + SOVERSION ${MAJORVER} + CLEAN_DIRECT_OUTPUT 1 +) + +INSTALL(TARGETS ${fw_name} DESTINATION ${LIB_INSTALL_DIR}) +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_INSTALL_DIR}/pkgconfig) + +ADD_SUBDIRECTORY(test) + diff --git a/client/LICENSE.APLv2 b/client/LICENSE.APLv2 new file mode 100644 index 0000000..bbe9d02 --- /dev/null +++ b/client/LICENSE.APLv2 @@ -0,0 +1,206 @@ +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. + + + diff --git a/client/NOTICE b/client/NOTICE new file mode 100644 index 0000000..ccdad52 --- /dev/null +++ b/client/NOTICE @@ -0,0 +1,3 @@ +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. diff --git a/client/capi-media-player2.manifest b/client/capi-media-player2.manifest new file mode 100644 index 0000000..d9569bd --- /dev/null +++ b/client/capi-media-player2.manifest @@ -0,0 +1,8 @@ + + + + + + + + diff --git a/client/capi-media-player2.pc.in b/client/capi-media-player2.pc.in new file mode 100644 index 0000000..afda32e --- /dev/null +++ b/client/capi-media-player2.pc.in @@ -0,0 +1,15 @@ + +# 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} + diff --git a/client/src/player2.c b/client/src/player2.c new file mode 100644 index 0000000..cebc9dc --- /dev/null +++ b/client/src/player2.c @@ -0,0 +1,3115 @@ +/* +* 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 +#include +#include +#include "glib.h" +#include "tbm_bufmgr.h" +#include "tbm_surface.h" +#include "tbm_surface_internal.h" +#include "Evas.h" +#include "Elementary.h" +#include "Ecore.h" +#ifdef HAVE_WAYLAND +#include "Ecore_Wayland.h" +#endif +#include "mmsvc_core.h" +#include "mmsvc_core_msg_json.h" +#include "mmsvc_core_ipc.h" +#include "player2_private.h" +#include "player_msg_private.h" +#include "sound_manager_internal.h" +#include "mm_error.h" +#include "mm_player.h" +#include "mm_player_mused.h" +#include "dlog.h" + +#define CALLBACK_TIME_OUT 12 +static tbm_bufmgr bufmgr; + +typedef struct { + int int_data; + char *buf; + callback_cb_info_s *cb_info; +}_player_cb_data; + +typedef struct { + int remote_pkt; + callback_cb_info_s *cb_info; +}_media_pkt_fin_data; + + +/* + Global varialbe +*/ + +/* +* Internal Implementation +*/ +static int _player_deinit_memory_buffer(player_cli_s *pc); + +int _player_media_packet_finalize(media_packet_h pkt, int error_code, + void *user_data) +{ + int ret = 0; + tbm_surface_h tsurf = NULL; + mm_player_api_e api = MM_PLAYER_API_MEDIA_PACKET_FINALIZE_CB; + _media_pkt_fin_data *fin_data = (_media_pkt_fin_data *)user_data; + int packet; + char *sndMsg; + + if (pkt == NULL || user_data == NULL) { + LOGE("invalid parameter buffer %p, user_data %p", pkt, + user_data); + return MEDIA_PACKET_FINALIZE; + } + + ret = media_packet_get_tbm_surface(pkt, &tsurf); + if (ret != MEDIA_PACKET_ERROR_NONE) { + LOGE("media_packet_get_tbm_surface failed 0x%x", ret); + return MEDIA_PACKET_FINALIZE; + } + + if (tsurf) { + tbm_surface_destroy(tsurf); + tsurf = NULL; + } + + packet = fin_data->remote_pkt; + sndMsg = mmsvc_core_msg_json_factory_new(api, "packet", packet, 0); + mmsvc_core_ipc_send_msg(fin_data->cb_info->fd, sndMsg); + mmsvc_core_msg_json_factory_free(sndMsg); + + g_free(fin_data); + + return MEDIA_PACKET_FINALIZE; +} + +#ifndef USE_ASM +static int __player_convert_error_code(int code, char* func_name) +{ + int ret = PLAYER_ERROR_INVALID_OPERATION; + char* msg="PLAYER_ERROR_INVALID_OPERATION"; + switch(code) + { + case MM_ERROR_NONE: + case MM_ERROR_PLAYER_AUDIO_CODEC_NOT_FOUND: + case MM_ERROR_PLAYER_VIDEO_CODEC_NOT_FOUND: + ret = PLAYER_ERROR_NONE; + msg = "PLAYER_ERROR_NONE"; + break; + case MM_ERROR_INVALID_ARGUMENT: + ret = PLAYER_ERROR_INVALID_PARAMETER; + msg = "PLAYER_ERROR_INVALID_PARAMETER"; + break; + case MM_ERROR_PLAYER_CODEC_NOT_FOUND: + case MM_ERROR_PLAYER_STREAMING_UNSUPPORTED_AUDIO: + case MM_ERROR_PLAYER_STREAMING_UNSUPPORTED_VIDEO: + case MM_ERROR_PLAYER_STREAMING_UNSUPPORTED_MEDIA_TYPE: + case MM_ERROR_PLAYER_NOT_SUPPORTED_FORMAT: + ret = PLAYER_ERROR_NOT_SUPPORTED_FILE; + msg = "PLAYER_ERROR_NOT_SUPPORTED_FILE"; + break; + case MM_ERROR_PLAYER_INVALID_STATE: + case MM_ERROR_PLAYER_NOT_INITIALIZED: + ret = PLAYER_ERROR_INVALID_STATE; + msg = "PLAYER_ERROR_INVALID_STATE"; + break; + case MM_ERROR_PLAYER_INTERNAL: + case MM_ERROR_PLAYER_INVALID_STREAM: + case MM_ERROR_PLAYER_STREAMING_FAIL: + case MM_ERROR_PLAYER_NO_OP: + ret = PLAYER_ERROR_INVALID_OPERATION; + msg = "PLAYER_ERROR_INVALID_OPERATION"; + break; + case MM_ERROR_PLAYER_SOUND_EFFECT_INVALID_STATUS: + case MM_ERROR_NOT_SUPPORT_API: + case MM_ERROR_PLAYER_SOUND_EFFECT_NOT_SUPPORTED_FILTER: + ret =PLAYER_ERROR_FEATURE_NOT_SUPPORTED_ON_DEVICE; + msg = "PLAYER_ERROR_FEATURE_NOT_SUPPORTED_ON_DEVICE"; + break; + case MM_ERROR_PLAYER_NO_FREE_SPACE: + ret = PLAYER_ERROR_FILE_NO_SPACE_ON_DEVICE; + msg = "PLAYER_ERROR_FILE_NO_SPACE_ON_DEVICE"; + break; + case MM_ERROR_PLAYER_FILE_NOT_FOUND: + ret = PLAYER_ERROR_NO_SUCH_FILE; + msg = "PLAYER_ERROR_NO_SUCH_FILE"; + break; + case MM_ERROR_PLAYER_SEEK: + ret = PLAYER_ERROR_SEEK_FAILED; + msg = "PLAYER_ERROR_SEEK_FAILED"; + break; + case MM_ERROR_PLAYER_INVALID_URI: + case MM_ERROR_PLAYER_STREAMING_INVALID_URL: + ret = PLAYER_ERROR_INVALID_URI; + msg = "PLAYER_ERROR_INVALID_URI"; + break; + case MM_ERROR_PLAYER_STREAMING_CONNECTION_FAIL: + case MM_ERROR_PLAYER_STREAMING_DNS_FAIL : + case MM_ERROR_PLAYER_STREAMING_SERVER_DISCONNECTED: + case MM_ERROR_PLAYER_STREAMING_INVALID_PROTOCOL: + case MM_ERROR_PLAYER_STREAMING_UNEXPECTED_MSG: + case MM_ERROR_PLAYER_STREAMING_OUT_OF_MEMORIES: + case MM_ERROR_PLAYER_STREAMING_RTSP_TIMEOUT: + case MM_ERROR_PLAYER_STREAMING_BAD_REQUEST: + case MM_ERROR_PLAYER_STREAMING_NOT_AUTHORIZED: + case MM_ERROR_PLAYER_STREAMING_PAYMENT_REQUIRED: + case MM_ERROR_PLAYER_STREAMING_FORBIDDEN: + case MM_ERROR_PLAYER_STREAMING_CONTENT_NOT_FOUND: + case MM_ERROR_PLAYER_STREAMING_METHOD_NOT_ALLOWED: + case MM_ERROR_PLAYER_STREAMING_NOT_ACCEPTABLE: + case MM_ERROR_PLAYER_STREAMING_PROXY_AUTHENTICATION_REQUIRED: + case MM_ERROR_PLAYER_STREAMING_SERVER_TIMEOUT: + case MM_ERROR_PLAYER_STREAMING_GONE: + case MM_ERROR_PLAYER_STREAMING_LENGTH_REQUIRED: + case MM_ERROR_PLAYER_STREAMING_PRECONDITION_FAILED: + case MM_ERROR_PLAYER_STREAMING_REQUEST_ENTITY_TOO_LARGE: + case MM_ERROR_PLAYER_STREAMING_REQUEST_URI_TOO_LARGE: + case MM_ERROR_PLAYER_STREAMING_PARAMETER_NOT_UNDERSTOOD: + case MM_ERROR_PLAYER_STREAMING_CONFERENCE_NOT_FOUND: + case MM_ERROR_PLAYER_STREAMING_NOT_ENOUGH_BANDWIDTH: + case MM_ERROR_PLAYER_STREAMING_NO_SESSION_ID: + case MM_ERROR_PLAYER_STREAMING_METHOD_NOT_VALID_IN_THIS_STATE: + case MM_ERROR_PLAYER_STREAMING_HEADER_FIELD_NOT_VALID_FOR_SOURCE: + case MM_ERROR_PLAYER_STREAMING_INVALID_RANGE: + case MM_ERROR_PLAYER_STREAMING_PARAMETER_IS_READONLY: + case MM_ERROR_PLAYER_STREAMING_AGGREGATE_OP_NOT_ALLOWED: + case MM_ERROR_PLAYER_STREAMING_ONLY_AGGREGATE_OP_ALLOWED: + case MM_ERROR_PLAYER_STREAMING_BAD_TRANSPORT: + case MM_ERROR_PLAYER_STREAMING_DESTINATION_UNREACHABLE: + case MM_ERROR_PLAYER_STREAMING_INTERNAL_SERVER_ERROR: + case MM_ERROR_PLAYER_STREAMING_NOT_IMPLEMENTED: + case MM_ERROR_PLAYER_STREAMING_BAD_GATEWAY: + case MM_ERROR_PLAYER_STREAMING_SERVICE_UNAVAILABLE: + case MM_ERROR_PLAYER_STREAMING_GATEWAY_TIME_OUT: + case MM_ERROR_PLAYER_STREAMING_OPTION_NOT_SUPPORTED: + ret = PLAYER_ERROR_CONNECTION_FAILED; + msg = "PLAYER_ERROR_CONNECTION_FAILED"; + break; + case MM_ERROR_POLICY_BLOCKED: + case MM_ERROR_POLICY_INTERRUPTED: + case MM_ERROR_POLICY_INTERNAL: + case MM_ERROR_POLICY_DUPLICATED: + ret = PLAYER_ERROR_SOUND_POLICY; + msg = "PLAYER_ERROR_SOUND_POLICY"; + break; + case MM_ERROR_PLAYER_DRM_EXPIRED: + ret = PLAYER_ERROR_DRM_EXPIRED; + msg = "PLAYER_ERROR_DRM_EXPIRED"; + break; + case MM_ERROR_PLAYER_DRM_NOT_AUTHORIZED: + case MM_ERROR_PLAYER_DRM_NO_LICENSE: + ret = PLAYER_ERROR_DRM_NO_LICENSE; + msg = "PLAYER_ERROR_DRM_NO_LICENSE"; + break; + case MM_ERROR_PLAYER_DRM_FUTURE_USE: + ret = PLAYER_ERROR_DRM_FUTURE_USE; + msg = "PLAYER_ERROR_DRM_FUTURE_USE"; + break; + case MM_ERROR_PLAYER_DRM_OUTPUT_PROTECTION: + ret = PLAYER_ERROR_DRM_NOT_PERMITTED; + msg = "PLAYER_ERROR_DRM_NOT_PERMITTED"; + break; + case MM_ERROR_PLAYER_RESOURCE_LIMIT: + ret = PLAYER_ERROR_RESOURCE_LIMIT; + msg = "PLAYER_ERROR_RESOURCE_LIMIT"; + break; + case MM_ERROR_PLAYER_PERMISSION_DENIED: + ret = PLAYER_ERROR_PERMISSION_DENIED; + msg = "PLAYER_ERROR_PERMISSION_DENIED"; + } + LOGE("[%s] %s(0x%08x) : core fw error(0x%x)",func_name,msg, ret, code); + return ret; +} +#endif /* USE_ASM */ + +static void * _get_mem(player_cli_s *player, int size) +{ + player_data_s *mem = g_new(player_data_s, sizeof(player_data_s)); + if(mem){ + mem->data = g_new(void, size); + mem->next = player->head; + player->head = mem; + return mem->data; + } + return NULL; +} + +static void _del_mem(player_cli_s *player) +{ + player_data_s *mem; + while(player->head){ + mem = player->head->next; + g_free(player->head->data); + g_free(player->head); + player->head = mem; + } +} + +static int player_recv_msg(callback_cb_info_s *cb_info, int len) +{ + int recvLen; + msg_buff_s *buff = &cb_info->buff; + char *new; + + if(len && buff->bufLen - MM_MSG_MAX_LENGTH <= len) { + LOGD("realloc Buffer %d -> %d, Msg Length %d", + buff->bufLen, buff->bufLen + MM_MSG_MAX_LENGTH, len); + buff->bufLen += MM_MSG_MAX_LENGTH; + new = g_renew(char, buff->recvMsg, buff->bufLen); + if(new && new != buff->recvMsg){ + buff->recvMsg = new; + } + } + + recvLen = mmsvc_core_ipc_recv_msg(cb_info->fd, buff->recvMsg + len); + len += recvLen; + + return len; +} + +static int __set_callback(_player_event_e type, player_h player, void *callback, + void *user_data) +{ + PLAYER_INSTANCE_CHECK(player); + PLAYER_NULL_ARG_CHECK(callback); + player_cli_s *handle = (player_cli_s *) player; + mm_player_api_e api = MM_PLAYER_API_SET_CALLBACK; + int sock_fd = handle->cb_info->fd; + int set = 1; + + player_msg_send2_async(api, handle->remote_handle, sock_fd, + INT, type, INT, set); + + handle->cb_info->user_cb[type] = callback; + handle->cb_info->user_data[type] = user_data; + LOGI("[%s] Event type : %d ", __FUNCTION__, type); + return PLAYER_ERROR_NONE; +} + +static int __unset_callback(_player_event_e type, player_h player) +{ + PLAYER_INSTANCE_CHECK(player); + player_cli_s *handle = (player_cli_s *) player; + mm_player_api_e api = MM_PLAYER_API_SET_CALLBACK; + int sock_fd = handle->cb_info->fd; + int set = 0; + + player_msg_send2_async(api, handle->remote_handle, sock_fd, + INT, type, INT, set); + + handle->cb_info->user_cb[type] = NULL; + handle->cb_info->user_data[type] = NULL; + LOGI("[%s] Event type : %d ", __FUNCTION__, type); + return PLAYER_ERROR_NONE; +} + +static void set_null_user_cb(callback_cb_info_s *cb_info, _player_event_e event) +{ + if(event < _PLAYER_EVENT_TYPE_NUM){ + cb_info->user_cb[event] = NULL; + cb_info->user_data[event] = NULL; + } +} + +static void __prepare_cb_handler(callback_cb_info_s * cb_info, char *recvMsg) +{ + char caps[MM_MSG_MAX_LENGTH] = {0}; + + if(player_msg_get_string(caps, recvMsg)) + if(strlen(caps) > 0) + mm_player_mused_realize(cb_info->local_handle, caps); + + ((player_prepared_cb) + cb_info->user_cb[_PLAYER_EVENT_TYPE_PREPARE])( + cb_info->user_data[_PLAYER_EVENT_TYPE_PREPARE]); + + set_null_user_cb(cb_info, _PLAYER_EVENT_TYPE_PREPARE); +} + +static void __complete_cb_handler(callback_cb_info_s * cb_info, char *recvMsg) +{ + ((player_completed_cb) + cb_info->user_cb[_PLAYER_EVENT_TYPE_COMPLETE])( + cb_info->user_data[_PLAYER_EVENT_TYPE_COMPLETE]); +} + +static void __interrupt_cb_handler(callback_cb_info_s * cb_info, char *recvMsg) +{ + int interrupt; + if(player_msg_get(interrupt, recvMsg)) { + player_interrupted_code_e ev = interrupt; + ((player_interrupted_cb) + cb_info->user_cb[_PLAYER_EVENT_TYPE_INTERRUPT])( + ev, cb_info->user_data[_PLAYER_EVENT_TYPE_INTERRUPT]); + } +} + +static void __error_cb_handler(callback_cb_info_s * cb_info, char *recvMsg) +{ + int code; + if(player_msg_get(code, recvMsg)) { + ((player_error_cb) cb_info->user_cb[_PLAYER_EVENT_TYPE_ERROR])( + code, cb_info->user_data[_PLAYER_EVENT_TYPE_ERROR]); + } +} + +static void __buffering_cb_handler(callback_cb_info_s * cb_info, char *recvMsg) +{ + int percent; + if(player_msg_get(percent, recvMsg)) { + ((player_buffering_cb) cb_info->user_cb[_PLAYER_EVENT_TYPE_BUFFERING])( + percent, cb_info->user_data[_PLAYER_EVENT_TYPE_BUFFERING]); + } +} + +static void __subtitle_cb_handler(callback_cb_info_s * cb_info, char *recvMsg) +{ + int duration = 0; + char text[MM_URI_MAX_LENGTH]; + if(player_msg_get(duration, recvMsg) + && player_msg_get_string(text, recvMsg)) { + ((player_subtitle_updated_cb) + cb_info->user_cb[_PLAYER_EVENT_TYPE_SUBTITLE]) ( + duration, text, cb_info->user_data[_PLAYER_EVENT_TYPE_SUBTITLE]); + } +} + +static void __capture_cb_handler(callback_cb_info_s * cb_info, char *recvMsg) +{ + unsigned char *data = NULL; + int width = 0; + int height = 0; + unsigned int size = 0; + tbm_bo bo; + tbm_bo_handle thandle; + tbm_key key; + + if(player_msg_get(width, recvMsg) && player_msg_get(height, recvMsg) + && player_msg_get(size, recvMsg)) { + if(!player_msg_get(key, recvMsg)) + goto capture_event_exit1; + + bo = tbm_bo_import(bufmgr, key); + if(bo == NULL) { + LOGE("TBM get error : bo is NULL"); + goto capture_event_exit1; + } + thandle = tbm_bo_map (bo, TBM_DEVICE_CPU, + TBM_OPTION_WRITE | TBM_OPTION_READ); + if(thandle.ptr == NULL) + { + LOGE("TBM get error : handle pointer is NULL"); + goto capture_event_exit2; + } + data = g_new(unsigned char, size); + if(data){ + memcpy(data, thandle.ptr, size); + ((player_video_captured_cb) + cb_info->user_cb[_PLAYER_EVENT_TYPE_CAPTURE]) ( + data, width, height, size, + cb_info->user_data[_PLAYER_EVENT_TYPE_CAPTURE]); + g_free(data); + } + else + LOGE("g_new failure"); + + /* mark to read */ + *((char *)thandle.ptr+size) = 0; + + tbm_bo_unmap(bo); +capture_event_exit2: + tbm_bo_unref(bo); + } +capture_event_exit1: + set_null_user_cb(cb_info, _PLAYER_EVENT_TYPE_CAPTURE); +} + +static void __seek_cb_handler(callback_cb_info_s * cb_info, char *recvMsg) +{ + ((player_seek_completed_cb)cb_info->user_cb[_PLAYER_EVENT_TYPE_SEEK]) + (cb_info->user_data[_PLAYER_EVENT_TYPE_SEEK]); + + set_null_user_cb(cb_info, _PLAYER_EVENT_TYPE_SEEK); +} + +static void __media_packet_video_frame_cb_handler( + callback_cb_info_s * cb_info, char *recvMsg) +{ + tbm_bo bo[4] = {NULL, }; + tbm_key key[4] = {0, }; + tbm_surface_info_s sinfo; + char *surface_info = (char *)&sinfo; + media_packet_h pkt = NULL; + tbm_surface_h tsurf = NULL; + int bo_num = 0; + media_format_mimetype_e mimetype = MEDIA_FORMAT_NV12; + bool make_pkt_fmt = false; + int ret; + _media_pkt_fin_data *fin_data; + int packet; + int i; + + player_msg_get(key[0], recvMsg); + player_msg_get(key[1], recvMsg); + player_msg_get(key[2], recvMsg); + player_msg_get(key[3], recvMsg); + player_msg_get(packet, recvMsg); + player_msg_get(mimetype, recvMsg); + player_msg_get_array(surface_info, recvMsg); + + LOGD("width %d, height %d", sinfo.width, sinfo.height); + + for(i = 0; i < 4; i++) { + if(key[i]){ + bo_num++; + bo[i] = tbm_bo_import(bufmgr, key[i]); + } + } + + tsurf = tbm_surface_internal_create_with_bos(&sinfo ,bo, bo_num); + if (tsurf) { + /* check media packet format */ + if (cb_info->pkt_fmt) { + int pkt_fmt_width = 0; + int pkt_fmt_height = 0; + media_format_mimetype_e pkt_fmt_mimetype = MEDIA_FORMAT_NV12; + + media_format_get_video_info(cb_info->pkt_fmt, &pkt_fmt_mimetype, + &pkt_fmt_width, &pkt_fmt_height, NULL, NULL); + if (pkt_fmt_mimetype != mimetype || + pkt_fmt_width != sinfo.width || + pkt_fmt_height != sinfo.height) { + LOGW("different format. current 0x%x, %dx%d, new 0x%x, %dx%d", + pkt_fmt_mimetype, pkt_fmt_width, pkt_fmt_height, mimetype, + sinfo.width, sinfo.height); + media_format_unref(cb_info->pkt_fmt); + cb_info->pkt_fmt = NULL; + make_pkt_fmt = true; + } + } else { + make_pkt_fmt = true; + } + /* create packet format */ + if (make_pkt_fmt) { + LOGI("make new pkt_fmt - mimetype 0x%x, %dx%d", mimetype, + sinfo.width, sinfo.height); + ret = media_format_create(&cb_info->pkt_fmt); + if (ret == MEDIA_FORMAT_ERROR_NONE) { + ret = media_format_set_video_mime(cb_info->pkt_fmt, mimetype); + ret |= media_format_set_video_width(cb_info->pkt_fmt, sinfo.width); + ret |= media_format_set_video_height(cb_info->pkt_fmt, sinfo.height); + LOGI("media_format_set_video_mime,width,height ret : 0x%x", ret); + } else { + LOGE("media_format_create failed"); + } + } + + fin_data = g_new(_media_pkt_fin_data, 1); + fin_data->remote_pkt = packet; + fin_data->cb_info = cb_info; + ret = media_packet_create_from_tbm_surface(cb_info->pkt_fmt, tsurf, + (media_packet_finalize_cb)_player_media_packet_finalize, + (void *)fin_data, &pkt); + if (ret != MEDIA_PACKET_ERROR_NONE) { + LOGE("media_packet_create_from_tbm_surface failed"); + tbm_surface_destroy(tsurf); + tsurf = NULL; + } + } + if (pkt) { + /* call media packet callback */ + ((player_media_packet_video_decoded_cb) + cb_info->user_cb[_PLAYER_EVENT_TYPE_MEDIA_PACKET_VIDEO_FRAME])( + pkt, cb_info->user_data[_PLAYER_EVENT_TYPE_MEDIA_PACKET_VIDEO_FRAME]); + } + for(i = 0; i < bo_num; i++) { + if(bo[i]) + tbm_bo_unref(bo[i]); + } +} + +static void __audio_frame_cb_handler( + callback_cb_info_s * cb_info, char *recvMsg) +{ +} + +static void __video_frame_render_error_cb_handler( + callback_cb_info_s * cb_info, char *recvMsg) +{ +} + +static void __pd_cb_handler(callback_cb_info_s * cb_info, char *recvMsg) +{ +} + +static void __supported_audio_effect_cb_handler( + callback_cb_info_s * cb_info, char *recvMsg) +{ +} + +static void __supported_audio_effect_freset_cb_handler( + callback_cb_info_s * cb_info, char *recvMsg) +{ +} + +static void __missed_plugin_cb_handler( + callback_cb_info_s * cb_info, char *recvMsg) +{ +} + +static void __media_stream_video_buffer_cb_handler( + callback_cb_info_s * cb_info, char *recvMsg) +{ + //player_media_stream_buffer_status_e status; + int status; + + if(player_msg_get(status, recvMsg)) { + ((player_media_stream_buffer_status_cb) + cb_info->user_cb[ + _PLAYER_EVENT_TYPE_MEDIA_STREAM_VIDEO_BUFFER_STATUS])( + (player_media_stream_buffer_status_e)status, cb_info->user_data[ + _PLAYER_EVENT_TYPE_MEDIA_STREAM_VIDEO_BUFFER_STATUS]); + } +} + +static void __media_stream_audio_buffer_cb_handler( + callback_cb_info_s * cb_info, char *recvMsg) +{ + //player_media_stream_buffer_status_e status; + int status; + + if(player_msg_get(status, recvMsg)) { + ((player_media_stream_buffer_status_cb) + cb_info->user_cb[ + _PLAYER_EVENT_TYPE_MEDIA_STREAM_AUDIO_BUFFER_STATUS])( + (player_media_stream_buffer_status_e)status, cb_info->user_data[ + _PLAYER_EVENT_TYPE_MEDIA_STREAM_AUDIO_BUFFER_STATUS]); + } + +} + + +static void __media_stream_video_seek_cb_handler( + callback_cb_info_s * cb_info, char *recvMsg) +{ + unsigned long long offset; + + if(player_msg_get_type(offset, recvMsg, INT64)) { + ((player_media_stream_seek_cb) + cb_info->user_cb[ + _PLAYER_EVENT_TYPE_MEDIA_STREAM_VIDEO_SEEK])( + offset, cb_info->user_data[ + _PLAYER_EVENT_TYPE_MEDIA_STREAM_VIDEO_SEEK]); + } +} + + +static void __media_stream_audio_seek_cb_handler( + callback_cb_info_s * cb_info, char *recvMsg) +{ + unsigned long long offset; + + if(player_msg_get_type(offset, recvMsg, INT64)) { + ((player_media_stream_seek_cb) + cb_info->user_cb[ + _PLAYER_EVENT_TYPE_MEDIA_STREAM_AUDIO_SEEK])( + offset, cb_info->user_data[ + _PLAYER_EVENT_TYPE_MEDIA_STREAM_AUDIO_SEEK]); + } +} + +static void __video_stream_changed_cb_handler( + callback_cb_info_s * cb_info, char *recvMsg) +{ + int width; + int height; + int fps; + int bit_rate; + if(player_msg_get(width, recvMsg) + && player_msg_get(height, recvMsg) + && player_msg_get(fps, recvMsg) + && player_msg_get(bit_rate, recvMsg)) { + ((player_video_stream_changed_cb) + cb_info->user_cb[ + _PLAYER_EVENT_TYPE_VIDEO_STREAM_CHANGED])( + width, height, fps, bit_rate, cb_info->user_data[ + _PLAYER_EVENT_TYPE_VIDEO_STREAM_CHANGED]); + } +} + +static void (*_user_callbacks[_PLAYER_EVENT_TYPE_NUM]) + (callback_cb_info_s * cb_info, char *recvMsg) = { + __prepare_cb_handler, /*_PLAYER_EVENT_TYPE_PREPARE*/ + __complete_cb_handler, /*_PLAYER_EVENT_TYPE_COMPLETE*/ + __interrupt_cb_handler, /*_PLAYER_EVENT_TYPE_INTERRUPT*/ + __error_cb_handler, /*_PLAYER_EVENT_TYPE_ERROR*/ + __buffering_cb_handler, /*_PLAYER_EVENT_TYPE_BUFFERING*/ + __subtitle_cb_handler, /*_PLAYER_EVENT_TYPE_SUBTITLE*/ + __capture_cb_handler, /*_PLAYER_EVENT_TYPE_CAPTURE*/ + __seek_cb_handler, /*_PLAYER_EVENT_TYPE_SEEK*/ + __media_packet_video_frame_cb_handler, /*_PLAYER_EVENT_TYPE_MEDIA_PACKET_VIDEO_FRAME*/ + __audio_frame_cb_handler, /*_PLAYER_EVENT_TYPE_AUDIO_FRAME*/ + __video_frame_render_error_cb_handler, /*_PLAYER_EVENT_TYPE_VIDEO_FRAME_RENDER_ERROR*/ + __pd_cb_handler, /*_PLAYER_EVENT_TYPE_PD*/ + __supported_audio_effect_cb_handler, /*_PLAYER_EVENT_TYPE_SUPPORTED_AUDIO_EFFECT*/ + __supported_audio_effect_freset_cb_handler, /*_PLAYER_EVENT_TYPE_SUPPORTED_AUDIO_EFFECT_PRESET*/ + __missed_plugin_cb_handler, /*_PLAYER_EVENT_TYPE_MISSED_PLUGIN*/ +#ifdef _PLAYER_FOR_PRODUCT + NULL, /*_PLAYER_EVENT_TYPE_IMAGE_BUFFER*/ + NULL, /*_PLAYER_EVENT_TYPE_SELECTED_SUBTITLE_LANGUAGE*/ +#endif + __media_stream_video_buffer_cb_handler, /*_PLAYER_EVENT_TYPE_MEDIA_STREAM_VIDEO_BUFFER_STATUS*/ + __media_stream_audio_buffer_cb_handler, /*_PLAYER_EVENT_TYPE_MEDIA_STREAM_AUDIO_BUFFER_STATUS*/ + __media_stream_video_seek_cb_handler, /*_PLAYER_EVENT_TYPE_MEDIA_STREAM_VIDEO_SEEK*/ + __media_stream_audio_seek_cb_handler, /*_PLAYER_EVENT_TYPE_MEDIA_STREAM_AUDIO_SEEK*/ + NULL, /*_PLAYER_EVENT_TYPE_AUDIO_STREAM_CHANGED*/ + __video_stream_changed_cb_handler, /*_PLAYER_EVENT_TYPE_VIDEO_STREAM_CHANGED*/ +}; + +static void _player_event_job_function(_player_cb_data *data) +{ + _user_callbacks[data->int_data](data->cb_info, data->buf); + + g_free(data->buf); + g_free(data); +} + +static void * _player_event_queue_loop(void *param) +{ + if(!param) { + LOGE("NULL parameter"); + return NULL; + } + callback_cb_info_s *cb_info = param; + player_event_queue *ev = &cb_info->event_queue; + _player_cb_data *event_data; + + g_mutex_lock(&ev->mutex); + while(ev->running) { + if(g_queue_is_empty(ev->queue)) { + g_cond_wait(&ev->cond, &ev->mutex); + if(!ev->running) + break; + } + while(1) { + event_data = (_player_cb_data *)g_queue_pop_head(ev->queue); + g_mutex_unlock(&ev->mutex); + if(event_data) + _player_event_job_function(event_data); + else { + g_mutex_lock(&ev->mutex); + break; + } + g_mutex_lock(&ev->mutex); + } + } + g_mutex_unlock(&ev->mutex); + LOGI("Exit event loop"); + return NULL; +} + +static gboolean _player_event_queue_new(callback_cb_info_s *cb_info) +{ + g_return_val_if_fail(cb_info, FALSE); + player_event_queue *ev = &cb_info->event_queue; + + ev->queue = g_queue_new(); + g_return_val_if_fail(ev->queue, FALSE); + + g_mutex_init(&ev->mutex); + g_cond_init(&ev->cond); + ev->running = TRUE; + ev->thread = + g_thread_new("cb_event_thread", _player_event_queue_loop, + (gpointer) cb_info); + g_return_val_if_fail(ev->thread, FALSE); + LOGI("event queue thread %p", ev->thread); + + return TRUE; + +} + +static void _player_event_queue_destroy(callback_cb_info_s *cb_info) +{ + g_return_if_fail(cb_info); + player_event_queue *ev = &cb_info->event_queue; + + LOGI("event queue thread %p", ev->thread); + + g_mutex_lock(&ev->mutex); + ev->running = FALSE; + g_cond_broadcast(&ev->cond); + g_mutex_unlock(&ev->mutex); + + g_thread_join(ev->thread); + g_thread_unref(ev->thread); + + g_queue_free(ev->queue); + g_mutex_clear(&ev->mutex); + g_cond_clear(&ev->cond); + +} + +static void _player_event_queue_add(player_event_queue *ev, _player_cb_data *data) +{ + g_mutex_lock(&ev->mutex); + if(ev->running){ + g_queue_push_tail(ev->queue, (gpointer)data); + g_cond_signal(&ev->cond); + } + g_mutex_unlock(&ev->mutex); +} + +static void _user_callback_handler(callback_cb_info_s * cb_info, + _player_event_e event, char *buffer) +{ + LOGD("get event %d", event); + + if(event < _PLAYER_EVENT_TYPE_NUM){ + if(cb_info->user_cb[event] && _user_callbacks[event]){ + _player_cb_data *data = NULL; + data = g_new( _player_cb_data, 1); + if(!data) { + LOGE("fail to alloc mem"); + return; + } + data->int_data = (int)event; + data->cb_info = cb_info; + data->buf = buffer; + _player_event_queue_add(&cb_info->event_queue, data); + } + } +} + +static void _add_ret_msg(mm_player_api_e api, callback_cb_info_s *cb_info, + int offset, int parse_len) +{ + ret_msg_s *msg = NULL; + ret_msg_s *last = cb_info->buff.retMsgHead; + + + msg = g_new(ret_msg_s, 1); + if(msg) + { + msg->api = api; + msg->msg = strndup(cb_info->buff.recvMsg + offset, parse_len); + msg->next = NULL; + if(last == NULL) + cb_info->buff.retMsgHead = msg; + else { + while(last->next) + last = last->next; + last->next = msg; + } + } + else + LOGE("g_new failure"); +} + +static ret_msg_s * _get_ret_msg(mm_player_api_e api, callback_cb_info_s *cb_info) +{ + ret_msg_s *msg = cb_info->buff.retMsgHead; + ret_msg_s *prev = NULL; + while(msg){ + if(msg->api == api){ + if(!prev) { + cb_info->buff.retMsgHead = msg->next; + } + else { + prev->next = msg->next; + } + return msg; + } + prev = msg; + msg = msg->next; + } + return NULL; +} + +static void *client_cb_handler(gpointer data) +{ + int api; + int len = 0; + int parse_len = 0; + int offset = 0; + callback_cb_info_s *cb_info = data; + char *recvMsg = cb_info->buff.recvMsg; + mused_msg_parse_err_e err; + + while (g_atomic_int_get(&cb_info->running)) { + len = 0; + err = MUSED_MSG_PARSE_ERROR_NONE; + do { + len = player_recv_msg(cb_info, len); + if (len <= 0) + break; + recvMsg[len] = '\0'; + parse_len = len; + offset = 0; + while(offset < len){ + api = MM_PLAYER_API_MAX; + if(player_msg_get_error_e(api, recvMsg + offset, parse_len, err)) { + if(api < MM_PLAYER_API_MAX){ + g_mutex_lock(&cb_info->player_mutex); + cb_info->buff.recved++; + _add_ret_msg(api, cb_info, offset, parse_len); + g_cond_signal(&cb_info->player_cond[api]); + g_mutex_unlock(&cb_info->player_mutex); + if (api == MM_PLAYER_API_DESTROY) { + g_atomic_int_set(&cb_info->running, 0); + } + } + else if(api == MM_PLAYER_CB_EVENT) { + int event; + char *buffer; + g_mutex_lock(&cb_info->player_mutex); + buffer = strndup(recvMsg + offset, parse_len); + g_mutex_unlock(&cb_info->player_mutex); + if(player_msg_get(event, buffer)) { + _user_callback_handler(cb_info, event, buffer); + } + } + } + if(parse_len == 0) break; + offset += parse_len; + parse_len = len - parse_len; + } + }while(err == MUSED_MSG_PARSE_ERROR_CONTINUE); + if (len <= 0) + break; + } + LOGD("client cb exit"); + + return NULL; +} + +static callback_cb_info_s *callback_new(gint sockfd) +{ + callback_cb_info_s *cb_info; + msg_buff_s *buff; + int i; + + g_return_val_if_fail(sockfd > 0, NULL); + + cb_info = g_new(callback_cb_info_s, 1); + memset(cb_info, 0, sizeof(callback_cb_info_s)); + + g_mutex_init(&cb_info->player_mutex); + for(i=0; iplayer_cond[i]); + + buff = &cb_info->buff; + buff->recvMsg = g_new(char, MM_MSG_MAX_LENGTH+1); + buff->bufLen = MM_MSG_MAX_LENGTH+1; + buff->recved = 0; + buff->retMsgHead = NULL; + + g_atomic_int_set(&cb_info->running, 1); + cb_info->fd = sockfd; + cb_info->thread = + g_thread_new("callback_thread", client_cb_handler, + (gpointer) cb_info); + + return cb_info; +} + +static void callback_destroy(callback_cb_info_s * cb_info) +{ + int i; + g_return_if_fail(cb_info); + + mmsvc_core_connection_close(cb_info->fd); + + g_thread_join(cb_info->thread); + g_thread_unref(cb_info->thread); + + LOGI("%p Callback destroyed", cb_info->thread); + + g_mutex_clear(&cb_info->player_mutex); + for(i=0; iplayer_cond[i]); + + g_free(cb_info->buff.recvMsg); + g_free(cb_info); +} + +static int wait_for_cb_return(mm_player_api_e api, callback_cb_info_s *cb_info, + char **ret_buf, int time_out) +{ + int ret = PLAYER_ERROR_NONE; + gint64 end_time = g_get_monotonic_time() + time_out * G_TIME_SPAN_SECOND; + msg_buff_s *buff = &cb_info->buff; + ret_msg_s *msg = NULL; + + g_mutex_lock(&cb_info->player_mutex); + + msg = _get_ret_msg(api, cb_info); + if(!buff->recved || !msg) { + if (!g_cond_wait_until(&cb_info->player_cond[api], &cb_info->player_mutex, end_time)) { + g_mutex_unlock(&cb_info->player_mutex); + return PLAYER_ERROR_INVALID_OPERATION; + } + } + if(!msg) + msg = _get_ret_msg(api, cb_info); + if(msg) { + *ret_buf = msg->msg; + g_free(msg); + if(!player_msg_get(ret, *ret_buf)) + ret = PLAYER_ERROR_INVALID_OPERATION; + } + else { + LOGE("api %d return msg is not exist", api); + ret = PLAYER_ERROR_INVALID_OPERATION; + } + buff->recved--; + + g_mutex_unlock(&cb_info->player_mutex); + + return ret; +} + +/* +* Public Implementation +*/ + +int player_create(player_h * player) +{ + PLAYER_INSTANCE_CHECK(player); + + int ret = PLAYER_ERROR_NONE; + int sock_fd = -1; + + mm_player_api_e api = MM_PLAYER_API_CREATE; + mmsvc_api_client_e client = MMSVC_PLAYER; + player_cli_s *pc = NULL; + char *ret_buf = NULL; + + LOGD("ENTER"); + + sock_fd = mmsvc_core_client_new(); + if(sock_fd < 0){ + LOGE("connection failure %d", errno); + ret = PLAYER_ERROR_INVALID_OPERATION; + goto ErrorExit; + } + player_msg_send1_async(api, (intptr_t)player, sock_fd, INT, client); + + pc = g_new0(player_cli_s, 1); + if (pc == NULL) { + ret = PLAYER_ERROR_OUT_OF_MEMORY; + goto ErrorExit; + } + + pc->cb_info = callback_new(sock_fd); + if(!pc->cb_info) { + LOGE("fail to create callback"); + ret = PLAYER_ERROR_INVALID_OPERATION; + goto ErrorExit; + } + if(!_player_event_queue_new(pc->cb_info)) { + LOGE("fail to create event queue"); + ret = PLAYER_ERROR_INVALID_OPERATION; + goto ErrorExit; + } + + ret = wait_for_cb_return(api, pc->cb_info, &ret_buf, CALLBACK_TIME_OUT); + if (ret == PLAYER_ERROR_NONE) { + intptr_t handle; + intptr_t client_addr; + char stream_path[MM_MSG_MAX_LENGTH] = {0,}; + if(player_msg_get_type(handle, ret_buf, POINTER)) { + EXT_HANDLE(pc) = handle; + LOGD("Player create 0x%x", EXT_HANDLE(pc)); + *player = (player_h) pc; + } + if(player_msg_get_type(client_addr, ret_buf, POINTER)) { + pc->cb_info->data_fd = mmsvc_core_client_new_data_ch(); + mmsvc_core_send_client_addr(client_addr, pc->cb_info->data_fd); + LOGD("Data channel fd %d, server side client info addr %p", + pc->cb_info->data_fd, client_addr); + } + + if(mm_player_mused_create(&INT_HANDLE(pc)) != MM_ERROR_NONE) { + LOGE("create failure"); + ret = PLAYER_ERROR_INVALID_OPERATION; + goto ErrorExit; + } + if(player_msg_get_string(stream_path, ret_buf)) { + LOGD("shmsrc stream path : %s", stream_path); + if(mm_player_set_shm_stream_path(INT_HANDLE(pc), stream_path) + != MM_ERROR_NONE) + goto ErrorExit; + } + } else + goto ErrorExit; + + bufmgr = tbm_bufmgr_init (-1); + + g_free(ret_buf); + return ret; + +ErrorExit: + if(pc && pc->cb_info) { + if(pc->cb_info->event_queue.running) + _player_event_queue_destroy(pc->cb_info); + callback_destroy(pc->cb_info); + pc->cb_info = NULL; + } + g_free(pc); + g_free(ret_buf); + LOGD("ret value : %d", ret); + return ret; +} + +int player_destroy(player_h player) +{ + PLAYER_INSTANCE_CHECK(player); + + int ret = PLAYER_ERROR_NONE; + mm_player_api_e api = MM_PLAYER_API_DESTROY; + player_cli_s *pc = (player_cli_s *) player; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + + LOGD("ENTER"); + + player_msg_send(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret); + + if(mm_player_mused_destroy(INT_HANDLE(pc)) != MM_ERROR_NONE) + ret = PLAYER_ERROR_INVALID_OPERATION; + + _player_event_queue_destroy(pc->cb_info); + callback_destroy(pc->cb_info); + + tbm_bufmgr_deinit (bufmgr); + + g_free(pc); + pc = NULL; + + g_free(ret_buf); + return ret; +} + +int player_prepare_async(player_h player, player_prepared_cb callback, + void *user_data) +{ + PLAYER_INSTANCE_CHECK(player); + int ret = PLAYER_ERROR_NONE; + mm_player_api_e api = MM_PLAYER_API_PREPARE_ASYNC; + player_cli_s *pc = (player_cli_s *) player; + int sock_fd; + char *ret_buf = NULL; + + LOGD("ENTER"); + sock_fd = pc->cb_info->fd; + + if (pc->cb_info->user_cb[_PLAYER_EVENT_TYPE_PREPARE]) { + LOGE("[%s] PLAYER_ERROR_INVALID_OPERATION (0x%08x) : preparing... we can't do any more ", __FUNCTION__, PLAYER_ERROR_INVALID_OPERATION); + return PLAYER_ERROR_INVALID_OPERATION; + } else { + pc->cb_info->user_cb[_PLAYER_EVENT_TYPE_PREPARE] = callback; + pc->cb_info->user_data[_PLAYER_EVENT_TYPE_PREPARE] = user_data; + } + player_msg_send(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret); + + g_free(ret_buf); + return ret; +} + +int player_prepare(player_h player) +{ + PLAYER_INSTANCE_CHECK(player); + int ret = PLAYER_ERROR_NONE; + mm_player_api_e api = MM_PLAYER_API_PREPARE; + player_cli_s *pc = (player_cli_s *) player; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + char caps[MM_MSG_MAX_LENGTH] = {0}; + + LOGD("ENTER"); + + player_msg_send(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret); + + if(ret == PLAYER_ERROR_NONE) { + player_msg_get_string(caps, ret_buf); + if(strlen(caps) > 0 && + mm_player_mused_realize(INT_HANDLE(pc), caps) != MM_ERROR_NONE) + ret = PLAYER_ERROR_INVALID_OPERATION; + } + + g_free(ret_buf); + return ret; +} + +int player_unprepare(player_h player) +{ + PLAYER_INSTANCE_CHECK(player); + int ret = PLAYER_ERROR_NONE; + mm_player_api_e api = MM_PLAYER_API_UNPREPARE; + player_cli_s *pc = (player_cli_s *) player; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + + LOGD("ENTER"); + + mm_player_mused_pre_unrealize(INT_HANDLE(pc)); + + player_msg_send(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret); + if(ret == PLAYER_ERROR_NONE){ + set_null_user_cb(pc->cb_info, _PLAYER_EVENT_TYPE_SEEK); + set_null_user_cb(pc->cb_info, _PLAYER_EVENT_TYPE_PREPARE); + _del_mem(pc); + _player_deinit_memory_buffer(pc); + } + + if(mm_player_mused_unrealize(INT_HANDLE(pc)) != MM_ERROR_NONE) + ret = PLAYER_ERROR_INVALID_OPERATION; + + g_free(ret_buf); + return ret; +} + +int player_set_uri(player_h player, const char *uri) +{ + PLAYER_INSTANCE_CHECK(player); + PLAYER_NULL_ARG_CHECK(uri); + int ret = PLAYER_ERROR_NONE; + mm_player_api_e api = MM_PLAYER_API_SET_URI; + player_cli_s *pc = (player_cli_s *) player; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + + LOGD("ENTER"); + + player_msg_send1(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret, + STRING, uri); + + g_free(ret_buf); + return ret; +} + +int player_set_memory_buffer(player_h player, const void *data, int size) +{ + PLAYER_INSTANCE_CHECK(player); + PLAYER_NULL_ARG_CHECK(data); + int ret = PLAYER_ERROR_NONE; + mm_player_api_e api = MM_PLAYER_API_SET_MEMORY_BUFFER; + player_cli_s *pc = (player_cli_s *) player; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + tbm_bo bo; + tbm_bo_handle thandle; + tbm_key key; + + if(pc->server_tbm.bo){ + LOGE("Already set the memory buffer. unprepare please"); + return PLAYER_ERROR_INVALID_OPERATION; + } + + bo = tbm_bo_alloc (bufmgr, size, TBM_BO_DEFAULT); + if(bo == NULL) { + LOGE("TBM get error : bo is NULL"); + return PLAYER_ERROR_INVALID_OPERATION; + } + thandle = tbm_bo_map (bo, TBM_DEVICE_CPU, TBM_OPTION_WRITE); + if(thandle.ptr == NULL) + { + LOGE("TBM get error : handle pointer is NULL"); + ret = PLAYER_ERROR_INVALID_OPERATION; + goto set_memory_exit; + } + memcpy(thandle.ptr, data, size); + tbm_bo_unmap(bo); + + key = tbm_bo_export(bo); + if(key == 0) { + LOGE("TBM get error : key is 0"); + ret = PLAYER_ERROR_INVALID_OPERATION; + goto set_memory_exit; + } + + player_msg_send2(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret, + INT, key, INT, size); + +set_memory_exit: + tbm_bo_unref(bo); + + if(ret == PLAYER_ERROR_NONE) { + intptr_t bo_addr = 0; + if(player_msg_get_type(bo_addr, ret_buf, POINTER)) + pc->server_tbm.bo = (intptr_t)bo_addr; + } + + g_free(ret_buf); + return ret; +} + +static int _player_deinit_memory_buffer(player_cli_s *pc) +{ + PLAYER_INSTANCE_CHECK(pc); + int ret = PLAYER_ERROR_NONE; + mm_player_api_e api = MM_PLAYER_API_DEINIT_MEMORY_BUFFER; + int sock_fd = pc->cb_info->fd; + intptr_t bo_addr = pc->server_tbm.bo; + + if(!bo_addr) + return ret; + + player_msg_send1_async(api, EXT_HANDLE(pc), sock_fd, + POINTER, bo_addr); + pc->server_tbm.bo = 0; + + return ret; +} + +int player_get_state(player_h player, player_state_e * pstate) +{ + PLAYER_INSTANCE_CHECK(player); + PLAYER_NULL_ARG_CHECK(pstate); + int ret = PLAYER_ERROR_NONE; + mm_player_api_e api = MM_PLAYER_API_GET_STATE; + player_cli_s *pc = (player_cli_s *) player; + int state; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + + LOGD("ENTER"); + + player_msg_send(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret); + + if (ret == PLAYER_ERROR_NONE) { + player_msg_get(state, ret_buf); + *pstate = state; + } + + g_free(ret_buf); + return ret; +} + +int player_set_volume(player_h player, float left, float right) +{ + PLAYER_INSTANCE_CHECK(player); + PLAYER_CHECK_CONDITION(left>=0 && left <= 1.0 ,PLAYER_ERROR_INVALID_PARAMETER,"PLAYER_ERROR_INVALID_PARAMETER" ); + PLAYER_CHECK_CONDITION(right>=0 && right <= 1.0 ,PLAYER_ERROR_INVALID_PARAMETER, "PLAYER_ERROR_INVALID_PARAMETER" ); + int ret = PLAYER_ERROR_NONE; + mm_player_api_e api = MM_PLAYER_API_SET_VOLUME; + player_cli_s *pc = (player_cli_s *) player; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + + LOGD("ENTER"); + + player_msg_send2(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret, + DOUBLE, right, DOUBLE, left); + g_free(ret_buf); + return ret; +} + +int player_get_volume(player_h player, float *pleft, float *pright) +{ + PLAYER_INSTANCE_CHECK(player); + PLAYER_NULL_ARG_CHECK(pleft); + PLAYER_NULL_ARG_CHECK(pright); + int ret = PLAYER_ERROR_NONE; + mm_player_api_e api = MM_PLAYER_API_GET_VOLUME; + player_cli_s *pc = (player_cli_s *) player; + double left = -1; + double right = -1; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + + LOGD("ENTER"); + + player_msg_send(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret); + + if(ret == PLAYER_ERROR_NONE) { + player_msg_get(left, ret_buf); + player_msg_get(right, ret_buf); + *pleft = (float)left; + *pright = (float)right; + } + + g_free(ret_buf); + return ret; +} + +int player_set_sound_type(player_h player, sound_type_e type) +{ + PLAYER_INSTANCE_CHECK(player); + int ret = PLAYER_ERROR_NONE; + mm_player_api_e api = MM_PLAYER_API_SET_SOUND_TYPE; + player_cli_s *pc = (player_cli_s *) player; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + + LOGD("ENTER"); + + player_msg_send1(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret, + INT, type); + g_free(ret_buf); + return ret; +} + +#ifndef USE_ASM +int player_set_audio_policy_info(player_h player, sound_stream_info_h stream_info) +{ + PLAYER_INSTANCE_CHECK(player); + + mm_player_api_e api = MM_PLAYER_API_SET_AUDIO_POLICY_INFO; + player_cli_s *pc = (player_cli_s *) player; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + + LOGD("ENTER"); + + bool is_available = false; + + /* check if stream_info is valid */ + int ret = __player_convert_error_code( + sound_manager_is_available_stream_information(stream_info, NATIVE_API_PLAYER, &is_available) + , (char*)__FUNCTION__); + + if(ret == PLAYER_ERROR_NONE) + { + if(is_available == false) + ret = PLAYER_ERROR_FEATURE_NOT_SUPPORTED_ON_DEVICE; + else + { + char *stream_type = NULL; + int stream_index = 0; + ret = sound_manager_get_type_from_stream_information(stream_info, &stream_type); + ret = sound_manager_get_index_from_stream_information(stream_info, &stream_index); + if (ret == SOUND_MANAGER_ERROR_NONE) + { + player_msg_send2(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret, + STRING, stream_type, INT, stream_index); + } + else + ret = PLAYER_ERROR_INVALID_OPERATION; + } + } + + g_free(ret_buf); + return ret; + +} +#endif /* USE_ASM */ + +int player_set_audio_latency_mode(player_h player, + audio_latency_mode_e latency_mode) +{ + PLAYER_INSTANCE_CHECK(player); + int ret = PLAYER_ERROR_NONE; + mm_player_api_e api = MM_PLAYER_API_SET_AUDIO_LATENCY_MODE; + player_cli_s *pc = (player_cli_s *) player; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + + LOGD("ENTER"); + + player_msg_send1(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret, + INT, latency_mode); + g_free(ret_buf); + return ret; +} + +int player_get_audio_latency_mode(player_h player, + audio_latency_mode_e * platency_mode) +{ + PLAYER_INSTANCE_CHECK(player); + PLAYER_NULL_ARG_CHECK(platency_mode); + int ret = PLAYER_ERROR_NONE; + mm_player_api_e api = MM_PLAYER_API_GET_AUDIO_LATENCY_MODE; + player_cli_s *pc = (player_cli_s *) player; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + int latency_mode = -1; + + LOGD("ENTER"); + + player_msg_send(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret); + + if (ret == PLAYER_ERROR_NONE) { + player_msg_get(latency_mode, ret_buf); + *platency_mode = latency_mode; + } + + g_free(ret_buf); + return ret; + +} + +int player_start(player_h player) +{ + PLAYER_INSTANCE_CHECK(player); + int ret = PLAYER_ERROR_NONE; + mm_player_api_e api = MM_PLAYER_API_START; + player_cli_s *pc = (player_cli_s *) player; + int sock_fd; + char *ret_buf = NULL; + + LOGD("ENTER"); + + sock_fd = pc->cb_info->fd; + + player_msg_send(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret); + + g_free(ret_buf); + return ret; +} + +int player_stop(player_h player) +{ + PLAYER_INSTANCE_CHECK(player); + int ret = PLAYER_ERROR_NONE; + mm_player_api_e api = MM_PLAYER_API_STOP; + player_cli_s *pc = (player_cli_s *) player; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + + LOGD("ENTER"); + + player_msg_send(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret); + if(ret == PLAYER_ERROR_NONE) { + set_null_user_cb(pc->cb_info, _PLAYER_EVENT_TYPE_SEEK); + } + + g_free(ret_buf); + return ret; +} + +int player_pause(player_h player) +{ + PLAYER_INSTANCE_CHECK(player); + int ret = PLAYER_ERROR_NONE; + mm_player_api_e api = MM_PLAYER_API_PAUSE; + player_cli_s *pc = (player_cli_s *) player; + int sock_fd; + char *ret_buf = NULL; + + LOGD("ENTER"); + + sock_fd = pc->cb_info->fd; + + player_msg_send(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret); + g_free(ret_buf); + return ret; +} + +int player_set_play_position(player_h player, int millisecond, bool accurate, + player_seek_completed_cb callback, void *user_data) +{ + PLAYER_INSTANCE_CHECK(player); + PLAYER_CHECK_CONDITION(millisecond >= 0, PLAYER_ERROR_INVALID_PARAMETER, + "PLAYER_ERROR_INVALID_PARAMETER"); + + int ret = PLAYER_ERROR_NONE; + mm_player_api_e api = MM_PLAYER_API_SET_PLAY_POSITION; + player_cli_s *pc = (player_cli_s *) player; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + int pos = millisecond; + + LOGD("ENTER"); + + if (pc->cb_info->user_cb[_PLAYER_EVENT_TYPE_SEEK]) { + LOGE("[%s] PLAYER_ERROR_SEEK_FAILED (0x%08x) : seeking... we can't do any more ", __FUNCTION__, PLAYER_ERROR_SEEK_FAILED); + return PLAYER_ERROR_SEEK_FAILED; + } else { + LOGI("[%s] Event type : %d, pos : %d ", __FUNCTION__, + _PLAYER_EVENT_TYPE_SEEK, millisecond); + pc->cb_info->user_cb[_PLAYER_EVENT_TYPE_SEEK] = callback; + pc->cb_info->user_data[_PLAYER_EVENT_TYPE_SEEK] = user_data; + } + + player_msg_send2(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret, + INT, pos, INT, accurate); + + if (ret != PLAYER_ERROR_NONE) { + pc->cb_info->user_cb[_PLAYER_EVENT_TYPE_SEEK] = NULL; + pc->cb_info->user_data[_PLAYER_EVENT_TYPE_SEEK] = NULL; + } + + g_free(ret_buf); + return ret; + +} + +int player_get_play_position(player_h player, int *millisecond) +{ + PLAYER_INSTANCE_CHECK(player); + PLAYER_NULL_ARG_CHECK(millisecond); + + int ret = PLAYER_ERROR_NONE; + mm_player_api_e api = MM_PLAYER_API_GET_PLAY_POSITION; + player_cli_s *pc = (player_cli_s *) player; + int pos; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + + LOGD("ENTER"); + + player_msg_send(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret); + + if (ret == PLAYER_ERROR_NONE) { + player_msg_get(pos, ret_buf); + *millisecond = pos; + } + + g_free(ret_buf); + return ret; +} + +int player_set_mute(player_h player, bool muted) +{ + PLAYER_INSTANCE_CHECK(player); + int ret = PLAYER_ERROR_NONE; + mm_player_api_e api = MM_PLAYER_API_SET_MUTE; + player_cli_s *pc = (player_cli_s *) player; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + int mute = (int)muted; + + LOGD("ENTER"); + + player_msg_send1(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret, + INT, mute); + g_free(ret_buf); + return ret; +} + +int player_is_muted(player_h player, bool * muted) +{ + PLAYER_INSTANCE_CHECK(player); + PLAYER_NULL_ARG_CHECK(muted); + int ret = PLAYER_ERROR_NONE; + mm_player_api_e api = MM_PLAYER_API_IS_MUTED; + player_cli_s *pc = (player_cli_s *) player; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + int mute = -1; + + LOGD("ENTER"); + + player_msg_send(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret); + if(ret == PLAYER_ERROR_NONE){ + player_msg_get(mute, ret_buf); + *muted = (bool)mute; + } + + g_free(ret_buf); + return ret; +} + +int player_set_looping(player_h player, bool looping) +{ + PLAYER_INSTANCE_CHECK(player); + int ret = PLAYER_ERROR_NONE; + mm_player_api_e api = MM_PLAYER_API_SET_LOOPING; + player_cli_s *pc = (player_cli_s *) player; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + + LOGD("ENTER"); + + player_msg_send1(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret, + INT, looping); + g_free(ret_buf); + return ret; +} + +int player_is_looping(player_h player, bool * plooping) +{ + PLAYER_INSTANCE_CHECK(player); + PLAYER_NULL_ARG_CHECK(plooping); + int ret = PLAYER_ERROR_NONE; + mm_player_api_e api = MM_PLAYER_API_IS_LOOPING; + player_cli_s *pc = (player_cli_s *) player; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + int looping = 0; + + LOGD("ENTER"); + + player_msg_send(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret); + if(ret == PLAYER_ERROR_NONE){ + player_msg_get(looping, ret_buf); + *plooping = looping; + } + g_free(ret_buf); + return ret; +} + +int player_get_duration(player_h player, int *pduration) +{ + PLAYER_INSTANCE_CHECK(player); + PLAYER_NULL_ARG_CHECK(pduration); + int ret = PLAYER_ERROR_NONE; + mm_player_api_e api = MM_PLAYER_API_GET_DURATION; + player_cli_s *pc = (player_cli_s *) player; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + int duration = 0; + + LOGD("ENTER"); + + player_msg_send(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret); + if(ret == PLAYER_ERROR_NONE){ + player_msg_get(duration, ret_buf); + *pduration = duration; + } + + g_free(ret_buf); + return ret; +} + +int player_set_display(player_h player, player_display_type_e type, + player_display_h display) +{ + PLAYER_INSTANCE_CHECK(player); + int ret = PLAYER_ERROR_NONE; + mm_player_api_e api = MM_PLAYER_API_SET_DISPLAY; + player_cli_s *pc = (player_cli_s *) player; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + Evas_Object *obj = NULL; + const char *object_type = NULL; +#ifdef HAVE_WAYLAND + void *set_handle = NULL; + void *set_wl_display = NULL; + Ecore_Wl_Window * wl_window = NULL; + wl_win_msg_type wl_win; + char *wl_win_msg = (char *)&wl_win; +#else + unsigned int xhandle = 0; +#endif + + LOGD("ENTER"); + + if(type != PLAYER_DISPLAY_TYPE_NONE) { + obj = (Evas_Object *) display; + if(!obj) + return PLAYER_ERROR_INVALID_PARAMETER; + + object_type = evas_object_type_get(obj); + if (object_type) { + if (type == PLAYER_DISPLAY_TYPE_OVERLAY + && !strcmp(object_type, "elm_win")) { +#ifdef HAVE_WAYLAND + /* wayland overlay surface*/ + LOGI("Wayland overlay surface type"); + wl_win.type = type; + + evas_object_geometry_get(obj, &wl_win.wl_window_x, &wl_win.wl_window_y, + &wl_win.wl_window_width, &wl_win.wl_window_height); + + wl_window = elm_win_wl_window_get(obj); + set_handle = (void *)ecore_wl_window_surface_get(wl_window); + + /* get wl_display */ + set_wl_display = (void *)ecore_wl_display_get(); + + LOGI("xid %d, surface_id %d, surface %p(%d), win_id %d", elm_win_xwindow_get(obj), + ecore_wl_window_surface_id_get(wl_window), + ecore_wl_window_surface_get(wl_window), *(int *)ecore_wl_window_surface_get(wl_window), + ecore_wl_window_id_get(wl_window)); +#else + /* x window overlay surface */ + LOGI("overlay surface type"); + xhandle = elm_win_xwindow_get(obj); +#endif + } + else + return PLAYER_ERROR_INVALID_PARAMETER; + } + else + return PLAYER_ERROR_INVALID_PARAMETER; + } +#ifdef HAVE_WAYLAND + else { + LOGI("Wayland surface type is NONE"); + wl_win.type = type; + wl_win.wl_window_x = 0; + wl_win.wl_window_y = 0; + wl_win.wl_window_width = 0; + wl_win.wl_window_height = 0; + } + player_msg_send_array(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret, + wl_win_msg, sizeof(wl_win_msg_type), sizeof(char)); + + ret = mm_player_set_attribute(INT_HANDLE(pc), NULL, + "display_surface_type", type, + "wl_display", set_wl_display, + sizeof(void*), + "display_overlay", set_handle, + sizeof(display), (char*)NULL); + if (ret != MM_ERROR_NONE) + LOGE("Failed to display surface change :%d", ret); + + ret = mm_player_set_attribute(INT_HANDLE(pc), NULL, + "wl_window_render_x", wl_win.wl_window_x, + "wl_window_render_y", wl_win.wl_window_y, + "wl_window_render_width", wl_win.wl_window_width, + "wl_window_render_height", wl_win.wl_window_height, + (char*)NULL); + + if (ret != MM_ERROR_NONE) + LOGE("Failed to set wl_window render rectangle :%d", ret); + +#else + player_msg_send2(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret, + INT, type, INT, xhandle); +#endif + + g_free(ret_buf); + return ret; +} + +int player_set_display_mode(player_h player, player_display_mode_e mode) +{ + PLAYER_INSTANCE_CHECK(player); + int ret = PLAYER_ERROR_NONE; + mm_player_api_e api = MM_PLAYER_API_SET_DISPLAY_MODE; + player_cli_s *pc = (player_cli_s *) player; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + + LOGD("ENTER"); + + player_msg_send1(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret, + INT, mode); + g_free(ret_buf); + return ret; +} + +int player_get_display_mode(player_h player, player_display_mode_e * pmode) +{ + PLAYER_INSTANCE_CHECK(player); + PLAYER_NULL_ARG_CHECK(pmode); + int ret = PLAYER_ERROR_NONE; + mm_player_api_e api = MM_PLAYER_API_GET_DISPLAY_MODE; + player_cli_s *pc = (player_cli_s *) player; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + int mode = -1; + + LOGD("ENTER"); + + player_msg_send(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret); + if(ret == PLAYER_ERROR_NONE){ + player_msg_get(mode, ret_buf); + *pmode = mode; + } + g_free(ret_buf); + return ret; +} + +int player_set_playback_rate(player_h player, float rate) +{ + PLAYER_INSTANCE_CHECK(player); + PLAYER_CHECK_CONDITION(rate>=-5.0 && rate <= 5.0 ,PLAYER_ERROR_INVALID_PARAMETER,"PLAYER_ERROR_INVALID_PARAMETER" ); + int ret = PLAYER_ERROR_NONE; + mm_player_api_e api = MM_PLAYER_API_SET_PLAYBACK_RATE; + player_cli_s *pc = (player_cli_s *) player; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + + LOGD("ENTER"); + + player_msg_send1(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret, + DOUBLE, rate); + g_free(ret_buf); + return ret; +} + +int player_set_display_rotation(player_h player, + player_display_rotation_e rotation) +{ + PLAYER_INSTANCE_CHECK(player); + int ret = PLAYER_ERROR_NONE; + mm_player_api_e api = MM_PLAYER_API_SET_DISPLAY_ROTATION; + player_cli_s *pc = (player_cli_s *) player; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + + LOGD("ENTER"); + + player_msg_send1(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret, + INT, rotation); + g_free(ret_buf); + return ret; +} + +int player_get_display_rotation(player_h player, + player_display_rotation_e * protation) +{ + PLAYER_INSTANCE_CHECK(player); + PLAYER_NULL_ARG_CHECK(protation); + int ret = PLAYER_ERROR_NONE; + mm_player_api_e api = MM_PLAYER_API_GET_DISPLAY_ROTATION; + player_cli_s *pc = (player_cli_s *) player; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + int rotation = -1; + + LOGD("ENTER"); + + player_msg_send(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret); + if(ret == PLAYER_ERROR_NONE){ + player_msg_get(rotation, ret_buf); + *protation = rotation; + } + g_free(ret_buf); + return ret; +} + +int player_set_display_visible(player_h player, bool visible) +{ + PLAYER_INSTANCE_CHECK(player); + int ret = PLAYER_ERROR_NONE; + mm_player_api_e api = MM_PLAYER_API_SET_DISPLAY_VISIBLE; + player_cli_s *pc = (player_cli_s *) player; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + + LOGD("ENTER"); + + player_msg_send1(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret, + INT, visible); + g_free(ret_buf); + return ret; +} + +int player_is_display_visible(player_h player, bool * pvisible) +{ + PLAYER_INSTANCE_CHECK(player); + PLAYER_NULL_ARG_CHECK(pvisible); + int ret = PLAYER_ERROR_NONE; + mm_player_api_e api = MM_PLAYER_API_IS_DISPLAY_VISIBLE; + player_cli_s *pc = (player_cli_s *) player; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + int visible = -1; + + LOGD("ENTER"); + + player_msg_send(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret); + if(ret == PLAYER_ERROR_NONE){ + player_msg_get(visible, ret_buf); + *pvisible = visible; + } + g_free(ret_buf); + return ret; +} + +int player_get_content_info(player_h player, player_content_info_e key, + char **pvalue) +{ + PLAYER_INSTANCE_CHECK(player); + PLAYER_NULL_ARG_CHECK(pvalue); + int ret = PLAYER_ERROR_NONE; + mm_player_api_e api = MM_PLAYER_API_GET_CONTENT_INFO; + player_cli_s *pc = (player_cli_s *) player; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + char value[MM_MSG_MAX_LENGTH] = {0,}; + + LOGD("ENTER"); + + player_msg_send1(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret, + INT, key); + if(ret == PLAYER_ERROR_NONE){ + player_msg_get_string(value, ret_buf); + *pvalue = strndup(value, MM_MSG_MAX_LENGTH); + } + g_free(ret_buf); + return ret; +} + +int player_get_codec_info(player_h player, char **paudio_codec, + char **pvideo_codec) +{ + PLAYER_INSTANCE_CHECK(player); + PLAYER_NULL_ARG_CHECK(paudio_codec); + PLAYER_NULL_ARG_CHECK(pvideo_codec); + int ret = PLAYER_ERROR_NONE; + mm_player_api_e api = MM_PLAYER_API_GET_CODEC_INFO; + player_cli_s *pc = (player_cli_s *) player; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + char video_codec[MM_MSG_MAX_LENGTH] = {0,}; + char audio_codec[MM_MSG_MAX_LENGTH] = {0,}; + + LOGD("ENTER"); + + player_msg_send(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret); + if(ret == PLAYER_ERROR_NONE){ + player_msg_get_string(video_codec, ret_buf); + player_msg_get_string(audio_codec, ret_buf); + *pvideo_codec = strndup(video_codec, MM_MSG_MAX_LENGTH); + *paudio_codec = strndup(audio_codec, MM_MSG_MAX_LENGTH); + } + g_free(ret_buf); + return ret; +} + +int player_get_audio_stream_info(player_h player, int *psample_rate, + int *pchannel, int *pbit_rate) +{ + PLAYER_INSTANCE_CHECK(player); + PLAYER_NULL_ARG_CHECK(psample_rate); + PLAYER_NULL_ARG_CHECK(pchannel); + PLAYER_NULL_ARG_CHECK(pbit_rate); + int ret = PLAYER_ERROR_NONE; + mm_player_api_e api = MM_PLAYER_API_GET_AUDIO_STREAM_INFO; + player_cli_s *pc = (player_cli_s *) player; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + int sample_rate = 0; + int channel = 0; + int bit_rate = 0; + + LOGD("ENTER"); + + player_msg_send(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret); + if(ret == PLAYER_ERROR_NONE){ + player_msg_get(sample_rate, ret_buf); + player_msg_get(channel, ret_buf); + player_msg_get(bit_rate, ret_buf); + *psample_rate = sample_rate; + *pchannel = channel; + *pbit_rate = bit_rate; + } + g_free(ret_buf); + return ret; +} + +int player_get_video_stream_info(player_h player, int *pfps, int *pbit_rate) +{ + PLAYER_INSTANCE_CHECK(player); + PLAYER_NULL_ARG_CHECK(pfps); + PLAYER_NULL_ARG_CHECK(pbit_rate); + int ret = PLAYER_ERROR_NONE; + mm_player_api_e api = MM_PLAYER_API_GET_VIDEO_STREAM_INFO; + player_cli_s *pc = (player_cli_s *) player; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + int fps = 0; + int bit_rate = 0; + + LOGD("ENTER"); + + player_msg_send(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret); + if(ret == PLAYER_ERROR_NONE){ + player_msg_get(fps, ret_buf); + player_msg_get(bit_rate, ret_buf); + *pfps = fps; + *pbit_rate = bit_rate; + } + g_free(ret_buf); + return ret; +} + +int player_get_video_size(player_h player, int *pwidth, int *pheight) +{ + PLAYER_INSTANCE_CHECK(player); + PLAYER_NULL_ARG_CHECK(pwidth); + PLAYER_NULL_ARG_CHECK(pheight); + int ret = PLAYER_ERROR_NONE; + mm_player_api_e api = MM_PLAYER_API_GET_VIDEO_SIZE; + player_cli_s *pc = (player_cli_s *) player; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + int width = 0; + int height = 0; + + LOGD("ENTER"); + + player_msg_send(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret); + if(ret == PLAYER_ERROR_NONE){ + player_msg_get(width, ret_buf); + player_msg_get(height, ret_buf); + *pwidth = width; + *pheight = height; + } + g_free(ret_buf); + return ret; +} + +int player_get_album_art(player_h player, void **palbum_art, int *psize) +{ + PLAYER_INSTANCE_CHECK(player); + PLAYER_NULL_ARG_CHECK(palbum_art); + PLAYER_NULL_ARG_CHECK(psize); + int ret = PLAYER_ERROR_NONE; + mm_player_api_e api = MM_PLAYER_API_GET_ALBUM_ART; + player_cli_s *pc = (player_cli_s *) player; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + char *album_art; + int size = 0; + + LOGD("ENTER"); + + player_msg_send(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret); + if(ret == PLAYER_ERROR_NONE){ + player_msg_get(size, ret_buf); + if(size > 0){ + album_art = _get_mem(pc, size); + player_msg_get_array(album_art, ret_buf); + *palbum_art = album_art; + } + else + *palbum_art = NULL; + + *psize = size; + } + g_free(ret_buf); + return ret; +} + +int player_audio_effect_get_equalizer_bands_count(player_h player, int *pcount) +{ + PLAYER_INSTANCE_CHECK(player); + PLAYER_NULL_ARG_CHECK(pcount); + int ret = PLAYER_ERROR_NONE; + mm_player_api_e api = MM_PLAYER_API_AUDIO_EFFECT_GET_EQUALIZER_BANDS_COUNT; + player_cli_s *pc = (player_cli_s *) player; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + int count; + + LOGD("ENTER"); + + player_msg_send(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret); + if(ret == PLAYER_ERROR_NONE){ + player_msg_get(count, ret_buf); + *pcount = count; + } + g_free(ret_buf); + return ret; +} + +int player_audio_effect_set_equalizer_all_bands(player_h player, + int *band_levels, int length) +{ + PLAYER_INSTANCE_CHECK(player); + PLAYER_NULL_ARG_CHECK(band_levels); + int ret = PLAYER_ERROR_NONE; + mm_player_api_e api = MM_PLAYER_API_AUDIO_EFFECT_SET_EQUALIZER_ALL_BANDS; + player_cli_s *pc = (player_cli_s *) player; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + + LOGD("ENTER"); + + player_msg_send_array(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret, + band_levels, length, sizeof(int)); + + g_free(ret_buf); + return ret; + +} + +int player_audio_effect_set_equalizer_band_level(player_h player, int index, + int level) +{ + PLAYER_INSTANCE_CHECK(player); + int ret = PLAYER_ERROR_NONE; + mm_player_api_e api = MM_PLAYER_API_AUDIO_EFFECT_SET_EQUALIZER_BAND_LEVEL; + player_cli_s *pc = (player_cli_s *) player; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + + LOGD("ENTER"); + + player_msg_send2(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret, + INT, index, INT, level); + + g_free(ret_buf); + return ret; +} + +int player_audio_effect_get_equalizer_band_level(player_h player, int index, + int *plevel) +{ + PLAYER_INSTANCE_CHECK(player); + PLAYER_NULL_ARG_CHECK(plevel); + int ret = PLAYER_ERROR_NONE; + mm_player_api_e api = MM_PLAYER_API_AUDIO_EFFECT_GET_EQUALIZER_BAND_LEVEL; + player_cli_s *pc = (player_cli_s *) player; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + int level; + + LOGD("ENTER"); + + player_msg_send1(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret, + INT, index); + if(ret == PLAYER_ERROR_NONE){ + player_msg_get(level, ret_buf); + *plevel = level; + } + g_free(ret_buf); + return ret; +} + +int player_audio_effect_get_equalizer_level_range(player_h player, int *pmin, + int *pmax) +{ + PLAYER_INSTANCE_CHECK(player); + PLAYER_NULL_ARG_CHECK(pmin); + PLAYER_NULL_ARG_CHECK(pmax); + int ret = PLAYER_ERROR_NONE; + mm_player_api_e api = MM_PLAYER_API_AUDIO_EFFECT_GET_EQUALIZER_LEVEL_RANGE; + player_cli_s *pc = (player_cli_s *) player; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + int min,max; + + LOGD("ENTER"); + + player_msg_send(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret); + if(ret == PLAYER_ERROR_NONE){ + player_msg_get(min, ret_buf); + player_msg_get(max, ret_buf); + *pmin = min; + *pmax = max; + } + g_free(ret_buf); + return ret; +} + +int player_audio_effect_get_equalizer_band_frequency(player_h player, int index, + int *pfrequency) +{ + PLAYER_INSTANCE_CHECK(player); + PLAYER_NULL_ARG_CHECK(pfrequency); + int ret = PLAYER_ERROR_NONE; + mm_player_api_e api = MM_PLAYER_API_AUDIO_EFFECT_GET_EQUALIZER_BAND_FREQUENCY; + player_cli_s *pc = (player_cli_s *) player; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + int frequency; + + LOGD("ENTER"); + + player_msg_send1(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret, + INT, index); + if(ret == PLAYER_ERROR_NONE){ + player_msg_get(frequency, ret_buf); + *pfrequency = frequency; + } + g_free(ret_buf); + return ret; +} + +int player_audio_effect_get_equalizer_band_frequency_range(player_h player, + int index, + int *prange) +{ + PLAYER_INSTANCE_CHECK(player); + PLAYER_NULL_ARG_CHECK(prange); + int ret = PLAYER_ERROR_NONE; + mm_player_api_e api = MM_PLAYER_API_AUDIO_EFFECT_GET_EQUALIZER_BAND_FREQUENCY_RANGE; + player_cli_s *pc = (player_cli_s *) player; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + int range; + + LOGD("ENTER"); + + player_msg_send1(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret, + INT, index); + if(ret == PLAYER_ERROR_NONE){ + player_msg_get(range, ret_buf); + *prange = range; + } + g_free(ret_buf); + return ret; +} + +int player_audio_effect_equalizer_clear(player_h player) +{ + PLAYER_INSTANCE_CHECK(player); + int ret = PLAYER_ERROR_NONE; + mm_player_api_e api = MM_PLAYER_API_AUDIO_EFFECT_EQUALIZER_CLEAR; + player_cli_s *pc = (player_cli_s *) player; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + + LOGD("ENTER"); + + player_msg_send(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret); + g_free(ret_buf); + return ret; +} + +int player_audio_effect_equalizer_is_available(player_h player, + bool * pavailable) +{ + PLAYER_INSTANCE_CHECK(player); + PLAYER_NULL_ARG_CHECK(pavailable); + int ret = PLAYER_ERROR_NONE; + mm_player_api_e api = MM_PLAYER_API_AUDIO_EFFECT_EQUALIZER_IS_AVAILABLE; + player_cli_s *pc = (player_cli_s *) player; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + int available; + + LOGD("ENTER"); + + player_msg_send(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret); + if(ret == PLAYER_ERROR_NONE){ + player_msg_get(available, ret_buf); + *pavailable = available; + } + g_free(ret_buf); + return ret; +} + +int player_set_subtitle_path(player_h player, const char *path) +{ + PLAYER_INSTANCE_CHECK(player); + int ret = PLAYER_ERROR_NONE; + mm_player_api_e api = MM_PLAYER_API_SET_SUBTITLE_PATH; + player_cli_s *pc = (player_cli_s *) player; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + + LOGD("ENTER"); + + player_msg_send1(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret, + STRING, path); + g_free(ret_buf); + return ret; +} + +int player_set_subtitle_position_offset(player_h player, int millisecond) +{ + PLAYER_INSTANCE_CHECK(player); + int ret = PLAYER_ERROR_NONE; + mm_player_api_e api = MM_PLAYER_API_SET_SUBTITLE_POSITION_OFFSET; + player_cli_s *pc = (player_cli_s *) player; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + + LOGD("ENTER"); + + player_msg_send1(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret, + INT, millisecond); + + g_free(ret_buf); + return ret; +} + +int player_set_progressive_download_path(player_h player, const char *path) +{ + PLAYER_INSTANCE_CHECK(player); + PLAYER_NULL_ARG_CHECK(path); + int ret = PLAYER_ERROR_NONE; + mm_player_api_e api = MM_PLAYER_API_SET_PROGRESSIVE_DOWNLOAD_PATH; + player_cli_s *pc = (player_cli_s *) player; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + + LOGD("ENTER"); + + player_msg_send1(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret, + STRING, path); + g_free(ret_buf); + return ret; +} + +int player_get_progressive_download_status(player_h player, + unsigned long *pcurrent, + unsigned long *ptotal_size) +{ + PLAYER_INSTANCE_CHECK(player); + PLAYER_NULL_ARG_CHECK(pcurrent); + PLAYER_NULL_ARG_CHECK(ptotal_size); + int ret = PLAYER_ERROR_NONE; + mm_player_api_e api = MM_PLAYER_API_GET_PROGRESSIVE_DOWNLOAD_STATUS; + player_cli_s *pc = (player_cli_s *) player; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + int current, total_size; + + LOGD("ENTER"); + + player_msg_send(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret); + if(ret == PLAYER_ERROR_NONE){ + player_msg_get(current, ret_buf); + player_msg_get(total_size, ret_buf); + *pcurrent = current; + *ptotal_size = total_size; + } + g_free(ret_buf); + return ret; + +} + +int player_capture_video(player_h player, player_video_captured_cb callback, + void *user_data) +{ + PLAYER_INSTANCE_CHECK(player); + PLAYER_NULL_ARG_CHECK(callback); + int ret = PLAYER_ERROR_NONE; + mm_player_api_e api = MM_PLAYER_API_CAPTURE_VIDEO; + player_cli_s *pc = (player_cli_s *) player; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + + LOGD("ENTER"); + if (pc->cb_info->user_cb[_PLAYER_EVENT_TYPE_CAPTURE]) { + LOGE("[%s] PLAYER_ERROR_VIDEO_CAPTURE_FAILED (0x%08x) : capturing... we can't do any more ", __FUNCTION__, PLAYER_ERROR_VIDEO_CAPTURE_FAILED); + return PLAYER_ERROR_VIDEO_CAPTURE_FAILED; + } else { + LOGI("[%s] Event type : %d ", __FUNCTION__, + _PLAYER_EVENT_TYPE_CAPTURE); + pc->cb_info->user_cb[_PLAYER_EVENT_TYPE_CAPTURE] = callback; + pc->cb_info->user_data[_PLAYER_EVENT_TYPE_CAPTURE] = user_data; + } + + player_msg_send(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret); + + if (ret != PLAYER_ERROR_NONE) { + set_null_user_cb(pc->cb_info, _PLAYER_EVENT_TYPE_CAPTURE); + } + + g_free(ret_buf); + return ret; +} + +int player_set_streaming_cookie(player_h player, const char *cookie, int size) +{ + PLAYER_INSTANCE_CHECK(player); + PLAYER_NULL_ARG_CHECK(cookie); + PLAYER_CHECK_CONDITION(size>=0,PLAYER_ERROR_INVALID_PARAMETER,"PLAYER_ERROR_INVALID_PARAMETER" ); + int ret = PLAYER_ERROR_NONE; + mm_player_api_e api = MM_PLAYER_API_SET_STREAMING_COOKIE; + player_cli_s *pc = (player_cli_s *) player; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + + LOGD("ENTER"); + + player_msg_send2(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret, + STRING, cookie, INT, size); + g_free(ret_buf); + return ret; +} + +int player_set_streaming_user_agent(player_h player, const char *user_agent, + int size) +{ + PLAYER_INSTANCE_CHECK(player); + PLAYER_NULL_ARG_CHECK(user_agent); + PLAYER_CHECK_CONDITION(size>=0,PLAYER_ERROR_INVALID_PARAMETER,"PLAYER_ERROR_INVALID_PARAMETER" ); + int ret = PLAYER_ERROR_NONE; + mm_player_api_e api = MM_PLAYER_API_SET_STREAMING_COOKIE; + player_cli_s *pc = (player_cli_s *) player; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + + LOGD("ENTER"); + + player_msg_send2(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret, + STRING, user_agent, INT, size); + g_free(ret_buf); + return ret; +} + +int player_get_streaming_download_progress(player_h player, int *pstart, + int *pcurrent) +{ + PLAYER_INSTANCE_CHECK(player); + PLAYER_NULL_ARG_CHECK(pstart); + PLAYER_NULL_ARG_CHECK(pcurrent); + int ret = PLAYER_ERROR_NONE; + mm_player_api_e api = MM_PLAYER_API_GET_STREAMING_DOWNLOAD_PROGRESS; + player_cli_s *pc = (player_cli_s *) player; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + int start, current; + + LOGD("ENTER"); + + player_msg_send(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret); + if(ret == PLAYER_ERROR_NONE){ + player_msg_get(start, ret_buf); + player_msg_get(current, ret_buf); + *pstart = start; + *pcurrent = current; + } + g_free(ret_buf); + return ret; + +} + +int player_set_completed_cb(player_h player, player_completed_cb callback, + void *user_data) +{ + return __set_callback(_PLAYER_EVENT_TYPE_COMPLETE, player, callback, + user_data); +} + +int player_unset_completed_cb(player_h player) +{ + return __unset_callback(_PLAYER_EVENT_TYPE_COMPLETE, player); +} + +int player_set_interrupted_cb(player_h player, player_interrupted_cb callback, + void *user_data) +{ + return __set_callback(_PLAYER_EVENT_TYPE_INTERRUPT, player, callback, + user_data); +} + +int player_unset_interrupted_cb(player_h player) +{ + return __unset_callback(_PLAYER_EVENT_TYPE_INTERRUPT, player); +} + +int player_set_error_cb(player_h player, player_error_cb callback, + void *user_data) +{ + return __set_callback(_PLAYER_EVENT_TYPE_ERROR, player, callback, + user_data); +} + +int player_unset_error_cb(player_h player) +{ + return __unset_callback(_PLAYER_EVENT_TYPE_ERROR, player); +} + +int player_set_buffering_cb(player_h player, player_buffering_cb callback, + void *user_data) +{ + return __set_callback(_PLAYER_EVENT_TYPE_BUFFERING, player, callback, + user_data); +} + +int player_unset_buffering_cb(player_h player) +{ + return __unset_callback(_PLAYER_EVENT_TYPE_BUFFERING, player); +} + +int player_set_subtitle_updated_cb(player_h player, + player_subtitle_updated_cb callback, + void *user_data) +{ + return __set_callback(_PLAYER_EVENT_TYPE_SUBTITLE, player, callback, + user_data); +} + +int player_unset_subtitle_updated_cb(player_h player) +{ + return __unset_callback(_PLAYER_EVENT_TYPE_SUBTITLE, player); +} + +int player_set_progressive_download_message_cb(player_h player, + player_pd_message_cb callback, + void *user_data) +{ + PLAYER_INSTANCE_CHECK(player); + PLAYER_NULL_ARG_CHECK(callback); + player_cli_s *pc = (player_cli_s *) player; + mm_player_api_e api = MM_PLAYER_API_SET_CALLBACK; + int sock_fd = pc->cb_info->fd; + int set = 1; + _player_event_e type = _PLAYER_EVENT_TYPE_PD; + + player_msg_send2_async(api, EXT_HANDLE(pc), sock_fd, + INT, type, INT, set); + + pc->cb_info->user_cb[_PLAYER_EVENT_TYPE_PD] = callback; + pc->cb_info->user_data[_PLAYER_EVENT_TYPE_PD] = user_data; + LOGI("[%s] Event type : %d ", __FUNCTION__, _PLAYER_EVENT_TYPE_PD); + return PLAYER_ERROR_NONE; +} + +int player_unset_progressive_download_message_cb(player_h player) +{ + PLAYER_INSTANCE_CHECK(player); + player_cli_s *pc = (player_cli_s *) player; + mm_player_api_e api = MM_PLAYER_API_SET_CALLBACK; + int sock_fd = pc->cb_info->fd; + int set = 0; + _player_event_e type = _PLAYER_EVENT_TYPE_PD; + + player_msg_send2_async(api, EXT_HANDLE(pc), sock_fd, + INT, type, INT, set); + + set_null_user_cb(pc->cb_info, type); + LOGI("[%s] Event type : %d ", __FUNCTION__, _PLAYER_EVENT_TYPE_PD); + + return PLAYER_ERROR_NONE; +} + +int player_set_media_packet_video_frame_decoded_cb(player_h player, + player_media_packet_video_decoded_cb + callback, void *user_data) +{ + PLAYER_INSTANCE_CHECK(player); + PLAYER_NULL_ARG_CHECK(callback); + int ret = PLAYER_ERROR_NONE; + player_cli_s *pc = (player_cli_s *) player; + mm_player_api_e api = MM_PLAYER_API_SET_CALLBACK; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + _player_event_e type = _PLAYER_EVENT_TYPE_MEDIA_PACKET_VIDEO_FRAME; + int set = 1; + + LOGD("ENTER"); + + player_msg_send2(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret, + INT, type, INT, set); + + if(ret == PLAYER_ERROR_NONE){ + pc->cb_info->user_cb[_PLAYER_EVENT_TYPE_MEDIA_PACKET_VIDEO_FRAME] = + callback; + pc->cb_info->user_data[_PLAYER_EVENT_TYPE_MEDIA_PACKET_VIDEO_FRAME] = + user_data; + LOGI("Event type : %d ", _PLAYER_EVENT_TYPE_MEDIA_PACKET_VIDEO_FRAME); + } + + g_free(ret_buf); + return ret; +} + +int player_unset_media_packet_video_frame_decoded_cb(player_h player) +{ + PLAYER_INSTANCE_CHECK(player); + int ret = PLAYER_ERROR_NONE; + player_cli_s *pc = (player_cli_s *) player; + mm_player_api_e api = MM_PLAYER_API_SET_CALLBACK; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + _player_event_e type = _PLAYER_EVENT_TYPE_MEDIA_PACKET_VIDEO_FRAME; + int set = 0; + + LOGD("ENTER"); + + set_null_user_cb(pc->cb_info, type); + + player_msg_send2(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret, + INT, type, INT, set); + + g_free(ret_buf); + return ret; +} + +int player_set_video_stream_changed_cb (player_h player, + player_video_stream_changed_cb callback, void *user_data) +{ + PLAYER_INSTANCE_CHECK(player); + PLAYER_NULL_ARG_CHECK(callback); + int ret = PLAYER_ERROR_NONE; + player_cli_s *pc = (player_cli_s *) player; + mm_player_api_e api = MM_PLAYER_API_SET_CALLBACK; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + _player_event_e type = _PLAYER_EVENT_TYPE_VIDEO_STREAM_CHANGED; + int set = 1; + + LOGD("ENTER"); + + player_msg_send2(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret, + INT, type, INT, set); + + if(ret == PLAYER_ERROR_NONE){ + pc->cb_info->user_cb[type] = callback; + pc->cb_info->user_data[type] = user_data; + LOGI("Event type : %d ", type); + } + + g_free(ret_buf); + return ret; +} + +int player_unset_video_stream_changed_cb (player_h player) +{ + PLAYER_INSTANCE_CHECK(player); + int ret = PLAYER_ERROR_NONE; + player_cli_s *pc = (player_cli_s *) player; + mm_player_api_e api = MM_PLAYER_API_SET_CALLBACK; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + _player_event_e type = _PLAYER_EVENT_TYPE_VIDEO_STREAM_CHANGED; + int set = 0; + + LOGD("ENTER"); + + set_null_user_cb(pc->cb_info, type); + + player_msg_send2(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret, + INT, type, INT, set); + + g_free(ret_buf); + return ret; +} + +int player_set_media_stream_buffer_status_cb ( player_h player, + player_stream_type_e stream_type, + player_media_stream_buffer_status_cb callback, + void *user_data) +{ + PLAYER_INSTANCE_CHECK(player); + PLAYER_NULL_ARG_CHECK(callback); + int ret = PLAYER_ERROR_NONE; + player_cli_s *pc = (player_cli_s *) player; + mm_player_api_e api = MM_PLAYER_API_SET_CALLBACK; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + _player_event_e type; + int set = 1; + + LOGD("ENTER"); + + if(stream_type == PLAYER_STREAM_TYPE_VIDEO) + type = _PLAYER_EVENT_TYPE_MEDIA_STREAM_VIDEO_BUFFER_STATUS; + else if(stream_type == PLAYER_STREAM_TYPE_AUDIO) + type = _PLAYER_EVENT_TYPE_MEDIA_STREAM_AUDIO_BUFFER_STATUS; + else { + LOGE("PLAYER_ERROR_INVALID_PARAMETER(type : %d)", stream_type); + return PLAYER_ERROR_INVALID_PARAMETER; + } + + player_msg_send2(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret, + INT, type, INT, set); + + if(ret == PLAYER_ERROR_NONE){ + pc->cb_info->user_cb[type] = callback; + pc->cb_info->user_data[type] = user_data; + LOGI("Event type : %d ", type); + } + + g_free(ret_buf); + return ret; +} + +int player_unset_media_stream_buffer_status_cb (player_h player, + player_stream_type_e stream_type) +{ + PLAYER_INSTANCE_CHECK(player); + int ret = PLAYER_ERROR_NONE; + player_cli_s *pc = (player_cli_s *) player; + mm_player_api_e api = MM_PLAYER_API_SET_CALLBACK; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + _player_event_e type; + int set = 0; + + LOGD("ENTER"); + + if(stream_type == PLAYER_STREAM_TYPE_VIDEO) + type = _PLAYER_EVENT_TYPE_MEDIA_STREAM_VIDEO_BUFFER_STATUS; + else if(stream_type == PLAYER_STREAM_TYPE_AUDIO) + type = _PLAYER_EVENT_TYPE_MEDIA_STREAM_AUDIO_BUFFER_STATUS; + else { + LOGE("PLAYER_ERROR_INVALID_PARAMETER(type : %d)", stream_type); + return PLAYER_ERROR_INVALID_PARAMETER; + } + + set_null_user_cb(pc->cb_info, type); + + player_msg_send2(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret, + INT, type, INT, set); + + g_free(ret_buf); + return ret; +} + +int player_set_media_stream_seek_cb (player_h player, + player_stream_type_e stream_type, + player_media_stream_seek_cb callback, + void *user_data) +{ + PLAYER_INSTANCE_CHECK(player); + PLAYER_NULL_ARG_CHECK(callback); + int ret = PLAYER_ERROR_NONE; + player_cli_s *pc = (player_cli_s *) player; + mm_player_api_e api = MM_PLAYER_API_SET_CALLBACK; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + _player_event_e type; + int set = 1; + + LOGD("ENTER"); + + if(stream_type == PLAYER_STREAM_TYPE_VIDEO) + type = _PLAYER_EVENT_TYPE_MEDIA_STREAM_VIDEO_SEEK; + else if(stream_type == PLAYER_STREAM_TYPE_AUDIO) + type = _PLAYER_EVENT_TYPE_MEDIA_STREAM_AUDIO_SEEK; + else { + LOGE("PLAYER_ERROR_INVALID_PARAMETER(type : %d)", stream_type); + return PLAYER_ERROR_INVALID_PARAMETER; + } + + player_msg_send2(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret, + INT, type, INT, set); + + if(ret == PLAYER_ERROR_NONE){ + pc->cb_info->user_cb[type] = callback; + pc->cb_info->user_data[type] = user_data; + LOGI("Event type : %d ", type); + } + + g_free(ret_buf); + return ret; +} + +int player_unset_media_stream_seek_cb (player_h player, + player_stream_type_e stream_type) +{ + PLAYER_INSTANCE_CHECK(player); + int ret = PLAYER_ERROR_NONE; + player_cli_s *pc = (player_cli_s *) player; + mm_player_api_e api = MM_PLAYER_API_SET_CALLBACK; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + _player_event_e type; + int set = 0; + + LOGD("ENTER"); + + if(stream_type == PLAYER_STREAM_TYPE_VIDEO) + type = _PLAYER_EVENT_TYPE_MEDIA_STREAM_VIDEO_SEEK; + else if(stream_type == PLAYER_STREAM_TYPE_AUDIO) + type = _PLAYER_EVENT_TYPE_MEDIA_STREAM_AUDIO_SEEK; + else { + LOGE("PLAYER_ERROR_INVALID_PARAMETER(type : %d)", stream_type); + return PLAYER_ERROR_INVALID_PARAMETER; + } + + set_null_user_cb(pc->cb_info, type); + + player_msg_send2(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret, + INT, type, INT, set); + + g_free(ret_buf); + return ret; +} + +/* TODO Implement raw data socket channel */ +int player_push_media_stream(player_h player, media_packet_h packet) +{ + PLAYER_INSTANCE_CHECK(player); + PLAYER_NULL_ARG_CHECK(packet); + int ret = PLAYER_ERROR_NONE; + player_cli_s *pc = (player_cli_s *) player; + mm_player_api_e api = MM_PLAYER_API_PUSH_MEDIA_STREAM; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + player_push_media_msg_type push_media; + char *push_media_msg = (char *)&push_media; + int msg_size = sizeof(player_push_media_msg_type); +#ifdef __UN_USED + tbm_bo bo = NULL; + tbm_bo_handle thandle; + int buf_size; +#endif + char *buf; + media_format_h format; + bool is_video; + bool is_audio; + + LOGD("ENTER"); + + media_packet_get_buffer_data_ptr(packet, (void **)&buf); + media_packet_get_buffer_size(packet, &push_media.size); + media_packet_get_pts(packet, &push_media.pts); + media_packet_get_format(packet, &format); + + push_media.buf_type = PUSH_MEDIA_BUF_TYPE_RAW; + + media_packet_is_video(packet, &is_video); + media_packet_is_audio(packet, &is_audio); + if(is_video) + media_format_get_video_info(format, &push_media.mimetype, NULL, NULL, NULL, NULL); + else if(is_audio) + media_format_get_audio_info(format, &push_media.mimetype, NULL, NULL, NULL, NULL); + +#ifdef __UN_USED + if(push_media.buf_type == PUSH_MEDIA_BUF_TYPE_TBM) { + bo = tbm_bo_alloc (bufmgr, push_media.size, TBM_BO_DEFAULT); + if(bo == NULL) { + LOGE("TBM get error : bo is NULL"); + return PLAYER_ERROR_INVALID_OPERATION; + } + thandle = tbm_bo_map (bo, TBM_DEVICE_CPU, TBM_OPTION_WRITE); + if(thandle.ptr == NULL) + { + LOGE("TBM get error : handle pointer is NULL"); + ret = PLAYER_ERROR_INVALID_OPERATION; + goto push_media_error; + } + memcpy(thandle.ptr, buf, push_media.size); + tbm_bo_unmap(bo); + + push_media.key = tbm_bo_export(bo); + if(push_media.key == 0) { + LOGE("TBM get error : key is 0"); + ret = PLAYER_ERROR_INVALID_OPERATION; + goto push_media_error; + } + + player_msg_send_array(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret, + push_media_msg, msg_size, sizeof(char)); + } else if(push_media.buf_type == PUSH_MEDIA_BUF_TYPE_MSG) { + buf_size = (int)push_media.size; + player_msg_send_array2(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret, + push_media_msg, msg_size, sizeof(char), + buf, buf_size, sizeof(char)); + } else +#endif + if(push_media.buf_type == PUSH_MEDIA_BUF_TYPE_RAW) { + mmsvc_core_ipc_push_data(pc->cb_info->data_fd, buf, push_media.size, push_media.pts); + player_msg_send_array(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret, + push_media_msg, msg_size, sizeof(char)); + } + + LOGD("ret_buf %s", ret_buf); + +#ifdef __UN_USED +push_media_error: + if(push_media.buf_type == PUSH_MEDIA_BUF_TYPE_TBM) + tbm_bo_unref(bo); +#endif + + g_free(ret_buf); + return ret; +} + +int player_set_media_stream_info(player_h player, + player_stream_type_e type, media_format_h format) +{ + PLAYER_INSTANCE_CHECK(player); + PLAYER_NULL_ARG_CHECK(format); + int ret = PLAYER_ERROR_NONE; + player_cli_s *pc = (player_cli_s *) player; + mm_player_api_e api = MM_PLAYER_API_SET_MEDIA_STREAM_INFO; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + media_format_mimetype_e mimetype; + int width; + int height; + int avg_bps; + int max_bps; + int channel; + int samplerate; + int bit; + + LOGD("ENTER"); + + media_format_ref(format); + if(type == PLAYER_STREAM_TYPE_VIDEO) { + media_format_get_video_info(format, &mimetype, &width, &height, &avg_bps, &max_bps); + player_msg_send6(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret, + INT, type, INT, mimetype, INT, width, INT, height, INT, avg_bps, INT, max_bps); + } else if(type == PLAYER_STREAM_TYPE_AUDIO) { + media_format_get_audio_info(format, &mimetype, &channel, &samplerate, &bit, &avg_bps); + player_msg_send6(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret, + INT, type, INT, mimetype, INT, channel, INT, samplerate, INT, avg_bps, INT, bit); + } + media_format_unref(format); + + g_free(ret_buf); + return ret; +} + +int player_set_media_stream_buffer_max_size(player_h player, + player_stream_type_e type, unsigned long long max_size) +{ + int ret = PLAYER_ERROR_NONE; + PLAYER_INSTANCE_CHECK(player); + player_cli_s *pc = (player_cli_s *) player; + mm_player_api_e api = MM_PLAYER_API_SET_MEDIA_STREAM_BUFFER_MAX_SIZE; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + + LOGD("ENTER"); + + player_msg_send2(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret, + INT, type, INT64, max_size); + + g_free(ret_buf); + return ret; +} + +int player_get_media_stream_buffer_max_size(player_h player, + player_stream_type_e type, unsigned long long *pmax_size) +{ + int ret = PLAYER_ERROR_NONE; + PLAYER_INSTANCE_CHECK(player); + PLAYER_NULL_ARG_CHECK(pmax_size); + player_cli_s *pc = (player_cli_s *) player; + mm_player_api_e api = MM_PLAYER_API_GET_MEDIA_STREAM_BUFFER_MAX_SIZE; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + unsigned long long max_size; + + LOGD("ENTER"); + + player_msg_send1(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret, + INT, type); + if(ret == PLAYER_ERROR_NONE){ + player_msg_get_type(max_size, ret_buf, INT64); + *pmax_size = max_size; + } + g_free(ret_buf); + return ret; +} + +int player_set_media_stream_buffer_min_threshold(player_h player, + player_stream_type_e type, unsigned int percent) +{ + int ret = PLAYER_ERROR_NONE; + PLAYER_INSTANCE_CHECK(player); + player_cli_s *pc = (player_cli_s *) player; + mm_player_api_e api = MM_PLAYER_API_SET_MEDIA_STREAM_BUFFER_MIN_THRESHOLD; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + + LOGD("ENTER"); + + player_msg_send2(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret, + INT, type, INT, percent); + + g_free(ret_buf); + return ret; +} + +int player_get_media_stream_buffer_min_threshold(player_h player, + player_stream_type_e type, unsigned int *ppercent) +{ + int ret = PLAYER_ERROR_NONE; + PLAYER_INSTANCE_CHECK(player); + PLAYER_NULL_ARG_CHECK(ppercent); + player_cli_s *pc = (player_cli_s *) player; + mm_player_api_e api = MM_PLAYER_API_SET_MEDIA_STREAM_BUFFER_MIN_THRESHOLD; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + uint percent; + + LOGD("ENTER"); + + player_msg_send1(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret, + INT, type); + if(ret == PLAYER_ERROR_NONE){ + player_msg_get(percent, ret_buf); + *ppercent = percent; + } + + g_free(ret_buf); + return ret; +} + +int player_get_track_count(player_h player, player_stream_type_e type, int *pcount) +{ + PLAYER_INSTANCE_CHECK(player); + PLAYER_NULL_ARG_CHECK(pcount); + int ret = PLAYER_ERROR_NONE; + player_cli_s *pc = (player_cli_s *) player; + mm_player_api_e api = MM_PLAYER_API_GET_TRACK_COUNT; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + int count; + + LOGD("ENTER"); + + player_msg_send1(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret, + INT, type); + if(ret == PLAYER_ERROR_NONE){ + player_msg_get(count, ret_buf); + *pcount = count; + } + + g_free(ret_buf); + return ret; +} + +int player_get_current_track(player_h player, player_stream_type_e type, int *pindex) +{ + PLAYER_INSTANCE_CHECK(player); + PLAYER_NULL_ARG_CHECK(pindex); + int ret = PLAYER_ERROR_NONE; + player_cli_s *pc = (player_cli_s *) player; + mm_player_api_e api = MM_PLAYER_API_GET_CURRENT_TRACK; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + int index; + + LOGD("ENTER"); + + player_msg_send1(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret, + INT, type); + if(ret == PLAYER_ERROR_NONE){ + player_msg_get(index, ret_buf); + *pindex = index; + } + + g_free(ret_buf); + return ret; +} + +int player_select_track(player_h player, player_stream_type_e type, int index) +{ + PLAYER_INSTANCE_CHECK(player); + int ret = PLAYER_ERROR_NONE; + player_cli_s *pc = (player_cli_s *) player; + mm_player_api_e api = MM_PLAYER_API_SELECT_TRACK; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + + LOGD("ENTER"); + + player_msg_send2(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret, + INT, type, INT, index); + + g_free(ret_buf); + return ret; +} + +int player_get_track_language_code(player_h player, player_stream_type_e type, int index, char **pcode) +{ + PLAYER_INSTANCE_CHECK(player); + PLAYER_NULL_ARG_CHECK(pcode); + int ret = PLAYER_ERROR_NONE; + player_cli_s *pc = (player_cli_s *) player; + mm_player_api_e api = MM_PLAYER_API_GET_TRACK_LANGUAGE_CODE; + int sock_fd = pc->cb_info->fd; + char *ret_buf = NULL; + char code[MM_MSG_MAX_LENGTH] = {0,}; + const int code_len=2; + + LOGD("ENTER"); + + player_msg_send2(api, EXT_HANDLE(pc), sock_fd, pc->cb_info, ret_buf, ret, + INT, type, INT, index); + if(ret == PLAYER_ERROR_NONE){ + if(player_msg_get_string(code, ret_buf)) + *pcode = strndup(code, code_len); + } + + g_free(ret_buf); + return ret; +} diff --git a/client/test/CMakeLists.txt b/client/test/CMakeLists.txt new file mode 100644 index 0000000..7f92847 --- /dev/null +++ b/client/test/CMakeLists.txt @@ -0,0 +1,28 @@ +CMAKE_MINIMUM_REQUIRED(VERSION 2.6) +SET(client_test "${fw_name}-test") + +INCLUDE_DIRECTORIES(../include) +link_directories(${CMAKE_SOURCE_DIR}/../) + +IF(X11_SUPPORT) + SET(WIN_PKG "ecore-x") +ENDIF(X11_SUPPORT) +IF(WAYLAND_SUPPORT) + SET(WIN_PKG "${WIN_PKG} ecore-wayland") +ENDIF(WAYLAND_SUPPORT) +INCLUDE(FindPkgConfig) +pkg_check_modules(${client_test} REQUIRED appcore-efl elementary ecore evas capi-media-sound-manager ${WIN_PKG}) +FOREACH(flag ${${client_test}_CFLAGS}) + SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}") +ENDFOREACH(flag) + +SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS} -pie") + +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-player2 ${${client_test}_LDFLAGS}) +ENDFOREACH() + diff --git a/client/test/mused_player_es_push_test.c b/client/test/mused_player_es_push_test.c new file mode 100644 index 0000000..315bb13 --- /dev/null +++ b/client/test/mused_player_es_push_test.c @@ -0,0 +1,601 @@ +/* + * Copyright (c) 2014 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 +#include +#include +#include +#include +#include +#ifdef HAVE_WAYLAND +#include +#include +#endif + +#define KEY_END "XF86Stop" +#define ES_FEEDING_PATH "es_buff://push_mode" +//#define ES_FEEDING_PATH "es_buff://pull_mode" + +#define ES_DEFAULT_DIR_PATH "/opt/usr/media/" +#define ES_DEFAULT_H264_VIDEO_PATH ES_DEFAULT_DIR_PATH"Simpsons.h264" +#define ES_DEFAULT_VIDEO_FORMAT_TYPE MEDIA_FORMAT_H264_SP +#define ES_DEFAULT_VIDEO_FORMAT_WIDTH 1280 +#define ES_DEFAULT_VIDEO_FORMAT_HEIGHT 544 +#define ES_DEFAULT_VIDEO_PTS_OFFSET 20000000 +#define ES_DEFAULT_NUMBER_OF_FEED 2000 + +unsigned char sps[100]; +unsigned char pps[100]; +unsigned char tmp_buf[1000000]; +static int sps_len, pps_len; + +#ifdef PACKAGE +#undef PACKAGE +#endif +#define PACKAGE "player_es_push_test" + +#ifdef LOG_TAG +#undef LOG_TAG +#endif +#define LOG_TAG "PLAYER_TEST" + +static int app_create(void *data); +static int app_reset(bundle *b, void *data); +static int app_resume(void *data); +static int app_pause(void *data); +static int app_terminate(void *data); + +struct appcore_ops ops = { + .create = app_create, + .terminate = app_terminate, + .pause = app_pause, + .resume = app_resume, + .reset = app_reset, +}; + +typedef struct appdata { + Evas_Object *win; + Evas_Object *rect; + player_h player_handle; + media_packet_h video_pkt; + media_format_h video_fmt; + FILE *file_src; + pthread_t feeding_thread_id; +} appdata_s; + +static void +win_delete_request_cb(void *data , Evas_Object *obj , void *event_info) +{ + elm_exit(); +} + +static Eina_Bool +keydown_cb(void *data , int type , void *event) +{ + //appdata_s *ad = data; + Ecore_Event_Key *ev = event; + + LOGD("start"); + + if (!strcmp(ev->keyname, KEY_END)) { + /* Let window go to hide state. */ + //elm_win_lower(ad->win); + LOGD("elm exit"); + elm_exit(); + + return ECORE_CALLBACK_DONE; + } + + LOGD("done"); + + return ECORE_CALLBACK_PASS_ON; +} + +static void win_del(void *data, Evas_Object *obj, void *event) +{ + elm_exit(); +} + +static Evas_Object* create_win(const char *name) +{ + Evas_Object *eo = NULL; + int w = 0; + int h = 0; + + eo = elm_win_add(NULL, name, ELM_WIN_BASIC); + if (eo) { + elm_win_title_set(eo, name); + elm_win_borderless_set(eo, EINA_TRUE); + evas_object_smart_callback_add(eo, "delete,request",win_del, NULL); + elm_win_screen_size_get(eo, NULL, NULL, &w, &h); + g_print ("window size :%d,%d", w, h); + evas_object_resize(eo, w, h); + elm_win_autodel_set(eo, EINA_TRUE); +#ifdef HAVE_WAYLAND + elm_win_alpha_set(eo, EINA_TRUE); +#endif + } + return eo; +} + +static Evas_Object *create_render_rect(Evas_Object *pParent) +{ + if(!pParent) { + return NULL; + } + + Evas *pEvas = evas_object_evas_get(pParent); + Evas_Object *pObj = evas_object_rectangle_add(pEvas); + if(pObj == NULL) { + return NULL; + } + + evas_object_size_hint_weight_set(pObj, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + evas_object_color_set(pObj, 0, 0, 0, 0); + evas_object_render_op_set(pObj, EVAS_RENDER_COPY); + evas_object_show(pObj); + elm_win_resize_object_add(pParent, pObj); + + return pObj; +} + +static void +create_base_gui(appdata_s *ad) +{ + /* Enable GLES Backened */ + elm_config_preferred_engine_set("3d"); + + /* Window */ + ad->win = create_win(PACKAGE);//elm_win_util_standard_add(PACKAGE, PACKAGE); + ad->rect = create_render_rect(ad->win); + /* This is not supported in 3.0 + elm_win_wm_desktop_layout_support_set(ad->win, EINA_TRUE);*/ + elm_win_autodel_set(ad->win, EINA_TRUE); + evas_object_smart_callback_add(ad->win, "delete,request", win_delete_request_cb, ad); + + /* Show window after base gui is set up */ + elm_win_activate(ad->win); + evas_object_show(ad->win); +} + +static int app_create(void *data) +{ + /* Hook to take necessary actions before main event loop starts + Initialize UI resources and application's data + If this function returns true, the main loop of application starts + If this function returns false, the application is terminated */ + appdata_s *ad = data; + + LOGD("start"); + + create_base_gui(ad); + ecore_event_handler_add(ECORE_EVENT_KEY_DOWN, keydown_cb, NULL); + + /* open test file*/ + ad->file_src = fopen(ES_DEFAULT_H264_VIDEO_PATH, "r"); + + LOGD("done"); + + return 0; +} + +static int app_pause(void *data) +{ + /* Take necessary actions when application becomes invisible. */ + appdata_s *ad = (appdata_s *)data; + int ret = PLAYER_ERROR_NONE; + + LOGD("start"); + + if (ad == NULL) { + LOGE("appdata is NULL"); + return -1; + } + + if (ad->player_handle == NULL) { + g_print("player_handle is NULL"); + return -1; + } + + if (ad->feeding_thread_id) + { + pthread_join(ad->feeding_thread_id, NULL); + ad->feeding_thread_id = 0; + } + + player_unset_media_stream_buffer_status_cb(ad->player_handle, PLAYER_STREAM_TYPE_VIDEO); + player_unset_media_stream_buffer_status_cb(ad->player_handle, PLAYER_STREAM_TYPE_AUDIO); + player_unset_media_stream_seek_cb(ad->player_handle, PLAYER_STREAM_TYPE_VIDEO); + player_unset_media_stream_seek_cb(ad->player_handle, PLAYER_STREAM_TYPE_AUDIO); + + ret = player_unprepare(ad->player_handle); + if (ret != PLAYER_ERROR_NONE) { + g_print("player_unprepare failed : 0x%x", ret); + return false; + } + + /* unref media format */ + if (ad->video_fmt) + media_format_unref(ad->video_fmt); + + fclose(ad->file_src); + + /* destroy player handle */ + ret = player_destroy(ad->player_handle); + if (ret != PLAYER_ERROR_NONE) { + g_print("player_destroy failed : 0x%x", ret); + return false; + } + + ad->player_handle = NULL; + + LOGD("done"); + + return 0; +} + +static int app_resume(void *data) +{ + LOGD("start"); + + LOGD("done"); + + return 0; +} + +static void _player_prepared_cb(void *user_data) +{ + int ret = PLAYER_ERROR_NONE; + appdata_s *ad = (appdata_s *)user_data; + + LOGD("prepared"); + + ret = player_start(ad->player_handle); + if (ret != PLAYER_ERROR_NONE) { + LOGE("player start failed : 0x%x", ret); + } + LOGD("done"); +} + +unsigned int bytestream2nalunit(FILE *fd, unsigned char* nal) +{ + int nal_length = 0; + size_t result; + int read_size = 1; + unsigned char buffer[1000000]; + unsigned char val, zero_count, i; + int nal_unit_type = 0; + int init; + + zero_count = 0; + if (feof(fd)) + return -1; + + result = fread(buffer, 1, read_size, fd); + + if(result != read_size) + { + //exit(1); + return -1; + } + val = buffer[0]; + while (!val) + { + if ((zero_count == 2 || zero_count == 3) && val == 1) + { + break; + } + zero_count++; + result = fread(buffer, 1, read_size, fd); + + if(result != read_size) + { + break; + } + val = buffer[0]; + } + nal[nal_length++] = 0; + nal[nal_length++] = 0; + nal[nal_length++] = 0; + nal[nal_length++] = 1; + zero_count = 0; + init = 1; + while(1) + { + if (feof(fd)) + return nal_length; + + result = fread(buffer, 1, read_size, fd); + if(result != read_size) + { + break; + } + val = buffer[0]; + + if(init) { + nal_unit_type = val & 0xf; + init = 0; + } + if (!val) + { + zero_count++; + } + else + { + if ((zero_count == 2 || zero_count == 3 || zero_count == 4) && (val == 1)) + { + break; + } + else + { + for (i = 0; ivideo_fmt, NULL, NULL, &ad->video_pkt) != MEDIA_PACKET_ERROR_NONE) { + LOGE("media_packet_create_alloc failed\n"); + return; + } + + if (media_packet_get_buffer_data_ptr(ad->video_pkt, &buf_data_ptr) != MEDIA_PACKET_ERROR_NONE) { + LOGE("media_packet_get_buffer_data_ptr failed\n"); + return; + } + + if (media_packet_set_pts(ad->video_pkt, (uint64_t)(pts/1000000)) != MEDIA_PACKET_ERROR_NONE) { + LOGE("media_packet_set_pts failed\n"); + return; + } + + /* NOTE: In case of H.264 video, stream format for feeding is NAL unit. + * And, SPS(0x67) and PPS(0x68) should be located before IDR.(0x65). + */ + read = bytestream2nalunit(ad->file_src, buf_data_ptr); + LOGD("real length = %d\n", read); + if (read == 0) { + LOGD("input file read failed\n"); + return; + } + + if (media_packet_set_buffer_size(ad->video_pkt, (uint64_t)read) != MEDIA_PACKET_ERROR_NONE) { + LOGE("media_packet_set_buffer_size failed\n"); + return; + } + + /* push media packet */ + player_push_media_stream(ad->player_handle, ad->video_pkt); + pts += ES_DEFAULT_VIDEO_PTS_OFFSET; + + /* destroy media packet after use*/ + media_packet_destroy(ad->video_pkt); + ad->video_pkt = NULL; + return; +} + +static void feed_video_data_thread_func(void *data) +{ + gboolean exit = FALSE; + appdata_s *ad = (appdata_s *)data; + + while (!exit) + { + static int frame_count = 0; + + if (frame_count < ES_DEFAULT_NUMBER_OF_FEED) { + feed_video_data(ad); + frame_count++; + } else { + exit = TRUE; + } + } +} + +void _video_buffer_status_cb (player_media_stream_buffer_status_e status, void *user_data) +{ + if (status == PLAYER_MEDIA_STREAM_BUFFER_UNDERRUN) + { + LOGE("video buffer is underrun state"); + } + else if (status == PLAYER_MEDIA_STREAM_BUFFER_OVERFLOW) + { + LOGE("video buffer is overrun state"); + } +} + +void _audio_buffer_status_cb (player_media_stream_buffer_status_e status, void *user_data) +{ + if (status == PLAYER_MEDIA_STREAM_BUFFER_UNDERRUN) + LOGE("audio buffer is underrun state"); + else if (status == PLAYER_MEDIA_STREAM_BUFFER_OVERFLOW) + LOGE("audio buffer is overrun state"); +} + +void _video_seek_data_cb (unsigned long long offset, void *user_data) +{ + LOGE("seek offset of video is %llu", offset); +} + +void _audio_seek_data_cb (unsigned long long offset, void *user_data) +{ + LOGE("seek offset of audio is %llu", offset); +} + +static int app_reset(bundle *b, void *data) +{ + /* Take necessary actions when application becomes visible. */ + appdata_s *ad = (appdata_s *)data; + int ret = PLAYER_ERROR_NONE; + + LOGD("start"); + + if (ad == NULL) { + LOGE("appdata is NULL"); + return -1; + } + + ret = player_create(&ad->player_handle); + if (ret != PLAYER_ERROR_NONE) { + LOGE("player_create failed : 0x%x", ret); + return -1; + } + + ret = player_set_display(ad->player_handle, PLAYER_DISPLAY_TYPE_OVERLAY, GET_DISPLAY(ad->win)); + if (ret != PLAYER_ERROR_NONE) { + LOGE("player_set_display failed : 0x%x", ret); + goto FAILED; + } + + ret = player_set_uri(ad->player_handle, ES_FEEDING_PATH); + if (ret != PLAYER_ERROR_NONE) { + LOGE("player_set_uri failed : 0x%x", ret); + goto FAILED; + } + + /* get media format format */ + ret = media_format_create(&ad->video_fmt); + if (ret != MEDIA_FORMAT_ERROR_NONE) { + LOGE("media_format_create : 0x%x", ret); + goto FAILED; + } + + /* set video format */ + media_format_set_video_mime(ad->video_fmt, ES_DEFAULT_VIDEO_FORMAT_TYPE); + media_format_set_video_width(ad->video_fmt, ES_DEFAULT_VIDEO_FORMAT_WIDTH); + media_format_set_video_height(ad->video_fmt,ES_DEFAULT_VIDEO_FORMAT_HEIGHT); + + ret = player_set_media_stream_buffer_status_cb(ad->player_handle, PLAYER_STREAM_TYPE_VIDEO, _video_buffer_status_cb, (void*)ad); + if (ret != PLAYER_ERROR_NONE) { + LOGE("player set video buffer status cb failed : 0x%x", ret); + goto FAILED; + } + ret = player_set_media_stream_buffer_status_cb(ad->player_handle, PLAYER_STREAM_TYPE_AUDIO, _audio_buffer_status_cb, (void*)ad); + if (ret != PLAYER_ERROR_NONE) { + LOGE("player set audio buffer status cb failed : 0x%x", ret); + goto FAILED; + } + + ret = player_set_media_stream_seek_cb(ad->player_handle, PLAYER_STREAM_TYPE_VIDEO, _video_seek_data_cb, (void*)ad); + if (ret != PLAYER_ERROR_NONE) { + LOGE("player set seek data cb for video failed : 0x%x", ret); + goto FAILED; + } + ret = player_set_media_stream_seek_cb(ad->player_handle, PLAYER_STREAM_TYPE_AUDIO, _audio_seek_data_cb, (void*)ad); + if (ret != PLAYER_ERROR_NONE) { + LOGE("player set seek data cb for audio failed : 0x%x", ret); + goto FAILED; + } + + /* send media packet to player */ + player_set_media_stream_info(ad->player_handle, PLAYER_STREAM_TYPE_VIDEO, ad->video_fmt); + + ret = player_prepare_async(ad->player_handle, _player_prepared_cb, (void*)ad); + if (ret != PLAYER_ERROR_NONE) { + LOGE("player prepare failed : 0x%x", ret); + goto FAILED; + } + + pthread_create(&ad->feeding_thread_id, NULL, (void*)feed_video_data_thread_func, (void *)ad); + + LOGD("done"); + + return 0; + +FAILED: + if (ad->player_handle) { + player_destroy(ad->player_handle); + ad->player_handle = NULL; + } + + return -1; +} + +static int app_terminate(void *data) +{ + /* Release all resources. */ + appdata_s *ad = (appdata_s *)data; + + LOGD("start"); + + if (ad == NULL) { + LOGE("appdata is NULL"); + return -1; + } + + app_pause(data); + + LOGD("done"); + + return 0; +} + +int main(int argc, char *argv[]) +{ + int ret = 0; + static appdata_s ad = {0,}; + + LOGD("start"); + + memset(&ad, 0x0, sizeof(appdata_s)); + + LOGD("call appcore_efl_main"); + + ops.data = &ad; + + ret = appcore_efl_main(PACKAGE, &argc, &argv, &ops); + + LOGD("appcore_efl_main() ret = 0x%x", ret); + + return ret; +} diff --git a/client/test/mused_player_media_packet_test.c b/client/test/mused_player_media_packet_test.c new file mode 100644 index 0000000..89d4f6e --- /dev/null +++ b/client/test/mused_player_media_packet_test.c @@ -0,0 +1,471 @@ +/* + * Copyright (c) 2014 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 +#include +#include +#include +#include +#include + +#define KEY_END "XF86Stop" +#define MEDIA_FILE_PATH "/opt/usr/media/Color.mp4" +#ifdef PACKAGE +#undef PACKAGE +#endif +#define PACKAGE "player_test" + +#ifdef LOG_TAG +#undef LOG_TAG +#endif +#define LOG_TAG "PLAYER_TEST" + +static int app_create(void *data); +static int app_reset(bundle *b, void *data); +static int app_resume(void *data); +static int app_pause(void *data); +static int app_terminate(void *data); + +struct appcore_ops ops = { + .create = app_create, + .terminate = app_terminate, + .pause = app_pause, + .resume = app_resume, + .reset = app_reset, +}; + +typedef struct appdata { + Evas_Object *win; + Evas_Object *img; + media_packet_h packet; + Ecore_Pipe *pipe; + player_h player_handle; + GList *packet_list; + GMutex buffer_lock; + int w, h; +} appdata_s; + +static void +win_delete_request_cb(void *data , Evas_Object *obj , void *event_info) +{ + elm_exit(); +} + +static Eina_Bool +keydown_cb(void *data , int type , void *event) +{ + //appdata_s *ad = data; + Ecore_Event_Key *ev = event; + + LOGD("start"); + + if (!strcmp(ev->keyname, KEY_END)) { + /* Let window go to hide state. */ + //elm_win_lower(ad->win); + LOGD("elm exit"); + elm_exit(); + + return ECORE_CALLBACK_DONE; + } + + LOGD("done"); + + return ECORE_CALLBACK_PASS_ON; +} + +static void +create_base_gui(appdata_s *ad) +{ + /* Enable GLES Backened */ + elm_config_preferred_engine_set("3d"); + + /* Window */ + ad->win = elm_win_util_standard_add(PACKAGE, PACKAGE); + /* This is not supported in 3.0 + elm_win_wm_desktop_layout_support_set(ad->win, EINA_TRUE); */ + elm_win_autodel_set(ad->win, EINA_TRUE); +#if 0 + if (elm_win_wm_rotation_supported_get(ad->win)) { + int rots[4] = { 0, 90, 180, 270 }; + elm_win_wm_rotation_available_rotations_set(ad->win, (const int *)(&rots), 4); + } +#endif + evas_object_smart_callback_add(ad->win, "delete,request", win_delete_request_cb, ad); + + Evas *e = evas_object_evas_get(ad->win); + + elm_win_screen_size_get(ad->win, NULL, NULL, &ad->w, &ad->h); + LOGD("surface size (%d x %d)\n", ad->w, ad->h); + + /* Image Object */ + ad->img = evas_object_image_filled_add(e); + evas_object_image_size_set(ad->img, ad->w, ad->h); + evas_object_size_hint_weight_set(ad->img, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + evas_object_show(ad->img); + + elm_win_resize_object_add(ad->win, ad->img); + + /* Show window after base gui is set up */ + evas_object_show(ad->win); +} + +static void +_media_packet_video_decoded_cb(media_packet_h packet, void *user_data) +{ + /* This callback function would be called on different thread */ + appdata_s *ad = user_data; + + if (ad == NULL) { + LOGE("appdata is NULL"); + return; + } + + g_mutex_lock(&ad->buffer_lock); + + if (ad->pipe == NULL) { + media_packet_destroy(packet); + LOGW("release media packet immediately"); + return; + } + + /* add packet list */ + ad->packet_list = g_list_prepend(ad->packet_list, (gpointer)packet); + + LOGD("packet %p", packet); + + /* Send packet to main thread */ + ecore_pipe_write(ad->pipe, &packet, sizeof(media_packet_h)); + + g_mutex_unlock(&ad->buffer_lock); + + return; +} + +static void +pipe_cb(void *data, void *buf, unsigned int len) +{ + /* Now, we get a player surface to be set here. */ + appdata_s *ad = data; + tbm_surface_h surface; +#ifdef _CAN_USE_NATIVE_SURFACE_TBM + Evas_Native_Surface surf; +#endif + tbm_surface_info_s suf_info; + uint32_t plane_idx; + int ret; + GList *last_item = NULL; + + LOGD("start"); + + g_mutex_lock(&ad->buffer_lock); + + /* Destroy previous packet */ + if (ad->packet) { + ret = media_packet_destroy(ad->packet); + if (ret != MEDIA_PACKET_ERROR_NONE) { + LOGE("Failed to destroy media packet. ret (%d)", ret); + } + ad->packet = NULL; + } + + /* remove packet from list */ + last_item = g_list_last(ad->packet_list); + if (last_item) { + /* Get new packet */ + ad->packet = (media_packet_h)last_item->data;; + ad->packet_list = g_list_remove(ad->packet_list, ad->packet); + LOGD("ad->packet %p", ad->packet); + } + + if (ad->packet == NULL) { + LOGW("NULL packet"); + g_mutex_unlock(&ad->buffer_lock); + return; + } + + ret = media_packet_get_tbm_surface(ad->packet, &surface); + if (ret != MEDIA_PACKET_ERROR_NONE) { + LOGE("Failed to get surface from media packet. ret(0x%x)", ret); + + media_packet_destroy(ad->packet); + ad->packet = NULL; + + g_mutex_unlock(&ad->buffer_lock); + + return; + } + + LOGD("surface %p", surface); + + g_mutex_unlock(&ad->buffer_lock); + +#ifdef _CAN_USE_NATIVE_SURFACE_TBM + /* Set tbm surface to image native surface */ + memset(&surf, 0x0, sizeof(surf)); + surf.version = EVAS_NATIVE_SURFACE_VERSION; + surf.type = EVAS_NATIVE_SURFACE_TBM; + surf.data.tizen.buffer = surface; + surf.data.tizen.rot = 270; + evas_object_image_native_surface_set(ad->img, &surf); + + /* Set dirty image region to be redrawn */ + evas_object_image_data_update_add(ad->img, 0, 0, ad->w, ad->h); +#else + unsigned char *ptr = NULL; + unsigned char *buf_data = NULL; + media_format_h format = NULL; + media_format_mimetype_e mimetype; + + media_packet_get_format(ad->packet, &format); + media_format_get_video_info(format, &mimetype, NULL, NULL, NULL, NULL); + + if (mimetype == MEDIA_FORMAT_I420 || mimetype == MEDIA_FORMAT_NV12 || mimetype == MEDIA_FORMAT_NV12T) { + + tbm_surface_get_info(surface,&suf_info); + buf_data = (unsigned char*)g_malloc0(suf_info.size); + ptr = buf_data; + + for (plane_idx = 0; plane_idx < suf_info.num_planes; plane_idx++) { + memcpy(ptr, suf_info.planes[plane_idx].ptr, suf_info.planes[plane_idx].size); + ptr += suf_info.planes[plane_idx].size; + } + /* dump buf data here, if needed */ + g_free(buf_data); + } +#endif + + LOGD("done"); + + return; +} + +static int app_create(void *data) +{ + /* Hook to take necessary actions before main event loop starts + Initialize UI resources and application's data + If this function returns true, the main loop of application starts + If this function returns false, the application is terminated */ + appdata_s *ad = data; + + LOGD("start"); + + create_base_gui(ad); + ecore_event_handler_add(ECORE_EVENT_KEY_DOWN, keydown_cb, NULL); + + g_mutex_init(&ad->buffer_lock); + + LOGD("done"); + + return 0; +} + +static int app_pause(void *data) +{ + /* Take necessary actions when application becomes invisible. */ + appdata_s *ad = (appdata_s *)data; + GList *list = NULL; + media_packet_h packet = NULL; + int ret = PLAYER_ERROR_NONE; + + LOGD("start"); + + if (ad == NULL) { + LOGE("appdata is NULL"); + return -1; + } + + if (ad->player_handle == NULL) { + g_print("player_handle is NULL"); + return -1; + } + + /* stop render last set frame */ + evas_object_image_native_surface_set(ad->img, NULL); + + g_mutex_lock(&ad->buffer_lock); + + /* remove ecore pipe */ + ecore_pipe_del(ad->pipe); + ad->pipe = NULL; + + /* remove packet list */ + list = ad->packet_list; + while (list) { + packet = list->data; + list = g_list_next(list); + + if (!packet) { + LOGW("packet is NULL"); + } else { + LOGD("destroy packet %p", packet); + media_packet_destroy(packet); + packet = NULL; + ad->packet_list = g_list_remove(ad->packet_list, packet); + } + } + + if (ad->packet_list) { + g_list_free(ad->packet_list); + ad->packet_list = NULL; + } + + /* Destroy previous packet */ + if (ad->packet) { + LOGD("destroy packet %p", ad->packet); + ret = media_packet_destroy(ad->packet); + if (ret != MEDIA_PACKET_ERROR_NONE) { + LOGE("Failed to destroy media packet. ret (%d)", ret); + } + ad->packet = NULL; + } + + g_mutex_unlock(&ad->buffer_lock); + + ret = player_unprepare(ad->player_handle); + if (ret != PLAYER_ERROR_NONE) { + g_print("player_unprepare failed : 0x%x", ret); + return false; + } + + ret = player_destroy(ad->player_handle); + if (ret != PLAYER_ERROR_NONE) { + g_print("player_destroy failed : 0x%x", ret); + return false; + } + + ad->player_handle = NULL; + + LOGD("done"); + + return 0; +} + +static int app_resume(void *data) +{ + LOGD("start"); + + LOGD("done"); + + return 0; +} + +static int app_reset(bundle *b, void *data) +{ + /* Take necessary actions when application becomes visible. */ + appdata_s *ad = (appdata_s *)data; + int ret = PLAYER_ERROR_NONE; + + LOGD("start"); + + if (ad == NULL) { + LOGE("appdata is NULL"); + return -1; + } + + /* create ecore pipe */ + ad->pipe = ecore_pipe_add(pipe_cb, ad); + + ret = player_create(&ad->player_handle); + if (ret != PLAYER_ERROR_NONE) { + LOGE("player_create failed : 0x%x", ret); + return -1; + } + + ret = player_set_media_packet_video_frame_decoded_cb(ad->player_handle, _media_packet_video_decoded_cb, ad); + if (ret != PLAYER_ERROR_NONE) { + LOGE("player_set_media_packet_video_frame_decoded_cb failed : 0x%x", ret); + goto FAILED; + } + + ret = player_set_display(ad->player_handle, PLAYER_DISPLAY_TYPE_NONE, NULL); + if (ret != PLAYER_ERROR_NONE) { + LOGE("player_set_display failed : 0x%x", ret); + goto FAILED; + } + + ret = player_set_uri(ad->player_handle, MEDIA_FILE_PATH); + if (ret != PLAYER_ERROR_NONE) { + LOGE("player_set_uri failed : 0x%x", ret); + goto FAILED; + } + + ret = player_prepare(ad->player_handle); + if (ret != PLAYER_ERROR_NONE) { + LOGE("player prepare failed : 0x%x", ret); + goto FAILED; + } + + ret = player_start(ad->player_handle); + if (ret != PLAYER_ERROR_NONE) { + LOGE("player start failed : 0x%x", ret); + goto FAILED; + } + + LOGD("done"); + + return 0; + +FAILED: + if (ad->player_handle) { + player_destroy(ad->player_handle); + ad->player_handle = NULL; + } + + return -1; + +} + +static int app_terminate(void *data) +{ + /* Release all resources. */ + appdata_s *ad = (appdata_s *)data; + + LOGD("start"); + + if (ad == NULL) { + LOGE("appdata is NULL"); + return -1; + } + + app_pause(data); + + g_mutex_clear(&ad->buffer_lock); + + LOGD("done"); + + return 0; +} + +int main(int argc, char *argv[]) +{ + int ret = 0; + static appdata_s ad = {0,}; + + LOGD("start"); + + memset(&ad, 0x0, sizeof(appdata_s)); + + LOGD("call appcore_efl_main"); + + ops.data = &ad; + + ret = appcore_efl_main(PACKAGE, &argc, &argv, &ops); + + LOGD("appcore_efl_main() ret = 0x%x", ret); + + return ret; +} + diff --git a/client/test/player_client_test.c b/client/test/player_client_test.c new file mode 100644 index 0000000..6d18a66 --- /dev/null +++ b/client/test/player_client_test.c @@ -0,0 +1,2515 @@ +/* +* 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 +#include +#include +#include +#include +#include +#include +#include +#ifdef HAVE_X11 +#include +#endif +#ifdef HAVE_WAYLAND +#include +#include +#endif +#include +//#define _USE_X_DIRECT_ +#ifdef _USE_X_DIRECT_ +#include +#endif +#define PACKAGE "player_test" +#define MAX_STRING_LEN 2048 +#define MMTS_SAMPLELIST_INI_DEFAULT_PATH "/opt/etc/mmts_filelist.ini" +#define PLAYER_TEST_DUMP_PATH_PREFIX "/opt/usr/media/dump_pcm_" +#define INI_SAMPLE_LIST_MAX 9 +#define DEFAULT_HTTP_TIMEOUT -1 + +static gboolean g_memory_playback = FALSE; +static char g_uri[MAX_STRING_LEN]; +static char g_subtitle_uri[MAX_STRING_LEN]; +static FILE *g_pcm_fd; + +static gboolean is_es_push_mode = FALSE; +static pthread_t g_feed_video_thread_id = 0; +static bool g_thread_end = FALSE; +static media_packet_h g_audio_pkt = NULL; +static media_format_h g_audio_fmt = NULL; + +static media_packet_h g_video_pkt = NULL; +static media_format_h g_video_fmt = NULL; + +static int _save(unsigned char * src, int length); + +#define DUMP_OUTBUF 1 +#if DUMP_OUTBUF +FILE *fp_out1 = NULL; +FILE *fp_out2 = NULL; +#endif + +enum +{ + CURRENT_STATUS_MAINMENU, + CURRENT_STATUS_HANDLE_NUM, + CURRENT_STATUS_FILENAME, + CURRENT_STATUS_VOLUME, + CURRENT_STATUS_SOUND_TYPE, + CURRENT_STATUS_MUTE, + CURRENT_STATUS_POSITION_TIME, + CURRENT_STATUS_LOOPING, + CURRENT_STATUS_DISPLAY_SURFACE_CHANGE, + CURRENT_STATUS_DISPLAY_MODE, + CURRENT_STATUS_DISPLAY_ROTATION, + CURRENT_STATUS_DISPLAY_VISIBLE, + CURRENT_STATUS_DISPLAY_ROI_MODE, + CURRENT_STATUS_DISPLAY_DST_ROI, + CURRENT_STATUS_DISPLAY_SRC_CROP, + CURRENT_STATUS_SUBTITLE_FILENAME, + CURRENT_STATUS_AUDIO_EQUALIZER, + CURRENT_STATUS_PLAYBACK_RATE, + CURRENT_STATUS_SWITCH_SUBTITLE, +}; + +#define MAX_HANDLE 20 + +/* for video display */ +#ifdef _USE_X_DIRECT_ +static Window g_xid; +static Display *g_dpy; +static GC g_gc; +#else +static Evas_Object* g_xid; +static Evas_Object* g_external_xid; +static Evas_Object* selected_xid; +#endif +static Evas_Object* g_eo[MAX_HANDLE] = {0}; +static int g_current_surface_type = PLAYER_DISPLAY_TYPE_OVERLAY; + +typedef struct +{ + Evas_Object *win; + Evas_Object *layout_main; /* layout widget based on EDJ */ +#ifdef HAVE_X11 + Ecore_X_Window xid; +#elif HAVE_WAYLAND + unsigned int xid; +#endif + /* add more variables here */ + int hdmi_output_id; +} appdata; + +static appdata ad; +static player_h g_player[MAX_HANDLE] = {0}; +int g_handle_num = 1; +int g_menu_state = CURRENT_STATUS_MAINMENU; +char g_file_list[9][256]; +gboolean quit_pushing; + +static void win_del(void *data, Evas_Object *obj, void *event) +{ + elm_exit(); +} + +static Evas_Object* create_win(const char *name) +{ + Evas_Object *eo = NULL; + int w = 0; + int h = 0; + + g_print ("[%s][%d] name=%s\n", __func__, __LINE__, name); + + eo = elm_win_add(NULL, name, ELM_WIN_BASIC); + if (eo) + { + elm_win_title_set(eo, name); + elm_win_borderless_set(eo, EINA_TRUE); + evas_object_smart_callback_add(eo, "delete,request",win_del, NULL); + elm_win_screen_size_get(eo, NULL, NULL, &w, &h); + g_print ("window size :%d,%d", w, h); + evas_object_resize(eo, w, h); + elm_win_autodel_set(eo, EINA_TRUE); +#ifdef HAVE_WAYLAND + elm_win_alpha_set(eo, EINA_TRUE); +#endif + } + return eo; +} + +static Evas_Object *create_image_object(Evas_Object *eo_parent) +{ + if(!eo_parent) + return NULL; + + Evas *evas = evas_object_evas_get(eo_parent); + Evas_Object *eo = NULL; + + eo = evas_object_image_add(evas); + + return eo; +} + +void +create_render_rect_and_bg (Evas_Object* win) +{ + if(!win) + { + g_print("no win"); + return; + } + Evas_Object *bg, *rect; + + bg = elm_bg_add (win); + elm_win_resize_object_add (win, bg); + evas_object_size_hint_weight_set (bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + evas_object_show (bg); + + rect = evas_object_rectangle_add (evas_object_evas_get(win)); + if(!rect) + { + g_print("no rect"); + return; + } + evas_object_color_set (rect, 0, 0, 0, 0); + evas_object_render_op_set (rect, EVAS_RENDER_COPY); + + elm_win_resize_object_add (win, rect); + evas_object_size_hint_weight_set (rect, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + evas_object_show (rect); + evas_object_show (win); +} + +int +eom_get_output_id (const char *output_name) +{ + eom_output_id *output_ids = NULL; + eom_output_id output_id = 0; + eom_output_type_e output_type = EOM_OUTPUT_TYPE_UNKNOWN; + int id_cnt = 0; + int i; + + /* get output_ids */ + output_ids = eom_get_eom_output_ids(&id_cnt); + if (id_cnt == 0) + { + g_print ("[eom] no external outuputs supported\n"); + return 0; + } + + /* find output ids interested */ + for (i = 0; i < id_cnt; i++) + { + eom_get_output_type(output_ids[i], &output_type); + if (!strncmp(output_name, "HDMI", 4)) + { + if (output_type == EOM_OUTPUT_TYPE_HDMIA || output_type == EOM_OUTPUT_TYPE_HDMIB) + { + output_id = output_ids[i]; + break; + } + } + else if (!strncmp(output_name, "Virtual", 4)) + { + if (output_type == EOM_OUTPUT_TYPE_VIRTUAL) + { + output_id = output_ids[i]; + break; + } + } + } + + if (output_ids) + free (output_ids); + + return output_id; +} + +static void +eom_notify_cb_output_add (eom_output_id output_id, void *user_data) +{ + appdata *info = (appdata*)user_data; + + if (info->hdmi_output_id != output_id) + { + g_print ("[eom] OUTPUT ADDED. SKIP. my output ID is %d\n", info->hdmi_output_id); + return; + } + g_print ("[eom] output(%d) connected\n", output_id); + /* it is for external window */ + if (!g_external_xid) + { + g_external_xid = elm_win_add(NULL, "External", ELM_WIN_BASIC); + if (eom_set_output_window(info->hdmi_output_id, g_external_xid) == EOM_ERROR_NONE) + { + create_render_rect_and_bg(g_external_xid); + g_print ("[eom] create external window\n"); + } + else + { + evas_object_del (g_external_xid); + g_external_xid = NULL; + g_print ("[eom] create external window fail\n"); + } + } +} + +static void +eom_notify_cb_output_remove (eom_output_id output_id, void *user_data) +{ + appdata *info = (appdata*)user_data; + player_state_e state; + + if (info->hdmi_output_id != output_id) + { + g_print ("[eom] OUTPUT REMOVED. SKIP. my output ID is %d\n", info->hdmi_output_id); + return; + } + g_print ("[eom] output(%d) disconnected\n", output_id); + + if(selected_xid==g_external_xid && g_player[0]) + { + player_get_state(g_player[0], &state); + if (state>=PLAYER_STATE_READY) + { + if(!g_xid) + { + g_xid = create_win(PACKAGE); + if (g_xid == NULL) + return; + g_print("create xid %p\n", g_xid); + create_render_rect_and_bg(g_xid); + elm_win_activate(g_xid); + evas_object_show(g_xid); + } + player_set_display(g_player[0], PLAYER_DISPLAY_TYPE_OVERLAY, GET_DISPLAY(g_xid)); + } + } + + /* it is for external window */ + if (g_external_xid) + { + evas_object_del(g_external_xid); + g_external_xid = NULL; + } + selected_xid = g_xid; +} + +static void +eom_notify_cb_mode_changed (eom_output_id output_id, void *user_data) +{ + appdata *info = (appdata*)user_data; + eom_output_mode_e mode = EOM_OUTPUT_MODE_NONE; + + if (info->hdmi_output_id != output_id) + { + g_print ("[eom] MODE CHANGED. SKIP. my output ID is %d\n", info->hdmi_output_id); + return; + } + + eom_get_output_mode(output_id, &mode); + g_print ("[eom] output(%d) mode changed(%d)\n", output_id, mode); +} + +static void +eom_notify_cb_attribute_changed (eom_output_id output_id, void *user_data) +{ + appdata *info = (appdata*)user_data; + + eom_output_attribute_e attribute = EOM_OUTPUT_ATTRIBUTE_NONE; + eom_output_attribute_state_e state = EOM_OUTPUT_ATTRIBUTE_STATE_NONE; + + if (info->hdmi_output_id != output_id) + { + g_print ("[eom] ATTR CHANGED. SKIP. my output ID is %d\n", info->hdmi_output_id); + return; + } + + eom_get_output_attribute(output_id, &attribute); + eom_get_output_attribute_state(output_id, &state); + + g_print ("[eom] output(%d) attribute changed(%d, %d)\n", output_id, attribute, state); + if (state == EOM_OUTPUT_ATTRIBUTE_STATE_ACTIVE) + { + g_print ("[eom] active\n"); + if (!g_external_xid) + { + g_external_xid = elm_win_add(NULL, "External", ELM_WIN_BASIC); + if (eom_set_output_window(info->hdmi_output_id, g_external_xid) == EOM_ERROR_NONE) + { + create_render_rect_and_bg(g_external_xid); + g_print ("[eom] create external window\n"); + } + else + { + evas_object_del (g_external_xid); + g_external_xid = NULL; + g_print ("[eom] create external window fail\n"); + } + } + selected_xid = g_external_xid; + /* play video on external window */ + if (g_player[0]) + player_set_display(g_player[0], PLAYER_DISPLAY_TYPE_OVERLAY, GET_DISPLAY(selected_xid)); + } + else if (state == EOM_OUTPUT_ATTRIBUTE_STATE_INACTIVE) + { + g_print ("[eom] inactive\n"); + if(!g_xid) + { + g_xid = create_win(PACKAGE); + if (g_xid == NULL) + return; + g_print("create xid %p\n", g_xid); + create_render_rect_and_bg(g_xid); + elm_win_activate(g_xid); + evas_object_show(g_xid); + } + selected_xid = g_xid; + if (g_player[0]) + player_set_display(g_player[0], PLAYER_DISPLAY_TYPE_OVERLAY, GET_DISPLAY(selected_xid)); + + if (g_external_xid) + { + evas_object_del(g_external_xid); + g_external_xid = NULL; + } + } + else if (state == EOM_OUTPUT_ATTRIBUTE_STATE_LOST) + { + g_print ("[eom] lost\n"); + if(!g_xid) + { + g_xid = create_win(PACKAGE); + if (g_xid == NULL) + return; + g_print("create xid %p\n", g_xid); + create_render_rect_and_bg(g_xid); + elm_win_activate(g_xid); + evas_object_show(g_xid); + } + selected_xid = g_xid; + + if (g_player[0]) + player_set_display(g_player[0], PLAYER_DISPLAY_TYPE_OVERLAY, GET_DISPLAY(selected_xid)); + + if (g_external_xid) + { + evas_object_del(g_external_xid); + g_external_xid = NULL; + } + + eom_unset_output_added_cb(eom_notify_cb_output_add); + eom_unset_output_removed_cb(eom_notify_cb_output_remove); + eom_unset_mode_changed_cb(eom_notify_cb_mode_changed); + eom_unset_attribute_changed_cb(eom_notify_cb_attribute_changed); + + eom_deinit (); + } +} + +static int app_create(void *data) +{ + appdata *ad = data; + Evas_Object *win = NULL; + eom_output_mode_e output_mode = EOM_OUTPUT_MODE_NONE; + + /* use gl backend */ + elm_config_preferred_engine_set("3d"); + + /* create window */ + win = create_win(PACKAGE); + if (win == NULL) + return -1; + ad->win = win; + g_xid = win; + selected_xid = g_xid; + create_render_rect_and_bg(ad->win); + /* Create evas image object for EVAS surface */ + g_eo[0] = create_image_object(ad->win); + evas_object_image_size_set(g_eo[0], 500, 500); + evas_object_image_fill_set(g_eo[0], 0, 0, 500, 500); + evas_object_resize(g_eo[0], 500, 500); + + elm_win_activate(win); + evas_object_show(win); + + /* check external device */ + eom_init (); + ad->hdmi_output_id = eom_get_output_id ("HDMI"); + if (ad->hdmi_output_id == 0) + { + g_print ("[eom] error : HDMI output id is NULL.\n"); + return 0; + } + + g_print ("eom_set_output_attribute EOM_OUTPUT_ATTRIBUTE_NORMAL(id:%d)\n", ad->hdmi_output_id); + if (eom_set_output_attribute(ad->hdmi_output_id, EOM_OUTPUT_ATTRIBUTE_NORMAL) != EOM_ERROR_NONE) + { + g_print ("attribute set fail. cannot use external output\n"); + eom_deinit (); + } + + eom_get_output_mode(ad->hdmi_output_id, &output_mode); + if (output_mode != EOM_OUTPUT_MODE_NONE) + { + g_external_xid = elm_win_add(NULL, "External", ELM_WIN_BASIC); + if (eom_set_output_window(ad->hdmi_output_id, g_external_xid) == EOM_ERROR_NONE) + { + create_render_rect_and_bg(g_external_xid); + g_print ("[eom] create external window\n"); + } + else + { + evas_object_del (g_external_xid); + g_external_xid = NULL; + g_print ("[eom] create external window fail\n"); + } + selected_xid = g_external_xid; + } + + /* set callback for detecting external device */ + eom_set_output_added_cb(eom_notify_cb_output_add, ad); + eom_set_output_removed_cb(eom_notify_cb_output_remove, ad); + eom_set_mode_changed_cb(eom_notify_cb_mode_changed, ad); + eom_set_attribute_changed_cb(eom_notify_cb_attribute_changed, ad); + + return 0; +} + +static int app_terminate(void *data) +{ + appdata *ad = data; + int i = 0; + + for (i = 0 ; i < MAX_HANDLE; i++) + { + if (g_eo[i]) + { + evas_object_del(g_eo[i]); + g_eo[i] = NULL; + } + } + if (g_xid) { + evas_object_del(g_xid); + g_xid = NULL; + } + if (g_external_xid) { + evas_object_del(g_external_xid); + g_external_xid = NULL; + } + ad->win = NULL; + selected_xid = NULL; +#ifdef _USE_X_DIRECT_ + if(g_dpy) + { + if(g_gc) + XFreeGC (g_dpy, g_gc); + if(g_xid) + XDestroyWindow (g_dpy, g_xid); + XCloseDisplay (g_dpy); + g_xid = 0; + g_dpy = NULL; + } +#endif + + eom_unset_output_added_cb(eom_notify_cb_output_add); + eom_unset_output_removed_cb(eom_notify_cb_output_remove); + eom_unset_mode_changed_cb(eom_notify_cb_mode_changed); + eom_unset_attribute_changed_cb(eom_notify_cb_attribute_changed); + + eom_deinit (); + + return 0; +} + +struct appcore_ops ops = { + .create = app_create, + .terminate = app_terminate, +}; + +static void prepared_cb(void *user_data) +{ + g_print("[Player_Test] prepared_cb!!!!\n"); +} + +/* TODO : Make internal API */ +#if 0 +static void _audio_frame_decoded_cb_ex(player_audio_raw_data_s *audio_raw_frame, void *user_data) +{ + player_audio_raw_data_s* audio_raw = audio_raw_frame; + + if (!audio_raw) return; + + g_print("[Player_Test] decoded_cb_ex! channel: %d channel_mask: %" G_GUINT64_FORMAT "\n", audio_raw->channel, audio_raw->channel_mask); + +#ifdef DUMP_OUTBUF + if(audio_raw->channel_mask == 1) + fwrite((guint8 *)audio_raw->data, 1, audio_raw->size, fp_out1); + else if(audio_raw->channel_mask == 2) + fwrite((guint8 *)audio_raw->data, 1, audio_raw->size, fp_out2); +#endif +} +#endif + +static void progress_down_cb(player_pd_message_type_e type, void *user_data) +{ + g_print("[Player_Test] progress_down_cb!!!! type : %d\n", type); +} + +static void buffering_cb(int percent, void *user_data) +{ + g_print("[Player_Test] buffering_cb!!!! percent : %d\n", percent); +} + +static void seek_completed_cb(void *user_data) +{ + g_print("[Player_Test] seek_completed_cb!!! \n"); +} + +static void completed_cb(void *user_data) +{ + g_print("[Player_Test] completed_cb!!!!\n"); +} + +static void error_cb(int code, void *user_data) +{ + g_print("[Player_Test] error_cb!!!! code : %d\n", code); +} + +static void interrupted_cb(player_interrupted_code_e code, void *user_data) +{ + g_print("[Player_Test] interrupted_cb!!!! code : %d\n", code); +} + +#if 0 +static void audio_frame_decoded_cb(unsigned char *data, unsigned int size, void *user_data) +{ + int pos=0; + + if (data && g_pcm_fd) + { + fwrite(data, 1, size, g_pcm_fd); + } + player_get_play_position(g_player[0], &pos); + g_print("[Player_Test] audio_frame_decoded_cb [size: %d] --- current pos : %d!!!!\n", size, pos); +} +#endif + +static void subtitle_updated_cb(unsigned long duration, char *text, void *user_data) +{ + g_print("[Player_Test] subtitle_updated_cb!!!! [%ld] %s\n",duration, text); +} + +static void video_captured_cb(unsigned char *data, int width, int height,unsigned int size, void *user_data) +{ + g_print("[Player_Test] video_captured_cb!!!! width: %d, height : %d, size : %d \n",width, height,size); + _save(data, size); +} + +static int _save(unsigned char * src, int length) +{ //unlink(CAPTUERD_IMAGE_SAVE_PATH); + FILE* fp; + char filename[256] = {0,}; + static int WRITE_COUNT = 0; + + //gchar *filename = CAPTUERD_IMAGE_SAVE_PATH; + snprintf (filename, 256, "IMAGE_client%d", WRITE_COUNT); + WRITE_COUNT++; + fp=fopen(filename, "w+"); + if(fp==NULL) + { + g_print("file open error!!\n"); + return FALSE; + } + else + { + g_print("open success\n"); + if(fwrite(src, 1, length, fp ) < 1) + { + g_print("file write error!!\n"); + fclose(fp); + return FALSE; + } + g_print("write success(%s)\n", filename); + fclose(fp); + } + + return TRUE; +} + +static void reset_display() +{ + int i = 0; + + /* delete evas window, if it is */ + for (i = 0 ; i < MAX_HANDLE; i++) + { + if (g_eo[i]) + { + evas_object_del(g_eo[i]); + g_eo[i] = NULL; + } + } + +#ifdef _USE_X_DIRECT_ + /* delete x window, if it is */ + if(g_dpy) + { + if(g_gc) + XFreeGC (g_dpy, g_gc); + if(g_xid) + XDestroyWindow (g_dpy, g_xid); + XCloseDisplay (g_dpy); + g_xid = 0; + g_dpy = NULL; + } +#endif +} + +static void input_filename(char *filename) +{ + int len = strlen(filename); + int i = 0; + + if ( len < 0 || len > MAX_STRING_LEN ) + return; + + for (i = 0; i < g_handle_num; i++) + { + if(g_player[i]!=NULL) + { + player_unprepare(g_player[i]); + player_destroy(g_player[i]); + } + g_player[i] = 0; + + if ( player_create(&g_player[i]) != PLAYER_ERROR_NONE ) + { + g_print("player create is failed\n"); + } + } + + strncpy (g_uri, filename,len); + g_uri[len] = '\0'; + +#if 0 //ned(APPSRC_TEST) + gchar uri[100]; + gchar *ext; + gsize file_size; + GMappedFile *file; + GError *error = NULL; + guint8* g_media_mem = NULL; + + ext = filename; + + file = g_mapped_file_new (ext, FALSE, &error); + file_size = g_mapped_file_get_length (file); + g_media_mem = (guint8 *) g_mapped_file_get_contents (file); + + g_sprintf(uri, "mem://ext=%s,size=%d", ext ? ext : "", file_size); + g_print("[uri] = %s\n", uri); + + mm_player_set_attribute(g_player[0], + &g_err_name, + "profile_uri", uri, strlen(uri), + "profile_user_param", g_media_mem, file_size + NULL); +#else + //player_set_uri(g_player[0], filename); +#endif /* APPSRC_TEST */ + + int ret; + player_state_e state; + for (i = 0; i < g_handle_num; i++) + { + ret = player_get_state(g_player[i], &state); + g_print("player_get_state returned [%d]\n", ret); + g_print("1. After player_create() - Current State : %d \n", state); + } +} + +// use this API instead of player_set_uri +static void player_set_memory_buffer_test() +{ + GMappedFile *file; + gsize file_size; + guint8* g_media_mem = NULL; + + file = g_mapped_file_new (g_uri, FALSE, NULL); + file_size = g_mapped_file_get_length (file); + g_media_mem = (guint8 *) g_mapped_file_get_contents (file); + + int ret = player_set_memory_buffer(g_player[0], (void*)g_media_mem, file_size); + g_print("player_set_memory_buffer ret : %d\n", ret); +} + +int video_packet_count = 0; + +static void buffer_need_video_data_cb(unsigned int size, void *user_data) +{ + int real_read_len = 0; + char fname[128]; + char fptsname[128]; + static guint64 pts = 0L; + + FILE *fp = NULL; + guint8 *buff_ptr = NULL; + void *src = NULL; + + memset(fname, 0, 128); + memset(fptsname, 0, 128); + + video_packet_count++; + + if (video_packet_count > 1000) + { + g_print("EOS.\n"); +// player_submit_packet(g_player[0], NULL, 0, 0, 1); + player_push_media_stream(g_player[0], NULL); + g_thread_end = TRUE; + } +// snprintf(fname, 128, "/opt/storage/usb/test/packet/packet_%d.dat", video_packet_count); +// snprintf(fptsname, 128, "/opt/storage/usb/test/packet/gstpts_%d.dat", video_packet_count); + snprintf(fname, 128, "/home/developer/test/packet/packet_%d.dat", video_packet_count); + snprintf(fptsname, 128, "/home/developer/test/packet/gstpts_%d.dat", video_packet_count); + + fp = fopen(fptsname, "rb"); + if (fp) + { + int pts_len = 0; + pts_len = fread(&pts, 1, sizeof(guint64), fp); + if (pts_len != sizeof(guint64)) + { + g_print("Warning, pts value can be wrong.\n"); + } + fclose(fp); + fp = NULL; + } + + fp = fopen(fname, "rb"); + if (fp) + { + buff_ptr = (guint8 *)g_malloc0(1048576); + real_read_len = fread(buff_ptr, 1, size, fp); + fclose(fp); + fp = NULL; + } + g_print("video need data - data size : %d, pts : %" G_GUINT64_FORMAT "\n", real_read_len, pts); +#if 0 + player_submit_packet(g_player[0], buff_ptr, real_read_len, (pts/1000000), 1); +#else + /* create media packet */ + if (g_video_pkt) { + media_packet_destroy(g_video_pkt); + g_video_pkt = NULL; + } + + media_packet_create_alloc(g_video_fmt, NULL, NULL, &g_video_pkt); + + g_print("packet = %p, src = %p\n", g_video_pkt, src); + + + if (media_packet_get_buffer_data_ptr(g_video_pkt, &src) != MEDIA_PACKET_ERROR_NONE) + return; + + if (media_packet_set_pts(g_video_pkt, (uint64_t)(pts/1000000)) != MEDIA_PACKET_ERROR_NONE) + return; + + if (media_packet_set_buffer_size(g_video_pkt, (uint64_t)real_read_len) != MEDIA_PACKET_ERROR_NONE) + return; + + memcpy(src, buff_ptr, real_read_len); + + /* then, push it */ + player_push_media_stream(g_player[0], g_video_pkt); +#endif + + if (buff_ptr) + { + g_free(buff_ptr); + buff_ptr = NULL; + } +} + +int audio_packet_count = 0; +static void buffer_need_audio_data_cb(unsigned int size, void *user_data) +{ + int real_read_len = 0; + char fname[128]; + FILE *fp = NULL; + guint8 *buff_ptr = NULL; + void *src = NULL; + + memset(fname, 0, 128); + audio_packet_count++; + + if (audio_packet_count > 1000) + { + g_print("EOS.\n"); +// player_submit_packet(g_player[0], NULL, 0, 0, 0); + player_push_media_stream(g_player[0], NULL); + g_thread_end = TRUE; + } + +// snprintf(fname, 128, "/opt/storage/usb/test/audio_packet/packet_%d.dat", audio_packet_count); + snprintf(fname, 128, "/home/developer/test/audio_packet/packet_%d.dat", audio_packet_count); + + static guint64 audio_pts = 0; + guint64 audio_dur = 21333333; + + fp = fopen(fname, "rb"); + if (fp) + { + buff_ptr = (guint8 *)g_malloc0(1048576); + real_read_len = fread(buff_ptr, 1, size, fp); + fclose(fp); + fp = NULL; + + g_print("\t audio need data - data size : %d, pts : %" G_GUINT64_FORMAT "\n", real_read_len, audio_pts); + } +#if 0 + player_submit_packet(g_player[0], buff_ptr, real_read_len, (audio_pts/1000000), 0); +#else + /* create media packet */ + if (g_audio_pkt) { + media_packet_destroy(g_audio_pkt); + g_audio_pkt = NULL; + } + media_packet_create_alloc(g_audio_fmt, NULL, NULL, &g_audio_pkt); + + g_print("packet = %p, src = %p\n", g_audio_pkt, src); + + + if (media_packet_get_buffer_data_ptr(g_audio_pkt, &src) != MEDIA_PACKET_ERROR_NONE) + return; + + if (media_packet_set_pts(g_audio_pkt, (uint64_t)(audio_pts/1000000)) != MEDIA_PACKET_ERROR_NONE) + return; + + if (media_packet_set_buffer_size(g_audio_pkt, (uint64_t)real_read_len) != MEDIA_PACKET_ERROR_NONE) + return; + + memcpy(src, buff_ptr, real_read_len); + + /* then, push it */ + player_push_media_stream(g_player[0], g_audio_pkt); +#endif + + audio_pts += audio_dur; + + if (buff_ptr) + { + g_free(buff_ptr); + buff_ptr = NULL; + } +} + +static void set_content_info(bool is_push_mode) +{ + /* testcode for es buff src case, please input url as es_buff://123 or es_buff://push_mode */ +// unsigned char codec_data[45] = {0x0,0x0,0x1,0xb0,0x1,0x0,0x0,0x1,0xb5,0x89,0x13,0x0,0x0,0x1,0x0,0x0,0x0,0x1,0x20,0x0,0xc4,0x8d,0x88,0x5d,0xad,0x14,0x4,0x22,0x14,0x43,0x0,0x0,0x1,0xb2,0x4c,0x61,0x76,0x63,0x35,0x31,0x2e,0x34,0x30,0x2e,0x34}; + + /* create media format */ + media_format_create(&g_audio_fmt); + media_format_create(&g_video_fmt); + + //Video + /* configure media format for video and set to player */ + media_format_set_video_mime(g_video_fmt, MEDIA_FORMAT_MPEG4_SP); + media_format_set_video_width(g_video_fmt, 640); + media_format_set_video_height(g_video_fmt,272); +// player_set_media_stream_info(g_player[0], PLAYER_STREAM_TYPE_VIDEO, g_video_fmt); + + //Audio--aac--StarWars.mp4 + media_format_set_audio_mime(g_audio_fmt, MEDIA_FORMAT_AAC); + media_format_set_audio_channel(g_audio_fmt, 2); + media_format_set_audio_samplerate(g_audio_fmt, 48000); +// player_set_media_stream_info(g_player[0], PLAYER_STREAM_TYPE_AUDIO, g_audio_fmt); +#if 0 +// video_info->mime = g_strdup("video/mpeg"); //CODEC_ID_MPEG4VIDEO + video_info->width = 640; + video_info->height = 272; + video_info->version = 4; + video_info->framerate_den = 100; + video_info->framerate_num = 2997; + + video_info->extradata_size = 45; + video_info->codec_extradata = codec_data; + player_set_video_stream_info(g_player[0], video_info); + + + //audio--aac--StarWars.mp4 +// audio_info->mime = g_strdup("audio/mpeg"); + //audio_info->version = 2; +// audio_info->user_info = 0; //raw +#endif + +#ifdef _ES_PULL_ + if (!is_push_mode) + { + player_set_buffer_need_video_data_cb(g_player[0], buffer_need_video_data_cb, (void*)g_player[0]); + player_set_buffer_need_audio_data_cb(g_player[0], buffer_need_audio_data_cb, (void*)g_player[0]); + } +#endif +} + +static void feed_video_data_thread_func(void *data) +{ + while (!g_thread_end) + { + buffer_need_video_data_cb(1048576, NULL); + buffer_need_audio_data_cb(1048576, NULL); + } +} + +static void _player_prepare(bool async) +{ + int ret = FALSE; + int slen = strlen(g_subtitle_uri); + + if ( slen > 0 && slen < MAX_STRING_LEN ) + { + g_print("0. set subtile path() (size : %d) - %s \n", slen, g_subtitle_uri); + player_set_subtitle_path(g_player[0],g_subtitle_uri); + player_set_subtitle_updated_cb(g_player[0], subtitle_updated_cb, (void*)g_player[0]); + } + if (g_current_surface_type == PLAYER_DISPLAY_TYPE_OVERLAY) + { + player_set_display(g_player[0], g_current_surface_type, GET_DISPLAY(selected_xid)); + player_set_buffering_cb(g_player[0], buffering_cb, (void*)g_player[0]); + player_set_completed_cb(g_player[0], completed_cb, (void*)g_player[0]); + player_set_interrupted_cb(g_player[0], interrupted_cb, (void*)g_player[0]); + player_set_error_cb(g_player[0], error_cb, (void*)g_player[0]); + if (g_memory_playback) + player_set_memory_buffer_test(); + else + player_set_uri(g_player[0], g_uri); + } + else + { + int i = 0; + for (i = 0; i < g_handle_num; i++) + { + player_set_display(g_player[i], g_current_surface_type, g_eo[i]); + player_set_buffering_cb(g_player[i], buffering_cb, (void*)g_player[i]); + player_set_completed_cb(g_player[i], completed_cb, (void*)g_player[i]); + player_set_interrupted_cb(g_player[i], interrupted_cb, (void*)g_player[i]); + player_set_error_cb(g_player[i], error_cb, (void*)g_player[i]); + if (g_memory_playback) + player_set_memory_buffer_test(); + else + player_set_uri(g_player[i], g_uri); + } + } + + if (strstr(g_uri, "es_buff://")) + { + is_es_push_mode = FALSE; + video_packet_count = 0; + audio_packet_count = 0; + + if (strstr(g_uri, "es_buff://push_mode")) + { + set_content_info(TRUE); + async = TRUE; + is_es_push_mode = TRUE; + } +#ifdef _ES_PULL_ + else + { + set_content_info(FALSE); + } +#endif + } + + if (g_current_surface_type == PLAYER_DISPLAY_TYPE_OVERLAY) + { + if ( async ) + { + ret = player_prepare_async(g_player[0], prepared_cb, (void*) g_player[0]); + } + else + ret = player_prepare(g_player[0]); + } + else + { + int i = 0; + for (i = 0; i < g_handle_num; i++) + { + if ( async ) + { + ret = player_prepare_async(g_player[i], prepared_cb, (void*) g_player[i]); + } + else + ret = player_prepare(g_player[i]); + } + } + + if ( ret != PLAYER_ERROR_NONE ) + { + g_print("prepare is failed (errno = %d) \n", ret); + } + player_state_e state; + if (g_current_surface_type == PLAYER_DISPLAY_TYPE_OVERLAY) + { + ret = player_get_state(g_player[0], &state); + g_print("After player_prepare() - Current State : %d \n", state); + } + else + { + int i = 0; + for (i = 0; i < g_handle_num; i++) + { + ret = player_get_state(g_player[i], &state); + g_print("After player_prepare() - Current State : %d \n", state); + } + } + + if (is_es_push_mode) { + pthread_create(&g_feed_video_thread_id, NULL, (void*)feed_video_data_thread_func, NULL); + } + +} + +static void _player_unprepare() +{ + int ret = FALSE; + int i = 0; + if (g_current_surface_type == PLAYER_DISPLAY_TYPE_OVERLAY) + { + ret = player_unprepare(g_player[0]); + if ( ret != PLAYER_ERROR_NONE ) + { + g_print("unprepare is failed (errno = %d) \n", ret); + } + ret = player_unset_subtitle_updated_cb(g_player[0]); + g_print("player_unset_subtitle_updated_cb ret %d\n", ret); + + ret = player_unset_buffering_cb(g_player[0]); + g_print("player_unset_buffering_cb ret %d\n", ret); + + ret = player_unset_completed_cb(g_player[0]); + g_print("player_unset_completed_cb ret %d\n", ret); + + ret = player_unset_interrupted_cb(g_player[0]); + g_print("player_unset_interrupted_cb ret %d\n", ret); + + ret = player_unset_error_cb(g_player[0]); + g_print("player_unset_error_cb ret %d\n", ret); + } + else + { + for (i = 0; i < g_handle_num ; i++) + { + if(g_player[i]!=NULL) + { + ret = player_unprepare(g_player[i]); + if ( ret != PLAYER_ERROR_NONE ) + { + g_print("unprepare is failed (errno = %d) \n", ret); + } + ret = player_unset_subtitle_updated_cb(g_player[i]); + g_print("player_unset_subtitle_updated_cb [%d] ret %d\n", i, ret); + + ret = player_unset_buffering_cb(g_player[i]); + g_print("player_unset_buffering_cb [%d] ret %d\n", i, ret); + + ret = player_unset_completed_cb(g_player[i]); + g_print("player_unset_completed_cb [%d] ret %d\n", i, ret); + + ret = player_unset_interrupted_cb(g_player[i]); + g_print("player_unset_interrupted_cb [%d] ret %d\n", i, ret); + + ret = player_unset_error_cb(g_player[i]); + g_print("player_unset_error_cb [%d] ret %d\n", i, ret); + } + } + } + reset_display(); //attention! surface(evas) -> unprepare -> surface(evas) : evas object will disappear. + memset(g_subtitle_uri, 0 , sizeof(g_subtitle_uri)); + player_state_e state; + if (g_current_surface_type == PLAYER_DISPLAY_TYPE_OVERLAY) + { + ret = player_get_state(g_player[0], &state); + g_print(" After player_unprepare() - Current State : %d \n", state); + } + else + { + for (i = 0; i < g_handle_num ; i++) + { + ret = player_get_state(g_player[i], &state); + g_print(" After player_unprepare() - Current State : %d \n", state); + } + } +} + +static void _player_destroy() +{ + int i = 0; + + if (g_current_surface_type == PLAYER_DISPLAY_TYPE_OVERLAY) + { + player_unprepare(g_player[0]); + for (i = 0; i < g_handle_num ; i++) + { + player_destroy(g_player[i]); + g_player[i] = 0; + } + } + else + { + for (i = 0; i < g_handle_num ; i++) + { + if(g_player[i]!=NULL) + { + player_unprepare(g_player[i]); + player_destroy(g_player[i]); + g_player[i] = 0; + } + } + } + + if (g_video_pkt) + media_packet_destroy(g_video_pkt); + + if (g_audio_pkt) + media_packet_destroy(g_audio_pkt); + +#if DUMP_OUTBUF + if (fp_out1) + fclose(fp_out1); + if (fp_out2) + fclose(fp_out2); +#endif + +} + +static void _player_play() +{ + int bRet = FALSE; + int i = 0; + if (g_current_surface_type == PLAYER_DISPLAY_TYPE_OVERLAY) + { + //for checking external display.... + player_set_display(g_player[0], g_current_surface_type, GET_DISPLAY(selected_xid)); + bRet = player_start(g_player[0]); + g_print("player_start returned [%d]", bRet); + } + else + { + for (i = 0; i < g_handle_num ; i++) + { + bRet = player_start(g_player[i]); + g_print("player_start returned [%d]", bRet); + } + } +} + +static void _player_stop() +{ + int bRet = FALSE; + int i = 0; + if (g_current_surface_type == PLAYER_DISPLAY_TYPE_OVERLAY) + { + bRet = player_stop(g_player[0]); + g_print("player_stop returned [%d]", bRet); + } + else + { + for (i = 0; i < g_handle_num ; i++) + { + bRet = player_stop(g_player[i]); + g_print("player_stop returned [%d]", bRet); + } + } + + g_thread_end = TRUE; + if (g_feed_video_thread_id) + { + pthread_join(g_feed_video_thread_id, NULL); + g_feed_video_thread_id = 0; + } + +} + +static void _player_resume() +{ + int bRet = FALSE; + int i = 0; + if (g_current_surface_type == PLAYER_DISPLAY_TYPE_OVERLAY) + { + //for checking external display.... + player_set_display(g_player[0], PLAYER_DISPLAY_TYPE_OVERLAY, GET_DISPLAY(selected_xid)); + bRet = player_start(g_player[0]); + g_print("player_start returned [%d]", bRet); + } + else + { + for (i = 0; i < g_handle_num ; i++) + { + bRet = player_start(g_player[i]); + g_print("player_start returned [%d]", bRet); + } + } +} + +static void _player_pause() +{ + int bRet = FALSE; + int i = 0; + if (g_current_surface_type == PLAYER_DISPLAY_TYPE_OVERLAY) + { + bRet = player_pause(g_player[0]); + g_print("player_pause returned [%d]", bRet); + } + else + { + for (i = 0; i < g_handle_num ; i++) + { + bRet = player_pause(g_player[i]); + g_print("player_pause returned [%d]", bRet); + } + } +} + +static void _player_state() +{ + player_state_e state; + player_get_state(g_player[0], &state); + g_print(" ==> [Player_Test] Current Player State : %d\n", state); +} + +static void _player_set_progressive_download() +{ + player_set_progressive_download_path(g_player[0], "/opt/test.pd"); + player_set_progressive_download_message_cb(g_player[0], progress_down_cb, (void*)g_player[0]); +} + +static void set_volume(float volume) +{ + if ( player_set_volume(g_player[0], volume, volume) != PLAYER_ERROR_NONE ) + { + g_print("failed to set volume\n"); + } +} + +static void get_volume(float* left, float* right) +{ + player_get_volume(g_player[0], left, right); + g_print(" ==> [Player_Test] volume - left : %f, right : %f\n", *left, *right); +} + +static void set_mute(bool mute) +{ + if ( player_set_mute(g_player[0], mute) != PLAYER_ERROR_NONE ) + { + g_print("failed to set_mute\n"); + } +} + +static void get_mute(bool *mute) +{ + player_is_muted(g_player[0], mute); + g_print(" ==> [Player_Test] mute = %d\n", *mute); +} + +static void set_sound_type(sound_type_e type) +{ + if ( player_set_sound_type(g_player[0], type) != PLAYER_ERROR_NONE ) + { + g_print("failed to set sound type(%d)\n", type); + } + else + g_print("set sound type(%d) success", type); +} + +static void get_position() +{ + int position = 0; + int ret; + ret = player_get_play_position(g_player[0], &position); + g_print(" ==> [Player_Test] player_get_play_position()%d return : %d\n", ret, position); +} + +static void set_position(int position) +{ + if ( player_set_play_position(g_player[0], position, TRUE, seek_completed_cb, g_player[0]) != PLAYER_ERROR_NONE ) + { + g_print("failed to set position\n"); + } +} + +static void set_playback_rate(float rate) +{ + if ( player_set_playback_rate(g_player[0], rate) != PLAYER_ERROR_NONE ) + { + g_print("failed to set playback rate\n"); + } +} + +static void get_duration() +{ + int duration = 0; + int ret; + ret = player_get_duration(g_player[0], &duration); + g_print(" ==> [Player_Test] player_get_duration() return : %d\n",ret); + g_print(" ==> [Player_Test] Duration: [%d ] msec\n",duration); +} + +static void audio_frame_decoded_cb_ex() +{ +/* TODO : Make internal API */ +#if 0 + int ret; + +#if DUMP_OUTBUF + fp_out1 = fopen("/opt/usr/media/out1.pcm", "wb"); + fp_out2 = fopen("/opt/usr/media/out2.pcm", "wb"); +#endif + + ret = player_set_pcm_extraction_mode(g_player[0], false, _audio_frame_decoded_cb_ex, &ret); + g_print(" ==> [Player_Test] player_set_audio_frame_decoded_cb_ex return: %d\n", ret); +#endif +} + +static void set_pcm_spec() +{ +/* TODO : Make internal API */ +#if 0 + int ret = 0; + + ret = player_set_pcm_spec(g_player[0], "F32LE", 44100, 2); + g_print("[Player_Test] set_pcm_spec return: %d\n", ret); +#endif +} + +static void get_stream_info() +{ + int w = 0; + int h = 0; + + char *value = NULL; + player_get_content_info(g_player[0], PLAYER_CONTENT_INFO_ALBUM, &value); + g_print(" ==> [Player_Test] PLAYER_CONTENT_INFO_ALBUM: [%s ] \n",value); + player_get_content_info(g_player[0], PLAYER_CONTENT_INFO_ARTIST, &value); + g_print(" ==> [Player_Test] PLAYER_CONTENT_INFO_ARTIST: [%s ] \n",value); + player_get_content_info(g_player[0], PLAYER_CONTENT_INFO_AUTHOR, &value); + g_print(" ==> [Player_Test] PLAYER_CONTENT_INFO_AUTHOR: [%s ] \n",value); + player_get_content_info(g_player[0], PLAYER_CONTENT_INFO_GENRE, &value); + g_print(" ==> [Player_Test] PLAYER_CONTENT_INFO_GENRE: [%s ] \n",value); + player_get_content_info(g_player[0], PLAYER_CONTENT_INFO_TITLE, &value); + g_print(" ==> [Player_Test] PLAYER_CONTENT_INFO_TITLE: [%s ] \n",value); + void *album; + int size; + player_get_album_art(g_player[0], &album, &size); + g_print(" ==> [Player_Test] Album art : [ data : %p, size : %d ]\n", (unsigned int *)album, size); + if(value!=NULL) + { + free(value); + value = NULL; + } + + int sample_rate; + int channel; + int bit_rate; + int fps, v_bit_rate; + player_get_audio_stream_info(g_player[0], &sample_rate, &channel, &bit_rate); + g_print(" ==> [Player_Test] Sample Rate: [%d ] , Channel: [%d ] , Bit Rate: [%d ] \n",sample_rate,channel,bit_rate); + + player_get_video_stream_info(g_player[0], &fps, &v_bit_rate); + g_print(" ==> [Player_Test] fps: [%d ] , Bit Rate: [%d ] \n",fps,v_bit_rate); + + char *audio_codec = NULL; + char *video_codec = NULL; + player_get_codec_info(g_player[0], &audio_codec, &video_codec); + if(audio_codec!=NULL) + { + g_print(" ==> [Player_Test] Audio Codec: [%s ] \n",audio_codec); + free(audio_codec); + audio_codec = NULL; + } + if(video_codec!=NULL) + { + g_print(" ==> [Player_Test] Video Codec: [%s ] \n",video_codec); + free(video_codec); + video_codec = NULL; + } + player_get_video_size(g_player[0], &w, &h); + g_print(" ==> [Player_Test] Width: [%d ] , Height: [%d ] \n",w,h); + } + +static void set_looping(bool looping) +{ + if (g_current_surface_type == PLAYER_DISPLAY_TYPE_OVERLAY) + { + if ( player_set_looping(g_player[0], looping) != PLAYER_ERROR_NONE ) + { + g_print("failed to set_looping\n"); + } + } + else + { + int i = 0; + for (i = 0; i < g_handle_num; i++) + { + if ( player_set_looping(g_player[i], looping) != PLAYER_ERROR_NONE ) + { + g_print("failed to set_looping\n"); + } + } + } +} + +static void get_looping(bool *looping) +{ + player_is_looping(g_player[0], looping); + g_print(" ==> [Player_Test] looping = %d\n", *looping); +} + +static void change_surface(int option) +{ + player_display_type_e surface_type = 0; + int ret = PLAYER_ERROR_NONE; + int hdmi_output_id; + eom_output_mode_e output_mode; + + switch (option) + { + case 0: /* X surface */ + surface_type = PLAYER_DISPLAY_TYPE_OVERLAY; + g_print("change surface type to X\n"); + break; +#ifdef TIZEN_MOBILE + case 1: /* EVAS surface */ + surface_type = PLAYER_DISPLAY_TYPE_EVAS; + g_print("change surface type to EVAS\n"); + break; +#endif + case 2: + g_print("change surface type to NONE\n"); + player_set_display(g_player[0], PLAYER_DISPLAY_TYPE_NONE, NULL); + break; + default: + g_print("invalid surface type\n"); + return; + } + + if (surface_type == g_current_surface_type) + { + g_print("same with the previous surface type(%d)\n", g_current_surface_type); + return; + } + else + { + player_state_e player_state = PLAYER_STATE_NONE; + ret = player_get_state(g_player[0], &player_state); + if (ret) + { + g_print("failed to player_get_state(), ret(0x%x)\n", ret); + } + reset_display(); + + if (surface_type == PLAYER_DISPLAY_TYPE_OVERLAY) + { +#ifdef _USE_X_DIRECT_ + /* Create xwindow for X surface */ + if(!g_dpy) + { + g_dpy = XOpenDisplay (NULL); + g_xid = create_window (g_dpy, 0, 0, 500, 500); + g_gc = XCreateGC (g_dpy, g_xid, 0, 0); + } + g_print("create x window dpy(%p), gc(%x), xid(%d)\n", g_dpy, (unsigned int)g_gc, (int)g_xid); + XImage *xim = make_transparent_image (g_dpy, 500, 500); + XPutImage (g_dpy, g_xid, g_gc, xim, 0, 0, 0, 0, 500, 500); + XSync (g_dpy, False); +#else + + hdmi_output_id = eom_get_output_id ("HDMI"); + if (hdmi_output_id == 0) + g_print ("[eom] error : HDMI output id is NULL.\n"); + + eom_get_output_mode(hdmi_output_id, &output_mode); + if (output_mode == EOM_OUTPUT_MODE_NONE) + { + if(!g_xid) + { + g_xid = create_win(PACKAGE); + if (g_xid == NULL) + return; + g_print("create xid %p\n", g_xid); + create_render_rect_and_bg(g_xid); + elm_win_activate(g_xid); + evas_object_show(g_xid); + g_xid = selected_xid; + } + } + else + { + //for external + } +#endif + ret = player_set_display(g_player[0], surface_type, GET_DISPLAY(selected_xid)); + } + else + { + if(!g_xid) + { + g_xid = create_win(PACKAGE); + if (g_xid == NULL) + return; + g_print("create xid %p\n", g_xid); + create_render_rect_and_bg(g_xid); + elm_win_activate(g_xid); + evas_object_show(g_xid); + } + int i = 0; + for (i = 0; i < g_handle_num ; i++) + { + /* Create evas image object for EVAS surface */ + if (!g_eo[i]) + { + g_eo[i] = create_image_object(g_xid); + g_print("create eo[%d] %p\n", i, g_eo[i]); + evas_object_image_size_set(g_eo[i], 500, 500); + evas_object_image_fill_set(g_eo[i], 0, 0, 500, 500); + evas_object_resize(g_eo[i], 500, 500); + evas_object_move(g_eo[i], i*20, i*20); + } + ret = player_set_display(g_player[i], surface_type, g_eo[i]); + } + } + if (ret) + { + g_print("failed to set display, surface_type(%d)\n", surface_type); + return; + } + g_current_surface_type = surface_type; + } + return; +} + +static void set_display_mode(int mode) +{ + if ( player_set_display_mode(g_player[0], mode) != PLAYER_ERROR_NONE ) + { + g_print("failed to player_set_display_mode\n"); + } +} + +static void get_display_mode() +{ + player_display_mode_e mode; + player_get_display_mode(g_player[0], &mode); + g_print(" ==> [Player_Test] Display mode: [%d ] \n",mode); +} + +static void set_display_rotation(int rotation) +{ + if ( player_set_display_rotation(g_player[0], rotation) != PLAYER_ERROR_NONE ) + { + g_print("failed to set_display_rotation\n"); + } +} + +static void get_display_rotation() +{ + player_display_rotation_e rotation = 0; + player_get_display_rotation(g_player[0], &rotation); + g_print(" ==> [Player_Test] X11 Display rotation: [%d ] \n",rotation); +} + + +static void set_display_visible(bool visible) +{ + if ( player_set_display_visible(g_player[0], visible) != PLAYER_ERROR_NONE ) + { + g_print("failed to player_set_x11_display_visible\n"); + } +} + +static void get_display_visible(bool *visible) +{ + player_is_display_visible(g_player[0], visible); + g_print(" ==> [Player_Test] X11 Display Visible = %d\n", *visible); +} + +static void set_display_dst_roi(int x, int y, int w, int h) +{ +#if 0 + if ( player_set_x11_display_dst_roi(g_player[0], x, y, w, h) != PLAYER_ERROR_NONE ) + { + g_print("failed to player_set_x11_display_dst_roi\n"); + } else { + g_print(" ==> [Player_Test] set X11 Display DST ROI (x:%d, y:%d, w:%d, h:%d)\n", x, y, w, h); + } +#endif +} + +static void get_display_dst_roi() +{ +#if 0 + int x = 0; + int y = 0; + int w = 0; + int h = 0; + + if ( player_get_x11_display_dst_roi(g_player[0], &x, &y, &w, &h) != PLAYER_ERROR_NONE ) + { + g_print("failed to player_get_x11_display_dst_roi\n"); + } else { + g_print(" ==> [Player_Test] got X11 Display DST ROI (x:%d, y:%d, w:%d, h:%d)\n", x, y, w, h); + } +#endif +} + +static void set_display_roi_mode(int mode) +{ +#if 0 + if ( player_set_x11_display_roi_mode(g_player[0], (player_display_roi_mode_e)mode) != PLAYER_ERROR_NONE ) + { + g_print("failed to player_set_x11_display_roi_mode\n"); + } else { + g_print(" ==> [Player_Test] set X11 Display ROI mode (%d)\n", mode); + } +#endif +} + +static void get_display_roi_mode() +{ +#if 0 + player_display_roi_mode_e mode; + if ( player_get_x11_display_roi_mode(g_player[0], &mode) != PLAYER_ERROR_NONE ) + { + g_print("failed to player_get_x11_display_roi_mode\n"); + } else { + g_print(" ==> [Player_Test] got X11 Display ROI mode (%d)\n", mode); + } +#endif +} + +static void set_display_src_crop(int x, int y, int w, int h) +{ +#if 0 + if ( player_set_x11_display_src_crop(g_player[0], x, y, w, h) != PLAYER_ERROR_NONE ) + { + g_print("failed to player_set_x11_display_src_crop\n"); + } else { + g_print(" ==> [Player_Test] set X11 Display SRC CROP (x:%d, y:%d, w:%d, h:%d)\n", x, y, w, h); + } +#endif +} + +static void get_display_src_crop() +{ +#if 0 + int x = 0; + int y = 0; + int w = 0; + int h = 0; + + if ( player_get_x11_display_src_crop(g_player[0], &x, &y, &w, &h) != PLAYER_ERROR_NONE ) + { + g_print("failed to player_get_x11_display_src_crop\n"); + } else { + g_print(" ==> [Player_Test] got X11 Display SRC CROP (x:%d, y:%d, w:%d, h:%d)\n", x, y, w, h); + } +#endif +} + +static void input_subtitle_filename(char *subtitle_filename) +{ + int len = strlen(subtitle_filename); + + if ( len < 1 || len > MAX_STRING_LEN ) + return; + + strncpy (g_subtitle_uri, subtitle_filename,len); + g_print("subtitle uri is set to %s\n", g_subtitle_uri); + player_set_subtitle_path (g_player[0], g_subtitle_uri); +} + +static void switch_subtitle(int index) +{ + char* lang_code = NULL; + if (player_select_track (g_player[0], PLAYER_STREAM_TYPE_TEXT, index) != PLAYER_ERROR_NONE) + { + g_print("player_select_track failed\n"); + } + if (player_get_track_language_code(g_player[0], PLAYER_STREAM_TYPE_TEXT, index, &lang_code) == PLAYER_ERROR_NONE) { + g_print("selected track code %s\n", lang_code); + free(lang_code); + } +} + +static void capture_video() +{ + if( player_capture_video(g_player[0],video_captured_cb,NULL)!=PLAYER_ERROR_NONE) + { + g_print("failed to player_capture_video\n"); + } +} + +static void decoding_audio() +{ +#if 0 + int ret; + char *suffix, *dump_path; + GDateTime *time = g_date_time_new_now_local(); + + suffix = g_date_time_format(time, "%Y%m%d_%H%M%S.pcm"); + dump_path = g_strjoin(NULL, PLAYER_TEST_DUMP_PATH_PREFIX, suffix, NULL); + g_pcm_fd = fopen(dump_path, "w+"); + g_free(dump_path); + g_free(suffix); + g_date_time_unref(time); + if(!g_pcm_fd) { + g_print("Can not create debug dump file"); + } + + ret =player_set_audio_frame_decoded_cb(g_player[0], 0, 0,audio_frame_decoded_cb, (void*)g_player[0]); + if ( ret != PLAYER_ERROR_NONE ) + { + g_print("player_set_audio_frame_decoded_cb is failed (errno = %d) \n", ret); + } +#endif +} +static void set_audio_eq(int value) +{ + bool available = FALSE; + int index, min, max; + + if(value) + { + if(player_audio_effect_equalizer_is_available(g_player[0], &available)!=PLAYER_ERROR_NONE) + g_print("failed to player_audio_effect_equalizer_is_available\n"); + + if(available) + { + if((player_audio_effect_get_equalizer_bands_count(g_player[0], &index)!=PLAYER_ERROR_NONE) || + (player_audio_effect_get_equalizer_level_range(g_player[0], &min, &max)!=PLAYER_ERROR_NONE) || + (player_audio_effect_set_equalizer_band_level(g_player[0], index/2, max)!=PLAYER_ERROR_NONE)) + g_print("failed to player_audio_effect_set_equalizer_band_level index %d, level %d\n", index/2, max); + } + } + + else + { + if(player_audio_effect_equalizer_clear(g_player[0])!=PLAYER_ERROR_NONE) + g_print("failed to player_audio_effect_equalizer_clear\n"); + } + +} + +static void get_audio_eq() +{ + int index, min, max, value; + player_audio_effect_get_equalizer_bands_count (g_player[0], &index); + g_print(" ==> [Player_Test] eq bands count: [%d] \n", index); + player_audio_effect_get_equalizer_level_range(g_player[0], &min, &max); + g_print(" ==> [Player_Test] eq bands range: [%d~%d] \n", min, max); + player_audio_effect_get_equalizer_band_level(g_player[0], index/2, &value); + g_print(" ==> [Player_Test] eq bands level: [%d] \n", value); + player_audio_effect_get_equalizer_band_frequency(g_player[0], 0, &value); + g_print(" ==> [Player_Test] eq bands frequency: [%d] \n", value); + player_audio_effect_get_equalizer_band_frequency_range(g_player[0], 0, &value); + g_print(" ==> [Player_Test] eq bands frequency range: [%d] \n", value); +} + +void quit_program() +{ + int i = 0; + + if(g_pcm_fd) + { + fclose(g_pcm_fd); + } + + for (i = 0; i < g_handle_num; i++) + { + if(g_player[i]!=NULL) + { + player_unprepare(g_player[i]); + player_destroy(g_player[i]); + g_player[i] = 0; + } + } + elm_exit(); + + if (g_audio_fmt) + media_format_unref(g_audio_fmt); + + if (g_video_fmt) + media_format_unref(g_video_fmt); +} + +void play_with_ini(char *file_path) +{ + input_filename(file_path); + _player_play(); +} + +void _interpret_main_menu(char *cmd) +{ + int len = strlen(cmd); + if ( len == 1 ) + { + if (strncmp(cmd, "a", 1) == 0) + { + g_menu_state = CURRENT_STATUS_FILENAME; + } + else if (strncmp(cmd, "1", 1) == 0) + { + play_with_ini(g_file_list[0]); + } + else if (strncmp(cmd, "2", 1) == 0) + { + play_with_ini(g_file_list[1]); + } + else if (strncmp(cmd, "3", 1) == 0) + { + play_with_ini(g_file_list[2]); + } + else if (strncmp(cmd, "4", 1) == 0) + { + play_with_ini(g_file_list[3]); + } + else if (strncmp(cmd, "5", 1) == 0) + { + play_with_ini(g_file_list[4]); + } + else if (strncmp(cmd, "6", 1) == 0) + { + play_with_ini(g_file_list[5]); + } + else if (strncmp(cmd, "7", 1) == 0) + { + play_with_ini(g_file_list[6]); + } + else if (strncmp(cmd, "8", 1) == 0) + { + play_with_ini(g_file_list[7]); + } + else if (strncmp(cmd, "9", 1) == 0) + { + play_with_ini(g_file_list[8]); + } + else if (strncmp(cmd, "b", 1) == 0) + { + _player_play(); + } + else if (strncmp(cmd, "c", 1) == 0) + { + _player_stop(); + } + else if (strncmp(cmd, "d", 1) == 0) + { + _player_resume(); + } + else if (strncmp(cmd, "e", 1) == 0) + { + _player_pause(); + } + else if (strncmp(cmd, "S", 1) == 0) + { + _player_state(); + } + else if (strncmp(cmd, "f", 1) == 0) + { + g_menu_state = CURRENT_STATUS_VOLUME; + } + else if (strncmp(cmd, "g", 1) == 0) + { + float left; + float right; + get_volume(&left, &right); + } + else if (strncmp(cmd, "z", 1) == 0) + { + g_menu_state = CURRENT_STATUS_SOUND_TYPE; + } + else if (strncmp(cmd, "h", 1) == 0 ) + { + g_menu_state = CURRENT_STATUS_MUTE; + } + else if (strncmp(cmd, "i", 1) == 0 ) + { + bool mute; + get_mute(&mute); + } + else if (strncmp(cmd, "j", 1) == 0 ) + { + g_menu_state = CURRENT_STATUS_POSITION_TIME; + } + else if (strncmp(cmd, "l", 1) == 0 ) + { + get_position(); + } + else if (strncmp(cmd, "m", 1) == 0 ) + { + get_duration(); + } + else if (strncmp(cmd, "n", 1) == 0 ) + { + get_stream_info(); + } + else if (strncmp(cmd, "o", 1) == 0 ) + { + g_menu_state = CURRENT_STATUS_LOOPING; + } + else if (strncmp(cmd, "p", 1) == 0 ) + { + bool looping; + get_looping(&looping); + } + else if (strncmp(cmd, "r", 1) == 0 ) + { + g_menu_state = CURRENT_STATUS_DISPLAY_MODE; + } + else if (strncmp(cmd, "s", 1) == 0 ) + { + get_display_mode(); + } + else if (strncmp(cmd, "t", 1) == 0 ) + { + g_menu_state = CURRENT_STATUS_DISPLAY_ROTATION; + } + else if (strncmp(cmd, "u", 1) == 0 ) + { + get_display_rotation(); + } + else if (strncmp(cmd, "v", 1) == 0 ) + { + g_menu_state = CURRENT_STATUS_DISPLAY_VISIBLE; + } + else if (strncmp(cmd, "w", 1) == 0 ) + { + bool visible; + get_display_visible(&visible); + } + else if (strncmp(cmd, "x", 1) == 0 ) + { + g_menu_state = CURRENT_STATUS_DISPLAY_DST_ROI; + } + else if (strncmp(cmd, "y", 1) == 0 ) + { + get_display_dst_roi(); + } + else if (strncmp(cmd, "M", 1) == 0 ) + { + g_menu_state = CURRENT_STATUS_DISPLAY_ROI_MODE; + } + else if (strncmp(cmd, "N", 1) == 0 ) + { + get_display_roi_mode(); + } + else if (strncmp(cmd, "F", 1) == 0 ) + { + g_menu_state = CURRENT_STATUS_DISPLAY_SRC_CROP; + } + else if (strncmp(cmd, "G", 1) == 0 ) + { + get_display_src_crop(); + } + else if (strncmp(cmd, "A", 1) == 0 ) + { + g_menu_state = CURRENT_STATUS_SUBTITLE_FILENAME; + } + else if (strncmp(cmd, "C", 1) == 0 ) + { + capture_video(); + } + else if (strncmp(cmd, "D", 1) == 0 ) + { + decoding_audio(); + } + else if (strncmp(cmd, "q", 1) == 0) + { + quit_pushing = TRUE; + quit_program(); + } + else if (strncmp(cmd, "E", 1) == 0 ) + { + g_menu_state = CURRENT_STATUS_AUDIO_EQUALIZER; + } + else if (strncmp(cmd, "H", 1) == 0 ) + { + get_audio_eq(); + } + else + { + g_print("unknown menu \n"); + } + } + else if(len == 2) + { + if (strncmp(cmd, "pr", 2) == 0) + { + _player_prepare(FALSE); // sync + } + else if (strncmp(cmd, "pa", 2) == 0) + { + _player_prepare(TRUE); // async + } + else if (strncmp(cmd, "un", 2) == 0) + { + _player_unprepare(); + } + else if (strncmp(cmd, "dt", 2) == 0) + { + _player_destroy(); + } + else if (strncmp(cmd, "sp", 2) == 0) + { + _player_set_progressive_download(); + } + else if (strncmp(cmd, "mp", 2) == 0) + { + g_memory_playback = (g_memory_playback ? FALSE : TRUE); + g_print("memory playback = %d\n", g_memory_playback); + } + else if (strncmp(cmd, "ds", 2) == 0 ) + { + g_menu_state = CURRENT_STATUS_DISPLAY_SURFACE_CHANGE; + } + else if (strncmp(cmd, "nb", 2) == 0 ) + { + g_menu_state = CURRENT_STATUS_HANDLE_NUM; + } + else if (strncmp(cmd, "tr", 2) == 0 ) + { + g_menu_state = CURRENT_STATUS_PLAYBACK_RATE; + } + else if (strncmp(cmd, "ss", 2) == 0 ) + { + g_menu_state = CURRENT_STATUS_SWITCH_SUBTITLE; + } + else if(strncmp(cmd, "X3", 2) == 0) + { + audio_frame_decoded_cb_ex(); + } + else if(strncmp(cmd, "X4", 2) == 0) + { + set_pcm_spec(); + } + else + { + g_print("unknown menu \n"); + } + } + else + { + g_print("unknown menu \n"); + } +} + +void display_sub_basic() +{ + int idx; + g_print("\n"); + g_print("=========================================================================================\n"); + g_print(" Player Test (press q to quit) \n"); + g_print("-----------------------------------------------------------------------------------------\n"); + g_print("*. Sample List in [%s] \t", MMTS_SAMPLELIST_INI_DEFAULT_PATH); + g_print("nb. num. of handles \n"); + for( idx = 1; idx <= INI_SAMPLE_LIST_MAX ; idx++ ) + { + if (strlen (g_file_list[idx-1]) > 0) + g_print("%d. Play [%s]\n", idx, g_file_list[idx-1]); + } + g_print("-----------------------------------------------------------------------------------------\n"); + g_print("[playback] a. Create\t"); + g_print("pr. Prepare \t"); + g_print("pa. Prepare async \t"); + g_print("b. Play \t"); + g_print("c. Stop \t"); + g_print("d. Resume\t"); + g_print("e. Pause \t"); + g_print("un. Unprepare \t"); + g_print("dt. Destroy \n"); + g_print("[State] S. Player State \n"); + g_print("[ volume ] f. Set Volume\t"); + g_print("g. Get Volume\t"); + g_print("z. Set Sound type\t"); + g_print("k. Set Sound Stream Info.\t"); + g_print("[ mute ] h. Set Mute\t"); + g_print("i. Get Mute\n"); + g_print("[audio eq] E. Set Audio EQ\t"); + g_print("H. Get Audio EQ\n"); + g_print("[position] j. Set Position \t"); + g_print("l. Get Position\n"); + g_print("[trick] tr. set playback rate\n"); + g_print("[duration] m. Get Duration\n"); + g_print("[Stream Info] n. Get stream info (Video Size, codec, audio stream info, and tag info)\n"); + g_print("[Looping] o. Set Looping\t"); + g_print("p. Get Looping\n"); + g_print("[display] v. Set display visible\t"); + g_print("w. Get display visible\n"); + g_print("[display] ds. Change display surface type\n"); + g_print("[x display] r. Set display mode\t"); + g_print("s. Get display mode\n"); + g_print("[x display] t. Set display Rotation\t"); + g_print("[Track] tl. Get Track language info(single only)\n"); + g_print("[subtitle] A. Set(or change) subtitle path\n"); + g_print("[subtitle] ss. Select(or change) subtitle track\n"); + g_print("[Video Capture] C. Capture \n"); + g_print("[etc] sp. Set Progressive Download\t"); + g_print("mp. memory playback\n"); + g_print("[audio_frame_decoded_cb_ex] X3. (input) set audio_frame_decoded_cb_ex callback \n"); + g_print("\n"); + g_print("=========================================================================================\n"); +} + +static void displaymenu() +{ + if (g_menu_state == CURRENT_STATUS_MAINMENU) + { + display_sub_basic(); + } + else if (g_menu_state == CURRENT_STATUS_HANDLE_NUM) + { + g_print("*** input number of handles.(recommended only for EVAS surface)\n"); + } + else if (g_menu_state == CURRENT_STATUS_FILENAME) + { + g_print("*** input mediapath.\n"); + } + else if (g_menu_state == CURRENT_STATUS_VOLUME) + { + g_print("*** input volume value.(0~1.0)\n"); + } + else if (g_menu_state == CURRENT_STATUS_SOUND_TYPE) + { + g_print("*** input sound type.(0:SYSTEM 1:NOTIFICATION 2:ALARM 3:RINGTONE 4:MEDIA 5:CALL 6:VOIP 7:FIXED)\n"); + } + else if (g_menu_state == CURRENT_STATUS_MUTE) + { + g_print("*** input mute value.(0: Not Mute, 1: Mute) \n"); + } + else if (g_menu_state == CURRENT_STATUS_POSITION_TIME) + { + g_print("*** input position value(msec)\n"); + } + else if (g_menu_state == CURRENT_STATUS_LOOPING) + { + g_print("*** input looping value.(0: Not Looping, 1: Looping) \n"); + } + else if (g_menu_state == CURRENT_STATUS_DISPLAY_SURFACE_CHANGE) { + g_print("*** input display surface type.(0: X surface, 1: EVAS surface) \n"); + } + else if (g_menu_state == CURRENT_STATUS_DISPLAY_MODE) + { + g_print("*** input display mode value.(0: LETTER BOX, 1: ORIGIN SIZE, 2: FULL_SCREEN, 3: CROPPED_FULL, 4: ORIGIN_OR_LETTER, 5: ROI) \n"); + } + else if (g_menu_state == CURRENT_STATUS_DISPLAY_ROTATION) + { + g_print("*** input display rotation value.(0: NONE, 1: 90, 2: 180, 3: 270, 4:F LIP_HORZ, 5: FLIP_VERT ) \n"); + } + else if (g_menu_state == CURRENT_STATUS_DISPLAY_VISIBLE) + { + g_print("*** input display visible value.(0: HIDE, 1: SHOW) \n"); + } + else if (g_menu_state == CURRENT_STATUS_DISPLAY_ROI_MODE) + { + g_print("*** input display roi mode.(0: FULL_SCREEN, 1: LETTER BOX)\n"); + } + else if (g_menu_state == CURRENT_STATUS_DISPLAY_DST_ROI) + { + g_print("*** input display roi value sequentially.(x, y, w, h)\n"); + } + else if (g_menu_state == CURRENT_STATUS_DISPLAY_SRC_CROP) + { + g_print("*** input display source crop value sequentially.(x, y, w, h)\n"); + } + else if (g_menu_state == CURRENT_STATUS_SUBTITLE_FILENAME) + { + g_print(" *** input subtitle file path.\n"); + } + else if (g_menu_state == CURRENT_STATUS_AUDIO_EQUALIZER) + { + g_print(" *** input audio eq value.(0: UNSET, 1: SET) \n"); + } + else if (g_menu_state == CURRENT_STATUS_PLAYBACK_RATE) + { + g_print(" *** input playback rate.(-5.0 ~ 5.0)\n"); + } + else if (g_menu_state == CURRENT_STATUS_SWITCH_SUBTITLE) + { + int count = 0, cur_index = 0; + int ret = 0; + + ret = player_get_track_count (g_player[0], PLAYER_STREAM_TYPE_TEXT, &count); + if(ret!=PLAYER_ERROR_NONE) + g_print ("player_get_track_count fail!!!!\n"); + else if (count) + { + g_print ("Total subtitle tracks = %d \n", count); + player_get_current_track (g_player[0], PLAYER_STREAM_TYPE_TEXT, &cur_index); + g_print ("Current index = %d \n", cur_index); + g_print (" *** input correct index 0 to %d\n:", (count - 1)); + } + else + g_print("no track\n"); + } + else + { + g_print("*** unknown status.\n"); + quit_program(); + } + g_print(" >>> "); +} + +gboolean timeout_menu_display(void* data) +{ + displaymenu(); + return FALSE; +} + +gboolean timeout_quit_program(void* data) +{ + quit_program(); + return FALSE; +} + +void reset_menu_state(void) +{ + g_menu_state = CURRENT_STATUS_MAINMENU; +} + +static void interpret (char *cmd) +{ + switch (g_menu_state) + { + case CURRENT_STATUS_MAINMENU: + { + _interpret_main_menu(cmd); + } + break; + case CURRENT_STATUS_HANDLE_NUM: + { + int num_handle = atoi(cmd); + if (0 >= num_handle || num_handle > MAX_HANDLE) + { + g_print("not supported this number for handles(%d)\n", num_handle); + } + else + { + g_handle_num = num_handle; + } + reset_menu_state(); + } + break; + case CURRENT_STATUS_FILENAME: + { + input_filename(cmd); + reset_menu_state(); + } + break; + case CURRENT_STATUS_VOLUME: + { + float level = atof(cmd); + set_volume(level); + reset_menu_state(); + } + break; + case CURRENT_STATUS_SOUND_TYPE: + { + int type = atoi(cmd); + set_sound_type(type); + reset_menu_state(); + } + break; + case CURRENT_STATUS_MUTE: + { + int mute = atoi(cmd); + set_mute(mute); + reset_menu_state(); + } + break; + case CURRENT_STATUS_POSITION_TIME: + { + long position = atol(cmd); + set_position(position); + reset_menu_state(); + } + break; + case CURRENT_STATUS_LOOPING: + { + int looping = atoi(cmd); + set_looping(looping); + reset_menu_state(); + } + break; + case CURRENT_STATUS_DISPLAY_SURFACE_CHANGE: + { + int type = atoi(cmd); + change_surface(type); + reset_menu_state(); + } + break; + case CURRENT_STATUS_DISPLAY_MODE: + { + int mode = atoi(cmd); + set_display_mode(mode); + reset_menu_state(); + } + break; + case CURRENT_STATUS_DISPLAY_ROTATION: + { + int rotation = atoi(cmd); + set_display_rotation(rotation); + reset_menu_state(); + } + break; + case CURRENT_STATUS_DISPLAY_VISIBLE: + { + int visible = atoi(cmd); + set_display_visible(visible); + reset_menu_state(); + } + break; + case CURRENT_STATUS_DISPLAY_DST_ROI: + { + int value = atoi(cmd); + static int roi_x = 0; + static int roi_y = 0; + static int roi_w = 0; + static int roi_h = 0; + static int cnt = 0; + switch (cnt) { + case 0: + roi_x = value; + cnt++; + break; + case 1: + roi_y = value; + cnt++; + break; + case 2: + roi_w = value; + cnt++; + break; + case 3: + cnt = 0; + roi_h = value; + set_display_dst_roi(roi_x, roi_y, roi_w, roi_h); + roi_x = roi_y = roi_w = roi_h = 0; + reset_menu_state(); + break; + default: + break; + } + } + break; + case CURRENT_STATUS_DISPLAY_SRC_CROP: + { + int value = atoi(cmd); + static int crop_x = 0; + static int crop_y = 0; + static int crop_w = 0; + static int crop_h = 0; + static int crop_cnt = 0; + switch (crop_cnt) { + case 0: + crop_x = value; + crop_cnt++; + break; + case 1: + crop_y = value; + crop_cnt++; + break; + case 2: + crop_w = value; + crop_cnt++; + break; + case 3: + crop_cnt = 0; + crop_h = value; + set_display_src_crop(crop_x, crop_y, crop_w, crop_h); + crop_x = crop_y = crop_w = crop_h = 0; + reset_menu_state(); + break; + default: + break; + } + } + break; + case CURRENT_STATUS_DISPLAY_ROI_MODE: + { + int value = atoi(cmd); + set_display_roi_mode(value); + reset_menu_state(); + } + break; + case CURRENT_STATUS_SUBTITLE_FILENAME: + { + input_subtitle_filename(cmd); + reset_menu_state(); + } + break; + case CURRENT_STATUS_AUDIO_EQUALIZER: + { + int value = atoi(cmd); + set_audio_eq(value); + reset_menu_state(); + } + break; + case CURRENT_STATUS_PLAYBACK_RATE: + { + float rate = atof(cmd); + set_playback_rate(rate); + reset_menu_state(); + } + break; + case CURRENT_STATUS_SWITCH_SUBTITLE: + { + int index = atoi(cmd); + switch_subtitle(index); + reset_menu_state(); + } + break; + } + g_timeout_add(100, timeout_menu_display, 0); +} + +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(); + memset(&ad, 0x0, sizeof(appdata)); + ops.data = &ad; + + return appcore_efl_main(PACKAGE, &argc, &argv, &ops); +} diff --git a/include/player2.h b/include/player2.h new file mode 100644 index 0000000..26e9ba8 --- /dev/null +++ b/include/player2.h @@ -0,0 +1,28 @@ +/* +* 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_PLAYER_2_H__ +#define __TIZEN_MEDIA_PLAYER_2_H__ + +#ifdef __cplusplus +extern "C" { +#endif + + +#ifdef __cplusplus +} +#endif +#endif /* __TIZEN_MEDIA_PLAYER_2_H__ */ diff --git a/include/player2_private.h b/include/player2_private.h new file mode 100644 index 0000000..89cc498 --- /dev/null +++ b/include/player2_private.h @@ -0,0 +1,239 @@ +/* +* 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_PLAYER_2_PRIVATE_H__ +#define __TIZEN_MEDIA_PLAYER_2_PRIVATE_H__ +#include "player.h" +#include "mm_types.h" +#include "mmsvc_core.h" +#include "mmsvc_core_ipc.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef LOG_TAG +#undef LOG_TAG +#endif +#define LOG_TAG "TIZEN_N_PLAYER" + +#define PLAYER_CHECK_CONDITION(condition,error,msg) \ + if(condition) {} else \ + { LOGE("[%s] %s(0x%08x)",__FUNCTION__, msg,error); return error;}; \ + +#define PLAYER_INSTANCE_CHECK(player) \ + PLAYER_CHECK_CONDITION(player != NULL, PLAYER_ERROR_INVALID_PARAMETER,"PLAYER_ERROR_INVALID_PARAMETER") + +#define PLAYER_STATE_CHECK(player,expected_state) \ + PLAYER_CHECK_CONDITION(player->state == expected_state,PLAYER_ERROR_INVALID_STATE,"PLAYER_ERROR_INVALID_STATE") + +#define PLAYER_NULL_ARG_CHECK(arg) \ + PLAYER_CHECK_CONDITION(arg != NULL,PLAYER_ERROR_INVALID_PARAMETER,"PLAYER_ERROR_INVALID_PARAMETER") + +#define PLAYER_RANGE_ARG_CHECK(arg, min, max) \ + PLAYER_CHECK_CONDITION(arg <= max,PLAYER_ERROR_INVALID_PARAMETER,"PLAYER_ERROR_INVALID_PARAMETER") \ + PLAYER_CHECK_CONDITION(arg >= min,PLAYER_ERROR_INVALID_PARAMETER,"PLAYER_ERROR_INVALID_PARAMETER") + +#define MM_PLAYER_HEAD_GAP(api) ((api)/(1000)+(1))*(1000) + + typedef enum { + MM_PLAYER_API_CREATE = API_CREATE, + MM_PLAYER_API_DESTROY = API_DESTROY, + MM_PLAYER_API_PREPARE, + MM_PLAYER_API_PREPARE_ASYNC, + MM_PLAYER_API_UNPREPARE, + MM_PLAYER_API_SET_URI, + MM_PLAYER_API_START, + MM_PLAYER_API_STOP, + MM_PLAYER_API_PAUSE, + MM_PLAYER_API_SET_MEMORY_BUFFER, + MM_PLAYER_API_DEINIT_MEMORY_BUFFER, + MM_PLAYER_API_GET_STATE, + MM_PLAYER_API_SET_VOLUME, + MM_PLAYER_API_GET_VOLUME, + MM_PLAYER_API_SET_SOUND_TYPE, +#ifndef USE_ASM + MM_PLAYER_API_SET_AUDIO_POLICY_INFO, +#endif + MM_PLAYER_API_SET_AUDIO_LATENCY_MODE, + MM_PLAYER_API_GET_AUDIO_LATENCY_MODE, + MM_PLAYER_API_SET_PLAY_POSITION, + MM_PLAYER_API_GET_PLAY_POSITION, + MM_PLAYER_API_SET_MUTE, + MM_PLAYER_API_IS_MUTED, + MM_PLAYER_API_SET_LOOPING, + MM_PLAYER_API_IS_LOOPING, + MM_PLAYER_API_GET_DURATION, + MM_PLAYER_API_SET_DISPLAY, + MM_PLAYER_API_SET_DISPLAY_MODE, + MM_PLAYER_API_GET_DISPLAY_MODE, + MM_PLAYER_API_SET_PLAYBACK_RATE, + MM_PLAYER_API_SET_DISPLAY_ROTATION, + MM_PLAYER_API_GET_DISPLAY_ROTATION, + MM_PLAYER_API_SET_DISPLAY_VISIBLE, + MM_PLAYER_API_IS_DISPLAY_VISIBLE, + MM_PLAYER_API_GET_CONTENT_INFO, + MM_PLAYER_API_GET_CODEC_INFO, + MM_PLAYER_API_GET_AUDIO_STREAM_INFO, + MM_PLAYER_API_GET_VIDEO_STREAM_INFO, + MM_PLAYER_API_GET_VIDEO_SIZE, + MM_PLAYER_API_GET_ALBUM_ART, + MM_PLAYER_API_AUDIO_EFFECT_GET_EQUALIZER_BANDS_COUNT, + MM_PLAYER_API_AUDIO_EFFECT_SET_EQUALIZER_ALL_BANDS, + MM_PLAYER_API_AUDIO_EFFECT_SET_EQUALIZER_BAND_LEVEL, + MM_PLAYER_API_AUDIO_EFFECT_GET_EQUALIZER_BAND_LEVEL, + MM_PLAYER_API_AUDIO_EFFECT_GET_EQUALIZER_LEVEL_RANGE, + MM_PLAYER_API_AUDIO_EFFECT_GET_EQUALIZER_BAND_FREQUENCY, + MM_PLAYER_API_AUDIO_EFFECT_GET_EQUALIZER_BAND_FREQUENCY_RANGE, + MM_PLAYER_API_AUDIO_EFFECT_EQUALIZER_CLEAR, + MM_PLAYER_API_AUDIO_EFFECT_EQUALIZER_IS_AVAILABLE, + MM_PLAYER_API_SET_PROGRESSIVE_DOWNLOAD_PATH, + MM_PLAYER_API_GET_PROGRESSIVE_DOWNLOAD_STATUS, + MM_PLAYER_API_CAPTURE_VIDEO, + MM_PLAYER_API_SET_STREAMING_COOKIE, + MM_PLAYER_API_SET_STREAMING_USER_AGENT, + MM_PLAYER_API_GET_STREAMING_DOWNLOAD_PROGRESS, + MM_PLAYER_API_SET_SUBTITLE_PATH, + MM_PLAYER_API_SET_SUBTITLE_POSITION_OFFSET, + MM_PLAYER_API_PUSH_MEDIA_STREAM, + MM_PLAYER_API_SET_MEDIA_STREAM_INFO, + MM_PLAYER_API_SET_CALLBACK, + MM_PLAYER_API_MEDIA_PACKET_FINALIZE_CB, + MM_PLAYER_API_SET_MEDIA_STREAM_BUFFER_MAX_SIZE, + MM_PLAYER_API_GET_MEDIA_STREAM_BUFFER_MAX_SIZE, + MM_PLAYER_API_SET_MEDIA_STREAM_BUFFER_MIN_THRESHOLD, + MM_PLAYER_API_GET_MEDIA_STREAM_BUFFER_MIN_THRESHOLD, + MM_PLAYER_API_GET_TRACK_COUNT, + MM_PLAYER_API_GET_CURRENT_TRACK, + MM_PLAYER_API_SELECT_TRACK, + MM_PLAYER_API_GET_TRACK_LANGUAGE_CODE, + MM_PLAYER_API_MAX + } mm_player_api_e; + + typedef enum { + MM_PLAYER_CB_EVENT = MM_PLAYER_HEAD_GAP(MM_PLAYER_API_MAX), + MM_PLAYER_CB_MAX + } mm_player_cb_e; + +typedef enum { + _PLAYER_EVENT_TYPE_PREPARE, + _PLAYER_EVENT_TYPE_COMPLETE, + _PLAYER_EVENT_TYPE_INTERRUPT, + _PLAYER_EVENT_TYPE_ERROR, + _PLAYER_EVENT_TYPE_BUFFERING, + _PLAYER_EVENT_TYPE_SUBTITLE, + _PLAYER_EVENT_TYPE_CAPTURE, + _PLAYER_EVENT_TYPE_SEEK, + _PLAYER_EVENT_TYPE_MEDIA_PACKET_VIDEO_FRAME, + _PLAYER_EVENT_TYPE_AUDIO_FRAME, + _PLAYER_EVENT_TYPE_VIDEO_FRAME_RENDER_ERROR, + _PLAYER_EVENT_TYPE_PD, + _PLAYER_EVENT_TYPE_SUPPORTED_AUDIO_EFFECT, + _PLAYER_EVENT_TYPE_SUPPORTED_AUDIO_EFFECT_PRESET, + _PLAYER_EVENT_TYPE_MISSED_PLUGIN, +#ifdef _PLAYER_FOR_PRODUCT + _PLAYER_EVENT_TYPE_IMAGE_BUFFER, + _PLAYER_EVENT_TYPE_SELECTED_SUBTITLE_LANGUAGE, +#endif + _PLAYER_EVENT_TYPE_MEDIA_STREAM_VIDEO_BUFFER_STATUS, + _PLAYER_EVENT_TYPE_MEDIA_STREAM_AUDIO_BUFFER_STATUS, + _PLAYER_EVENT_TYPE_MEDIA_STREAM_VIDEO_SEEK, + _PLAYER_EVENT_TYPE_MEDIA_STREAM_AUDIO_SEEK, + _PLAYER_EVENT_TYPE_AUDIO_STREAM_CHANGED, + _PLAYER_EVENT_TYPE_VIDEO_STREAM_CHANGED, + _PLAYER_EVENT_TYPE_NUM +}_player_event_e; + +typedef struct _player_s{ + MMHandleType mm_handle; + const void* user_cb[_PLAYER_EVENT_TYPE_NUM]; + void* user_data[_PLAYER_EVENT_TYPE_NUM]; + void* display_handle; + player_display_type_e display_type; + int state; + bool is_set_pixmap_cb; + bool is_stopped; + bool is_display_visible; + bool is_progressive_download; + pthread_t prepare_async_thread; + GHashTable *ecore_jobs; + player_error_e error_code; + bool is_doing_jobs; + media_format_h pkt_fmt; +}player_s; + +typedef struct _ret_msg_s{ + gint api; + gchar *msg; + struct _ret_msg_s *next; +}ret_msg_s; + +typedef struct { + gint bufLen; + gchar *recvMsg; + gint recved; + ret_msg_s *retMsgHead; +}msg_buff_s; + +typedef struct _player_data{ + void *data; + struct _player_data *next; +}player_data_s; + +typedef struct { + GThread *thread; + GQueue *queue; + GMutex mutex; + GCond cond; + gboolean running; +} player_event_queue; + +typedef struct _callback_cb_info { + GThread *thread; + gint running; + gint fd; + gint data_fd; + gpointer user_cb[_PLAYER_EVENT_TYPE_NUM]; + gpointer user_data[_PLAYER_EVENT_TYPE_NUM]; + GMutex player_mutex; + GCond player_cond[MM_PLAYER_API_MAX]; + msg_buff_s buff; + player_event_queue event_queue; + media_format_h pkt_fmt; + MMHandleType local_handle; +} callback_cb_info_s; + +typedef struct { + intptr_t bo; +}server_tbm_info_s; + +typedef struct _player_cli_s{ + gint remote_handle; + callback_cb_info_s *cb_info; + player_data_s *head; + server_tbm_info_s server_tbm; +}player_cli_s; + +/* Internal handle cast */ +#define INT_HANDLE(h) ((h)->cb_info->local_handle) +/* external handle cast */ +#define EXT_HANDLE(h) ((h)->remote_handle) + +#ifdef __cplusplus +} +#endif + +#endif //__TIZEN_MEDIA_PLAYER_2_PRIVATE_H__ diff --git a/include/player_msg_private.h b/include/player_msg_private.h new file mode 100644 index 0000000..ab8dbfe --- /dev/null +++ b/include/player_msg_private.h @@ -0,0 +1,705 @@ +/* +* 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 __PLAYER_MSG_PRIVATE_H__ +#define __PLAYER_MSG_PRIVATE_H__ + +#ifdef __cplusplus +extern "C" { +#endif + +#include "mmsvc_core_msg_json.h" +#include "media_format.h" +#include "tbm_bufmgr.h" + +typedef int32_t INT; +typedef int64_t INT64; +typedef intptr_t POINTER; +typedef double DOUBLE; +typedef const char* STRING; + +typedef enum { + PUSH_MEDIA_BUF_TYPE_TBM, + PUSH_MEDIA_BUF_TYPE_MSG, + PUSH_MEDIA_BUF_TYPE_RAW +} push_media_buf_type_e; + +typedef struct _player_push_media_msg_type{ + push_media_buf_type_e buf_type; + uint64_t size; + uint64_t pts; + media_format_mimetype_e mimetype; + tbm_key key; +}player_push_media_msg_type; + +typedef struct { + int type; + intptr_t surface; + int wl_window_x; + int wl_window_y; + int wl_window_width; + int wl_window_height; +}wl_win_msg_type; + +/** + * @brief Get value from Message. + * @remarks Does NOT guarantee thread safe. + * @param[out] param the name of param is key, must be local variable. never be pointer. + * @param[in] buf string of message buffer. has key and value + */ +#define player_msg_get(param, buf) \ + mmsvc_core_msg_json_deserialize(#param, buf, ¶m, NULL) + +/** + * @brief Get value from Message. + * @remarks Does NOT guarantee thread safe. + * @param[out] param the name of param is key, must be local variable. never be pointer. + * @param[in] buf string of message buffer. has key and value + * @parma[in] type The enum of parameter type. Muse be one of thease(INT, INT64, POINTER, DOUBLE, STRING, ARRAY) + */ +#define player_msg_get_type(param, buf, type) \ + mmsvc_core_msg_json_deserialize_type(#param, buf, ¶m, NULL, MUSED_TYPE_##type) + +/** + * @brief Get value from Message. + * @remarks Does NOT guarantee thread safe. + * @param[out] param the name of param is key, must be local pointer variable. + * @param[in] buf string of message buffer. has key and value + */ +#define player_msg_get_string(param, buf) \ + mmsvc_core_msg_json_deserialize(#param, buf, param, NULL) + +/** + * @brief Get value from Message. + * @remarks Does NOT guarantee thread safe. + * @param[out] param the name of param is key, must be local pointer variable. + * @param[in] buf string of message buffer. has key and value + */ +#define player_msg_get_array(param, buf) \ + mmsvc_core_msg_json_deserialize(#param, buf, param, NULL) + +/** + * @brief Get value from Message. + * @remarks Does NOT guarantee thread safe. + * @param[out] param the name of param is key, must be local variable. never be pointer. + * @param[in] buf string of message buffer. has key and value + * @param[in/out] len size of buffer. After retrun len is set parsed length. + * @parma[out] e the error number. + */ +#define player_msg_get_error_e(param, buf, len, e) \ + mmsvc_core_msg_json_deserialize_len(#param, buf, &len, ¶m, &e, MUSED_TYPE_INT) + +/** + * @brief Create and send message. Wait for server result. + * @remarks Does NOT guarantee thread safe. + * @param[in] api The enum of module API. + * @param[in] player The server side handle of media player. + * @param[in] fd socket fd + * @param[in] cb_info The infomation of callback. + * @parma[out] retbuf The buffer of return message. Must be char pointer. + * @parma[out] ret The return value from server. + */ +#define player_msg_send(api, player, fd, cb_info, retbuf, ret) \ + do{ \ + char *__sndMsg__; \ + int __len__; \ + __sndMsg__ = mmsvc_core_msg_json_factory_new(api, PARAM_HANDLE, player, \ + 0); \ + __len__ = mmsvc_core_ipc_send_msg(fd, __sndMsg__); \ + if (__len__ <= 0) { \ + LOGE("sending message failed"); \ + ret = PLAYER_ERROR_INVALID_OPERATION; \ + } else \ + ret = wait_for_cb_return(api, cb_info, &retbuf, CALLBACK_TIME_OUT); \ + mmsvc_core_msg_json_factory_free(__sndMsg__); \ + }while(0) + +/** + * @brief Create and send message. Wait for server result. + * @remarks Does NOT guarantee thread safe. + * @param[in] api The enum of module API. + * @param[in] player The server side handle of media player. + * @param[in] fd socket fd + * @param[in] cb_info The infomation of callback. + * @parma[out] retbuf The buffer of return message. Must be char pointer.Must free after use. + * @parma[out] ret The return value from server. + * @parma[in] type The enum of parameter type. Muse be one of thease(INT, INT64, POINTER, DOUBLE, STRING, ARRAY) + * @param[in] param the name of param is key, must be local variable. never be pointer. + */ +#define player_msg_send1(api, player, fd, cb_info, retbuf, ret, type, param) \ + do{ \ + char *__sndMsg__; \ + int __len__; \ + type __value__ = (type)param; \ + __sndMsg__ = mmsvc_core_msg_json_factory_new(api, PARAM_HANDLE, player, \ + MUSED_TYPE_##type, #param, __value__, \ + 0); \ + __len__ = mmsvc_core_ipc_send_msg(fd, __sndMsg__); \ + if (__len__ <= 0) { \ + LOGE("sending message failed"); \ + ret = PLAYER_ERROR_INVALID_OPERATION; \ + } else \ + ret = wait_for_cb_return(api, cb_info, &retbuf, CALLBACK_TIME_OUT); \ + mmsvc_core_msg_json_factory_free(__sndMsg__); \ + }while(0) + +/** + * @brief Create and send message. Wait for server result. + * @remarks Does NOT guarantee thread safe. + * @param[in] api The enum of module API. + * @param[in] player The server side handle of media player. + * @param[in] fd socket fd + * @param[in] cb_info The infomation of callback. + * @parma[out] retbuf The buffer of return message. Must be char pointer.Must free after use. + * @parma[out] ret The return value from server. + * @parma[in] type The enum of parameter type. Muse be one of thease(INT, INT64, POINTER, DOUBLE, STRING, ARRAY) + * @param[in] param# the name of param is key, must be local variable. never be pointer. + */ +#define player_msg_send2(api, player, fd, cb_info, retbuf, ret, type1, param1, type2, param2) \ + do{ \ + char *__sndMsg__; \ + int __len__; \ + type1 __value1__ = (type1)param1; \ + type2 __value2__ = (type2)param2; \ + __sndMsg__ = mmsvc_core_msg_json_factory_new(api, PARAM_HANDLE, player, \ + MUSED_TYPE_##type1, #param1, __value1__, \ + MUSED_TYPE_##type2, #param2, __value2__, \ + 0); \ + __len__ = mmsvc_core_ipc_send_msg(fd, __sndMsg__); \ + if (__len__ <= 0) { \ + LOGE("sending message failed"); \ + ret = PLAYER_ERROR_INVALID_OPERATION; \ + } else \ + ret = wait_for_cb_return(api, cb_info, &retbuf, CALLBACK_TIME_OUT); \ + mmsvc_core_msg_json_factory_free(__sndMsg__); \ + }while(0) + +/** + * @brief Create and send message. Wait for server result. + * @remarks Does NOT guarantee thread safe. + * @param[in] api The enum of module API. + * @param[in] player The server side handle of media player. + * @param[in] fd socket fd + * @param[in] cb_info The infomation of callback. + * @parma[out] retbuf The buffer of return message. Must be char pointer.Must free after use. + * @parma[out] ret The return value from server. + * @parma[in] type The enum of parameter type. Muse be one of thease(INT, INT64, POINTER, DOUBLE, STRING, ARRAY) + * @param[in] param# the name of param is key, must be local variable. never be pointer. + */ +#define player_msg_send3(api, player, fd, cb_info, retbuf, ret, type1, param1, type2, param2, type3, param3) \ + do{ \ + char *__sndMsg__; \ + int __len__; \ + type1 __value1__ = (type1)param1; \ + type2 __value2__ = (type2)param2; \ + type3 __value3__ = (type3)param3; \ + __sndMsg__ = mmsvc_core_msg_json_factory_new(api, PARAM_HANDLE, player, \ + MUSED_TYPE_##type1, #param1, __value1__, \ + MUSED_TYPE_##type2, #param2, __value2__, \ + MUSED_TYPE_##type3, #param3, __value3__, \ + 0); \ + __len__ = mmsvc_core_ipc_send_msg(fd, __sndMsg__); \ + if (__len__ <= 0) { \ + LOGE("sending message failed"); \ + ret = PLAYER_ERROR_INVALID_OPERATION; \ + } else \ + ret = wait_for_cb_return(api, cb_info, &retbuf, CALLBACK_TIME_OUT); \ + mmsvc_core_msg_json_factory_free(__sndMsg__); \ + }while(0) + +/** + * @brief Create and send message. Wait for server result. + * @remarks Does NOT guarantee thread safe. + * @param[in] api The enum of module API. + * @param[in] player The server side handle of media player. + * @param[in] fd socket fd + * @param[in] cb_info The infomation of callback. + * @parma[out] retbuf The buffer of return message. Must be char pointer.Must free after use. + * @parma[out] ret The return value from server. + * @parma[in] type The enum of parameter type. Muse be one of thease(INT, INT64, POINTER, DOUBLE, STRING, ARRAY) + * @param[in] param# the name of param is key, must be local variable. never be pointer. + */ +#define player_msg_send6(api, player, fd, cb_info, retbuf, ret, type1, param1, type2, param2, type3, param3, type4, param4, type5, param5, type6, param6) \ + do{ \ + char *__sndMsg__; \ + int __len__; \ + type1 __value1__ = (type1)param1; \ + type2 __value2__ = (type2)param2; \ + type3 __value3__ = (type3)param3; \ + type4 __value4__ = (type4)param4; \ + type5 __value5__ = (type5)param5; \ + type6 __value6__ = (type6)param6; \ + __sndMsg__ = mmsvc_core_msg_json_factory_new(api, PARAM_HANDLE, player, \ + MUSED_TYPE_##type1, #param1, __value1__, \ + MUSED_TYPE_##type2, #param2, __value2__, \ + MUSED_TYPE_##type3, #param3, __value3__, \ + MUSED_TYPE_##type4, #param4, __value4__, \ + MUSED_TYPE_##type5, #param5, __value5__, \ + MUSED_TYPE_##type6, #param6, __value6__, \ + 0); \ + __len__ = mmsvc_core_ipc_send_msg(fd, __sndMsg__); \ + if (__len__ <= 0) { \ + LOGE("sending message failed"); \ + ret = PLAYER_ERROR_INVALID_OPERATION; \ + } else \ + ret = wait_for_cb_return(api, cb_info, &retbuf, CALLBACK_TIME_OUT); \ + mmsvc_core_msg_json_factory_free(__sndMsg__); \ + }while(0) + +/** + * @brief Create and send message. Wait for server result. + * @remarks Does NOT guarantee thread safe. + * @param[in] api The enum of module API. + * @param[in] player The server side handle of media player. + * @param[in] fd socket fd + * @param[in] cb_info The infomation of callback. + * @parma[out] retbuf The buffer of return message. Must be char pointer.Must free after use. + * @parma[out] ret The return value from server. + * @param[in] param the name of param is key, must be local array/pointer variable. + * @param[in] length The size of array. + * @param[in] datum_size The size of a array's datum. + */ +#define player_msg_send_array(api, player, fd, cb_info, retbuf, ret, param, length, datum_size) \ + do{ \ + char *__sndMsg__; \ + int __len__; \ + int *__value__ = (int *)param; \ + __sndMsg__ = mmsvc_core_msg_json_factory_new(api, PARAM_HANDLE, player, \ + MUSED_TYPE_INT, #length, length, \ + MUSED_TYPE_ARRAY, #param, \ + datum_size == sizeof(int)? length : \ + length / sizeof(int) + (length % sizeof(int)?1:0), \ + __value__, \ + 0); \ + __len__ = mmsvc_core_ipc_send_msg(fd, __sndMsg__); \ + if (__len__ <= 0) { \ + LOGE("sending message failed"); \ + ret = PLAYER_ERROR_INVALID_OPERATION; \ + } else \ + ret = wait_for_cb_return(api, cb_info, &retbuf, CALLBACK_TIME_OUT); \ + mmsvc_core_msg_json_factory_free(__sndMsg__); \ + }while(0) + +/** + * @brief Create and send message. Wait for server result. + * @remarks Does NOT guarantee thread safe. + * @param[in] api The enum of module API. + * @param[in] player The server side handle of media player. + * @param[in] fd socket fd + * @param[in] cb_info The infomation of callback. + * @parma[out] retbuf The buffer of return message. Must be char pointer.Must free after use. + * @parma[out] ret The return value from server. + * @param[in] param# the name of param is key, must be local array/pointer variable. + * @param[in] length# The size of array. + * @param[in] datum_size# The size of a array's datum. + */ +#define player_msg_send_array2(api, player, fd, cb_info, retbuf, ret, param1, length1, datum_size1, param2, length2, datum_size2) \ + do{ \ + char *__sndMsg__; \ + int __len__; \ + int *__value1__ = (int *)param1; \ + int *__value2__ = (int *)param2; \ + __sndMsg__ = mmsvc_core_msg_json_factory_new(api, PARAM_HANDLE, player, \ + MUSED_TYPE_INT, #length1, length1, \ + MUSED_TYPE_ARRAY, #param1, \ + datum_size1 == sizeof(int)? length1 : \ + length1 / sizeof(int) + (length1 % sizeof(int)?1:0), \ + __value1__, \ + MUSED_TYPE_INT, #length2, length2, \ + MUSED_TYPE_ARRAY, #param2, \ + datum_size2 == sizeof(int)? length2 : \ + length2 / sizeof(int) + (length2 % sizeof(int)?1:0), \ + __value2__, \ + 0); \ + __len__ = mmsvc_core_ipc_send_msg(fd, __sndMsg__); \ + if (__len__ <= 0) { \ + LOGE("sending message failed"); \ + ret = PLAYER_ERROR_INVALID_OPERATION; \ + } else \ + ret = wait_for_cb_return(api, cb_info, &retbuf, CALLBACK_TIME_OUT); \ + mmsvc_core_msg_json_factory_free(__sndMsg__); \ + }while(0) + + +/** + * @brief Create and send message. Does not wait server result. + * @remarks Does NOT guarantee thread safe. + * @param[in] api The enum of module API. + * @param[in] player The server side handle of media player. + * @param[in] fd socket fd + * @parma[in] type The enum of parameter type. Muse be one of thease(INT, INT64, POINTER, DOUBLE, STRING, ARRAY) + * @param[in] param the name of param is key, must be local variable. never be pointer. + */ +#define player_msg_send1_async(api, player, fd, type, param) \ + do{ \ + char *__sndMsg__; \ + int __len__; \ + type __value__ = (type)param; \ + __sndMsg__ = mmsvc_core_msg_json_factory_new(api, PARAM_HANDLE, player, \ + MUSED_TYPE_##type, #param, __value__, \ + 0); \ + __len__ = mmsvc_core_ipc_send_msg(fd, __sndMsg__); \ + mmsvc_core_msg_json_factory_free(__sndMsg__); \ + if (__len__ <= 0) { \ + LOGE("sending message failed"); \ + return PLAYER_ERROR_INVALID_OPERATION; \ + } \ + }while(0) + +/** + * @brief Create and send message. Does not wait server result. + * @remarks Does NOT guarantee thread safe. + * @param[in] api The enum of module API. + * @param[in] player The server side handle of media player. + * @param[in] fd socket fd + * @parma[in] type The enum of parameter type. Muse be one of thease(INT, INT64, POINTER, DOUBLE, STRING, ARRAY) + * @param[in] param# the name of param is key, must be local variable. never be pointer. + */ +#define player_msg_send2_async(api, player, fd, type1, param1, type2, param2) \ + do{ \ + char *__sndMsg__; \ + int __len__; \ + type1 __value1__ = (type1)param1; \ + type2 __value2__ = (type2)param2; \ + __sndMsg__ = mmsvc_core_msg_json_factory_new(api, PARAM_HANDLE, player, \ + MUSED_TYPE_##type1, #param1, __value1__, \ + MUSED_TYPE_##type2, #param2, __value2__, \ + 0); \ + __len__ = mmsvc_core_ipc_send_msg(fd, __sndMsg__); \ + mmsvc_core_msg_json_factory_free(__sndMsg__); \ + if (__len__ <= 0) { \ + LOGE("sending message failed"); \ + return PLAYER_ERROR_INVALID_OPERATION; \ + } \ + }while(0) + +/** + * @brief Create and send return message. + * @remarks Does NOT guarantee thread safe. + * @param[in] api The enum of module API. + * @param[in] ret Thre result of API. + * @param[in] client socket client information + */ +#define player_msg_return(api, ret, client) \ + do{ \ + char *__sndMsg__; \ + int __len__; \ + __sndMsg__ = mmsvc_core_msg_json_factory_new(api, PARAM_RETURN, ret, \ + 0); \ + __len__ = mmsvc_core_ipc_send_msg(mmsvc_core_client_get_msg_fd(client), __sndMsg__); \ + if (__len__ <= 0) { \ + LOGE("sending message failed"); \ + ret = PLAYER_ERROR_INVALID_OPERATION; \ + } \ + mmsvc_core_msg_json_factory_free(__sndMsg__); \ + }while(0) + +/** + * @brief Create and send return message. + * @remarks Does NOT guarantee thread safe. + * @param[in] api The enum of module API. + * @param[in] ret Thre result of API. + * @param[in] client socket client information + * @parma[in] type The enum of parameter type. Muse be one of thease(INT, INT64, POINTER, DOUBLE, STRING, ARRAY) + * @param[in] param the name of param is key, must be local variable. never be pointer. + */ +#define player_msg_return1(api, ret, client, type, param) \ + do{ \ + char *__sndMsg__; \ + int __len__; \ + type __value__ = (type)param; \ + __sndMsg__ = mmsvc_core_msg_json_factory_new(api, PARAM_RETURN, ret, \ + MUSED_TYPE_##type, #param, __value__, \ + 0); \ + __len__ = mmsvc_core_ipc_send_msg(mmsvc_core_client_get_msg_fd(client), __sndMsg__); \ + if (__len__ <= 0) { \ + LOGE("sending message failed"); \ + ret = PLAYER_ERROR_INVALID_OPERATION; \ + } \ + mmsvc_core_msg_json_factory_free(__sndMsg__); \ + }while(0) + +/** + * @brief Create and send return message. + * @remarks Does NOT guarantee thread safe. + * @param[in] api The enum of module API. + * @param[in] ret Thre result of API. + * @param[in] client socket client information + * @parma[in] type The enum of parameter type. Muse be one of thease(INT, INT64, POINTER, DOUBLE, STRING, ARRAY) + * @param[in] param# the name of param is key, must be local variable. never be pointer. + */ +#define player_msg_return2(api, ret, client, type1, param1, type2, param2) \ + do{ \ + char *__sndMsg__; \ + int __len__; \ + type1 __value1__ = (type1)param1; \ + type2 __value2__ = (type2)param2; \ + __sndMsg__ = mmsvc_core_msg_json_factory_new(api, PARAM_RETURN, ret, \ + MUSED_TYPE_##type1, #param1, __value1__, \ + MUSED_TYPE_##type2, #param2, __value2__, \ + 0); \ + __len__ = mmsvc_core_ipc_send_msg(mmsvc_core_client_get_msg_fd(client), __sndMsg__); \ + if (__len__ <= 0) { \ + LOGE("sending message failed"); \ + ret = PLAYER_ERROR_INVALID_OPERATION; \ + } \ + mmsvc_core_msg_json_factory_free(__sndMsg__); \ + }while(0) + +/** + * @brief Create and send return message. + * @remarks Does NOT guarantee thread safe. + * @param[in] api The enum of module API. + * @param[in] ret Thre result of API. + * @param[in] client socket client information + * @parma[in] type The enum of parameter type. Muse be one of thease(INT, INT64, POINTER, DOUBLE, STRING, ARRAY) + * @param[in] param# the name of param is key, must be local variable. never be pointer. + */ +#define player_msg_return3(api, ret, client, type1, param1, type2, param2, type3, param3) \ + do{ \ + char *__sndMsg__; \ + int __len__; \ + type1 __value1__ = (type1)param1; \ + type2 __value2__ = (type2)param2; \ + type3 __value3__ = (type3)param3; \ + __sndMsg__ = mmsvc_core_msg_json_factory_new(api, PARAM_RETURN, ret, \ + MUSED_TYPE_##type1, #param1, __value1__, \ + MUSED_TYPE_##type2, #param2, __value2__, \ + MUSED_TYPE_##type3, #param3, __value3__, \ + 0); \ + __len__ = mmsvc_core_ipc_send_msg(mmsvc_core_client_get_msg_fd(client), __sndMsg__); \ + if (__len__ <= 0) { \ + LOGE("sending message failed"); \ + ret = PLAYER_ERROR_INVALID_OPERATION; \ + } \ + mmsvc_core_msg_json_factory_free(__sndMsg__); \ + }while(0) + +/** + * @brief Create and send return message. + * @remarks Does NOT guarantee thread safe. + * @param[in] api The enum of module API. + * @param[in] ret Thre result of API. + * @param[in] client socket client information + * @param[in] param the name of param is key, must be local array/pointer variable. + * @param[in] length The size of array. + * @param[in] datum_size The size of a array's datum. + */ +#define player_msg_return_array(api, ret, client, param, length, datum_size) \ + do{ \ + char *__sndMsg__; \ + int __len__; \ + int *__value__ = (int *)param; \ + __sndMsg__ = mmsvc_core_msg_json_factory_new(api, PARAM_RETURN, ret, \ + MUSED_TYPE_INT, #length, length, \ + MUSED_TYPE_ARRAY, #param, \ + datum_size == sizeof(int)? length : \ + length / sizeof(int) + (length % sizeof(int)?1:0), \ + __value__, \ + 0); \ + __len__ = mmsvc_core_ipc_send_msg(mmsvc_core_client_get_msg_fd(client), __sndMsg__); \ + if (__len__ <= 0) { \ + LOGE("sending message failed"); \ + ret = PLAYER_ERROR_INVALID_OPERATION; \ + } \ + mmsvc_core_msg_json_factory_free(__sndMsg__); \ + }while(0) + +/** + * @brief Create and send return message. + * @remarks Does NOT guarantee thread safe. + * @param[in] api The enum of module API. + * @param[in] event The event number. + * @param[in] client socket client information + */ +#define player_msg_event(api, event, client) \ + do{ \ + char *__sndMsg__; \ + __sndMsg__ = mmsvc_core_msg_json_factory_new(api, PARAM_EVENT, event, \ + 0); \ + mmsvc_core_ipc_send_msg(mmsvc_core_client_get_msg_fd(client), __sndMsg__); \ + mmsvc_core_msg_json_factory_free(__sndMsg__); \ + }while(0) + +/** + * @brief Create and send return message. + * @remarks Does NOT guarantee thread safe. + * @param[in] api The enum of module API. + * @param[in] event The event number. + * @param[in] client socket client information + * @parma[in] type The enum of parameter type. Muse be one of thease(INT, INT64, POINTER, DOUBLE, STRING, ARRAY) + * @param[in] param the name of param is key, must be local variable. never be pointer. + */ +#define player_msg_event1(api, event, client, type, param) \ + do{ \ + char *__sndMsg__; \ + type __value__ = (type)param; \ + __sndMsg__ = mmsvc_core_msg_json_factory_new(api, PARAM_EVENT, event, \ + MUSED_TYPE_##type, #param, __value__, \ + 0); \ + mmsvc_core_ipc_send_msg(mmsvc_core_client_get_msg_fd(client), __sndMsg__); \ + mmsvc_core_msg_json_factory_free(__sndMsg__); \ + }while(0) + +/** + * @brief Create and send return message. + * @remarks Does NOT guarantee thread safe. + * @param[in] api The enum of module API. + * @param[in] event The event number. + * @param[in] client socket client information + * @parma[in] type The enum of parameter type. Muse be one of thease(INT, INT64, POINTER, DOUBLE, STRING, ARRAY) + * @param[in] param# the name of param is key, must be local variable. never be pointer. + */ +#define player_msg_event2(api, event, client, type1, param1, type2, param2) \ + do{ \ + char *__sndMsg__; \ + type1 __value1__ = (type1)param1; \ + type2 __value2__ = (type2)param2; \ + __sndMsg__ = mmsvc_core_msg_json_factory_new(api, PARAM_EVENT, event, \ + MUSED_TYPE_##type1, #param1, __value1__, \ + MUSED_TYPE_##type2, #param2, __value2__, \ + 0); \ + mmsvc_core_ipc_send_msg(mmsvc_core_client_get_msg_fd(client), __sndMsg__); \ + mmsvc_core_msg_json_factory_free(__sndMsg__); \ + }while(0) + +/** + * @brief Create and send return message. + * @remarks Does NOT guarantee thread safe. + * @param[in] api The enum of module API. + * @param[in] event The event number. + * @param[in] client socket client information + * @parma[in] type The enum of parameter type. Muse be one of thease(INT, INT64, POINTER, DOUBLE, STRING, ARRAY) + * @param[in] param# the name of param is key, must be local variable. never be pointer. + */ +#define player_msg_event3(api, event, client, type1, param1, type2, param2, type3, param3) \ + do{ \ + char *__sndMsg__; \ + type1 __value1__ = (type1)param1; \ + type2 __value2__ = (type2)param2; \ + type3 __value3__ = (type3)param3; \ + __sndMsg__ = mmsvc_core_msg_json_factory_new(api, PARAM_EVENT, event, \ + MUSED_TYPE_##type1, #param1, __value1__, \ + MUSED_TYPE_##type2, #param2, __value2__, \ + MUSED_TYPE_##type3, #param3, __value3__, \ + 0); \ + mmsvc_core_ipc_send_msg(mmsvc_core_client_get_msg_fd(client), __sndMsg__); \ + mmsvc_core_msg_json_factory_free(__sndMsg__); \ + }while(0) + +/** + * @brief Create and send return message. + * @remarks Does NOT guarantee thread safe. + * @param[in] api The enum of module API. + * @param[in] event The event number. + * @param[in] client socket client information + * @parma[in] type The enum of parameter type. Muse be one of thease(INT, INT64, POINTER, DOUBLE, STRING, ARRAY) + * @param[in] param# the name of param is key, must be local variable. never be pointer. + */ +#define player_msg_event4(api, event, client, type1, param1, type2, param2, type3, param3, type4, param4) \ + do{ \ + char *__sndMsg__; \ + type1 __value1__ = (type1)param1; \ + type2 __value2__ = (type2)param2; \ + type3 __value3__ = (type3)param3; \ + type4 __value4__ = (type4)param4; \ + __sndMsg__ = mmsvc_core_msg_json_factory_new(api, PARAM_EVENT, event, \ + MUSED_TYPE_##type1, #param1, __value1__, \ + MUSED_TYPE_##type2, #param2, __value2__, \ + MUSED_TYPE_##type3, #param3, __value3__, \ + MUSED_TYPE_##type4, #param4, __value4__, \ + 0); \ + mmsvc_core_ipc_send_msg(mmsvc_core_client_get_msg_fd(client), __sndMsg__); \ + mmsvc_core_msg_json_factory_free(__sndMsg__); \ + }while(0) + +/** + * @brief Create and send return message. + * @remarks Does NOT guarantee thread safe. + * @param[in] api The enum of module API. + * @param[in] event The event number. + * @param[in] client socket client information + * @parma[in] type The enum of parameter type. Muse be one of thease(INT, INT64, POINTER, DOUBLE, STRING, ARRAY) + * @param[in] param# the name of param is key, must be local variable. never be pointer. + * @param[in] arr_param the name of param is key, must be local pointer/array variable. + * @param[in] length The size of array. + * @param[in] datum_size The size of a array's datum. + */ +#define player_msg_event2_array(api, event, client, type1, param1, type2, param2, arr_param, length, datum_size) \ + do{ \ + char *__sndMsg__; \ + type1 __value1__ = (type1)param1; \ + type2 __value2__ = (type2)param2; \ + int *__arr_value__ = (int *)arr_param; \ + __sndMsg__ = mmsvc_core_msg_json_factory_new(api, PARAM_EVENT, event, \ + MUSED_TYPE_##type1, #param1, __value1__, \ + MUSED_TYPE_##type2, #param2, __value2__, \ + MUSED_TYPE_INT, #length, length, \ + MUSED_TYPE_ARRAY, #arr_param, \ + datum_size == sizeof(int)? length : \ + length / sizeof(int) + (length % sizeof(int)?1:0), \ + __arr_value__, \ + 0); \ + mmsvc_core_ipc_send_msg(mmsvc_core_client_get_msg_fd(client), __sndMsg__); \ + mmsvc_core_msg_json_factory_free(__sndMsg__); \ + }while(0) + +/** + * @brief Create and send return message. + * @remarks Does NOT guarantee thread safe. + * @param[in] api The enum of module API. + * @param[in] event The event number. + * @param[in] client socket client information + * @parma[in] type The enum of parameter type. Muse be one of thease(INT, INT64, POINTER, DOUBLE, STRING, ARRAY) + * @param[in] param# the name of param is key, must be local variable. never be pointer. + * @param[in] arr_param the name of param is key, must be local array/pointer variable. + * @param[in] length The size of array. + * @param[in] datum_size The size of a array's datum. + */ +#define player_msg_event6_array(api, event, client, type1, param1, type2, param2, type3, param3, type4, param4, type5, param5, type6, param6, arr_param, length, datum_size) \ + do{ \ + char *__sndMsg__; \ + type1 __value1__ = (type1)param1; \ + type2 __value2__ = (type2)param2; \ + type3 __value3__ = (type3)param3; \ + type4 __value4__ = (type4)param4; \ + type5 __value5__ = (type5)param5; \ + type6 __value6__ = (type6)param6; \ + int *__arr_value__ = (int *)arr_param; \ + __sndMsg__ = mmsvc_core_msg_json_factory_new(api, PARAM_EVENT, event, \ + MUSED_TYPE_##type1, #param1, __value1__, \ + MUSED_TYPE_##type2, #param2, __value2__, \ + MUSED_TYPE_##type3, #param3, __value3__, \ + MUSED_TYPE_##type4, #param4, __value4__, \ + MUSED_TYPE_##type5, #param5, __value5__, \ + MUSED_TYPE_##type6, #param6, __value6__, \ + MUSED_TYPE_INT, #length, length, \ + MUSED_TYPE_ARRAY, #arr_param, \ + datum_size == sizeof(int)? length : \ + length / sizeof(int) + (length % sizeof(int)?1:0), \ + __arr_value__, \ + 0); \ + mmsvc_core_ipc_send_msg(mmsvc_core_client_get_msg_fd(client), __sndMsg__); \ + mmsvc_core_msg_json_factory_free(__sndMsg__); \ + }while(0) + + + +#ifdef __cplusplus +} +#endif + +#endif /*__PLAYER_MSG_PRIVATE_H__*/ diff --git a/mused-player.manifest b/mused-player.manifest new file mode 100644 index 0000000..55c989e --- /dev/null +++ b/mused-player.manifest @@ -0,0 +1,9 @@ + + + + + + + + + diff --git a/mused-player.pc.in b/mused-player.pc.in new file mode 100644 index 0000000..afda32e --- /dev/null +++ b/mused-player.pc.in @@ -0,0 +1,15 @@ + +# 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} + diff --git a/packaging/mused-player.spec b/packaging/mused-player.spec new file mode 100644 index 0000000..7286dca --- /dev/null +++ b/packaging/mused-player.spec @@ -0,0 +1,114 @@ +%bcond_with wayland +%bcond_with x + +Name: mused-player +Summary: A Media Daemon player 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(mused) +BuildRequires: pkgconfig(mm-common) +BuildRequires: pkgconfig(mm-player) +BuildRequires: pkgconfig(capi-base-common) +BuildRequires: pkgconfig(capi-media-sound-manager) +BuildRequires: pkgconfig(capi-media-player) +BuildRequires: pkgconfig(appcore-efl) +BuildRequires: pkgconfig(elementary) +BuildRequires: pkgconfig(ecore) +BuildRequires: pkgconfig(evas) +%if %{with x} +BuildRequires: pkgconfig(ecore-x) +%endif +%if %{with wayland} +BuildRequires: pkgconfig(ecore-wayland) +%endif +BuildRequires: pkgconfig(capi-media-tool) +BuildRequires: pkgconfig(json) +BuildRequires: pkgconfig(libtbm) +BuildRequires: pkgconfig(eom) + +Requires(post): /sbin/ldconfig +Requires(postun): /sbin/ldconfig + +%description +A Media Player Daemon library in Tizen Native API. + +%package devel +Summary: A Media Player Daemon library in Tizen Native API.(Development) +Group: Development/Multimedia +Requires: %{name} = %{version}-%{release} + +%description devel + +%prep +%setup -q + + +%build +%if 0%{?sec_build_binary_debug_enable} +export CFLAGS="$CFLAGS -DTIZEN_DEBUG_ENABLE" +#export CFLAGS+=" -D_USE_X_DIRECT_" +export CXXFLAGS="$CXXFLAGS -DTIZEN_DEBUG_ENABLE" +export FFLAGS="$FFLAGS -DTIZEN_DEBUG_ENABLE" +%endif +MAJORVER=`echo %{version} | awk 'BEGIN {FS="."}{print $1}'` +%cmake . -DFULLVER=%{version} -DMAJORVER=${MAJORVER} \ +%if "%{?profile}" == "wearable" + -DTIZEN_WEARABLE=YES \ + %else + -DTIZEN_MOBILE=YES \ + %endif +%if %{with wayland} + -DWAYLAND_SUPPORT=On \ +%else + -DWAYLAND_SUPPORT=Off \ +%endif +%if %{with x} + -DX11_SUPPORT=On \ +%else + -DX11_SUPPORT=Off \ +%endif + -DCMAKE_INSTALL_PREFIX=/usr -DFULLVER=%{version} -DMAJORVER=${MAJORVER} \ + -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 +cp LICENSE.APLv2 %{buildroot}/usr/share/license/%{name} +cp client/test/player_client_test %{buildroot}/usr/bin +cp client/test/mused_player_media_packet_test %{buildroot}/usr/bin +cp client/test/mused_player_es_push_test %{buildroot}/usr/bin + +%make_install + +%post +/sbin/ldconfig + +%postun -p /sbin/ldconfig + + +%files +%manifest mused-player.manifest +%manifest client/capi-media-player2.manifest +%{_libdir}/libmused-player.so.* +%{_libdir}/libcapi-media-player2.so.* +%{_datadir}/license/%{name} +/usr/bin/player_client_test +/usr/bin/mused_player_media_packet_test +/usr/bin/mused_player_es_push_test + +%files devel +%{_includedir}/media/*.h +%{_libdir}/pkgconfig/*.pc +%{_libdir}/libmused-player.so +%{_libdir}/libcapi-media-player2.so + + diff --git a/src/player_msg_dispatcher.c b/src/player_msg_dispatcher.c new file mode 100644 index 0000000..a551954 --- /dev/null +++ b/src/player_msg_dispatcher.c @@ -0,0 +1,2184 @@ +/* +* 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 +#include +#include +#include +#include +#include +#include +#include +#include + +#include "tbm_bufmgr.h" +#include "tbm_surface.h" +#include "tbm_surface_internal.h" +#include "media_packet.h" +#include "mm_types.h" +#include "mm_debug.h" +#include "mm_error.h" +#include "mm_player.h" +#include "mmsvc_core.h" +#include "mmsvc_core_ipc.h" +#include "player2_private.h" +#include "player_msg_private.h" + +#define SOCK_BUFFER_LENGTH 250 +#define HEADER_LENGTH 10 +#define STREAM_PATH_LENGTH 32 +#define STREAM_PATH_BASE "/tmp/mused_gst.%d" + +static tbm_bufmgr bufmgr; +__thread media_format_h audio_format = NULL; +__thread media_format_h video_format = NULL; + +typedef struct { + GThread *thread; + GQueue *queue; + GMutex mutex; + GCond cond; + gint running; +}data_thread_info_t; + +typedef struct { + intptr_t handle; + uint64_t pts; + uint64_t size; + media_format_mimetype_e mimetype; +}push_data_q_t; + +typedef struct { + player_h player; + Client client; +}prepare_data_t; + +/* +* define for lagacy API for mused +*/ +#ifdef HAVE_WAYLAND +extern int player_set_display_wl_for_mused(player_h player, player_display_type_e type, intptr_t surface, + int x, int y, int w, int h); +#else +extern int player_set_display_for_mused(player_h player, player_display_type_e type, unsigned int xhandle); +#endif +#ifndef USE_ASM +extern int player_set_audio_policy_info_for_mused(player_h player, + char *stream_type, int stream_index); +#endif + +int player_set_shm_stream_path_for_mused (player_h player, const char *stream_path); +int player_get_raw_video_caps(player_h player, char **caps); +/* +* Internal Implementation +*/ +static int _push_media_stream(intptr_t handle, player_push_media_msg_type *push_media, char *buf); +static gpointer _player_push_media_stream_handler(gpointer param); + +static void __player_callback(_player_event_e ev, Client client) +{ + mm_player_cb_e api = MM_PLAYER_CB_EVENT; + + LOGD("ENTER"); + + player_msg_event(api, ev, client); +} + +static void _prepare_async_cb(void *user_data) +{ + _player_event_e ev = _PLAYER_EVENT_TYPE_PREPARE; + mm_player_cb_e api = MM_PLAYER_CB_EVENT; + prepare_data_t *prepare_data = (prepare_data_t *)user_data; + Client client; + player_h player; + char *caps = NULL; + + if(!prepare_data) { + LOGE("user data of callback is NULL"); + return; + } + client = prepare_data->client; + player = prepare_data->player; + g_free(prepare_data); + + if(player_get_raw_video_caps(player, &caps) == PLAYER_ERROR_NONE) { + if(caps) { + player_msg_event1(api, ev, client, STRING, caps); + g_free(caps); + return; + } + } + player_msg_event(api, ev, client); +} + +static void _seek_complate_cb(void *user_data) +{ + _player_event_e ev = _PLAYER_EVENT_TYPE_SEEK; + __player_callback(ev, (Client)user_data); +} + +static void _buffering_cb(int percent, void *user_data) +{ + mm_player_cb_e api = MM_PLAYER_CB_EVENT; + _player_event_e ev = _PLAYER_EVENT_TYPE_BUFFERING; + Client client = (Client)user_data; + + LOGD("ENTER"); + + player_msg_event1(api, ev, client, INT, percent); + +} + +static void _completed_cb(void *user_data) +{ + _player_event_e ev = _PLAYER_EVENT_TYPE_COMPLETE; + __player_callback(ev, (Client)user_data); +} + +static void _interrupted_cb(player_interrupted_code_e code, void *user_data) +{ + mm_player_cb_e api = MM_PLAYER_CB_EVENT; + _player_event_e ev = _PLAYER_EVENT_TYPE_INTERRUPT; + Client client = (Client)user_data; + + LOGD("ENTER"); + + player_msg_event1(api, ev, client, INT, code); +} + +static void _error_cb(int code, void *user_data) +{ + mm_player_cb_e api = MM_PLAYER_CB_EVENT; + _player_event_e ev = _PLAYER_EVENT_TYPE_ERROR; + Client client = (Client)user_data; + + LOGD("ENTER"); + + player_msg_event1(api, ev, client, INT, code); +} + +static void _subtitle_updated_cb(unsigned long duration, char *text, void *user_data) +{ + mm_player_cb_e api = MM_PLAYER_CB_EVENT; + _player_event_e ev = _PLAYER_EVENT_TYPE_SUBTITLE; + Client client = (Client)user_data; + + LOGD("ENTER"); + + player_msg_event2(api, ev, client, INT, duration, STRING, text); +} + +static void _capture_video_cb(unsigned char *data, int width, int height, + unsigned int size, void *user_data) +{ + mm_player_cb_e api = MM_PLAYER_CB_EVENT; + _player_event_e ev = _PLAYER_EVENT_TYPE_CAPTURE; + Client client = (Client)user_data; + tbm_bo bo; + tbm_bo_handle thandle; + tbm_key key; + char checker = 1; + unsigned int expired = 0x0fffffff; + + LOGD("ENTER"); + + bo = tbm_bo_alloc (bufmgr, size+1, TBM_BO_DEFAULT); + if(!bo) { + LOGE("TBM get error : tbm_bo_alloc return NULL"); + return; + } + thandle = tbm_bo_map (bo, TBM_DEVICE_CPU, TBM_OPTION_WRITE); + if(thandle.ptr == NULL) + { + LOGE("TBM get error : handle pointer is NULL"); + goto capture_event_exit1; + } + memcpy(thandle.ptr, data, size); + key = tbm_bo_export(bo); + if(key == 0) + { + LOGE("TBM get error : export key is 0"); + checker = 0; + goto capture_event_exit2; + } + /* mark to write */ + *((char *)thandle.ptr+size) = 1; + + player_msg_event4(api, ev, client, INT, width, INT, height, + INT, size, INT, key); + +capture_event_exit2: + tbm_bo_unmap(bo); + + while(checker && expired--) { + thandle = tbm_bo_map (bo, TBM_DEVICE_CPU, TBM_OPTION_READ); + checker = *((char *)thandle.ptr+size); + tbm_bo_unmap(bo); + } + +capture_event_exit1: + tbm_bo_unref(bo); +} + +static void _pd_msg_cb(player_pd_message_type_e type, void *user_data) +{ + mm_player_cb_e api = MM_PLAYER_CB_EVENT; + _player_event_e ev = _PLAYER_EVENT_TYPE_PD; + Client client = (Client)user_data; + + LOGD("ENTER"); + + player_msg_event1(api, ev, client, INT, type); +} + +static void _media_packet_video_decoded_cb(media_packet_h pkt, void *user_data) +{ + int ret; + mm_player_cb_e api = MM_PLAYER_CB_EVENT; + _player_event_e ev = _PLAYER_EVENT_TYPE_MEDIA_PACKET_VIDEO_FRAME; + Client client = (Client)user_data; + tbm_surface_h suf; + tbm_bo bo[4]; + int bo_num; + tbm_key key[4] = {0,}; + tbm_surface_info_s sinfo; + int i; + char *surface_info = (char *)&sinfo; + int surface_info_size = sizeof(tbm_surface_info_s); + intptr_t packet = (intptr_t)pkt; + media_format_mimetype_e mimetype = MEDIA_FORMAT_NV12; + media_format_h fmt; + + memset(&sinfo, 0, sizeof(tbm_surface_info_s)); + + ret = media_packet_get_tbm_surface(pkt, &suf); + if(ret != MEDIA_PACKET_ERROR_NONE){ + LOGE("get tbm surface error %d", ret); + return; + } + + bo_num = tbm_surface_internal_get_num_bos(suf); + for(i = 0; i < bo_num; i++) { + bo[i] = tbm_surface_internal_get_bo(suf, i); + if(bo[i]) + key[i] = tbm_bo_export(bo[i]); + else + LOGE("bo_num is %d, bo[%d] is NULL", bo_num, i); + }; + + ret = tbm_surface_get_info(suf, &sinfo); + if(ret != TBM_SURFACE_ERROR_NONE){ + LOGE("tbm_surface_get_info error %d", ret); + return; + } + media_packet_get_format(pkt, &fmt); + media_format_get_video_info(fmt, &mimetype, NULL, NULL, NULL, NULL); + player_msg_event6_array(api, ev, client, + INT, key[0], + INT, key[1], + INT, key[2], + INT, key[3], + INT, packet, + INT, mimetype, + surface_info, surface_info_size, sizeof(char)); +} + +static void _video_stream_changed_cb( + int width, int height, int fps, int bit_rate, void *user_data) +{ + mm_player_cb_e api = MM_PLAYER_CB_EVENT; + _player_event_e ev = _PLAYER_EVENT_TYPE_VIDEO_STREAM_CHANGED; + Client client = (Client)user_data; + + player_msg_event4(api, ev, client, + INT, width, INT, height, INT, fps, INT, bit_rate); +} + +static void _media_stream_audio_buffer_status_cb( + player_media_stream_buffer_status_e status, void *user_data) +{ + mm_player_cb_e api = MM_PLAYER_CB_EVENT; + _player_event_e ev = _PLAYER_EVENT_TYPE_MEDIA_STREAM_AUDIO_BUFFER_STATUS; + Client client = (Client)user_data; + + player_msg_event1(api, ev, client, INT, status); +} + +static void _media_stream_video_buffer_status_cb( + player_media_stream_buffer_status_e status, void *user_data) +{ + mm_player_cb_e api = MM_PLAYER_CB_EVENT; + _player_event_e ev = _PLAYER_EVENT_TYPE_MEDIA_STREAM_VIDEO_BUFFER_STATUS; + Client client = (Client)user_data; + + player_msg_event1(api, ev, client, INT, status); +} + +static void _media_stream_audio_seek_cb( + unsigned long long offset, void *user_data) +{ + mm_player_cb_e api = MM_PLAYER_CB_EVENT; + _player_event_e ev = _PLAYER_EVENT_TYPE_MEDIA_STREAM_AUDIO_SEEK; + Client client = (Client)user_data; + +#if 0 + unsigned upper_offset = (unsigned)((offset >> 32) & 0xffffffff); + unsigned lower_offset = (unsigned)(offset & 0xffffffff); + + player_msg_event2(api, ev, client, + INT, upper_offset, INT, lower_offset); +#else + player_msg_event1(api, ev, client, + INT64, offset); +#endif + +} + +static void _media_stream_video_seek_cb( + unsigned long long offset, void *user_data) +{ + mm_player_cb_e api = MM_PLAYER_CB_EVENT; + _player_event_e ev = _PLAYER_EVENT_TYPE_MEDIA_STREAM_VIDEO_SEEK; + Client client = (Client)user_data; + +#if 0 + unsigned upper_offset = (unsigned)((offset >> 32) & 0xffffffff); + unsigned lower_offset = (unsigned)(offset & 0xffffffff); + + player_msg_event2(api, ev, client, + INT, upper_offset, INT, lower_offset); +#else + player_msg_event1(api, ev, client, + INT64, offset); +#endif +} + +static void _set_completed_cb(player_h player, void *client, bool set) +{ + if(set) + player_set_completed_cb(player, _completed_cb, client); + else + player_unset_completed_cb(player); +} + +static void _set_interrupted_cb(player_h player, void *client, bool set) +{ + if(set) + player_set_interrupted_cb(player, _interrupted_cb, client); + else + player_unset_interrupted_cb(player); +} + +static void _set_error_cb(player_h player, void *client, bool set) +{ + if(set) + player_set_error_cb(player, _error_cb, client); + else + player_unset_error_cb(player); +} + +static void _set_subtitle_cb(player_h player, void *client, bool set) +{ + if(set) + player_set_subtitle_updated_cb(player, _subtitle_updated_cb, client); + else + player_unset_subtitle_updated_cb(player); +} + +static void _set_buffering_cb(player_h player, void *client, bool set) +{ + if(set) + player_set_buffering_cb(player, _buffering_cb, client); + else + player_unset_buffering_cb(player); +} + +static void _set_pd_msg_cb(player_h player, void *client, bool set) +{ + if(set) + player_set_progressive_download_message_cb(player, _pd_msg_cb, client); + else + player_unset_progressive_download_message_cb(player); +} + +static void _set_media_packet_video_frame_cb(player_h player, + void *data, bool set) +{ + int ret = PLAYER_ERROR_NONE; + mm_player_api_e api = MM_PLAYER_API_SET_CALLBACK; + Client client = (Client)data; + + if(set){ + ret = player_set_media_packet_video_frame_decoded_cb( + player, _media_packet_video_decoded_cb, client); + } else { + ret = player_unset_media_packet_video_frame_decoded_cb(player); + } + + player_msg_return(api, ret, client); +} + +static void _set_video_stream_changed_cb(player_h player, + void *data, bool set) +{ + int ret = PLAYER_ERROR_NONE; + mm_player_api_e api = MM_PLAYER_API_SET_CALLBACK; + Client client = (Client)data; + + if(set){ + ret = player_set_video_stream_changed_cb( + player, _video_stream_changed_cb, client); + } else { + ret = player_unset_video_stream_changed_cb(player); + } + + player_msg_return(api, ret, client); +} + +static void _set_media_stream_audio_seek_cb(player_h player, + void *data, bool set) +{ + int ret = PLAYER_ERROR_NONE; + mm_player_api_e api = MM_PLAYER_API_SET_CALLBACK; + Client client = (Client)data; + + if(set){ + ret = player_set_media_stream_seek_cb( + player, PLAYER_STREAM_TYPE_AUDIO, + _media_stream_audio_seek_cb, client); + } else { + ret = player_unset_media_stream_seek_cb( + player, PLAYER_STREAM_TYPE_AUDIO); + } + + player_msg_return(api, ret, client); +} + +static void _set_media_stream_video_seek_cb(player_h player, + void *data, bool set) +{ + int ret = PLAYER_ERROR_NONE; + mm_player_api_e api = MM_PLAYER_API_SET_CALLBACK; + Client client = (Client)data; + + if(set){ + ret = player_set_media_stream_seek_cb( + player, PLAYER_STREAM_TYPE_VIDEO, + _media_stream_video_seek_cb, client); + } else { + ret = player_unset_media_stream_seek_cb( + player, PLAYER_STREAM_TYPE_VIDEO); + } + + player_msg_return(api, ret, client); +} + +static void _set_media_stream_audio_buffer_cb(player_h player, + void *data, bool set) +{ + int ret = PLAYER_ERROR_NONE; + mm_player_api_e api = MM_PLAYER_API_SET_CALLBACK; + Client client = (Client)data; + + if(set){ + ret = player_set_media_stream_buffer_status_cb( + player, PLAYER_STREAM_TYPE_AUDIO, + _media_stream_audio_buffer_status_cb, client); + } else { + ret = player_unset_media_stream_buffer_status_cb( + player, PLAYER_STREAM_TYPE_AUDIO); + } + + player_msg_return(api, ret, client); +} + +static void _set_media_stream_video_buffer_cb(player_h player, + void *data, bool set) +{ + int ret = PLAYER_ERROR_NONE; + mm_player_api_e api = MM_PLAYER_API_SET_CALLBACK; + Client client = (Client)data; + + if(set){ + ret = player_set_media_stream_buffer_status_cb( + player, PLAYER_STREAM_TYPE_VIDEO, + _media_stream_video_buffer_status_cb, client); + } else { + ret = player_unset_media_stream_buffer_status_cb( + player, PLAYER_STREAM_TYPE_VIDEO); + } + + player_msg_return(api, ret, client); +} + +static void (*set_callback_func[_PLAYER_EVENT_TYPE_NUM]) + (player_h player, void *user_data, bool set) = { + NULL, /* _PLAYER_EVENT_TYPE_PREPARE */ + _set_completed_cb, /* _PLAYER_EVENT_TYPE_COMPLETE */ + _set_interrupted_cb, /* _PLAYER_EVENT_TYPE_INTERRUPT */ + _set_error_cb, /* _PLAYER_EVENT_TYPE_ERROR */ + _set_buffering_cb, /* _PLAYER_EVENT_TYPE_BUFFERING */ + _set_subtitle_cb, /* _PLAYER_EVENT_TYPE_SUBTITLE */ + NULL, /* _PLAYER_EVENT_TYPE_CAPTURE */ + NULL, /* _PLAYER_EVENT_TYPE_SEEK */ + _set_media_packet_video_frame_cb, /* _PLAYER_EVENT_TYPE_MEDIA_PACKET_VIDEO_FRAME */ + NULL, /* _PLAYER_EVENT_TYPE_AUDIO_FRAME */ + NULL, /* _PLAYER_EVENT_TYPE_VIDEO_FRAME_RENDER_ERROR */ + _set_pd_msg_cb, /* _PLAYER_EVENT_TYPE_PD */ + NULL, /* _PLAYER_EVENT_TYPE_SUPPORTED_AUDIO_EFFECT */ + NULL, /* _PLAYER_EVENT_TYPE_SUPPORTED_AUDIO_EFFECT_PRESET */ + NULL, /* _PLAYER_EVENT_TYPE_MISSED_PLUGIN */ +#ifdef _PLAYER_FOR_PRODUCT + NULL, /* _PLAYER_EVENT_TYPE_IMAGE_BUFFER */ + NULL, /*_PLAYER_EVENT_TYPE_SELECTED_SUBTITLE_LANGUAGE */ +#endif + _set_media_stream_video_buffer_cb, /*_PLAYER_EVENT_TYPE_MEDIA_STREAM_VIDEO_BUFFER_STATUS*/ + _set_media_stream_audio_buffer_cb, /*_PLAYER_EVENT_TYPE_MEDIA_STREAM_AUDIO_BUFFER_STATUS*/ + _set_media_stream_video_seek_cb, /*_PLAYER_EVENT_TYPE_MEDIA_STREAM_VIDEO_SEEK*/ + _set_media_stream_audio_seek_cb, /*_PLAYER_EVENT_TYPE_MEDIA_STREAM_AUDIO_SEEK*/ + NULL, /*_PLAYER_EVENT_TYPE_AUDIO_STREAM_CHANGED*/ + _set_video_stream_changed_cb, /*_PLAYER_EVENT_TYPE_VIDEO_STREAM_CHANGED*/ +}; + +static int player_disp_set_callback(Client client) +{ + intptr_t handle; + _player_event_e type; + int set; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + player_msg_get(type, mmsvc_core_client_get_msg(client)); + player_msg_get(set, mmsvc_core_client_get_msg(client)); + + if(type < _PLAYER_EVENT_TYPE_NUM && set_callback_func[type] != NULL){ + set_callback_func[type]((player_h)handle, client, set); + } + + return PLAYER_ERROR_NONE; +} + +static int player_disp_create(Client client) +{ + int ret = -1; + player_h player; + mm_player_api_e api = MM_PLAYER_API_CREATE; + intptr_t handle = 0; + intptr_t client_addr = (intptr_t)client; + data_thread_info_t *thread_i; + static guint stream_id = 0; + char stream_path[STREAM_PATH_LENGTH]; + + ret = player_create(&player); + LOGD("handle : %p\n", player); + + if(ret == PLAYER_ERROR_NONE) { + thread_i = g_new(data_thread_info_t, 1); + thread_i->running = 1; + g_mutex_init(&thread_i->mutex); + g_cond_init(&thread_i->cond); + thread_i->queue = g_queue_new(); + thread_i->thread = (gpointer) g_thread_new("push_media", + _player_push_media_stream_handler, client); + + mmsvc_core_client_set_cust_data(client, thread_i); + + bufmgr = tbm_bufmgr_init (-1); + + stream_id = mmsvc_core_get_atomic_uint(); + snprintf(stream_path, STREAM_PATH_LENGTH, STREAM_PATH_BASE, stream_id); + unlink(stream_path); + ret = player_set_shm_stream_path_for_mused(player, stream_path); + + handle = (intptr_t)player; + player_msg_return3(api, ret, client, + POINTER, handle, POINTER, client_addr, STRING, stream_path); + } + else + player_msg_return(api, ret, client); + + return 1; +} + +static int player_disp_set_uri(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_SET_URI; + char uri[MM_URI_MAX_LENGTH] = { 0, }; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + player_msg_get_string(uri, mmsvc_core_client_get_msg(client)); + + ret = player_set_uri((player_h) handle, uri); + + player_msg_return(api, ret, client); + + return 1; +} + +static int player_disp_prepare(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_PREPARE; + player_h player; + char *caps = NULL; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + + player = (player_h) handle; + + ret = player_prepare(player); + if(ret == PLAYER_ERROR_NONE) { + ret = player_get_raw_video_caps(player, &caps); + if(ret == PLAYER_ERROR_NONE && caps) { + player_msg_return1(api, ret, client, STRING, caps); + g_free(caps); + return 1; + } + } + + player_msg_return(api, ret, client); + + return 1; +} + +static int player_disp_prepare_async(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_PREPARE_ASYNC; + player_h player; + prepare_data_t *prepare_data; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + player = (player_h) handle; + + prepare_data = g_new(prepare_data_t, 1); + prepare_data->player = player; + prepare_data->client = client; + + ret = player_prepare_async(player, _prepare_async_cb, prepare_data); + + player_msg_return(api, ret, client); + + return 1; +} + +static int player_disp_unprepare(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_UNPREPARE; + player_h player; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + player = (player_h) handle; + + ret = player_unprepare(player); + + player_msg_return(api, ret, client); + + return 1; +} + +static int player_disp_destroy(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_DESTROY; + data_thread_info_t *thread_i; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + + ret = player_destroy((player_h) handle); + + thread_i = (data_thread_info_t *)mmsvc_core_client_get_cust_data(client); + thread_i->running = 0; + g_cond_signal(&thread_i->cond); + + g_thread_join(thread_i->thread); + g_thread_unref(thread_i->thread); + g_queue_free(thread_i->queue); + g_mutex_clear(&thread_i->mutex); + g_cond_clear(&thread_i->cond); + g_free(thread_i); + mmsvc_core_client_set_cust_data(client, NULL); + + tbm_bufmgr_deinit (bufmgr); + if(audio_format) { + media_format_unref(audio_format); + audio_format = NULL; + } + if(video_format) { + media_format_unref(video_format); + video_format = NULL; + } + + player_msg_return(api, ret, client); + + return 1; +} + +static int player_disp_start(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_START; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + + ret = player_start((player_h) handle); + + player_msg_return(api, ret, client); + + return 1; +} + +static int player_disp_stop(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_STOP; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + + ret = player_stop((player_h) handle); + + player_msg_return(api, ret, client); + + return ret; +} + +static int player_disp_pause(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_PAUSE; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + + ret = player_pause((player_h) handle); + + player_msg_return(api, ret, client); + + return ret; +} + +static int player_disp_set_memory_buffer(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_SET_MEMORY_BUFFER; + tbm_bo bo; + tbm_bo_handle thandle; + tbm_key key; + int size; + intptr_t bo_addr; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + player_msg_get(key, mmsvc_core_client_get_msg(client)); + player_msg_get(size, mmsvc_core_client_get_msg(client)); + + bo = tbm_bo_import(bufmgr, key); + if(bo == NULL) { + LOGE("TBM get error : bo is NULL"); + ret = PLAYER_ERROR_INVALID_OPERATION; + player_msg_return(api, ret, client); + return ret; + } + thandle = tbm_bo_map (bo, TBM_DEVICE_CPU, TBM_OPTION_READ); + if(thandle.ptr == NULL) + { + LOGE("TBM get error : handle pointer is NULL"); + ret = PLAYER_ERROR_INVALID_OPERATION; + player_msg_return(api, ret, client); + return ret; + } + + bo_addr = (intptr_t)bo; + ret = player_set_memory_buffer((player_h) handle, thandle.ptr, size); + player_msg_return1(api, ret, client, INT, bo_addr); + + return ret; +} + +static int player_disp_deinit_memory_buffer(Client client) +{ + intptr_t handle; + intptr_t bo_addr; + tbm_bo bo; + + if( player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER) + && player_msg_get(bo_addr, mmsvc_core_client_get_msg(client))) { + + bo = (tbm_bo)bo_addr; + + tbm_bo_unmap(bo); + tbm_bo_unref(bo); + } + + return PLAYER_ERROR_NONE; +} + +static int player_disp_set_volume(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_SET_VOLUME; + double left, right; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + player_msg_get(left, mmsvc_core_client_get_msg(client)); + player_msg_get(right, mmsvc_core_client_get_msg(client)); + + ret = player_set_volume((player_h) handle, (float)left, (float)right); + + player_msg_return(api, ret, client); + + return 1; +} + +static int player_disp_get_volume(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_GET_VOLUME; + float left, right; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + + ret = player_get_volume((player_h) handle, &left, &right); + + player_msg_return2(api, ret, client, DOUBLE, left, DOUBLE, right); + + return 1; +} + +static int player_disp_get_state(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_GET_STATE; + player_state_e state; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + + ret = player_get_state((player_h) handle, &state); + + player_msg_return1(api, ret, client, INT, state); + + return 1; +} + + +static int player_disp_set_play_position(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_SET_PLAY_POSITION; + int pos; + int accurate; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + player_msg_get(pos, mmsvc_core_client_get_msg(client)); + player_msg_get(accurate, mmsvc_core_client_get_msg(client)); + + ret = player_set_play_position((player_h) handle, pos, accurate, _seek_complate_cb ,client); + + player_msg_return(api, ret, client); + + return 1; +} + +static int player_disp_get_play_position(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_GET_PLAY_POSITION; + int pos; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + + ret = player_get_play_position((player_h) handle, &pos); + + player_msg_return1(api, ret, client, INT, pos); + + return 1; +} + +static int player_disp_set_display(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_SET_DISPLAY; +#ifdef HAVE_WAYLAND + wl_win_msg_type wl_win; + char *wl_win_msg = (char *)&wl_win; +#else + int type; + unsigned int xhandle; +#endif + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); +#ifdef HAVE_WAYLAND + player_msg_get_array(wl_win_msg, mmsvc_core_client_get_msg(client)); + + ret = player_set_display_wl_for_mused((player_h) handle, wl_win.type, wl_win.surface, + wl_win.wl_window_x, wl_win.wl_window_y, wl_win.wl_window_width, wl_win.wl_window_height); +#else + player_msg_get(type, mmsvc_core_client_get_msg(client)); + player_msg_get(xhandle, mmsvc_core_client_get_msg(client)); + + ret = player_set_display_for_mused((player_h) handle, type, xhandle); +#endif + player_msg_return(api, ret, client); + + return 1; +} + +static int player_disp_set_mute(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_SET_MUTE; + int mute; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + player_msg_get(mute, mmsvc_core_client_get_msg(client)); + + ret = player_set_mute((player_h) handle, (bool)mute); + + player_msg_return(api, ret, client); + + return ret; +} + +static int player_disp_is_muted(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_IS_MUTED; + bool mute; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + + ret = player_is_muted((player_h) handle, &mute); + + player_msg_return1(api, ret, client, INT, mute); + + return ret; +} + +static int player_disp_get_duration(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_GET_DURATION; + int duration = 0; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + + ret = player_get_duration((player_h) handle, &duration); + + player_msg_return1(api, ret, client, INT, duration); + + return ret; +} + +static int player_disp_set_sound_type(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_SET_SOUND_TYPE; + int type; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + player_msg_get(type, mmsvc_core_client_get_msg(client)); + + ret = player_set_sound_type((player_h) handle, (sound_type_e)type); + + player_msg_return(api, ret, client); + + return ret; +} + +#ifndef USE_ASM +static int player_disp_set_audio_policy_info(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_SET_AUDIO_POLICY_INFO; + int stream_index; + char stream_type[MM_URI_MAX_LENGTH] = { 0, }; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + player_msg_get(stream_index, mmsvc_core_client_get_msg(client)); + player_msg_get_string(stream_type, mmsvc_core_client_get_msg(client)); + + ret = player_set_audio_policy_info_for_mused((player_h) handle, + stream_type, stream_index); + + player_msg_return(api, ret, client); + + return ret; +} +#endif /* USE_ASM */ + +static int player_disp_set_latency_mode(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_SET_AUDIO_LATENCY_MODE; + int latency_mode; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + player_msg_get(latency_mode, mmsvc_core_client_get_msg(client)); + + ret = player_set_audio_latency_mode((player_h) handle, + (audio_latency_mode_e)latency_mode); + + player_msg_return(api, ret, client); + + return ret; +} + +static int player_disp_get_latency_mode(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_GET_AUDIO_LATENCY_MODE; + audio_latency_mode_e latency_mode; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + + ret = player_get_audio_latency_mode((player_h) handle, &latency_mode); + + player_msg_return1(api, ret, client, INT, latency_mode); + + return ret; +} + +static int player_disp_set_looping(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_SET_LOOPING; + int looping; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + player_msg_get(looping, mmsvc_core_client_get_msg(client)); + + ret = player_set_looping((player_h) handle, (bool)looping); + + player_msg_return(api, ret, client); + + return ret; +} + +static int player_disp_is_looping(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_IS_LOOPING; + bool looping; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + + ret = player_is_looping((player_h) handle, &looping); + + player_msg_return1(api, ret, client, INT, looping); + + return ret; +} + +static int player_disp_set_display_mode(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_SET_DISPLAY_MODE; + int mode = 0; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + player_msg_get(mode, mmsvc_core_client_get_msg(client)); + + ret = player_set_display_mode((player_h) handle, (player_display_mode_e)mode); + + player_msg_return(api, ret, client); + + return ret; +} + +static int player_disp_get_display_mode(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_GET_DISPLAY_MODE; + player_display_mode_e mode = 0; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + + ret = player_get_display_mode((player_h) handle, &mode); + + player_msg_return1(api, ret, client, INT, mode); + + return ret; +} + +static int player_disp_set_playback_rate(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_SET_PLAYBACK_RATE; + double rate = 0; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + player_msg_get(rate, mmsvc_core_client_get_msg(client)); + + ret = player_set_playback_rate((player_h) handle, (float)rate); + + player_msg_return(api, ret, client); + + return ret; +} + +static int player_disp_set_display_rotation(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_SET_DISPLAY_ROTATION; + int rotation = 0; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + player_msg_get(rotation, mmsvc_core_client_get_msg(client)); + + ret = player_set_display_rotation((player_h) handle, + (player_display_rotation_e)rotation); + + player_msg_return(api, ret, client); + + return ret; +} + +static int player_disp_get_display_rotation(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_GET_DISPLAY_ROTATION; + player_display_rotation_e rotation; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + + ret = player_get_display_rotation((player_h) handle, &rotation); + + player_msg_return1(api, ret, client, INT, rotation); + + return ret; +} + +static int player_disp_set_display_visible(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_SET_DISPLAY_VISIBLE; + int visible = 0; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + player_msg_get(visible, mmsvc_core_client_get_msg(client)); + + ret = player_set_display_visible((player_h) handle, visible); + + player_msg_return(api, ret, client); + + return ret; +} + +static int player_disp_is_display_visible(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_IS_DISPLAY_VISIBLE; + bool visible = 0; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + + ret = player_is_display_visible((player_h) handle, &visible); + + player_msg_return1(api, ret, client, INT, visible); + + return ret; +} + +static int player_disp_get_content_info(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_GET_CONTENT_INFO; + char *value; + player_content_info_e key; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + player_msg_get(key, mmsvc_core_client_get_msg(client)); + + ret = player_get_content_info((player_h) handle, key, &value); + + if(ret == PLAYER_ERROR_NONE) { + player_msg_return1(api, ret, client, STRING, value); + free(value); + } + else + player_msg_return(api, ret, client); + + + return 1; +} + +static int player_disp_get_codec_info(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_GET_CODEC_INFO; + char *video_codec; + char *audio_codec; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + + ret = player_get_codec_info((player_h) handle, &audio_codec, &video_codec); + + if(ret == PLAYER_ERROR_NONE) { + player_msg_return2(api, ret, client, + STRING, audio_codec, STRING, video_codec); + + free(audio_codec); + free(video_codec); + } + else + player_msg_return(api, ret, client); + + return 1; +} + +static int player_disp_get_audio_stream_info(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_GET_AUDIO_STREAM_INFO; + int sample_rate = 0; + int channel = 0; + int bit_rate = 0; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + + ret = player_get_audio_stream_info((player_h) handle, + &sample_rate, &channel, &bit_rate); + + player_msg_return3(api, ret, client, + INT, sample_rate, INT, channel, INT, bit_rate); + + return 1; +} + +static int player_disp_get_video_stream_info(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_GET_VIDEO_STREAM_INFO; + int fps = 0; + int bit_rate = 0; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + + ret = player_get_video_stream_info((player_h) handle, &fps, &bit_rate); + + player_msg_return2(api, ret, client, + INT, fps, INT, bit_rate); + + return 1; +} + +static int player_disp_get_video_size(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_GET_VIDEO_SIZE; + int width = 0; + int height = 0; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + + ret = player_get_video_size((player_h) handle, &width, &height); + + player_msg_return2(api, ret, client, + INT, width, INT, height); + + return 1; +} + +static int player_disp_get_album_art(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_GET_ALBUM_ART; + void *album_art; + int size; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + + ret = player_get_album_art((player_h) handle, &album_art, &size); + + if(ret == PLAYER_ERROR_NONE) { + player_msg_return_array(api, ret, client, + album_art, size, sizeof(char)); + } + else + player_msg_return(api, ret, client); + + return 1; +} + +static int player_disp_get_eq_bands_count(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_AUDIO_EFFECT_GET_EQUALIZER_BANDS_COUNT; + int count; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + + ret = player_audio_effect_get_equalizer_bands_count((player_h) handle, &count); + + player_msg_return1(api, ret, client, INT, count); + + return ret; +} + +static int player_disp_set_eq_all_bands(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_AUDIO_EFFECT_SET_EQUALIZER_ALL_BANDS; + int *band_levels; + int length; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + player_msg_get(length, mmsvc_core_client_get_msg(client)); + band_levels = (int *)g_try_new(int, length); + + if(band_levels) { + player_msg_get_array(band_levels, mmsvc_core_client_get_msg(client)); + ret = player_audio_effect_set_equalizer_all_bands((player_h) handle, band_levels, length); + g_free(band_levels); + } + else + ret = PLAYER_ERROR_INVALID_OPERATION; + + player_msg_return(api, ret, client); + + return ret; +} + +static int player_disp_set_eq_band_level(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_AUDIO_EFFECT_SET_EQUALIZER_BAND_LEVEL; + int index, level; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + player_msg_get(index, mmsvc_core_client_get_msg(client)); + player_msg_get(level, mmsvc_core_client_get_msg(client)); + + ret = player_audio_effect_set_equalizer_band_level((player_h) handle, index, level); + + player_msg_return(api, ret, client); + + return ret; +} + +static int player_disp_get_eq_band_level(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_AUDIO_EFFECT_GET_EQUALIZER_BAND_LEVEL; + int index, level; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + player_msg_get(index, mmsvc_core_client_get_msg(client)); + + ret = player_audio_effect_get_equalizer_band_level((player_h) handle, index, &level); + + player_msg_return1(api, ret, client, INT, level); + + return ret; +} + +static int player_disp_get_eq_level_range(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_AUDIO_EFFECT_GET_EQUALIZER_LEVEL_RANGE; + int min, max; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + + ret = player_audio_effect_get_equalizer_level_range((player_h) handle, &min, &max); + + player_msg_return2(api, ret, client, INT, min, INT, max); + + return ret; +} + +static int player_disp_get_eq_band_frequency(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_AUDIO_EFFECT_GET_EQUALIZER_BAND_FREQUENCY; + int index, frequency; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + player_msg_get(index, mmsvc_core_client_get_msg(client)); + + ret = player_audio_effect_get_equalizer_band_frequency((player_h) handle, index, &frequency); + + player_msg_return1(api, ret, client, INT, frequency); + + return ret; +} + +static int player_disp_get_eq_band_frequency_range(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_AUDIO_EFFECT_GET_EQUALIZER_BAND_FREQUENCY_RANGE; + int index, range; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + player_msg_get(index, mmsvc_core_client_get_msg(client)); + + ret = player_audio_effect_get_equalizer_band_frequency_range((player_h) handle, + index, &range); + + player_msg_return1(api, ret, client, INT, range); + + return ret; +} + +static int player_disp_eq_clear(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_AUDIO_EFFECT_EQUALIZER_CLEAR; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + + ret = player_audio_effect_equalizer_clear((player_h) handle); + + player_msg_return(api, ret, client); + + return ret; +} + +static int player_disp_eq_is_available(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_AUDIO_EFFECT_EQUALIZER_IS_AVAILABLE; + bool available; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + + ret = player_audio_effect_equalizer_is_available((player_h) handle, &available); + + player_msg_return1(api, ret, client, INT, available); + + return ret; +} + +static int player_disp_set_subtitle_path(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_SET_SUBTITLE_PATH; + char path[MM_URI_MAX_LENGTH] = { 0, }; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + player_msg_get_string(path, mmsvc_core_client_get_msg(client)); + + ret = player_set_subtitle_path((player_h) handle, path); + + player_msg_return(api, ret, client); + + return ret; +} + +static int player_disp_set_subtitle_position_offset(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_SET_SUBTITLE_POSITION_OFFSET; + int millisecond; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + player_msg_get(millisecond, mmsvc_core_client_get_msg(client)); + + ret = player_set_subtitle_position_offset((player_h) handle, millisecond); + + player_msg_return(api, ret, client); + + return ret; +} + +static int player_disp_set_progressive_download_path(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_SET_PROGRESSIVE_DOWNLOAD_PATH; + char path[MM_URI_MAX_LENGTH] = { 0, }; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + player_msg_get_string(path, mmsvc_core_client_get_msg(client)); + + ret = player_set_progressive_download_path((player_h) handle, path); + + player_msg_return(api, ret, client); + + return ret; +} + +static int player_disp_get_progressive_download_status(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_GET_PROGRESSIVE_DOWNLOAD_STATUS; + unsigned long current = 0; + unsigned long total_size = 0; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + player_msg_get(current, mmsvc_core_client_get_msg(client)); + player_msg_get(total_size, mmsvc_core_client_get_msg(client)); + + ret = player_get_progressive_download_status((player_h) handle, + ¤t, &total_size); + + player_msg_return2(api, ret, client, INT, current, INT, total_size); + + return ret; +} + +static int player_disp_capture_video(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_CAPTURE_VIDEO; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + + ret = player_capture_video((player_h) handle, _capture_video_cb, client); + + player_msg_return(api, ret, client); + + return ret; +} + +static int player_disp_set_streaming_cookie(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_SET_STREAMING_COOKIE; + char *cookie = NULL; + int size; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + player_msg_get(size, mmsvc_core_client_get_msg(client)); + cookie = (char *)g_try_new(char, size+1); + if(cookie) { + player_msg_get_string(cookie, mmsvc_core_client_get_msg(client)); + ret = player_set_streaming_cookie((player_h) handle, cookie, size); + g_free(cookie); + } + else + ret = PLAYER_ERROR_INVALID_OPERATION; + + player_msg_return(api, ret, client); + + return ret; +} + +static int player_disp_set_streaming_user_agent(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_SET_STREAMING_USER_AGENT; + char *user_agent; + int size; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + player_msg_get(size, mmsvc_core_client_get_msg(client)); + user_agent = (char *)g_try_new(char, size+1); + if(user_agent) { + player_msg_get_string(user_agent, mmsvc_core_client_get_msg(client)); + ret = player_set_streaming_user_agent((player_h) handle, user_agent, size); + g_free(user_agent); + } + else + ret = PLAYER_ERROR_INVALID_OPERATION; + + player_msg_return(api, ret, client); + + return ret; +} + +static int player_disp_get_streaming_download_progress(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_GET_STREAMING_DOWNLOAD_PROGRESS; + int start, current; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + + ret = player_get_streaming_download_progress((player_h) handle, &start, ¤t); + + player_msg_return2(api, ret, client, INT, start, INT, current); + + return ret; +} + +static gpointer _player_push_media_stream_handler(gpointer param) +{ + Client client = (Client)param; + char *buf; + push_data_q_t *qData; + player_push_media_msg_type push_media; + + LOGD("Enter"); + + if(!client){ + LOGE("Null parameter"); + return NULL; + } + data_thread_info_t *thread_i = + (data_thread_info_t *)mmsvc_core_client_get_cust_data(client); + if(!thread_i){ + LOGE("Null parameter"); + return NULL; + } + + g_mutex_lock(&thread_i->mutex); + while(thread_i->running) { + if(g_queue_is_empty(thread_i->queue)) { + g_cond_wait(&thread_i->cond, &thread_i->mutex); + if(!thread_i->running) { + break; + } + } + while(1) { + qData = g_queue_pop_head(thread_i->queue); + g_mutex_unlock(&thread_i->mutex); + if(qData) { + push_media.mimetype = qData->mimetype; + push_media.pts = qData->pts; + push_media.size = qData->size; + buf = mmsvc_core_ipc_get_data(client); + if(buf) { + _push_media_stream(qData->handle, &push_media, buf); + mmsvc_core_ipc_delete_data(buf); + } + g_free(qData); + } else { + g_mutex_lock(&thread_i->mutex); + break; + } + g_mutex_lock(&thread_i->mutex); + } + } + g_mutex_unlock(&thread_i->mutex); + + LOGD("Leave"); + + return NULL; +} + +static int _push_media_stream(intptr_t handle, player_push_media_msg_type *push_media, char *buf) +{ + int ret = MEDIA_FORMAT_ERROR_NONE; + media_format_h format; + media_packet_h packet; + media_format_mimetype_e mimetype; + + if(push_media->mimetype & MEDIA_FORMAT_VIDEO) { + if(!video_format) { + media_format_create(&video_format); + if(!video_format) { + LOGE("fail to create media format"); + return PLAYER_ERROR_INVALID_PARAMETER; + } + ret |= media_format_set_video_mime(video_format, push_media->mimetype); + } + ret |= media_format_get_video_info(video_format, &mimetype, NULL, NULL, NULL, NULL); + if(mimetype != push_media->mimetype) { + media_format_unref(video_format); + media_format_create(&video_format); + ret |= media_format_set_video_mime(video_format, push_media->mimetype); + } + format = video_format; + } + else if(push_media->mimetype & MEDIA_FORMAT_AUDIO) { + if(!audio_format) { + media_format_create(&audio_format); + if(!audio_format) { + LOGE("fail to create media format"); + return PLAYER_ERROR_INVALID_PARAMETER; + } + ret |= media_format_set_audio_mime(audio_format, push_media->mimetype); + } + ret |= media_format_get_audio_info(audio_format, &mimetype, NULL, NULL, NULL, NULL); + if(mimetype != push_media->mimetype) { + media_format_unref(audio_format); + media_format_create(&audio_format); + ret |= media_format_set_audio_mime(audio_format, push_media->mimetype); + } + format = audio_format; + } + else + ret = MEDIA_FORMAT_ERROR_INVALID_PARAMETER; + + + if(ret != MEDIA_FORMAT_ERROR_NONE) { + LOGE("Invalid MIME %d", push_media->mimetype); + return PLAYER_ERROR_INVALID_PARAMETER; + } + + ret = media_packet_create_from_external_memory(format, buf, + push_media->size, NULL, NULL, &packet); + if(ret != MEDIA_PACKET_ERROR_NONE) { + return PLAYER_ERROR_INVALID_PARAMETER; + } + + media_packet_set_pts(packet, push_media->pts); + + ret = player_push_media_stream((player_h)handle, packet); + if(ret != PLAYER_ERROR_NONE) + LOGE("ret %d", ret); + + media_packet_destroy(packet); + + return ret; +} + +static int player_disp_push_media_stream(Client client) +{ + int ret = MEDIA_FORMAT_ERROR_NONE; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_PUSH_MEDIA_STREAM; + player_push_media_msg_type push_media; + char *push_media_msg = (char *)&push_media; + tbm_bo bo = NULL; + tbm_bo_handle thandle; + char *buf = NULL; + + if(!player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER) || + !player_msg_get_array(push_media_msg, mmsvc_core_client_get_msg(client))) { + ret = PLAYER_ERROR_INVALID_OPERATION; + goto push_media_stream_exit1; + } + + if(push_media.buf_type == PUSH_MEDIA_BUF_TYPE_TBM) { + bo = tbm_bo_import(bufmgr, push_media.key); + if(bo == NULL) { + LOGE("TBM get error : bo is NULL"); + ret = PLAYER_ERROR_INVALID_OPERATION; + goto push_media_stream_exit1; + } + thandle = tbm_bo_map (bo, TBM_DEVICE_CPU, TBM_OPTION_READ); + if(thandle.ptr == NULL) + { + LOGE("TBM get error : handle pointer is NULL"); + ret = PLAYER_ERROR_INVALID_OPERATION; + goto push_media_stream_exit2; + } + buf = thandle.ptr; + } else if(push_media.buf_type == PUSH_MEDIA_BUF_TYPE_MSG) { + buf = g_new(char,push_media.size); + if(!buf) { + ret = PLAYER_ERROR_OUT_OF_MEMORY; + goto push_media_stream_exit1; + } + player_msg_get_array(buf, mmsvc_core_client_get_msg(client)); + } else if(push_media.buf_type == PUSH_MEDIA_BUF_TYPE_RAW) { + push_data_q_t *qData = g_new(push_data_q_t, 1); + data_thread_info_t *thread_i = + (data_thread_info_t *)mmsvc_core_client_get_cust_data(client); + if(!qData) { + ret = PLAYER_ERROR_OUT_OF_MEMORY; + goto push_media_stream_exit1; + } + qData->handle = handle; + qData->mimetype = push_media.mimetype; + qData->pts = push_media.pts; + qData->size = push_media.size; + g_queue_push_tail(thread_i->queue ,qData); + g_cond_signal(&thread_i->cond); + } + + if(push_media.buf_type == PUSH_MEDIA_BUF_TYPE_RAW) + ret = PLAYER_ERROR_NONE; + else + ret = _push_media_stream(handle, &push_media, buf); + + if(push_media.buf_type == PUSH_MEDIA_BUF_TYPE_TBM) + tbm_bo_unmap(bo); +push_media_stream_exit2: + if(push_media.buf_type == PUSH_MEDIA_BUF_TYPE_TBM) + tbm_bo_unref(bo); + else if(push_media.buf_type == PUSH_MEDIA_BUF_TYPE_MSG) + g_free(buf); + +push_media_stream_exit1: + player_msg_return(api, ret, client); + return ret; +} + +static int player_disp_set_media_stream_info(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_SET_MEDIA_STREAM_INFO; + media_format_mimetype_e mimetype; + player_stream_type_e type; + int width; + int height; + int avg_bps; + int max_bps; + int channel; + int samplerate; + int bit; + media_format_h format; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + player_msg_get(mimetype, mmsvc_core_client_get_msg(client)); + player_msg_get(type, mmsvc_core_client_get_msg(client)); + player_msg_get(avg_bps, mmsvc_core_client_get_msg(client)); + if(type == PLAYER_STREAM_TYPE_VIDEO) { + player_msg_get(width, mmsvc_core_client_get_msg(client)); + player_msg_get(height, mmsvc_core_client_get_msg(client)); + player_msg_get(max_bps, mmsvc_core_client_get_msg(client)); + } else if(type == PLAYER_STREAM_TYPE_AUDIO) { + player_msg_get(channel, mmsvc_core_client_get_msg(client)); + player_msg_get(samplerate, mmsvc_core_client_get_msg(client)); + player_msg_get(bit, mmsvc_core_client_get_msg(client)); + } else { + ret = PLAYER_ERROR_INVALID_PARAMETER; + goto set_media_stream_info_exit; + } + + if(media_format_create(&format) == MEDIA_FORMAT_ERROR_NONE) { + if(type == PLAYER_STREAM_TYPE_VIDEO) { + ret = media_format_set_video_mime(format, mimetype); + ret |= media_format_set_video_width(format, width); + ret |= media_format_set_video_height(format, height); + ret |= media_format_set_video_avg_bps(format, avg_bps); + ret |= media_format_set_video_max_bps(format, max_bps); + } else if(type == PLAYER_STREAM_TYPE_AUDIO) { + ret = media_format_set_audio_mime(format, mimetype); + ret |= media_format_set_audio_channel(format, channel); + ret |= media_format_set_audio_samplerate(format, samplerate); + ret |= media_format_set_audio_bit(format, bit); + ret |= media_format_set_audio_avg_bps(format, avg_bps); + } + if(ret != MEDIA_FORMAT_ERROR_NONE) { + ret = PLAYER_ERROR_INVALID_OPERATION; + goto set_media_stream_info_exit; + } + } + else { + ret = PLAYER_ERROR_OUT_OF_MEMORY; + goto set_media_stream_info_exit; + } + + ret = player_set_media_stream_info((player_h)handle, type, format); + +set_media_stream_info_exit: + player_msg_return(api, ret, client); + return ret; +} + +static int player_disp_media_packet_finalize_cb(Client client) +{ + media_packet_h packet; + + player_msg_get(packet, mmsvc_core_client_get_msg(client)); + + media_packet_destroy(packet); + + return PLAYER_ERROR_NONE; +} + +static int player_disp_set_media_stream_buffer_max_size(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_SET_MEDIA_STREAM_BUFFER_MAX_SIZE; + player_stream_type_e type; + unsigned long long max_size; + //unsigned upper_max_size, lower_max_size; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + player_msg_get(type, mmsvc_core_client_get_msg(client)); +#if 0 + player_msg_get(upper_max_size, mmsvc_core_client_get_msg(client)); + player_msg_get(lower_max_size, mmsvc_core_client_get_msg(client)); + + max_size = (((unsigned long long)upper_max_size << 32) & 0xffffffff00000000) + | (lower_max_size & 0xffffffff); +#else + player_msg_get_type(max_size, mmsvc_core_client_get_msg(client), INT64); +#endif + + ret = player_set_media_stream_buffer_max_size((player_h) handle, type, max_size); + + player_msg_return(api, ret, client); + + return ret; +} + +static int player_disp_get_media_stream_buffer_max_size(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_GET_MEDIA_STREAM_BUFFER_MAX_SIZE; + player_stream_type_e type; + unsigned long long max_size; + //unsigned upper_max_size, lower_max_size; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + player_msg_get(type, mmsvc_core_client_get_msg(client)); + + ret = player_get_media_stream_buffer_max_size((player_h) handle, type, &max_size); + if(ret == PLAYER_ERROR_NONE) { +#if 0 + upper_max_size = (unsigned)((max_size >> 32) & 0xffffffff); + lower_max_size = (unsigned)(max_size & 0xffffffff); + player_msg_return2(api, ret, client, + INT, upper_max_size, INT, lower_max_size); +#else + player_msg_return1(api, ret, client, + INT64, max_size); +#endif + } + else + player_msg_return(api, ret, client); + + return ret; +} + +static int player_disp_set_media_stream_buffer_min_threshold(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_SET_MEDIA_STREAM_BUFFER_MIN_THRESHOLD; + player_stream_type_e type; + unsigned percent; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + player_msg_get(type, mmsvc_core_client_get_msg(client)); + player_msg_get(percent, mmsvc_core_client_get_msg(client)); + + ret = player_set_media_stream_buffer_min_threshold((player_h) handle, type, percent); + + player_msg_return(api, ret, client); + + return ret; +} + +static int player_disp_get_media_stream_buffer_min_threshold(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_GET_MEDIA_STREAM_BUFFER_MIN_THRESHOLD; + player_stream_type_e type; + unsigned percent; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + player_msg_get(type, mmsvc_core_client_get_msg(client)); + + ret = player_get_media_stream_buffer_min_threshold((player_h) handle, type, &percent); + if(ret == PLAYER_ERROR_NONE) { + player_msg_return1(api, ret, client, INT, percent); + } + else + player_msg_return(api, ret, client); + + return ret; +} + +static int player_disp_get_track_count(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_GET_TRACK_COUNT; + player_stream_type_e type; + int count; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + player_msg_get(type, mmsvc_core_client_get_msg(client)); + + ret = player_get_track_count((player_h) handle, type, &count); + if(ret == PLAYER_ERROR_NONE) { + player_msg_return1(api, ret, client, INT, count); + } + else + player_msg_return(api, ret, client); + + return ret; +} + +static int player_disp_get_current_track(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_GET_CURRENT_TRACK; + player_stream_type_e type; + int index; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + player_msg_get(type, mmsvc_core_client_get_msg(client)); + + ret = player_get_current_track((player_h) handle, type, &index); + if(ret == PLAYER_ERROR_NONE) { + player_msg_return1(api, ret, client, INT, index); + } + else + player_msg_return(api, ret, client); + + return ret; +} + +static int player_disp_select_track(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_SELECT_TRACK; + player_stream_type_e type; + int index; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + player_msg_get(type, mmsvc_core_client_get_msg(client)); + player_msg_get(index, mmsvc_core_client_get_msg(client)); + + ret = player_select_track((player_h) handle, type, index); + player_msg_return(api, ret, client); + + return ret; +} + +static int player_disp_get_track_language_code(Client client) +{ + int ret = -1; + intptr_t handle; + mm_player_api_e api = MM_PLAYER_API_GET_TRACK_LANGUAGE_CODE; + player_stream_type_e type; + int index; + char *code; + const int code_len=2; + + player_msg_get_type(handle, mmsvc_core_client_get_msg(client), POINTER); + player_msg_get(type, mmsvc_core_client_get_msg(client)); + player_msg_get(index, mmsvc_core_client_get_msg(client)); + + ret = player_get_track_language_code((player_h) handle, type, index, &code); + if(ret == PLAYER_ERROR_NONE) { + player_msg_return_array(api, ret, client, code, code_len, sizeof(char)); + } + else + player_msg_return(api, ret, client); + + return ret; +} + +int (*dispatcher[MM_PLAYER_API_MAX]) (Client client) = { + player_disp_create, /* MM_PLAYER_API_CREATE */ + player_disp_destroy, /* MM_PLAYER_API_DESTROY */ + player_disp_prepare, /* MM_PLAYER_API_PREPARE */ + player_disp_prepare_async, /* MM_PLAYER_API_PREPARE_ASYNC */ + player_disp_unprepare, /* MM_PLAYER_API_UNPREPARE */ + player_disp_set_uri, /* MM_PLAYER_API_SET_URI */ + player_disp_start, /* MM_PLAYER_API_START */ + player_disp_stop, /* MM_PLAYER_API_STOP */ + player_disp_pause, /* MM_PLAYER_API_PAUSE */ + player_disp_set_memory_buffer, /* MM_PLAYER_API_SET_MEMORY_BUFFER */ + player_disp_deinit_memory_buffer, /* MM_PLAYER_API_DEINIT_MEMORY_BUFFER */ + player_disp_get_state, /* MM_PLAYER_API_GET_STATE */ + player_disp_set_volume, /* MM_PLAYER_API_SET_VOLUME */ + player_disp_get_volume, /* MM_PLAYER_API_GET_VOLUME */ + player_disp_set_sound_type, /* MM_PLAYER_API_SET_SOUND_TYPE */ +#ifndef USE_ASM + player_disp_set_audio_policy_info, /* MM_PLAYER_API_SET_AUDIO_POLICY_INFO */ +#endif + player_disp_set_latency_mode, /* MM_PLAYER_API_SET_AUDIO_LATENCY_MODE */ + player_disp_get_latency_mode, /* MM_PLAYER_API_GET_AUDIO_LATENCY_MODE */ + player_disp_set_play_position, /* MM_PLAYER_API_SET_PLAY_POSITION */ + player_disp_get_play_position, /* MM_PLAYER_API_GET_PLAY_POSITION */ + player_disp_set_mute, /* MM_PLAYER_API_SET_MUTE */ + player_disp_is_muted, /* MM_PLAYER_API_IS_MUTED */ + player_disp_set_looping, /* MM_PLAYER_API_SET_LOOPING */ + player_disp_is_looping, /* MM_PLAYER_API_IS_LOOPING */ + player_disp_get_duration, /* MM_PLAYER_API_GET_DURATION */ + player_disp_set_display, /* MM_PLAYER_API_SET_DISPLAY */ + player_disp_set_display_mode, /* MM_PLAYER_API_SET_DISPLAY_MODE */ + player_disp_get_display_mode, /* MM_PLAYER_API_GET_DISPLAY_MODE */ + player_disp_set_playback_rate, /* MM_PLAYER_API_SET_PLAYBACK_RATE */ + player_disp_set_display_rotation, /* MM_PLAYER_API_SET_DISPLAY_ROTATION */ + player_disp_get_display_rotation, /* MM_PLAYER_API_GET_DISPLAY_ROTATION */ + player_disp_set_display_visible, /* MM_PLAYER_API_SET_DISPLAY_VISIBLE */ + player_disp_is_display_visible, /* MM_PLAYER_API_IS_DISPLAY_VISIBLE */ + player_disp_get_content_info, /* MM_PLAYER_API_GET_CONTENT_INFO */ + player_disp_get_codec_info, /* MM_PLAYER_API_GET_CODEC_INFO */ + player_disp_get_audio_stream_info, /* MM_PLAYER_API_GET_AUDIO_STREAM_INFO */ + player_disp_get_video_stream_info, /* MM_PLAYER_API_GET_VIDEO_STREAM_INFO */ + player_disp_get_video_size, /* MM_PLAYER_API_GET_VIDEO_SIZE */ + player_disp_get_album_art, /* MM_PLAYER_API_GET_ALBUM_ART */ + player_disp_get_eq_bands_count, /* MM_PLAYER_API_AUDIO_EFFECT_GET_EQUALIZER_BANDS_COUNT */ + player_disp_set_eq_all_bands, /* MM_PLAYER_API_AUDIO_EFFECT_SET_EQUALIZER_ALL_BANDS */ + player_disp_set_eq_band_level, /* MM_PLAYER_API_AUDIO_EFFECT_SET_EQUALIZER_BAND_LEVEL */ + player_disp_get_eq_band_level, /* MM_PLAYER_API_AUDIO_EFFECT_GET_EQUALIZER_BAND_LEVEL */ + player_disp_get_eq_level_range, /* MM_PLAYER_API_AUDIO_EFFECT_GET_EQUALIZER_LEVEL_RANGE */ + player_disp_get_eq_band_frequency, /* MM_PLAYER_API_AUDIO_EFFECT_GET_EQUALIZER_BAND_FREQUENCY */ + player_disp_get_eq_band_frequency_range, /* MM_PLAYER_API_AUDIO_EFFECT_GET_EQUALIZER_BAND_FREQUENCY_RANGE */ + player_disp_eq_clear, /* MM_PLAYER_API_AUDIO_EFFECT_EQUALIZER_CLEAR */ + player_disp_eq_is_available, /* MM_PLAYER_API_AUDIO_EFFECT_EQUALIZER_IS_AVAILABLE */ + player_disp_set_progressive_download_path, /* MM_PLAYER_API_SET_PROGRESSIVE_DOWNLOAD_PATH */ + player_disp_get_progressive_download_status, /* MM_PLAYER_API_GET_PROGRESSIVE_DOWNLOAD_STATUS */ + player_disp_capture_video, /* MM_PLAYER_API_CAPTURE_VIDEO */ + player_disp_set_streaming_cookie, /* MM_PLAYER_API_SET_STREAMING_COOKIE */ + player_disp_set_streaming_user_agent, /* MM_PLAYER_API_SET_STREAMING_USER_AGENT */ + player_disp_get_streaming_download_progress, /* MM_PLAYER_API_GET_STREAMING_DOWNLOAD_PROGRESS */ + player_disp_set_subtitle_path, /* MM_PLAYER_API_SET_SUBTITLE_PATH */ + player_disp_set_subtitle_position_offset, /* MM_PLAYER_API_SET_SUBTITLE_POSITION_OFFSET */ + player_disp_push_media_stream, /* MM_PLAYER_API_PUSH_MEDIA_STREAM */ + player_disp_set_media_stream_info, /* MM_PLAYER_API_SET_MEDIA_STREAM_INFO */ + player_disp_set_callback, /* MM_PLAYER_API_SET_CALLBACK */ + player_disp_media_packet_finalize_cb, /* MM_PLAYER_API_MEDIA_PACKET_FINALIZE_CB */ + player_disp_set_media_stream_buffer_max_size, /* MM_PLAYER_API_SET_MEDIA_STREAM_BUFFER_MAX_SIZE */ + player_disp_get_media_stream_buffer_max_size, /* MM_PLAYER_API_GET_MEDIA_STREAM_BUFFER_MAX_SIZE */ + player_disp_set_media_stream_buffer_min_threshold, /* MM_PLAYER_API_SET_MEDIA_STREAM_BUFFER_MIN_THRESHOLD */ + player_disp_get_media_stream_buffer_min_threshold, /* MM_PLAYER_API_GET_MEDIA_STREAM_BUFFER_MIN_THRESHOLD */ + player_disp_get_track_count, /* MM_PLAYER_API_GET_TRACK_COUNT */ + player_disp_get_current_track, /* MM_PLAYER_API_GET_CURRENT_TRACK */ + player_disp_select_track, /* MM_PLAYER_API_SELECT_TRACK */ + player_disp_get_track_language_code, /* MM_PLAYER_API_GET_TRACK_LANGUAGE_CODE */ +}; +