From a47368698aaed5bef3eb35ececf9f990548d9970 Mon Sep 17 00:00:00 2001 From: Eunhae Choi Date: Wed, 17 Feb 2016 17:18:37 +0900 Subject: [PATCH] rearrange the layer structure of player modules Change-Id: I68e667c08a73a5b93db1d2c410116de3722d366f --- AUTHORS | 3 +- CMakeLists.txt | 11 +- ...i-media-player.pc.in => capi-media-player.pc.in | 0 include/mobile/player_internal.h | 5 +- include/player_private.h | 225 +- include/player_wayland.h | 47 + include/wearable/player_internal.h | 5 +- ...ia-player.changes => capi-media-player.changes} | 0 ...-player.manifest => capi-media-player.manifest} | 0 ...pi-media-player.spec => capi-media-player.spec} | 38 +- src/player.c | 4256 ++++++++++---------- src/player_internal.c | 309 +- src/player_priv.c | 350 -- src/player_wayland.c | 150 + test/CMakeLists.txt | 9 +- ...player_es_push_test.c => player_es_push_test.c} | 34 +- ...ia_packet_test.c => player_media_packet_test.c} | 17 +- test/{legacy_player_test.c => player_test.c} | 592 ++- 18 files changed, 3048 insertions(+), 3003 deletions(-) rename legacy-capi-media-player.pc.in => capi-media-player.pc.in (100%) create mode 100644 include/player_wayland.h rename packaging/{legacy-capi-media-player.changes => capi-media-player.changes} (100%) rename packaging/{legacy-capi-media-player.manifest => capi-media-player.manifest} (100%) rename packaging/{legacy-capi-media-player.spec => capi-media-player.spec} (70%) delete mode 100644 src/player_priv.c create mode 100644 src/player_wayland.c rename test/{legacy_player_es_push_test.c => player_es_push_test.c} (95%) rename test/{legacy_player_media_packet_test.c => player_media_packet_test.c} (95%) rename test/{legacy_player_test.c => player_test.c} (78%) diff --git a/AUTHORS b/AUTHORS index 68b49ae..81fabf6 100644 --- a/AUTHORS +++ b/AUTHORS @@ -1,2 +1 @@ -Kangho Hur -Seungkeun Lee +Heechul Jeon \ No newline at end of file diff --git a/CMakeLists.txt b/CMakeLists.txt index 838b88f..a7e37d6 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,6 +1,6 @@ CMAKE_MINIMUM_REQUIRED(VERSION 2.6) -SET(fw_name "legacy-capi-media-player") +SET(fw_name "capi-media-player") PROJECT(${fw_name}) @@ -19,8 +19,7 @@ SET(INC_COM_DIR include) INCLUDE_DIRECTORIES(${INC_DIR}, ${INC_COM_DIR}) -SET(dependents "libtbm capi-media-tool dlog mm-player capi-base-common capi-media-sound-manager gstreamer-1.0 evas ecore elementary capi-system-info mm-sound") -SET(pc_dependents "libtbm capi-media-tool capi-base-common capi-media-sound-manager") +SET(dependents "dlog libtbm capi-media-tool mused mmsvc-player mm-common tizen-extension-client evas elementary") INCLUDE(FindPkgConfig) pkg_check_modules(${fw_name} REQUIRED ${dependents}) @@ -28,7 +27,7 @@ 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-deprecated -Wno-deprecated-declarations -DGST_EXT_TIME_ANALYSIS") +SET(CMAKE_C_FLAGS "-I./${INC_DIR} ${CMAKE_C_FLAGS} ${EXTRA_CFLAGS} -fPIC -Wall -Werror -Wno-deprecated -Wno-deprecated-declarations") SET(CMAKE_C_FLAGS_DEBUG "-O0 -g") IF("${ARCH}" STREQUAL "arm") @@ -51,9 +50,7 @@ ENDIF(TIZEN_MOBILE) SET(CMAKE_EXE_LINKER_FLAGS "-Wl,--as-needed -Wl,--rpath=${LIB_INSTALL_DIR}") -#aux_source_directory(src SOURCES) -SET(SOURCES src/player.c src/player_internal.c src/player_priv.c) - +aux_source_directory(src SOURCES) ADD_LIBRARY(${fw_name} SHARED ${SOURCES}) TARGET_LINK_LIBRARIES(${fw_name} ${${fw_name}_LDFLAGS}) diff --git a/legacy-capi-media-player.pc.in b/capi-media-player.pc.in similarity index 100% rename from legacy-capi-media-player.pc.in rename to capi-media-player.pc.in diff --git a/include/mobile/player_internal.h b/include/mobile/player_internal.h index 6f168ff..691233a 100644 --- a/include/mobile/player_internal.h +++ b/include/mobile/player_internal.h @@ -17,7 +17,6 @@ #ifndef __TIZEN_MEDIA_PLAYER_INTERNAL_H__ #define __TIZEN_MEDIA_PLAYER_INTERNAL_H__ #include -#include #ifdef __cplusplus extern "C" { #endif @@ -42,7 +41,7 @@ typedef struct { int rate; /**< Samplerate */ int depth; /**< Depth */ bool little_endian; /**< Endianness */ - guint64 channel_mask; /**< channel_mask */ + unsigned long long channel_mask; /**< channel_mask */ } player_audio_raw_data_s; /** @@ -165,6 +164,6 @@ int player_unset_media_stream_buffer_status_cb_ex(player_h player, player_stream } #endif -#endif //__TIZEN_MEDIA_PLAYER_PRODUCT_H__ +#endif //__TIZEN_MEDIA_PLAYER_INTERNAL_H__ diff --git a/include/player_private.h b/include/player_private.h index 56d43f4..fb9a992 100644 --- a/include/player_private.h +++ b/include/player_private.h @@ -16,9 +16,12 @@ #ifndef __TIZEN_MEDIA_PLAYER_PRIVATE_H__ #define __TIZEN_MEDIA_PLAYER_PRIVATE_H__ -#include -#include -#include +#include +#include +#include +#include +#include "player.h" +#include "player_wayland.h" #ifdef __cplusplus extern "C" { @@ -28,7 +31,6 @@ extern "C" { #undef LOG_TAG #endif #define LOG_TAG "TIZEN_N_PLAYER" -//#define USE_ECORE_FUNCTIONS #define PLAYER_CHECK_CONDITION(condition,error,msg) \ if(condition) {} else \ @@ -43,139 +45,90 @@ extern "C" { #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") - -#ifdef TIZEN_TTRACE -#include -#define PLAYER_TRACE_BEGIN(NAME) traceBegin(TTRACE_TAG_VIDEO, NAME) -#define PLAYER_TRACE_END() traceEnd(TTRACE_TAG_VIDEO) -#define PLAYER_TRACE_ASYNC_BEGIN(NAME, COOKIE) traceAsyncBegin (TTRACE_TAG_VIDEO, COOKIE, NAME); -#define PLAYER_TRACE_ASYNC_END(NAME, COOKIE) traceAsyncEnd(TTRACE_TAG_VIDEO, COOKIE, NAME); -#else -#define PLAYER_TRACE_BEGIN(NAME) -#define PLAYER_TRACE_END() -#define PLAYER_TRACE_ASYNC_BEGIN(NAME, KEY) -#define PLAYER_TRACE_ASYNC_END(NAME, KEY) -#endif - -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_BUFFER_STATUS_WITH_INFO, - _PLAYER_EVENT_TYPE_MEDIA_STREAM_AUDIO_BUFFER_STATUS_WITH_INFO, - _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_VIDEO_BIN_CREATED, - _PLAYER_EVENT_TYPE_NUM -}_player_event_e; - -#ifndef USE_ECORE_FUNCTIONS -typedef enum { - PLAYER_MESSAGE_NONE, - PLAYER_MESSAGE_PREPARED, - PLAYER_MESSAGE_ERROR, - PLAYER_MESSAGE_SEEK_DONE, - PLAYER_MESSAGE_EOS, - PLAYER_MESSAGE_LOOP_EXIT, - PLAYER_MESSAGE_MAX -}_player_message_e; -#endif - -typedef struct _player_s{ - MMHandleType mm_handle; - const void* user_cb[_PLAYER_EVENT_TYPE_NUM]; - void* user_data[_PLAYER_EVENT_TYPE_NUM]; -#ifdef HAVE_WAYLAND - void* wl_display; -#endif - 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; -#ifdef USE_ECORE_FUNCTIONS - GHashTable *ecore_jobs; -#else - pthread_t message_thread; - GQueue *message_queue; - GMutex message_queue_lock; - GCond message_queue_cond; - int current_message; -#endif - player_error_e error_code; - bool is_doing_jobs; +#define CALLBACK_TIME_OUT 5 + + +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 qlock; + 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[MUSE_PLAYER_EVENT_TYPE_NUM]; + gpointer user_data[MUSE_PLAYER_EVENT_TYPE_NUM]; + GMutex player_mutex; + GCond player_cond[MUSE_PLAYER_API_MAX]; + msg_buff_s buff; + player_event_queue event_queue; media_format_h pkt_fmt; -} player_s; - -int __player_convert_error_code(int code, char* func_name); -bool __player_state_validate(player_s * handle, player_state_e threshold); -int player_sound_register(player_h player, int pid); -int player_is_streaming(player_h player, bool *is_streaming); - -/** - * @brief Called when the video sink bin is crated. - * @since_tizen 3.0 - * @param[out] caps video sink current caps - * @param[out ] user_data The user data passed from the callback registration function - * @see player_set_vidoe_bin_created_cb() - * @see player_unset_vidoe_bin_created_cb() - */ -typedef void (*player_video_bin_created_cb)(const char *caps, void *user_data); - -/** - * @brief Registers a callback function to be invoked when video sink bin is created. - * @since_tizen 3.0 - * @param[in] player The handle to the media player - * @param[in] callback The callback function to register - * @param[in] user_data The user data to be passed to the callback function - * @return @c 0 on success, - * otherwise a negative error value - * @retval #PLAYER_ERROR_NONE Successful - * @retval #PLAYER_ERROR_INVALID_PARAMETER Invalid parameter - * @post player_video_bin_created_cb() will be invoked. - * @see player_unset_vidoe_bin_created_cb() - */ -int player_set_video_bin_created_cb(player_h player, player_video_bin_created_cb callback, void *user_data); - -/** - * @brief Unregisters a callback function to be invoked when video sink bin is created. - * @since_tizen 3.0 - * @param[in] player The handle to the media player - * @return @c 0 on success, - * otherwise a negative error value - * @retval #PLAYER_ERROR_NONE Successful - * @retval #PLAYER_ERROR_INVALID_PARAMETER Invalid parameter - * @post player_video_bin_created_cb() will be invoked. - * @see player_unset_vidoe_bin_created_cb() - */ -int player_unset_video_bin_created_cb(player_h player); - +// MMHandleType local_handle; + tbm_bufmgr bufmgr; +} callback_cb_info_s; + +typedef struct { + intptr_t bo; + gboolean is_streaming; + gint timeout; +} server_info_s; // to check + +typedef struct _player_cli_s{ + callback_cb_info_s *cb_info; + player_data_s *head; + server_info_s server; + wl_client *wlclient; + Evas_Object * eo; + gboolean have_evas_callback; +} player_cli_s; + +/* Internal handle */ +#define INT_HANDLE(h) ((h)->cb_info->local_handle) + +/* player callback infomatnio */ +#define CALLBACK_INFO(h) ((h)->cb_info) +/* MSG Channel socket fd */ +#define MSG_FD(h) (CALLBACK_INFO(h)->fd) +/* Data Channel socket fd */ +#define DATA_FD(h) (CALLBACK_INFO(h)->data_fd) +/* TBM buffer manager */ +#define TBM_BUFMGR(h) (CALLBACK_INFO(h)->bufmgr) + +/* server tbm bo */ +#define SERVER_TBM_BO(h) ((h)->server.bo) +/* content type is streaming */ +#define IS_STREAMING_CONTENT(h) ((h)->server.is_streaming) +/* server state change timeout */ +#define SERVER_TIMEOUT(h) ((h)->server.timeout) + +int _get_api_timeout(player_cli_s *pc, muse_player_api_e api); +int wait_for_cb_return(muse_player_api_e api, callback_cb_info_s *cb_info, char **ret_buf, int time_out); +int player_set_evas_object_cb(player_h player, Evas_Object * eo); +int player_unset_evas_object_cb(player_h player); #ifdef __cplusplus } diff --git a/include/player_wayland.h b/include/player_wayland.h new file mode 100644 index 0000000..db2b348 --- /dev/null +++ b/include/player_wayland.h @@ -0,0 +1,47 @@ +/* +* 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_WLCLIENT_H__ +#define __TIZEN_MEDIA_PLAYER_WLCLIENT_H__ +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + +typedef struct +{ + struct wl_display *display; + struct wl_registry *registry; + struct tizen_surface *tz_surface; + struct tizen_resource *tz_resource; +} wl_client; +int _wlclient_create (wl_client ** wlclient); +int _wlclient_get_wl_window_wl_surface_id (wl_client * wlclient, struct wl_surface *surface, struct wl_display *display); +void _wlclient_finalize (wl_client * wlclient); + +#ifdef __cplusplus +} +#endif + +#endif /* __TIZEN_MEDIA_PLAYER_WLCLIENT_H__ */ diff --git a/include/wearable/player_internal.h b/include/wearable/player_internal.h index 6f168ff..691233a 100644 --- a/include/wearable/player_internal.h +++ b/include/wearable/player_internal.h @@ -17,7 +17,6 @@ #ifndef __TIZEN_MEDIA_PLAYER_INTERNAL_H__ #define __TIZEN_MEDIA_PLAYER_INTERNAL_H__ #include -#include #ifdef __cplusplus extern "C" { #endif @@ -42,7 +41,7 @@ typedef struct { int rate; /**< Samplerate */ int depth; /**< Depth */ bool little_endian; /**< Endianness */ - guint64 channel_mask; /**< channel_mask */ + unsigned long long channel_mask; /**< channel_mask */ } player_audio_raw_data_s; /** @@ -165,6 +164,6 @@ int player_unset_media_stream_buffer_status_cb_ex(player_h player, player_stream } #endif -#endif //__TIZEN_MEDIA_PLAYER_PRODUCT_H__ +#endif //__TIZEN_MEDIA_PLAYER_INTERNAL_H__ diff --git a/packaging/legacy-capi-media-player.changes b/packaging/capi-media-player.changes similarity index 100% rename from packaging/legacy-capi-media-player.changes rename to packaging/capi-media-player.changes diff --git a/packaging/legacy-capi-media-player.manifest b/packaging/capi-media-player.manifest similarity index 100% rename from packaging/legacy-capi-media-player.manifest rename to packaging/capi-media-player.manifest diff --git a/packaging/legacy-capi-media-player.spec b/packaging/capi-media-player.spec similarity index 70% rename from packaging/legacy-capi-media-player.spec rename to packaging/capi-media-player.spec index 84164fd..92d99c1 100644 --- a/packaging/legacy-capi-media-player.spec +++ b/packaging/capi-media-player.spec @@ -1,21 +1,21 @@ %bcond_with wayland %bcond_with x -Name: legacy-capi-media-player -Summary: A Media Player library in Tizen Native API -Version: 0.2.8 +Name: capi-media-player +Summary: A Media Player API +Version: 0.3.4 Release: 0 Group: Multimedia/API License: Apache-2.0 Source0: %{name}-%{version}.tar.gz -Source1001: legacy-capi-media-player.manifest +Source1001: capi-media-player.manifest BuildRequires: cmake -BuildRequires: pkgconfig(gstreamer-1.0) -BuildRequires: pkgconfig(gstreamer-plugins-base-1.0) BuildRequires: pkgconfig(dlog) -BuildRequires: pkgconfig(mm-player) +BuildRequires: pkgconfig(mused) +BuildRequires: pkgconfig(mm-common) BuildRequires: pkgconfig(capi-base-common) BuildRequires: pkgconfig(capi-media-sound-manager) +BuildRequires: pkgconfig(tizen-extension-client) BuildRequires: pkgconfig(appcore-efl) BuildRequires: pkgconfig(elementary) BuildRequires: pkgconfig(ecore) @@ -27,10 +27,10 @@ BuildRequires: pkgconfig(ecore-x) BuildRequires: pkgconfig(ecore-wayland) %endif BuildRequires: pkgconfig(capi-media-tool) +BuildRequires: pkgconfig(mmsvc-player) +BuildRequires: pkgconfig(json-c) BuildRequires: pkgconfig(libtbm) -#BuildRequires: pkgconfig(ttrace) -BuildRequires: pkgconfig(capi-system-info) -BuildRequires: pkgconfig(mm-sound) +BuildRequires: pkgconfig(eom) Requires(post): /sbin/ldconfig Requires(postun): /sbin/ldconfig @@ -83,12 +83,10 @@ 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 test/legacy_player_test %{buildroot}/usr/bin -cp test/legacy_player_media_packet_test %{buildroot}/usr/bin -cp test/legacy_player_es_push_test %{buildroot}/usr/bin +cp test/player_test %{buildroot}/usr/bin +cp test/player_media_packet_test %{buildroot}/usr/bin +cp test/player_es_push_test %{buildroot}/usr/bin %make_install @@ -100,15 +98,13 @@ cp test/legacy_player_es_push_test %{buildroot}/usr/bin %files %manifest %{name}.manifest %license LICENSE.APLv2 -%manifest legacy-capi-media-player.manifest -%{_libdir}/liblegacy-capi-media-player.so.* -%{_datadir}/license/%{name} +%{_libdir}/libcapi-media-player.so.* %{_bindir}/* %files devel %manifest %{name}.manifest -%{_includedir}/media/*.h +%{_includedir}/media/player.h +%{_includedir}/media/player_internal.h %{_libdir}/pkgconfig/*.pc -%{_libdir}/liblegacy-capi-media-player.so - +%{_libdir}/libcapi-media-player.so diff --git a/src/player.c b/src/player.c index b5c3110..b88ca63 100644 --- a/src/player.c +++ b/src/player.c @@ -17,111 +17,86 @@ #include #include #include -#include -#include -#include -#include -#include -#include -#include -#include -#include +#include +#include +#include +#include +#include #include -#include #include #include #ifdef HAVE_WAYLAND #include #endif -#include -#include -#include - -#define __JOB_KEY_PREPARED "prepared" -#define __JOB_KEY_ERROR "error" -#define __JOB_KEY_SEEK_DONE "seek_done" -#define __JOB_KEY_EOS "eos" - -#define __RELEASEIF_PREPARE_THREAD(thread_id) \ - do { \ - if (thread_id) { \ - pthread_join(thread_id, NULL); \ - thread_id = 0; \ - LOGI("prepare thread released\n"); \ - } \ - } while (0) - -#ifndef USE_ECORE_FUNCTIONS -#define __RELEASEIF_MESSAGE_THREAD(thread_id) \ - do { \ - if (thread_id) { \ - pthread_join(thread_id, NULL); \ - thread_id = 0; \ - LOGI("message thread released\n"); \ - } \ - } while (0) -#endif +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "player_internal.h" +#include "player_private.h" -#ifdef USE_ECORE_FUNCTIONS -#define __DELETE_ECORE_ITEM(ecore_job) \ - do { \ - if (ecore_job) { \ - ecore_job_del(ecore_job); \ - ecore_job = NULL; \ - } \ - } while (0) - -#define __ADD_ECORE_JOB(handle, key, job_callback) \ - do { \ - Ecore_Job *job = NULL; \ - job = ecore_job_add(job_callback, (void *)handle); \ - LOGI("adding %s job - %p\n", key, job); \ - g_hash_table_insert(handle->ecore_jobs, g_strdup(key), job); \ - } while (0) - -#define __REMOVE_ECORE_JOB(handle, job_key) \ - do { \ - LOGI("%s done so, remove\n", job_key); \ - g_hash_table_remove(handle->ecore_jobs, job_key); \ - handle->is_doing_jobs = FALSE; \ - } while (0) -#else -#define __GET_MESSAGE(handle) \ - do { \ - if (handle && handle->message_queue) { \ - g_mutex_lock(&handle->message_queue_lock); \ - if (g_queue_is_empty(handle->message_queue)) { \ - g_cond_wait(&handle->message_queue_cond, &handle->message_queue_lock); \ - } \ - handle->current_message = (int)(intptr_t)g_queue_pop_head(handle->message_queue); \ - g_mutex_unlock(&handle->message_queue_lock); \ - LOGI("Retrived message [%d] from queue", handle->current_message); \ - } else { \ - LOGI("Failed to retrive message from queue"); \ - handle->current_message = PLAYER_MESSAGE_NONE; \ - } \ - } while (0) - -#define __ADD_MESSAGE(handle, message) \ - do { \ - if (handle && handle->message_queue) { \ - g_mutex_lock(&handle->message_queue_lock); \ - if (message == PLAYER_MESSAGE_LOOP_EXIT) \ - g_queue_clear(handle->message_queue); \ - g_queue_push_tail(handle->message_queue, (gpointer)message); \ - g_cond_signal(&handle->message_queue_cond); \ - g_mutex_unlock(&handle->message_queue_lock); \ - LOGI("Adding message [%d] to queue", message); \ - } else { \ - LOGI("Failed to add message [%d] to queue", message); \ - } \ - } while (0) -#endif +typedef struct { + int int_data; + char *buf; + callback_cb_info_s *cb_info; +} _player_cb_data; + +typedef struct { + intptr_t remote_pkt; + callback_cb_info_s *cb_info; +} _media_pkt_fin_data; + +/* + Global varialbe +*/ /* * Internal Implementation */ -int __player_convert_error_code(int code, char *func_name) +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; + muse_player_api_e api = MUSE_PLAYER_API_MEDIA_PACKET_FINALIZE_CB; + _media_pkt_fin_data *fin_data = (_media_pkt_fin_data *)user_data; + intptr_t 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 = muse_core_msg_json_factory_new(api, MUSE_TYPE_POINTER, "packet", packet, 0); + muse_core_ipc_send_msg(fin_data->cb_info->fd, sndMsg); + muse_core_msg_json_factory_free(sndMsg); + + g_free(fin_data); + + return MEDIA_PACKET_FINALIZE; +} + +static int __player_convert_error_code(int code, char *func_name) { int ret = PLAYER_ERROR_INVALID_OPERATION; char *msg = "PLAYER_ERROR_INVALID_OPERATION"; @@ -252,1129 +227,1116 @@ int __player_convert_error_code(int code, char *func_name) case MM_ERROR_PLAYER_PERMISSION_DENIED: ret = PLAYER_ERROR_PERMISSION_DENIED; msg = "PLAYER_ERROR_PERMISSION_DENIED"; - break; - case MM_ERROR_PLAYER_BUFFER_SPACE: - ret = PLAYER_ERROR_BUFFER_SPACE; - msg = "PLAYER_ERROR_BUFFER_SPACE"; - break; - default: - break; } LOGE("[%s] %s(0x%08x) : core fw error(0x%x)", func_name, msg, ret, code); return ret; } -int _player_get_tbm_surface_format(int in_format, uint32_t *out_format) +static void *_get_mem(player_cli_s *player, int size) { - if (in_format <= MM_PIXEL_FORMAT_INVALID || in_format >= MM_PIXEL_FORMAT_NUM || out_format == NULL) { - LOGE("INVALID_PARAMETER : in_format %d, out_format ptr %p", in_format, out_format); - return PLAYER_ERROR_INVALID_PARAMETER; + 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; +} - switch (in_format) { - case MM_PIXEL_FORMAT_NV12: - case MM_PIXEL_FORMAT_NV12T: - *out_format = TBM_FORMAT_NV12; - break; - case MM_PIXEL_FORMAT_NV16: - *out_format = TBM_FORMAT_NV16; - break; - case MM_PIXEL_FORMAT_NV21: - *out_format = TBM_FORMAT_NV21; - break; - case MM_PIXEL_FORMAT_YUYV: - *out_format = TBM_FORMAT_YUYV; - break; - case MM_PIXEL_FORMAT_UYVY: - case MM_PIXEL_FORMAT_ITLV_JPEG_UYVY: - *out_format = TBM_FORMAT_UYVY; - break; - case MM_PIXEL_FORMAT_422P: - *out_format = TBM_FORMAT_YUV422; - break; - case MM_PIXEL_FORMAT_I420: - *out_format = TBM_FORMAT_YUV420; - break; - case MM_PIXEL_FORMAT_YV12: - *out_format = TBM_FORMAT_YVU420; - break; - case MM_PIXEL_FORMAT_RGB565: - *out_format = TBM_FORMAT_RGB565; - break; - case MM_PIXEL_FORMAT_RGB888: - *out_format = TBM_FORMAT_RGB888; - break; - case MM_PIXEL_FORMAT_RGBA: - *out_format = TBM_FORMAT_RGBA8888; - break; - case MM_PIXEL_FORMAT_ARGB: - *out_format = TBM_FORMAT_ARGB8888; - break; - default: - LOGE("invalid in_format %d", in_format); - return PLAYER_ERROR_INVALID_PARAMETER; +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; } - - return PLAYER_ERROR_NONE; } -int _player_get_media_packet_mimetype(int in_format, media_format_mimetype_e *mimetype) +static int player_recv_msg(callback_cb_info_s *cb_info, int len) { - if (in_format <= MM_PIXEL_FORMAT_INVALID || in_format >= MM_PIXEL_FORMAT_NUM || mimetype == NULL) { - LOGE("INVALID_PARAMETER : in_format %d, mimetype ptr %p", in_format, mimetype); - return PLAYER_ERROR_INVALID_PARAMETER; - } + int recvLen; + msg_buff_s *buff = &cb_info->buff; + char *new; - switch (in_format) { - case MM_PIXEL_FORMAT_NV12: - case MM_PIXEL_FORMAT_NV12T: - *mimetype = MEDIA_FORMAT_NV12; - break; - case MM_PIXEL_FORMAT_NV16: - *mimetype = MEDIA_FORMAT_NV16; - break; - case MM_PIXEL_FORMAT_NV21: - *mimetype = MEDIA_FORMAT_NV21; - break; - case MM_PIXEL_FORMAT_YUYV: - *mimetype = MEDIA_FORMAT_YUYV; - break; - case MM_PIXEL_FORMAT_UYVY: - case MM_PIXEL_FORMAT_ITLV_JPEG_UYVY: - *mimetype = MEDIA_FORMAT_UYVY; - break; - case MM_PIXEL_FORMAT_422P: - *mimetype = MEDIA_FORMAT_422P; - break; - case MM_PIXEL_FORMAT_I420: - *mimetype = MEDIA_FORMAT_I420; - break; - case MM_PIXEL_FORMAT_YV12: - *mimetype = MEDIA_FORMAT_YV12; - break; - case MM_PIXEL_FORMAT_RGB565: - *mimetype = MEDIA_FORMAT_RGB565; - break; - case MM_PIXEL_FORMAT_RGB888: - *mimetype = MEDIA_FORMAT_RGB888; - break; - case MM_PIXEL_FORMAT_RGBA: - *mimetype = MEDIA_FORMAT_RGBA; - break; - case MM_PIXEL_FORMAT_ARGB: - *mimetype = MEDIA_FORMAT_ARGB; - break; - default: - LOGE("invalid in_format %d", in_format); - return PLAYER_ERROR_INVALID_PARAMETER; + if (len && buff->bufLen - MUSE_MSG_MAX_LENGTH <= len) { + LOGD("realloc Buffer %d -> %d, Msg Length %d", buff->bufLen, buff->bufLen + MUSE_MSG_MAX_LENGTH, len); + buff->bufLen += MUSE_MSG_MAX_LENGTH; + new = g_renew(char, buff->recvMsg, buff->bufLen); + if (new && new != buff->recvMsg) + buff->recvMsg = new; } - return PLAYER_ERROR_NONE; + recvLen = muse_core_ipc_recv_msg(cb_info->fd, buff->recvMsg + len); + len += recvLen; + + return len; } -int _player_media_packet_finalize(media_packet_h pkt, int error_code, void *user_data) +static void set_null_user_cb(callback_cb_info_s *cb_info, muse_player_event_e event) { - int ret = 0; - void *internal_buffer = NULL; - tbm_surface_h tsurf = NULL; - - 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_extra(pkt, &internal_buffer); - if (ret != MEDIA_PACKET_ERROR_NONE) { - LOGE("media_packet_get_extra failed 0x%x", ret); - return MEDIA_PACKET_FINALIZE; + if (cb_info && event < MUSE_PLAYER_EVENT_TYPE_NUM) { + cb_info->user_cb[event] = NULL; + cb_info->user_data[event] = NULL; } +} - /* LOGD("pointer gst buffer %p, ret 0x%x", internal_buffer, ret); */ - mm_player_media_packet_video_stream_internal_buffer_unref(internal_buffer); +static void set_null_user_cb_lock(callback_cb_info_s *cb_info, muse_player_event_e event) +{ + bool lock = g_thread_self() != cb_info->event_queue.thread; - 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 (lock) + g_mutex_lock(&cb_info->event_queue.mutex); - if (tsurf) { - tbm_surface_destroy(tsurf); - tsurf = NULL; - } + set_null_user_cb(cb_info, event); - return MEDIA_PACKET_FINALIZE; + if (lock) + g_mutex_unlock(&cb_info->event_queue.mutex); } -static bool _player_network_availability_check() +static int __set_callback(muse_player_event_e type, player_h player, void *callback, void *user_data) { -#define _FEATURE_NAME_WIFI "http://tizen.org/feature/network.wifi" -#define _FEATURE_NAME_TELEPHONY "http://tizen.org/feature/network.telephony" -#define _FEATURE_NAME_ETHERNET "http://tizen.org/feature/network.ethernet" - bool enabled = FALSE; - bool supported = FALSE; + PLAYER_INSTANCE_CHECK(player); + PLAYER_NULL_ARG_CHECK(callback); + int ret = PLAYER_ERROR_NONE; + player_cli_s *pc = (player_cli_s *)player; + muse_player_api_e api = MUSE_PLAYER_API_SET_CALLBACK; + int set = 1; - if (SYSTEM_INFO_ERROR_NONE == system_info_get_platform_bool(_FEATURE_NAME_WIFI, &enabled)) { - LOGI("wifi status = %d", enabled); - if (enabled) - supported = TRUE; - } else { - LOGE("SYSTEM_INFO_ERROR"); - } + LOGI("Event type : %d ", type); + player_msg_set_callback(api, pc, ret, type, set); - if (SYSTEM_INFO_ERROR_NONE == system_info_get_platform_bool(_FEATURE_NAME_TELEPHONY, &enabled)) { - LOGI("telephony status = %d", enabled); - if (enabled) - supported = TRUE; - } else { - LOGE("SYSTEM_INFO_ERROR"); + if (ret == PLAYER_ERROR_NONE) { + pc->cb_info->user_cb[type] = callback; + pc->cb_info->user_data[type] = user_data; } + return ret; +} - if (SYSTEM_INFO_ERROR_NONE == system_info_get_platform_bool(_FEATURE_NAME_ETHERNET, &enabled)) { - LOGI("ethernet status = %d", enabled); - if (enabled) - supported = TRUE; - } else { - LOGE("SYSTEM_INFO_ERROR"); - } +static int __unset_callback(muse_player_event_e type, player_h player) +{ + PLAYER_INSTANCE_CHECK(player); + int ret = PLAYER_ERROR_NONE; + player_cli_s *pc = (player_cli_s *)player; + muse_player_api_e api = MUSE_PLAYER_API_SET_CALLBACK; + int set = 0; - if (!supported) - return FALSE; + LOGI("Event type : %d ", type); - return TRUE; -} + PLAYER_NULL_ARG_CHECK(CALLBACK_INFO(pc)); + set_null_user_cb_lock(CALLBACK_INFO(pc), type); + + player_msg_set_callback(api, pc, ret, type, set); + ret = PLAYER_ERROR_NONE; -static player_interrupted_code_e __convert_interrupted_code(int code) -{ - player_interrupted_code_e ret = PLAYER_INTERRUPTED_BY_RESOURCE_CONFLICT; - switch (code) { - case MM_MSG_CODE_INTERRUPTED_BY_CALL_END: - case MM_MSG_CODE_INTERRUPTED_BY_ALARM_END: - case MM_MSG_CODE_INTERRUPTED_BY_EMERGENCY_END: - case MM_MSG_CODE_INTERRUPTED_BY_NOTIFICATION_END: - ret = PLAYER_INTERRUPTED_COMPLETED; - break; - case MM_MSG_CODE_INTERRUPTED_BY_MEDIA: - case MM_MSG_CODE_INTERRUPTED_BY_OTHER_PLAYER_APP: - ret = PLAYER_INTERRUPTED_BY_MEDIA; - break; - case MM_MSG_CODE_INTERRUPTED_BY_CALL_START: - ret = PLAYER_INTERRUPTED_BY_CALL; - break; - case MM_MSG_CODE_INTERRUPTED_BY_EARJACK_UNPLUG: - ret = PLAYER_INTERRUPTED_BY_EARJACK_UNPLUG; - break; - case MM_MSG_CODE_INTERRUPTED_BY_ALARM_START: - ret = PLAYER_INTERRUPTED_BY_ALARM; - break; - case MM_MSG_CODE_INTERRUPTED_BY_NOTIFICATION_START: - ret = PLAYER_INTERRUPTED_BY_NOTIFICATION; - break; - case MM_MSG_CODE_INTERRUPTED_BY_EMERGENCY_START: - ret = PLAYER_INTERRUPTED_BY_EMERGENCY; - break; - case MM_MSG_CODE_INTERRUPTED_BY_RESOURCE_CONFLICT: - default: - ret = PLAYER_INTERRUPTED_BY_RESOURCE_CONFLICT; - break; - } - LOGE("[%s] interrupted code(%d) => ret(%d)", __FUNCTION__, code, ret); return ret; } -static player_state_e __convert_player_state(MMPlayerStateType state) +static void __prepare_cb_handler(callback_cb_info_s *cb_info, char *recvMsg) { - if (state == MM_PLAYER_STATE_NONE) - return PLAYER_STATE_NONE; - else - return state + 1; + muse_player_event_e ev = MUSE_PLAYER_EVENT_TYPE_PREPARE; + + ((player_prepared_cb)cb_info->user_cb[ev])(cb_info->user_data[ev]); + + set_null_user_cb(cb_info, ev); } -bool __player_state_validate(player_s *handle, player_state_e threshold) +static void __complete_cb_handler(callback_cb_info_s *cb_info, char *recvMsg) { - if (handle->state < threshold) - return FALSE; - return TRUE; + muse_player_event_e ev = MUSE_PLAYER_EVENT_TYPE_COMPLETE; + ((player_completed_cb)cb_info->user_cb[ev])(cb_info->user_data[ev]); } -static int __set_callback(_player_event_e type, player_h player, void *callback, void *user_data) +static void __interrupt_cb_handler(callback_cb_info_s *cb_info, char *recvMsg) { - PLAYER_INSTANCE_CHECK(player); - PLAYER_NULL_ARG_CHECK(callback); - if (_PLAYER_EVENT_TYPE_BUFFERING == type) { - if (!_player_network_availability_check()) - return PLAYER_ERROR_FEATURE_NOT_SUPPORTED_ON_DEVICE; - } + int code; + muse_player_event_e ev = MUSE_PLAYER_EVENT_TYPE_INTERRUPT; - player_s *handle = (player_s *)player; - handle->user_cb[type] = callback; - handle->user_data[type] = user_data; - LOGI("[%s] Event type : %d ", __FUNCTION__, type); - return PLAYER_ERROR_NONE; + if (player_msg_get(code, recvMsg)) + ((player_interrupted_cb)cb_info->user_cb[ev])(code, cb_info->user_data[ev]); } -static int __unset_callback(_player_event_e type, player_h player) +static void __error_cb_handler(callback_cb_info_s *cb_info, char *recvMsg) { - PLAYER_INSTANCE_CHECK(player); - player_s *handle = (player_s *)player; - handle->user_cb[type] = NULL; - handle->user_data[type] = NULL; - LOGI("[%s] Event type : %d ", __FUNCTION__, type); - return PLAYER_ERROR_NONE; -} + int code; + muse_player_event_e ev = MUSE_PLAYER_EVENT_TYPE_ERROR; -#ifdef USE_ECORE_FUNCTIONS -static void __job_prepared_cb(void *user_data) -{ - player_s *handle = (player_s *)user_data; - LOGI("Start"); - handle->is_doing_jobs = TRUE; - handle->state = PLAYER_STATE_READY; - ((player_prepared_cb)handle->user_cb[_PLAYER_EVENT_TYPE_PREPARE])(handle->user_data[_PLAYER_EVENT_TYPE_PREPARE]); - handle->user_cb[_PLAYER_EVENT_TYPE_PREPARE] = NULL; - handle->user_data[_PLAYER_EVENT_TYPE_PREPARE] = NULL; - __REMOVE_ECORE_JOB(handle, __JOB_KEY_PREPARED); - LOGI("End"); + if (player_msg_get(code, recvMsg)) + ((player_error_cb)cb_info->user_cb[ev])(code, cb_info->user_data[ev]); } -static void __job_error_cb(void *user_data) +static void __buffering_cb_handler(callback_cb_info_s *cb_info, char *recvMsg) { - player_s *handle = (player_s *)user_data; - LOGI("Start"); - handle->is_doing_jobs = TRUE; - ((player_error_cb)handle->user_cb[_PLAYER_EVENT_TYPE_ERROR])(handle->error_code, handle->user_data[_PLAYER_EVENT_TYPE_ERROR]); - __REMOVE_ECORE_JOB(handle, __JOB_KEY_ERROR); - LOGI("End"); -} + int percent; + muse_player_event_e ev = MUSE_PLAYER_EVENT_TYPE_BUFFERING; -static void __job_seek_done_cb(void *user_data) -{ - player_s *handle = (player_s *)user_data; - LOGI("Start"); - handle->is_doing_jobs = TRUE; - ((player_seek_completed_cb)handle->user_cb[_PLAYER_EVENT_TYPE_SEEK])(handle->user_data[_PLAYER_EVENT_TYPE_SEEK]); - handle->user_cb[_PLAYER_EVENT_TYPE_SEEK] = NULL; - handle->user_data[_PLAYER_EVENT_TYPE_SEEK] = NULL; - __REMOVE_ECORE_JOB(handle, __JOB_KEY_SEEK_DONE); - LOGI("End"); + if (player_msg_get(percent, recvMsg)) + ((player_buffering_cb)cb_info->user_cb[ev])(percent, cb_info->user_data[ev]); } -static void __job_eos_cb(void *user_data) +static void __subtitle_cb_handler(callback_cb_info_s *cb_info, char *recvMsg) { - player_s *handle = (player_s *)user_data; - LOGI("Start"); - handle->is_doing_jobs = TRUE; - ((player_completed_cb)handle->user_cb[_PLAYER_EVENT_TYPE_COMPLETE])(handle->user_data[_PLAYER_EVENT_TYPE_COMPLETE]); - __REMOVE_ECORE_JOB(handle, __JOB_KEY_EOS); - LOGI("End"); -} -#else -static void __message_cb_loop(void *data) -{ - bool running = TRUE; - player_s *handle = (player_s *)data; - if (!handle) { - LOGE("null handle in __message_cb_loop"); - return; + int duration = 0; + char text[MUSE_URI_MAX_LENGTH]; + muse_player_event_e ev = MUSE_PLAYER_EVENT_TYPE_SUBTITLE; + + if (player_msg_get(duration, recvMsg) + && player_msg_get_string(text, recvMsg)) { + ((player_subtitle_updated_cb)cb_info->user_cb[ev])(duration, text, cb_info->user_data[ev]); } - do { - __GET_MESSAGE(handle); - switch (handle->current_message) { - case PLAYER_MESSAGE_NONE: - { - LOGW("PLAYER_MESSAGE_NONE"); - running = FALSE; - } - break; - case PLAYER_MESSAGE_PREPARED: - { - LOGW("PLAYER_MESSAGE_PREPARED"); - if (handle->user_cb[_PLAYER_EVENT_TYPE_PREPARE]) { - handle->is_doing_jobs = TRUE; - handle->state = PLAYER_STATE_READY; - ((player_prepared_cb)handle->user_cb[_PLAYER_EVENT_TYPE_PREPARE])(handle->user_data[_PLAYER_EVENT_TYPE_PREPARE]); - handle->user_cb[_PLAYER_EVENT_TYPE_PREPARE] = NULL; - handle->user_data[_PLAYER_EVENT_TYPE_PREPARE] = NULL; - handle->is_doing_jobs = FALSE; - } else { - LOGE("null handle in PLAYER_MESSAGE_PREPARED"); - } - } - break; - case PLAYER_MESSAGE_ERROR: - { - LOGW("PLAYER_MESSAGE_ERROR"); - if (handle->user_cb[_PLAYER_EVENT_TYPE_ERROR]) { - handle->is_doing_jobs = TRUE; - ((player_error_cb)handle->user_cb[_PLAYER_EVENT_TYPE_ERROR])(handle->error_code, handle->user_data[_PLAYER_EVENT_TYPE_ERROR]); - handle->is_doing_jobs = FALSE; - } else { - LOGE("null handle in PLAYER_MESSAGE_ERROR"); - } - } - break; - case PLAYER_MESSAGE_SEEK_DONE: - { - LOGW("PLAYER_MESSAGE_SEEK_DONE"); - if (handle->user_cb[_PLAYER_EVENT_TYPE_SEEK]) { - handle->is_doing_jobs = TRUE; - ((player_seek_completed_cb)handle->user_cb[_PLAYER_EVENT_TYPE_SEEK])(handle->user_data[_PLAYER_EVENT_TYPE_SEEK]); - handle->user_cb[_PLAYER_EVENT_TYPE_SEEK] = NULL; - handle->user_data[_PLAYER_EVENT_TYPE_SEEK] = NULL; - handle->is_doing_jobs = FALSE; - } else { - LOGE("null handle in PLAYER_MESSAGE_SEEK_DONE"); - } - } - break; - case PLAYER_MESSAGE_EOS: - { - LOGW("PLAYER_MESSAGE_EOS"); - if (handle->user_cb[_PLAYER_EVENT_TYPE_COMPLETE]) { - handle->is_doing_jobs = TRUE; - ((player_completed_cb)handle->user_cb[_PLAYER_EVENT_TYPE_COMPLETE])(handle->user_data[_PLAYER_EVENT_TYPE_COMPLETE]); - handle->is_doing_jobs = FALSE; - } else { - LOGE("null handle in PLAYER_MESSAGE_EOS"); - } - } - break; - case PLAYER_MESSAGE_LOOP_EXIT: - { - LOGW("PLAYER_MESSAGE_LOOP_EXIT"); - running = FALSE; - } - break; - case PLAYER_MESSAGE_MAX: - { - LOGW("PLAYER_MESSAGE_MAX"); - running = FALSE; - } - break; - default: - break; - } - } while (running); - return; } -#endif -static int __msg_callback(int message, void *param, void *user_data) +static void __capture_cb_handler(callback_cb_info_s *cb_info, char *recvMsg) { - player_s *handle = (player_s *)user_data; - MMMessageParamType *msg = (MMMessageParamType *)param; - LOGW("[%s] Got message type : 0x%x", __FUNCTION__, message); - player_error_e err_code = PLAYER_ERROR_NONE; - switch (message) { - case MM_MESSAGE_ERROR: /* 0x01 */ - err_code = __player_convert_error_code(msg->code, (char *)__FUNCTION__); - break; - case MM_MESSAGE_STATE_CHANGED: /* 0x03 */ - LOGI("STATE CHANGED INTERNALLY - from : %d, to : %d (CAPI State : %d)", msg->state.previous, msg->state.current, handle->state); - if ((handle->is_progressive_download && msg->state.previous == MM_PLAYER_STATE_NULL && msg->state.current == MM_PLAYER_STATE_READY) || (msg->state.previous == MM_PLAYER_STATE_READY && msg->state.current == MM_PLAYER_STATE_PAUSED)) { - if (handle->user_cb[_PLAYER_EVENT_TYPE_PREPARE]) { - /* asyc && prepared cb has been set */ - LOGI("[%s] Prepared! [current state : %d]", __FUNCTION__, handle->state); - PLAYER_TRACE_ASYNC_END("MM:PLAYER:PREPARE_ASYNC", *(int *)handle); -#ifdef USE_ECORE_FUNCTIONS - __ADD_ECORE_JOB(handle, __JOB_KEY_PREPARED, __job_prepared_cb); -#else - __ADD_MESSAGE(handle, PLAYER_MESSAGE_PREPARED); -#endif - } - } - break; - case MM_MESSAGE_READY_TO_RESUME: /* 0x05 */ - if (handle->user_cb[_PLAYER_EVENT_TYPE_INTERRUPT]) - ((player_interrupted_cb)handle->user_cb[_PLAYER_EVENT_TYPE_INTERRUPT])(PLAYER_INTERRUPTED_COMPLETED, handle->user_data[_PLAYER_EVENT_TYPE_INTERRUPT]); - break; - case MM_MESSAGE_BEGIN_OF_STREAM: /* 0x104 */ - LOGI("[%s] Ready to streaming information (BOS) [current state : %d]", __FUNCTION__, handle->state); - break; - case MM_MESSAGE_END_OF_STREAM: /* 0x105 */ - if (handle->user_cb[_PLAYER_EVENT_TYPE_COMPLETE]) { -#ifdef USE_ECORE_FUNCTIONS - __ADD_ECORE_JOB(handle, __JOB_KEY_EOS, __job_eos_cb); -#else - __ADD_MESSAGE(handle, PLAYER_MESSAGE_EOS); -#endif - } - break; - case MM_MESSAGE_BUFFERING: /* 0x103 */ - if (handle->user_cb[_PLAYER_EVENT_TYPE_BUFFERING]) - ((player_buffering_cb)handle->user_cb[_PLAYER_EVENT_TYPE_BUFFERING])(msg->connection.buffering, handle->user_data[_PLAYER_EVENT_TYPE_BUFFERING]); - break; - case MM_MESSAGE_STATE_INTERRUPTED: /* 0x04 */ - if (handle->user_cb[_PLAYER_EVENT_TYPE_INTERRUPT]) { - handle->state = __convert_player_state(msg->state.current); - if (handle->state == PLAYER_STATE_READY) - handle->is_stopped = TRUE; - ((player_interrupted_cb)handle->user_cb[_PLAYER_EVENT_TYPE_INTERRUPT])(__convert_interrupted_code(msg->code), handle->user_data[_PLAYER_EVENT_TYPE_INTERRUPT]); - } - break; - case MM_MESSAGE_CONNECTION_TIMEOUT: /* 0x102 */ - LOGI("[%s] PLAYER_ERROR_CONNECTION_FAILED (0x%08x) : CONNECTION_TIMEOUT", __FUNCTION__, PLAYER_ERROR_CONNECTION_FAILED); - err_code = PLAYER_ERROR_CONNECTION_FAILED; - break; - case MM_MESSAGE_UPDATE_SUBTITLE: /* 0x109 */ - if (handle->user_cb[_PLAYER_EVENT_TYPE_SUBTITLE]) - ((player_subtitle_updated_cb)handle->user_cb[_PLAYER_EVENT_TYPE_SUBTITLE])(msg->subtitle.duration, (char *)msg->data, handle->user_data[_PLAYER_EVENT_TYPE_SUBTITLE]); - break; - case MM_MESSAGE_VIDEO_NOT_CAPTURED: /* 0x113 */ - LOGI("[%s] PLAYER_ERROR_VIDEO_CAPTURE_FAILED (0x%08x)", __FUNCTION__, PLAYER_ERROR_VIDEO_CAPTURE_FAILED); - if (handle->user_cb[_PLAYER_EVENT_TYPE_ERROR]) - ((player_error_cb)handle->user_cb[_PLAYER_EVENT_TYPE_ERROR])(PLAYER_ERROR_VIDEO_CAPTURE_FAILED, handle->user_data[_PLAYER_EVENT_TYPE_ERROR]); - break; - case MM_MESSAGE_VIDEO_CAPTURED: /* 0x110 */ - if (handle->user_cb[_PLAYER_EVENT_TYPE_CAPTURE]) { - int w; - int h; - int ret = mm_player_get_attribute(handle->mm_handle, NULL, MM_PLAYER_VIDEO_WIDTH, &w, MM_PLAYER_VIDEO_HEIGHT, &h, (char *)NULL); - if (ret != MM_ERROR_NONE && handle->user_cb[_PLAYER_EVENT_TYPE_ERROR]) { - LOGE("[%s] PLAYER_ERROR_VIDEO_CAPTURE_FAILED (0x%08x) : Failed to get video size on video captured (0x%x)", __FUNCTION__, PLAYER_ERROR_VIDEO_CAPTURE_FAILED, ret); - err_code = PLAYER_ERROR_VIDEO_CAPTURE_FAILED; - } else { - MMPlayerVideoCapture *capture = (MMPlayerVideoCapture *)msg->data; - - switch (msg->captured_frame.orientation) { - case 0: - case 180: - { - /* use video resolution from above */ - } - break; - case 90: - case 270: - { - /* use calculated size during rotation */ - w = msg->captured_frame.width; - h = msg->captured_frame.height; - } - break; - default: - break; - } + unsigned char *data = NULL; + int width = 0; + int height = 0; + unsigned int size = 0; + tbm_bo bo; + tbm_bo_handle thandle; + tbm_key key; - LOGI("[%s] captured image width : %d height : %d", __FUNCTION__, w, h); + 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; - /* call application callback */ - ((player_video_captured_cb)handle->user_cb[_PLAYER_EVENT_TYPE_CAPTURE])(capture->data, w, h, capture->size, handle->user_data[_PLAYER_EVENT_TYPE_CAPTURE]); - - if (capture->data) { - g_free(capture->data); - capture->data = NULL; - } - } - handle->user_cb[_PLAYER_EVENT_TYPE_CAPTURE] = NULL; - handle->user_data[_PLAYER_EVENT_TYPE_CAPTURE] = NULL; - } - break; - case MM_MESSAGE_FILE_NOT_SUPPORTED: /* 0x10f */ - LOGI("[%s] PLAYER_ERROR_NOT_SUPPORTED_FILE (0x%08x) : FILE_NOT_SUPPORTED", __FUNCTION__, PLAYER_ERROR_NOT_SUPPORTED_FILE); - err_code = PLAYER_ERROR_NOT_SUPPORTED_FILE; - break; - case MM_MESSAGE_FILE_NOT_FOUND: /* 0x110 */ - LOGI("[%s] PLAYER_ERROR_NOT_SUPPORTED_FILE (0x%08x) : FILE_NOT_FOUND", __FUNCTION__, PLAYER_ERROR_NOT_SUPPORTED_FILE); - err_code = PLAYER_ERROR_NOT_SUPPORTED_FILE; - break; - case MM_MESSAGE_SEEK_COMPLETED: /* 0x114 */ - if (handle->display_type != PLAYER_DISPLAY_TYPE_NONE && handle->state == PLAYER_STATE_READY) { - if (handle->is_display_visible) - mm_player_set_attribute(handle->mm_handle, NULL, "display_visible", 1, (char *)NULL); - } - if (handle->user_cb[_PLAYER_EVENT_TYPE_SEEK]) { -#ifdef USE_ECORE_FUNCTIONS - __ADD_ECORE_JOB(handle, __JOB_KEY_SEEK_DONE, __job_seek_done_cb); -#else - __ADD_MESSAGE(handle, PLAYER_MESSAGE_SEEK_DONE); -#endif + bo = tbm_bo_import(cb_info->bufmgr, key); + if (bo == NULL) { + LOGE("TBM get error : bo is NULL"); + goto capture_event_exit1; } - break; - case MM_MESSAGE_VIDEO_BIN_CREATED: - if (handle->user_cb[_PLAYER_EVENT_TYPE_VIDEO_BIN_CREATED]) { - char *caps = (char *)msg->data; - if (caps) - ((player_video_bin_created_cb)handle->user_cb[_PLAYER_EVENT_TYPE_VIDEO_BIN_CREATED])(caps, handle->user_data[_PLAYER_EVENT_TYPE_VIDEO_BIN_CREATED]); - g_free(caps); + 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; } - break; - case MM_MESSAGE_UNKNOWN: /* 0x00 */ - case MM_MESSAGE_WARNING: /* 0x02 */ - case MM_MESSAGE_CONNECTING: /* 0x100 */ - case MM_MESSAGE_CONNECTED: /* 0x101 */ - case MM_MESSAGE_BLUETOOTH_ON: /* 0x106 */ - case MM_MESSAGE_BLUETOOTH_OFF: /* 0x107 */ - case MM_MESSAGE_RTP_SENDER_REPORT: /* 0x10a */ - case MM_MESSAGE_RTP_RECEIVER_REPORT: /* 0x10b */ - case MM_MESSAGE_RTP_SESSION_STATUS: /* 0x10c */ - case MM_MESSAGE_SENDER_STATE: /* 0x10d */ - case MM_MESSAGE_RECEIVER_STATE: /* 0x10e */ - default: - break; - } + data = g_new(unsigned char, size); + if (data) { + memcpy(data, thandle.ptr, size); + ((player_video_captured_cb)cb_info->user_cb[MUSE_PLAYER_EVENT_TYPE_CAPTURE])(data, width, height, size, cb_info->user_data[MUSE_PLAYER_EVENT_TYPE_CAPTURE]); + g_free(data); + } else + LOGE("g_new failure"); - if (err_code != PLAYER_ERROR_NONE && handle->user_cb[_PLAYER_EVENT_TYPE_ERROR]) { - handle->error_code = err_code; -#ifdef USE_ECORE_FUNCTIONS - __ADD_ECORE_JOB(handle, __JOB_KEY_ERROR, __job_error_cb); -#else - __ADD_MESSAGE(handle, PLAYER_MESSAGE_ERROR); -#endif + /* mark to read */ + *((char *)thandle.ptr + size) = 0; + + tbm_bo_unmap(bo); +capture_event_exit2: + tbm_bo_unref(bo); } - LOGW("[%s] End", __FUNCTION__); - return 1; +capture_event_exit1: + set_null_user_cb(cb_info, MUSE_PLAYER_EVENT_TYPE_CAPTURE); } -static bool __video_stream_callback(void *stream, void *user_data) +static void __seek_cb_handler(callback_cb_info_s *cb_info, char *recvMsg) { - player_s *handle = (player_s *)user_data; - MMPlayerVideoStreamDataType *video_stream = (MMPlayerVideoStreamDataType *)stream; - - if (handle->user_cb[_PLAYER_EVENT_TYPE_MEDIA_PACKET_VIDEO_FRAME]) { - /* media packet and zero-copy */ - media_packet_h pkt = NULL; - tbm_surface_h tsurf = NULL; - uint32_t bo_format = 0; - int i; - int bo_num; - int ret = 0; - media_format_mimetype_e mimetype = MEDIA_FORMAT_NV12; - bool make_pkt_fmt = false; + muse_player_event_e ev = MUSE_PLAYER_EVENT_TYPE_SEEK; - /* create tbm surface */ - for (i = 0, bo_num = 0; i < BUFFER_MAX_PLANE_NUM; i++) { - if (video_stream->bo[i]) - bo_num++; - } + ((player_seek_completed_cb)cb_info->user_cb[ev])(cb_info->user_data[ev]); - /* get tbm surface format */ - ret = _player_get_tbm_surface_format(video_stream->format, &bo_format); - ret |= _player_get_media_packet_mimetype(video_stream->format, &mimetype); - - if (bo_num > 0 && ret == PLAYER_ERROR_NONE) { - tbm_surface_info_s info; - memset(&info, 0, sizeof(tbm_surface_info_s)); - info.width = video_stream->width; - info.height = video_stream->height; - info.format = bo_format; - info.bpp = tbm_surface_internal_get_bpp(bo_format); - info.num_planes = tbm_surface_internal_get_num_planes(bo_format); - info.size = 0; - for (i = 0; i < info.num_planes; i++) { - info.planes[i].stride = video_stream->stride[i]; - info.planes[i].size = video_stream->stride[i] * video_stream->elevation[i]; - if (i < bo_num) - info.planes[i].offset = 0; - else - info.planes[i].offset = info.planes[i - 1].offset + info.planes[i - 1].size; - info.size += info.planes[i].size; - } - tsurf = tbm_surface_internal_create_with_bos(&info, (tbm_bo *)video_stream->bo, bo_num); - /*LOGD("tbm surface %p", tsurf); */ - } else if (bo_num == 0) { - int plane_idx = 0; - tbm_surface_info_s tsuri; - unsigned char *ptr = video_stream->data[0]; - unsigned char *ptr2 = video_stream->data[1]; - - if (!ptr) - return TRUE; - if (!ptr2 && video_stream->format == MM_PIXEL_FORMAT_NV12T) - return TRUE; - - tsurf = tbm_surface_create(video_stream->width, video_stream->height, bo_format); - if (tsurf) { - /* map surface to set data */ - if (tbm_surface_map(tsurf, TBM_SURF_OPTION_READ | TBM_SURF_OPTION_WRITE, &tsuri)) { - LOGE("tbm_surface_map failed"); - return TRUE; - } + set_null_user_cb(cb_info, ev); +} - if (video_stream->format == MM_PIXEL_FORMAT_NV12T) { - memcpy(tsuri.planes[0].ptr, ptr, tsuri.planes[0].size); - memcpy(tsuri.planes[1].ptr, ptr2, tsuri.planes[1].size); - } else { - for (plane_idx = 0; plane_idx < tsuri.num_planes; plane_idx++) { - memcpy(tsuri.planes[plane_idx].ptr, ptr, tsuri.planes[plane_idx].size); - ptr += tsuri.planes[plane_idx].size; - } - } - } else { - LOGW("tbm_surface_create failed"); - } +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; + intptr_t packet; + uint64_t pts = 0; + 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_type(packet, recvMsg, POINTER); + player_msg_get(mimetype, recvMsg); + player_msg_get_type(pts, recvMsg, INT64); + 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(cb_info->bufmgr, key[i]); } + } - if (tsurf) { - /* check media packet format */ - if (handle->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(handle->pkt_fmt, &pkt_fmt_mimetype, - &pkt_fmt_width, &pkt_fmt_height, NULL, NULL); - if (pkt_fmt_mimetype != mimetype || - pkt_fmt_width != video_stream->width || - pkt_fmt_height != video_stream->height) { - LOGW("different format. current 0x%x, %dx%d, new 0x%x, %dx%d", - pkt_fmt_mimetype, pkt_fmt_width, pkt_fmt_height, mimetype, - video_stream->width, video_stream->height); - media_format_unref(handle->pkt_fmt); - handle->pkt_fmt = NULL; - make_pkt_fmt = true; - } - } else { + 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; } - - /* create packet format */ - if (make_pkt_fmt) { - LOGW("make new pkt_fmt - mimetype 0x%x, %dx%d", mimetype, video_stream->width, video_stream->height); - ret = media_format_create(&handle->pkt_fmt); - if (ret == MEDIA_FORMAT_ERROR_NONE) { - ret = media_format_set_video_mime(handle->pkt_fmt, mimetype); - ret |= media_format_set_video_width(handle->pkt_fmt, video_stream->width); - ret |= media_format_set_video_height(handle->pkt_fmt, video_stream->height); - LOGW("media_format_set_video_mime,width,height ret : 0x%x", ret); - } else { - LOGW("media_format_create failed"); - } - } - - /* create media packet */ - ret = media_packet_create_from_tbm_surface(handle->pkt_fmt, tsurf, (media_packet_finalize_cb)_player_media_packet_finalize, (void *)handle, &pkt); - if (ret != MEDIA_PACKET_ERROR_NONE) { - LOGE("media_packet_create_from_tbm_surface failed"); - - tbm_surface_destroy(tsurf); - tsurf = NULL; - } } else { - LOGE("failed to create tbm surface %dx%d, format %d, bo_num %d", - video_stream->width, video_stream->height, video_stream->format, bo_num); + make_pkt_fmt = true; } - - if (pkt) { - /* LOGD("media packet %p, internal buffer %p", pkt, stream->internal_buffer); */ - if (video_stream->timestamp) { - ret = media_packet_set_pts(pkt, (uint64_t)video_stream->timestamp * 1000000); - if (ret != MEDIA_PACKET_ERROR_NONE) { - LOGE("media_packet_set_pts failed"); - - media_packet_destroy(pkt); - pkt = NULL; - } + /* 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 { - LOGD("media packet %p, didn't have video-stream timestamp", pkt); + LOGE("media_format_create failed"); } + } - /* set internal buffer */ - if (video_stream->internal_buffer) - ret = media_packet_set_extra(pkt, video_stream->internal_buffer); - - if (ret != MEDIA_PACKET_ERROR_NONE) { - LOGE("media_packet_set_extra 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) { + if (pts != 0) { + ret = media_packet_set_pts(pkt, (uint64_t)pts); + if (ret != MEDIA_PACKET_ERROR_NONE) + LOGE("media_packet_set_pts failed"); + } + /* call media packet callback */ + ((player_media_packet_video_decoded_cb)cb_info->user_cb[MUSE_PLAYER_EVENT_TYPE_MEDIA_PACKET_VIDEO_FRAME])(pkt, cb_info->user_data[MUSE_PLAYER_EVENT_TYPE_MEDIA_PACKET_VIDEO_FRAME]); + } + for (i = 0; i < bo_num; i++) { + if (bo[i]) + tbm_bo_unref(bo[i]); + } +} - media_packet_destroy(pkt); - pkt = NULL; - } else { - mm_player_media_packet_video_stream_internal_buffer_ref(video_stream->internal_buffer); +static void __audio_frame_cb_handler(callback_cb_info_s *cb_info, char *recvMsg) +{ + unsigned char *data = NULL; + unsigned int size = 0; + tbm_bo bo; + tbm_bo_handle thandle; + tbm_key key; + player_audio_raw_data_s audio; + void *audio_frame = &audio; - /* call media packet callback */ - ((player_media_packet_video_decoded_cb)handle->user_cb[_PLAYER_EVENT_TYPE_MEDIA_PACKET_VIDEO_FRAME])(pkt, handle->user_data[_PLAYER_EVENT_TYPE_MEDIA_PACKET_VIDEO_FRAME]); + if (player_msg_get_array(audio_frame, recvMsg) && player_msg_get(size, recvMsg)) { + if (!player_msg_get(key, recvMsg)) + return; - if (bo_num == 0) - tbm_surface_unmap(tsurf); - } + bo = tbm_bo_import(cb_info->bufmgr, key); + if (bo == NULL) { + LOGE("TBM get error : bo is NULL"); + return; + } + 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"); + tbm_bo_unref(bo); + return; } + data = g_new(unsigned char, size); + if (data) { + memcpy(data, thandle.ptr, size); + audio.data = data; + audio.size = size; + LOGD("user callback data %p, size %d", audio.data, audio.size); + ((player_audio_pcm_extraction_cb)cb_info->user_cb[MUSE_PLAYER_EVENT_TYPE_AUDIO_FRAME])(&audio, cb_info->user_data[MUSE_PLAYER_EVENT_TYPE_AUDIO_FRAME]); + g_free(data); + } else + LOGE("g_new failure"); + + /* mark to read */ + *((char *)thandle.ptr + size) = 0; + LOGD("Fin"); + + tbm_bo_unmap(bo); + tbm_bo_unref(bo); } - return TRUE; } -static int __pd_message_callback(int message, void *param, void *user_data) +static void __video_frame_render_error_cb_handler(callback_cb_info_s *cb_info, char *recvMsg) { - player_s *handle = (player_s *)user_data; - player_pd_message_type_e type; - switch (message) { - case MM_MESSAGE_PD_DOWNLOADER_START: - type = PLAYER_PD_STARTED; - break; - case MM_MESSAGE_PD_DOWNLOADER_END: - type = PLAYER_PD_COMPLETED; - break; - default: - return 0; - } +} - if (handle->user_cb[_PLAYER_EVENT_TYPE_PD]) - ((player_pd_message_cb)handle->user_cb[_PLAYER_EVENT_TYPE_PD])(type, handle->user_data[_PLAYER_EVENT_TYPE_PD]); +static void __pd_cb_handler(callback_cb_info_s *cb_info, char *recvMsg) +{ + int type; + muse_player_event_e ev = MUSE_PLAYER_EVENT_TYPE_PD; - return 0; + if (player_msg_get(type, recvMsg)) + ((player_pd_message_cb)cb_info->user_cb[ev])(type, cb_info->user_data[ev]); } -#ifdef USE_ECORE_FUNCTIONS -static void __job_key_to_remove(gpointer key) +static void __supported_audio_effect_cb_handler(callback_cb_info_s *cb_info, char *recvMsg) { - LOGI("%s", key); - g_free(key); } -static void __job_value_to_destroy(gpointer value) +static void __supported_audio_effect_freset_cb_handler(callback_cb_info_s *cb_info, char *recvMsg) { - Ecore_Job *job = (Ecore_Job *) value; - LOGI("%p", job); - __DELETE_ECORE_ITEM(job); } -#endif -static MMDisplaySurfaceType __player_convet_display_type(player_display_type_e type) +static void __missed_plugin_cb_handler(callback_cb_info_s *cb_info, char *recvMsg) { - switch (type) { - case PLAYER_DISPLAY_TYPE_OVERLAY: - return MM_DISPLAY_SURFACE_OVERLAY; -#ifdef TIZEN_MOBILE - case PLAYER_DISPLAY_TYPE_EVAS: - return MM_DISPLAY_SURFACE_EVAS; -#endif - case PLAYER_DISPLAY_TYPE_NONE: - return MM_DISPLAY_SURFACE_NULL; - default: - return MM_DISPLAY_SURFACE_NULL; +} + +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[MUSE_PLAYER_EVENT_TYPE_MEDIA_STREAM_VIDEO_BUFFER_STATUS])((player_media_stream_buffer_status_e)status, cb_info->user_data[MUSE_PLAYER_EVENT_TYPE_MEDIA_STREAM_VIDEO_BUFFER_STATUS]); } } -/* -* Public Implementation -*/ +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; -int player_create(player_h *player) + if (player_msg_get(status, recvMsg)) { + ((player_media_stream_buffer_status_cb) + cb_info->user_cb[MUSE_PLAYER_EVENT_TYPE_MEDIA_STREAM_AUDIO_BUFFER_STATUS]) + ((player_media_stream_buffer_status_e)status, cb_info->user_data[MUSE_PLAYER_EVENT_TYPE_MEDIA_STREAM_AUDIO_BUFFER_STATUS]); + } + +} + +static void __media_stream_video_buffer_cb_handler_ex(callback_cb_info_s *cb_info, char *recvMsg) { - PLAYER_INSTANCE_CHECK(player); - PLAYER_TRACE_BEGIN("MM:PLAYER:CREATE"); - player_s *handle; - handle = (player_s *)malloc(sizeof(player_s)); - if (handle != NULL) - memset(handle, 0, sizeof(player_s)); - else { - LOGE("[%s] PLAYER_ERROR_OUT_OF_MEMORY(0x%08x)", __FUNCTION__, PLAYER_ERROR_OUT_OF_MEMORY); - return PLAYER_ERROR_OUT_OF_MEMORY; - } - int ret = mm_player_create(&handle->mm_handle); - if (ret != MM_ERROR_NONE) { - LOGE("[%s] PLAYER_ERROR_INVALID_OPERATION(0x%08x)", __FUNCTION__, PLAYER_ERROR_INVALID_OPERATION); - handle->state = PLAYER_STATE_NONE; - free(handle); - handle = NULL; - return PLAYER_ERROR_INVALID_OPERATION; - } else { - *player = (player_h)handle; - handle->state = PLAYER_STATE_IDLE; - handle->display_type = PLAYER_DISPLAY_TYPE_NONE; - handle->is_stopped = false; - handle->is_display_visible = true; -#ifdef USE_ECORE_FUNCTIONS - handle->ecore_jobs = g_hash_table_new_full(g_str_hash, g_str_equal, __job_key_to_remove, __job_value_to_destroy); -#else - handle->message_queue = g_queue_new(); - g_mutex_init(&handle->message_queue_lock); - g_cond_init(&handle->message_queue_cond); - ret = pthread_create(&handle->message_thread, NULL, (void *)__message_cb_loop, (void *)handle); - if (ret != 0) { - LOGE("[%s] failed to create message thread ret = %d", __FUNCTION__, ret); - return PLAYER_ERROR_OUT_OF_MEMORY; - } -#endif - LOGI("[%s] new handle : %p", __FUNCTION__, *player); - PLAYER_TRACE_END(); - return PLAYER_ERROR_NONE; + /* player_media_stream_buffer_status_e status; */ + int status; + unsigned long long bytes; + + if (player_msg_get(status, recvMsg) && player_msg_get_type(bytes, recvMsg, INT64)) { + ((player_media_stream_buffer_status_cb_ex) + cb_info->user_cb[MUSE_PLAYER_EVENT_TYPE_MEDIA_STREAM_VIDEO_BUFFER_STATUS_WITH_INFO]) + ((player_media_stream_buffer_status_e)status, bytes, cb_info->user_data[MUSE_PLAYER_EVENT_TYPE_MEDIA_STREAM_VIDEO_BUFFER_STATUS_WITH_INFO]); } } -int player_destroy(player_h player) +static void __media_stream_audio_buffer_cb_handler_ex(callback_cb_info_s *cb_info, char *recvMsg) { - LOGI("[%s] Start, handle to destroy : %p", __FUNCTION__, player); - PLAYER_TRACE_BEGIN("MM:PLAYER:DESTROY"); - PLAYER_INSTANCE_CHECK(player); - player_s *handle = (player_s *)player; - if (handle->is_doing_jobs) { - LOGE("jobs not completed. can't do destroy"); - return PLAYER_ERROR_INVALID_OPERATION; + /* player_media_stream_buffer_status_e status; */ + int status; + unsigned long long bytes; + + if (player_msg_get(status, recvMsg) && player_msg_get_type(bytes, recvMsg, INT64)) { + ((player_media_stream_buffer_status_cb_ex) + cb_info->user_cb[MUSE_PLAYER_EVENT_TYPE_MEDIA_STREAM_AUDIO_BUFFER_STATUS_WITH_INFO]) + ((player_media_stream_buffer_status_e)status, bytes, cb_info->user_data[MUSE_PLAYER_EVENT_TYPE_MEDIA_STREAM_AUDIO_BUFFER_STATUS_WITH_INFO]); } -#ifdef USE_ECORE_FUNCTIONS - g_hash_table_remove_all(handle->ecore_jobs); - g_hash_table_unref(handle->ecore_jobs); - handle->ecore_jobs = NULL; -#else - __ADD_MESSAGE(handle, PLAYER_MESSAGE_LOOP_EXIT); -#endif - __RELEASEIF_PREPARE_THREAD(handle->prepare_async_thread); -#ifndef USE_ECORE_FUNCTIONS - __RELEASEIF_MESSAGE_THREAD(handle->message_thread); -#endif +} - int ret = mm_player_destroy(handle->mm_handle); +static void __media_stream_video_seek_cb_handler(callback_cb_info_s *cb_info, char *recvMsg) +{ + unsigned long long offset; - if (handle->pkt_fmt) { - media_format_unref(handle->pkt_fmt); - handle->pkt_fmt = NULL; + if (player_msg_get_type(offset, recvMsg, INT64)) { + ((player_media_stream_seek_cb) + cb_info->user_cb[MUSE_PLAYER_EVENT_TYPE_MEDIA_STREAM_VIDEO_SEEK]) + (offset, cb_info->user_data[MUSE_PLAYER_EVENT_TYPE_MEDIA_STREAM_VIDEO_SEEK]); } +} - LOGI("[%s] Done mm_player_destroy", __FUNCTION__); +static void __media_stream_audio_seek_cb_handler(callback_cb_info_s *cb_info, char *recvMsg) +{ + unsigned long long offset; - if (ret != MM_ERROR_NONE) { - LOGE("[%s] PLAYER_ERROR_INVALID_OPERATION(0x%08x)", __FUNCTION__, PLAYER_ERROR_INVALID_OPERATION); - return PLAYER_ERROR_INVALID_OPERATION; - } else { - handle->state = PLAYER_STATE_NONE; -#ifndef USE_ECORE_FUNCTIONS - if (handle->message_queue) { - g_queue_free(handle->message_queue); - handle->message_queue = NULL; - } + if (player_msg_get_type(offset, recvMsg, INT64)) { + ((player_media_stream_seek_cb) + cb_info->user_cb[MUSE_PLAYER_EVENT_TYPE_MEDIA_STREAM_AUDIO_SEEK]) + (offset, cb_info->user_data[MUSE_PLAYER_EVENT_TYPE_MEDIA_STREAM_AUDIO_SEEK]); + } +} - g_cond_broadcast(&handle->message_queue_cond); - g_mutex_clear(&handle->message_queue_lock); - g_cond_clear(&handle->message_queue_cond); +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[MUSE_PLAYER_EVENT_TYPE_VIDEO_STREAM_CHANGED]) + (width, height, fps, bit_rate, cb_info->user_data[MUSE_PLAYER_EVENT_TYPE_VIDEO_STREAM_CHANGED]); + } +} + +static void (*_user_callbacks[MUSE_PLAYER_EVENT_TYPE_NUM])(callback_cb_info_s *cb_info, char *recvMsg) = { + __prepare_cb_handler, /* MUSE_PLAYER_EVENT_TYPE_PREPARE */ + __complete_cb_handler, /* MUSE_PLAYER_EVENT_TYPE_COMPLETE */ + __interrupt_cb_handler, /* MUSE_PLAYER_EVENT_TYPE_INTERRUPT */ + __error_cb_handler, /* MUSE_PLAYER_EVENT_TYPE_ERROR */ + __buffering_cb_handler, /* MUSE_PLAYER_EVENT_TYPE_BUFFERING */ + __subtitle_cb_handler, /* MUSE_PLAYER_EVENT_TYPE_SUBTITLE */ + __capture_cb_handler, /* MUSE_PLAYER_EVENT_TYPE_CAPTURE */ + __seek_cb_handler, /* MUSE_PLAYER_EVENT_TYPE_SEEK*/ + __media_packet_video_frame_cb_handler, /* MUSE_PLAYER_EVENT_TYPE_MEDIA_PACKET_VIDEO_FRAME */ + __audio_frame_cb_handler, /* MUSE_PLAYER_EVENT_TYPE_AUDIO_FRAME */ + __video_frame_render_error_cb_handler, /* MUSE_PLAYER_EVENT_TYPE_VIDEO_FRAME_RENDER_ERROR */ + __pd_cb_handler, /* MUSE_PLAYER_EVENT_TYPE_PD */ + __supported_audio_effect_cb_handler, /* MUSE_PLAYER_EVENT_TYPE_SUPPORTED_AUDIO_EFFECT */ + __supported_audio_effect_freset_cb_handler, /* MUSE_PLAYER_EVENT_TYPE_SUPPORTED_AUDIO_EFFECT_PRESET */ + __missed_plugin_cb_handler, /* MUSE_PLAYER_EVENT_TYPE_MISSED_PLUGIN */ +#ifdef _PLAYER_FOR_PRODUCT + NULL, /* MUSE_PLAYER_EVENT_TYPE_IMAGE_BUFFER */ + NULL, /* MUSE_PLAYER_EVENT_TYPE_SELECTED_SUBTITLE_LANGUAGE */ #endif - free(handle); - handle = NULL; - LOGI("[%s] End", __FUNCTION__); - PLAYER_TRACE_END(); - return PLAYER_ERROR_NONE; + __media_stream_video_buffer_cb_handler, /* MUSE_PLAYER_EVENT_TYPE_MEDIA_STREAM_VIDEO_BUFFER_STATUS */ + __media_stream_audio_buffer_cb_handler, /* MUSE_PLAYER_EVENT_TYPE_MEDIA_STREAM_AUDIO_BUFFER_STATUS */ + __media_stream_video_buffer_cb_handler_ex, /* MUSE_PLAYER_EVENT_TYPE_MEDIA_STREAM_VIDEO_BUFFER_STATUS_WITH_INFO */ + __media_stream_audio_buffer_cb_handler_ex, /* MUSE_PLAYER_EVENT_TYPE_MEDIA_STREAM_AUDIO_BUFFER_STATUS_WITH_INFO */ + __media_stream_video_seek_cb_handler, /* MUSE_PLAYER_EVENT_TYPE_MEDIA_STREAM_VIDEO_SEEK */ + __media_stream_audio_seek_cb_handler, /* MUSE_PLAYER_EVENT_TYPE_MEDIA_STREAM_AUDIO_SEEK */ + NULL, /* MUSE_PLAYER_EVENT_TYPE_AUDIO_STREAM_CHANGED */ + __video_stream_changed_cb_handler, /* MUSE_PLAYER_EVENT_TYPE_VIDEO_STREAM_CHANGED */ +}; + +static void _player_event_job_function(_player_cb_data *data) +{ + muse_player_event_e ev = data->int_data; + if (data->cb_info->user_cb[ev]) + _user_callbacks[ev] (data->cb_info, data->buf); + else + LOGW("user callback is unset. type : %d", ev); + + 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) { + g_mutex_lock(&ev->qlock); + if (g_queue_is_empty(ev->queue)) { + g_mutex_unlock(&ev->qlock); + g_cond_wait(&ev->cond, &ev->mutex); + if (!ev->running) + break; + } else + g_mutex_unlock(&ev->qlock); + + while (1) { + g_mutex_lock(&ev->qlock); + event_data = (_player_cb_data *)g_queue_pop_head(ev->queue); + g_mutex_unlock(&ev->qlock); + if (event_data) + _player_event_job_function(event_data); + else + break; + } + } + g_mutex_unlock(&ev->mutex); + LOGI("Exit event loop"); + return NULL; } -static void *__prepare_async_thread_func(void *data) +static gboolean _player_event_queue_new(callback_cb_info_s *cb_info) { - player_s *handle = data; - int ret = MM_ERROR_NONE; - LOGI("[%s]", __FUNCTION__); + 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->qlock); - ret = mm_player_pause(handle->mm_handle); - if (ret != MM_ERROR_NONE) { - LOGE("[%s] Failed to pause - core fw error(0x%x)", __FUNCTION__, ret); - /*MM_MESSAGE_ERROR will not be posted as player_prepare(sync API) works with return value - of mm_player_pause So in case of async API we post the error message to application from here */ - MMMessageParamType msg_param; - msg_param.code = ret; - __msg_callback(MM_MESSAGE_ERROR, (void *)&msg_param, (void *)handle); + 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; - ret = mm_player_unrealize(handle->mm_handle); - if (ret != MM_ERROR_NONE) - LOGE("[%s] Failed to unrealize - 0x%x", __FUNCTION__, ret); +} + +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; + _player_cb_data *event_data; + + 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); + + while (!g_queue_is_empty(ev->queue)) { + event_data = (_player_cb_data *)g_queue_pop_head(ev->queue); + if (event_data) { + g_free(event_data->buf); + g_free(event_data); + } } - LOGI("[%s], done", __FUNCTION__); - return NULL; + g_queue_free(ev->queue); + g_mutex_clear(&ev->qlock); + g_mutex_clear(&ev->mutex); + g_cond_clear(&ev->cond); + } -int player_prepare_async(player_h player, player_prepared_cb callback, void *user_data) +static void _player_event_queue_add(player_event_queue *ev, _player_cb_data *data) { - LOGI("[%s] Start", __FUNCTION__); - PLAYER_INSTANCE_CHECK(player); - player_s *handle = (player_s *)player; - PLAYER_TRACE_ASYNC_BEGIN("MM:PLAYER:PREPARE_ASYNC", *(int *)handle); - PLAYER_STATE_CHECK(handle, PLAYER_STATE_IDLE); + if (ev->running) { + g_mutex_lock(&ev->qlock); + g_queue_push_tail(ev->queue, (gpointer)data); + g_mutex_unlock(&ev->qlock); + g_cond_signal(&ev->cond); + } +} - int ret; - int visible; - int value; +static void _user_callback_handler(callback_cb_info_s *cb_info, muse_player_event_e event, char *buffer) +{ + LOGD("get event %d", event); - if (handle->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 { - /* LOGI("[%s] Event type : %d ",__FUNCTION__, _PLAYER_EVENT_TYPE_PREPARE); */ - handle->user_cb[_PLAYER_EVENT_TYPE_PREPARE] = callback; - handle->user_data[_PLAYER_EVENT_TYPE_PREPARE] = user_data; + if (event < MUSE_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); + } } +} - ret = mm_player_set_message_callback(handle->mm_handle, __msg_callback, (void *)handle); - if (ret != MM_ERROR_NONE) - LOGW("[%s] Failed to set message callback function (0x%x)", __FUNCTION__, ret); +static void _add_ret_msg(muse_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; - if (handle->display_type == PLAYER_DISPLAY_TYPE_NONE) { - ret = mm_player_set_attribute(handle->mm_handle, NULL, "display_surface_type", MM_DISPLAY_SURFACE_NULL, (char *)NULL); - if (ret != MM_ERROR_NONE) - LOGW("[%s] Failed to set display surface type 'MM_DISPLAY_SURFACE_NULL' (0x%x)", __FUNCTION__, ret); - } else { - ret = mm_player_get_attribute(handle->mm_handle, NULL, "display_visible", &visible, (char *)NULL); - if (ret != MM_ERROR_NONE) - return __player_convert_error_code(ret, (char *)__FUNCTION__); + 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"); +} - if (!visible) - value = FALSE; - else - value = TRUE; +static ret_msg_s *_get_ret_msg(muse_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; +} - ret = mm_player_set_attribute(handle->mm_handle, NULL, "display_visible", value, (char *)NULL); - if (ret != MM_ERROR_NONE) - return __player_convert_error_code(ret, (char *)__FUNCTION__); +static void _notify_disconnected(callback_cb_info_s *cb_info) +{ + int code = PLAYER_ERROR_SERVICE_DISCONNECTED; + muse_player_event_e ev = MUSE_PLAYER_EVENT_TYPE_ERROR; + if (!cb_info || !cb_info->user_cb[ev]) + return; + ((player_error_cb) cb_info->user_cb[ev]) (code, cb_info->user_data[ev]); +} + +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; + muse_core_msg_parse_err_e err; + + while (g_atomic_int_get(&cb_info->running)) { + len = 0; + err = MUSE_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 = MUSE_PLAYER_API_MAX; + if (player_msg_get_error_e(api, recvMsg + offset, parse_len, err)) { + if (api < MUSE_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 == MUSE_PLAYER_API_DESTROY) + g_atomic_int_set(&cb_info->running, 0); + } else if (api == MUSE_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 == MUSE_MSG_PARSE_ERROR_CONTINUE); + if (len <= 0) + break; } + if (g_atomic_int_get(&cb_info->running)) + _notify_disconnected(cb_info); + LOGD("client cb exit"); - ret = mm_player_realize(handle->mm_handle); - if (ret != MM_ERROR_NONE) { - LOGE("[%s] Failed to realize - 0x%x", __FUNCTION__, ret); - return __player_convert_error_code(ret, (char *)__FUNCTION__); + 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; i < MUSE_PLAYER_API_MAX; i++) + g_cond_init(&cb_info->player_cond[i]); + + buff = &cb_info->buff; + buff->recvMsg = g_new(char, MUSE_MSG_MAX_LENGTH + 1); + buff->bufLen = MUSE_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); + + muse_core_connection_close(cb_info->fd); + muse_core_connection_close(cb_info->data_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; i < MUSE_PLAYER_API_MAX; i++) + g_cond_clear(&cb_info->player_cond[i]); + + g_free(cb_info->buff.recvMsg); + g_free(cb_info); +} + +int _get_api_timeout(player_cli_s *pc, muse_player_api_e api) +{ + int timeout = 0; + + switch (api) { + case MUSE_PLAYER_API_PREPARE: + case MUSE_PLAYER_API_PREPARE_ASYNC: + case MUSE_PLAYER_API_UNPREPARE: + case MUSE_PLAYER_API_START: + case MUSE_PLAYER_API_STOP: + case MUSE_PLAYER_API_PAUSE: + timeout += SERVER_TIMEOUT(pc); + break; + default: + /* check prepare async is done */ + if (pc && CALLBACK_INFO(pc) && CALLBACK_INFO(pc)->user_cb[MUSE_PLAYER_EVENT_TYPE_PREPARE]) + timeout += SERVER_TIMEOUT(pc); + break; } + timeout += CALLBACK_TIME_OUT; + return timeout; +} + +int wait_for_cb_return(muse_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; - if (!handle->is_progressive_download) { - ret = pthread_create(&handle->prepare_async_thread, NULL, (void *)__prepare_async_thread_func, (void *)handle); + g_mutex_lock(&cb_info->player_mutex); - if (ret != 0) { - LOGE("[%s] failed to create thread ret = %d", __FUNCTION__, ret); - return PLAYER_ERROR_OUT_OF_MEMORY; + 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)) { + LOGW("api %d return msg does not received %ds", api, time_out); + 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); - LOGI("[%s] End", __FUNCTION__); - return PLAYER_ERROR_NONE; + return ret; } -int player_prepare(player_h player) +/* +* Public Implementation +*/ + +int player_create(player_h *player) { - LOGI("[%s] Start", __FUNCTION__); - PLAYER_TRACE_BEGIN("MM:PLAYER:PREPARE"); PLAYER_INSTANCE_CHECK(player); - player_s *handle = (player_s *)player; - PLAYER_STATE_CHECK(handle, PLAYER_STATE_IDLE); - int ret; - int visible; - int value; - ret = mm_player_set_message_callback(handle->mm_handle, __msg_callback, (void *)handle); - if (ret != MM_ERROR_NONE) - LOGW("[%s] Failed to set message callback function (0x%x)", __FUNCTION__, ret); + int ret = PLAYER_ERROR_NONE; + int sock_fd = -1; + int pid = getpid(); - if (handle->display_type == PLAYER_DISPLAY_TYPE_NONE) { - ret = mm_player_set_attribute(handle->mm_handle, NULL, "display_surface_type", MM_DISPLAY_SURFACE_NULL, (char *)NULL); - if (ret != MM_ERROR_NONE) - LOGW("[%s] Failed to set display surface type 'MM_DISPLAY_SURFACE_NULL' (0x%x)", __FUNCTION__, ret); - } else { - ret = mm_player_get_attribute(handle->mm_handle, NULL, "display_visible", &visible, (char *)NULL); - if (ret != MM_ERROR_NONE) - return __player_convert_error_code(ret, (char *)__FUNCTION__); + muse_player_api_e api = MUSE_PLAYER_API_CREATE; + muse_core_api_module_e module = MUSE_PLAYER; + player_cli_s *pc = NULL; + char *ret_buf = NULL; - if (!visible) - value = FALSE; - else - value = TRUE; + LOGD("ENTER"); - mm_player_set_attribute(handle->mm_handle, NULL, "display_visible", value, (char *)NULL); + sock_fd = muse_core_client_new(); + if (sock_fd < 0) { + LOGE("connection failure %d", errno); + ret = PLAYER_ERROR_INVALID_OPERATION; + goto ErrorExit; + } + player_msg_create_handle(api, sock_fd, INT, module, INT, pid); - if (ret != MM_ERROR_NONE) - LOGW("[%s] Failed to set display display_visible '0' (0x%x)", __FUNCTION__, ret); + pc = g_new0(player_cli_s, 1); + if (pc == NULL) { + ret = PLAYER_ERROR_OUT_OF_MEMORY; + goto ErrorExit; } - ret = mm_player_realize(handle->mm_handle); - if (ret != MM_ERROR_NONE) { - LOGE("[%s] Failed to realize - 0x%x", __FUNCTION__, ret); - return __player_convert_error_code(ret, (char *)__FUNCTION__); + 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; } - if (!handle->is_progressive_download) - ret = mm_player_pause(handle->mm_handle); + ret = wait_for_cb_return(api, pc->cb_info, &ret_buf, CALLBACK_TIME_OUT); + if (ret == PLAYER_ERROR_NONE) { + intptr_t module_addr; + *player = (player_h)pc; + if (player_msg_get_type(module_addr, ret_buf, POINTER)) { + pc->cb_info->data_fd = muse_core_client_new_data_ch(); + muse_core_send_client_addr(module_addr, pc->cb_info->data_fd); + LOGD("Data channel fd %d, muse module addr %p", pc->cb_info->data_fd, module_addr); + } + } else + goto ErrorExit; - if (ret != MM_ERROR_NONE) { - int uret; - uret = mm_player_unrealize(handle->mm_handle); - if (uret != MM_ERROR_NONE) - LOGE("[%s] Failed to unrealize - 0x%x", __FUNCTION__, uret); + pc->cb_info->bufmgr = tbm_bufmgr_init(-1); - LOGE("[%s] Failed to pause - 0x%x", __FUNCTION__, ret); - return __player_convert_error_code(ret, (char *)__FUNCTION__); - } else { - handle->state = PLAYER_STATE_READY; - LOGI("[%s] End", __FUNCTION__); - PLAYER_TRACE_END(); - return PLAYER_ERROR_NONE; + 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_unprepare(player_h player) +int player_destroy(player_h player) { - LOGI("[%s] Start", __FUNCTION__); - PLAYER_TRACE_BEGIN("MM:PLAYER:UNPREPARE"); PLAYER_INSTANCE_CHECK(player); - player_s *handle = (player_s *)player; - if (!__player_state_validate(handle, PLAYER_STATE_READY)) { - LOGE("[%s] PLAYER_ERROR_INVALID_STATE(0x%08x) : current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state); - return PLAYER_ERROR_INVALID_STATE; + int ret = PLAYER_ERROR_NONE; + muse_player_api_e api = MUSE_PLAYER_API_DESTROY; + player_cli_s *pc = (player_cli_s *)player; + char *ret_buf = NULL; + + LOGD("ENTER"); + + player_msg_send(api, pc, ret_buf, ret); + + if(player_unset_evas_object_cb(player) != MM_ERROR_NONE) + LOGW("fail to unset evas object callback"); + + if (CALLBACK_INFO(pc)) { + _player_event_queue_destroy(CALLBACK_INFO(pc)); + tbm_bufmgr_deinit(TBM_BUFMGR(pc)); + + callback_destroy(CALLBACK_INFO(pc)); } - __RELEASEIF_PREPARE_THREAD(handle->prepare_async_thread); + g_free(pc); + pc = NULL; - int ret = mm_player_unrealize(handle->mm_handle); + g_free(ret_buf); + return ret; +} - if (ret != MM_ERROR_NONE) { - return __player_convert_error_code(ret, (char *)__FUNCTION__); +int player_prepare_async(player_h player, player_prepared_cb callback, void *user_data) +{ + PLAYER_INSTANCE_CHECK(player); + int ret = PLAYER_ERROR_NONE; + muse_player_api_e api = MUSE_PLAYER_API_PREPARE_ASYNC; + player_cli_s *pc = (player_cli_s *)player; + char *ret_buf = NULL; + + LOGD("ENTER"); + + if (pc->cb_info->user_cb[MUSE_PLAYER_EVENT_TYPE_PREPARE]) { + LOGE("PLAYER_ERROR_INVALID_OPERATION (0x%08x) : preparing...", PLAYER_ERROR_INVALID_OPERATION); + return PLAYER_ERROR_INVALID_OPERATION; } else { - if (handle->user_cb[_PLAYER_EVENT_TYPE_SEEK]) { - handle->user_cb[_PLAYER_EVENT_TYPE_SEEK] = NULL; - handle->user_data[_PLAYER_EVENT_TYPE_SEEK] = NULL; - } + pc->cb_info->user_cb[MUSE_PLAYER_EVENT_TYPE_PREPARE] = callback; + pc->cb_info->user_data[MUSE_PLAYER_EVENT_TYPE_PREPARE] = user_data; + } + player_msg_send(api, pc, ret_buf, ret); - if (handle->user_cb[_PLAYER_EVENT_TYPE_PREPARE]) { - handle->user_cb[_PLAYER_EVENT_TYPE_PREPARE] = NULL; - handle->user_data[_PLAYER_EVENT_TYPE_PREPARE] = NULL; - } + g_free(ret_buf); + return ret; +} - handle->state = PLAYER_STATE_IDLE; - handle->display_type = PLAYER_DISPLAY_TYPE_NONE; - handle->is_set_pixmap_cb = false; - handle->is_stopped = false; - handle->is_display_visible = true; - handle->is_progressive_download = false; - LOGI("[%s] End", __FUNCTION__); - PLAYER_TRACE_END(); - return PLAYER_ERROR_NONE; +int player_prepare(player_h player) +{ + PLAYER_INSTANCE_CHECK(player); + int ret = PLAYER_ERROR_NONE; + muse_player_api_e api = MUSE_PLAYER_API_PREPARE; + player_cli_s *pc = (player_cli_s *)player; + char *ret_buf = NULL; + + LOGD("ENTER"); + + player_msg_send(api, pc, ret_buf, ret); + + g_free(ret_buf); + return ret; +} + +int player_unprepare(player_h player) +{ + PLAYER_INSTANCE_CHECK(player); + int ret = PLAYER_ERROR_NONE; + muse_player_api_e api = MUSE_PLAYER_API_UNPREPARE; + player_cli_s *pc = (player_cli_s *)player; + char *ret_buf = NULL; + + LOGD("ENTER"); + + if (!CALLBACK_INFO(pc)) + return PLAYER_ERROR_INVALID_STATE; + + player_msg_send(api, pc, ret_buf, ret); + if (ret == PLAYER_ERROR_NONE) { + set_null_user_cb_lock(pc->cb_info, MUSE_PLAYER_EVENT_TYPE_SEEK); + set_null_user_cb_lock(pc->cb_info, MUSE_PLAYER_EVENT_TYPE_PREPARE); + _del_mem(pc); + _player_deinit_memory_buffer(pc); } + + 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); - player_s *handle = (player_s *)player; - PLAYER_STATE_CHECK(handle, PLAYER_STATE_IDLE); + int ret = PLAYER_ERROR_NONE; + muse_player_api_e api = MUSE_PLAYER_API_SET_URI; + player_cli_s *pc = (player_cli_s *)player; + char *ret_buf = NULL; - int ret = mm_player_set_uri(handle->mm_handle, uri); + LOGD("ENTER"); - if (ret != MM_ERROR_NONE) - return __player_convert_error_code(ret, (char *)__FUNCTION__); - else - return PLAYER_ERROR_NONE; + player_msg_send1(api, pc, 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); - PLAYER_CHECK_CONDITION(size >= 0, PLAYER_ERROR_INVALID_PARAMETER, "PLAYER_ERROR_INVALID_PARAMETER"); - player_s *handle = (player_s *)player; - PLAYER_STATE_CHECK(handle, PLAYER_STATE_IDLE); + int ret = PLAYER_ERROR_NONE; + muse_player_api_e api = MUSE_PLAYER_API_SET_MEMORY_BUFFER; + player_cli_s *pc = (player_cli_s *)player; + char *ret_buf = NULL; + tbm_bo bo; + tbm_bo_handle thandle; + tbm_key key; + + if (SERVER_TBM_BO(pc)) { + LOGE("Already set the memory buffer. unprepare please"); + return PLAYER_ERROR_INVALID_OPERATION; + } + + bo = tbm_bo_alloc(pc->cb_info->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); - char uri[PATH_MAX]; + key = tbm_bo_export(bo); + if (key == 0) { + LOGE("TBM get error : key is 0"); + ret = PLAYER_ERROR_INVALID_OPERATION; + goto set_memory_exit; + } - snprintf(uri, sizeof(uri), "mem:///ext=%s,size=%d", "", size); - int ret = mm_player_set_attribute(handle->mm_handle, NULL, MM_PLAYER_CONTENT_URI, uri, strlen(uri), MM_PLAYER_MEMORY_SRC, data, size, (char *)NULL); - if (ret != MM_ERROR_NONE) - return __player_convert_error_code(ret, (char *)__FUNCTION__); - else - return PLAYER_ERROR_NONE; + player_msg_send2(api, pc, 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)) + SERVER_TBM_BO(pc) = (intptr_t)bo_addr; + } + + g_free(ret_buf); + return ret; } -int player_get_state(player_h player, player_state_e *state) +static int _player_deinit_memory_buffer(player_cli_s *pc) +{ + PLAYER_INSTANCE_CHECK(pc); + int ret = PLAYER_ERROR_NONE; + muse_player_api_e api = MUSE_PLAYER_API_DEINIT_MEMORY_BUFFER; + intptr_t bo_addr = SERVER_TBM_BO(pc); + + if (!bo_addr) + return ret; + + player_msg_send1_async(api, pc, POINTER, bo_addr); + SERVER_TBM_BO(pc) = 0; + + return ret; +} + +int player_get_state(player_h player, player_state_e *pstate) { PLAYER_INSTANCE_CHECK(player); - PLAYER_NULL_ARG_CHECK(state); - player_s *handle = (player_s *)player; - *state = handle->state; - MMPlayerStateType currentStat = MM_PLAYER_STATE_NULL; - mm_player_get_state(handle->mm_handle, ¤tStat); - /* LOGI("[%s] State : %d (FW state : %d)", __FUNCTION__,handle->state, currentStat); */ - return PLAYER_ERROR_NONE; + PLAYER_NULL_ARG_CHECK(pstate); + int ret = PLAYER_ERROR_NONE; + muse_player_api_e api = MUSE_PLAYER_API_GET_STATE; + player_cli_s *pc = (player_cli_s *)player; + int state; + char *ret_buf = NULL; + + LOGD("ENTER"); + + player_msg_send(api, pc, 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) @@ -1382,1041 +1344,997 @@ 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"); - player_s *handle = (player_s *)player; - MMPlayerVolumeType vol; - vol.level[MM_VOLUME_CHANNEL_LEFT] = left; - vol.level[MM_VOLUME_CHANNEL_RIGHT] = right; - int ret = mm_player_set_volume(handle->mm_handle, &vol); - if (ret != MM_ERROR_NONE) - return __player_convert_error_code(ret, (char *)__FUNCTION__); - else - return PLAYER_ERROR_NONE; + int ret = PLAYER_ERROR_NONE; + muse_player_api_e api = MUSE_PLAYER_API_SET_VOLUME; + player_cli_s *pc = (player_cli_s *)player; + char *ret_buf = NULL; + + LOGD("ENTER"); + + player_msg_send2(api, pc, ret_buf, ret, DOUBLE, right, DOUBLE, left); + g_free(ret_buf); + return ret; } -int player_get_volume(player_h player, float *left, float *right) +int player_get_volume(player_h player, float *pleft, float *pright) { PLAYER_INSTANCE_CHECK(player); - PLAYER_NULL_ARG_CHECK(left); - PLAYER_NULL_ARG_CHECK(right); - player_s *handle = (player_s *)player; - MMPlayerVolumeType vol; - int ret = mm_player_get_volume(handle->mm_handle, &vol); - if (ret != MM_ERROR_NONE) { - return __player_convert_error_code(ret, (char *)__FUNCTION__); - } else { - *left = vol.level[MM_VOLUME_CHANNEL_LEFT]; - *right = vol.level[MM_VOLUME_CHANNEL_RIGHT]; - return PLAYER_ERROR_NONE; + PLAYER_NULL_ARG_CHECK(pleft); + PLAYER_NULL_ARG_CHECK(pright); + int ret = PLAYER_ERROR_NONE; + muse_player_api_e api = MUSE_PLAYER_API_GET_VOLUME; + player_cli_s *pc = (player_cli_s *)player; + double left = -1; + double right = -1; + char *ret_buf = NULL; + + LOGD("ENTER"); + + player_msg_send(api, pc, ret_buf, ret); + + if (ret == PLAYER_ERROR_NONE) { + player_msg_get_type(left, ret_buf, DOUBLE); + player_msg_get_type(right, ret_buf, DOUBLE); + *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); - player_s *handle = (player_s *)player; + int ret = PLAYER_ERROR_NONE; + muse_player_api_e api = MUSE_PLAYER_API_SET_SOUND_TYPE; + player_cli_s *pc = (player_cli_s *)player; + char *ret_buf = NULL; - PLAYER_STATE_CHECK(handle, PLAYER_STATE_IDLE); + LOGD("ENTER"); - int sig_value = 0; - char *stream_type = NULL; - int stream_index = -1; - - /* check if focus is released */ - mm_sound_get_signal_value(MM_SOUND_SIGNAL_RELEASE_INTERNAL_FOCUS, &sig_value); - if(sig_value) - return PLAYER_ERROR_SOUND_POLICY; - - /* convert volume_type to stream_type */ - switch(type) { - case SOUND_TYPE_SYSTEM: - stream_type = "system"; - break; - case SOUND_TYPE_NOTIFICATION: - stream_type = "notification"; - break; - case SOUND_TYPE_ALARM: - stream_type = "alarm"; - break; - case SOUND_TYPE_RINGTONE: - stream_type = "ringtone-voip"; - break; - case SOUND_TYPE_MEDIA: - case SOUND_TYPE_CALL: - stream_type = "media"; - break; - case SOUND_TYPE_VOIP: - stream_type = "voip"; - break; - case SOUND_TYPE_VOICE: - stream_type = "voice-information"; - break; - default: - LOGW("check the value[%d].\n", type); - return PLAYER_ERROR_INVALID_PARAMETER; - } - LOGI("[%s] sound type = %s", __FUNCTION__, stream_type); - - int ret = mm_player_set_attribute(handle->mm_handle, NULL, "sound_stream_type", stream_type, strlen(stream_type), "sound_stream_index", stream_index, (char *)NULL); - if (ret != MM_ERROR_NONE) - return __player_convert_error_code(ret, (char *)__FUNCTION__); - else - return PLAYER_ERROR_NONE; + player_msg_send1(api, pc, ret_buf, ret, INT, type); + g_free(ret_buf); + return ret; } int player_set_audio_policy_info(player_h player, sound_stream_info_h stream_info) { PLAYER_INSTANCE_CHECK(player); - player_s *handle = (player_s *)player; - PLAYER_STATE_CHECK(handle, PLAYER_STATE_IDLE); + + muse_player_api_e api = MUSE_PLAYER_API_SET_AUDIO_POLICY_INFO; + player_cli_s *pc = (player_cli_s *)player; + char *ret_buf = NULL; + + LOGD("ENTER"); bool is_available = false; /* check if stream_info is valid */ - int ret = sound_manager_is_available_stream_information(stream_info, NATIVE_API_PLAYER, &is_available); + int ret = __player_convert_error_code( + sound_manager_is_available_stream_information( + stream_info, NATIVE_API_PLAYER, &is_available), (char *)__FUNCTION__); - if (ret != MM_ERROR_NONE) { - return __player_convert_error_code(ret, (char *)__FUNCTION__); - } else { + if (ret == PLAYER_ERROR_NONE) { if (is_available == false) - ret = MM_ERROR_NOT_SUPPORT_API; + 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) - ret = mm_player_set_attribute(handle->mm_handle, NULL, "sound_stream_type", stream_type, strlen(stream_type), "sound_stream_index", stream_index, (char *)NULL); + player_msg_send2(api, pc, ret_buf, ret, STRING, stream_type, INT, stream_index); else - ret = MM_ERROR_PLAYER_INTERNAL; + ret = PLAYER_ERROR_INVALID_OPERATION; } } - if (ret != MM_ERROR_NONE) - return __player_convert_error_code(ret, (char *)__FUNCTION__); - else - return PLAYER_ERROR_NONE; + g_free(ret_buf); + return ret; + } int player_set_audio_latency_mode(player_h player, audio_latency_mode_e latency_mode) { PLAYER_INSTANCE_CHECK(player); - player_s *handle = (player_s *)player; + int ret = PLAYER_ERROR_NONE; + muse_player_api_e api = MUSE_PLAYER_API_SET_AUDIO_LATENCY_MODE; + player_cli_s *pc = (player_cli_s *)player; + char *ret_buf = NULL; - int ret = mm_player_set_attribute(handle->mm_handle, NULL, "sound_latency_mode", latency_mode, (char *)NULL); - if (ret != MM_ERROR_NONE) - return __player_convert_error_code(ret, (char *)__FUNCTION__); - else - return PLAYER_ERROR_NONE; + LOGD("ENTER"); + + player_msg_send1(api, pc, 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 * latency_mode) +int player_get_audio_latency_mode(player_h player, audio_latency_mode_e *platency_mode) { PLAYER_INSTANCE_CHECK(player); - PLAYER_NULL_ARG_CHECK(latency_mode); - player_s *handle = (player_s *)player; + PLAYER_NULL_ARG_CHECK(platency_mode); + int ret = PLAYER_ERROR_NONE; + muse_player_api_e api = MUSE_PLAYER_API_GET_AUDIO_LATENCY_MODE; + player_cli_s *pc = (player_cli_s *)player; + char *ret_buf = NULL; + int latency_mode = -1; + + LOGD("ENTER"); + + player_msg_send(api, pc, 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 ret = mm_player_get_attribute(handle->mm_handle, NULL, "sound_latency_mode", latency_mode, (char *)NULL); - if (ret != MM_ERROR_NONE) - return __player_convert_error_code(ret, (char *)__FUNCTION__); - else - return PLAYER_ERROR_NONE; } int player_start(player_h player) { - LOGI("[%s] Start", __FUNCTION__); PLAYER_INSTANCE_CHECK(player); - player_s *handle = (player_s *)player; - int ret; - if (handle->state == PLAYER_STATE_READY || handle->state == PLAYER_STATE_PAUSED) { - if (handle->display_type == PLAYER_DISPLAY_TYPE_OVERLAY -#ifdef TIZEN_MOBILE - || handle->display_type == PLAYER_DISPLAY_TYPE_EVAS -#endif - ) { - if (handle->is_display_visible) - ret = mm_player_set_attribute(handle->mm_handle, NULL, "display_visible", 1, (char *)NULL); - } + int ret = PLAYER_ERROR_NONE; + muse_player_api_e api = MUSE_PLAYER_API_START; + player_cli_s *pc = (player_cli_s *)player; + char *ret_buf = NULL; - if (handle->is_stopped) { - if (handle->is_progressive_download) { - LOGE("[%s] PLAYER_ERROR_INVALID_OPERATION(0x%08x)", __FUNCTION__, PLAYER_ERROR_INVALID_OPERATION); - return PLAYER_ERROR_INVALID_OPERATION; - } + LOGD("ENTER"); - ret = mm_player_start(handle->mm_handle); - LOGI("[%s] stop -> start() ", __FUNCTION__); - } else { - if (handle->is_progressive_download && handle->state == PLAYER_STATE_READY) - ret = mm_player_start(handle->mm_handle); - else - ret = mm_player_resume(handle->mm_handle); - } - } else { - LOGE("[%s] PLAYER_ERROR_INVALID_STATE(0x%08x) : current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state); - return PLAYER_ERROR_INVALID_STATE; - } + player_msg_send(api, pc, ret_buf, ret); - if (ret != MM_ERROR_NONE) { - return __player_convert_error_code(ret, (char *)__FUNCTION__); - } else { - handle->is_stopped = FALSE; - handle->state = PLAYER_STATE_PLAYING; - LOGI("[%s] End", __FUNCTION__); - return PLAYER_ERROR_NONE; - } + g_free(ret_buf); + return ret; } int player_stop(player_h player) { - LOGI("[%s] Start", __FUNCTION__); PLAYER_INSTANCE_CHECK(player); - player_s *handle = (player_s *)player; - if (handle->state == PLAYER_STATE_PLAYING || handle->state == PLAYER_STATE_PAUSED) { - int ret = mm_player_stop(handle->mm_handle); + int ret = PLAYER_ERROR_NONE; + muse_player_api_e api = MUSE_PLAYER_API_STOP; + player_cli_s *pc = (player_cli_s *)player; + char *ret_buf = NULL; - if (handle->display_type == PLAYER_DISPLAY_TYPE_OVERLAY -#ifdef TIZEN_MOBILE - || handle->display_type == PLAYER_DISPLAY_TYPE_EVAS -#endif - ) { - ret = mm_player_set_attribute(handle->mm_handle, NULL, "display_visible", 0, (char *)NULL); - } + LOGD("ENTER"); - if (ret != MM_ERROR_NONE) { - return __player_convert_error_code(ret, (char *)__FUNCTION__); - } else { - if (handle->user_cb[_PLAYER_EVENT_TYPE_SEEK]) { - handle->user_cb[_PLAYER_EVENT_TYPE_SEEK] = NULL; - handle->user_data[_PLAYER_EVENT_TYPE_SEEK] = NULL; - } + player_msg_send(api, pc, ret_buf, ret); + if (ret == PLAYER_ERROR_NONE) + set_null_user_cb_lock(pc->cb_info, MUSE_PLAYER_EVENT_TYPE_SEEK); - handle->state = PLAYER_STATE_READY; - handle->is_stopped = TRUE; - LOGI("[%s] End", __FUNCTION__); - return PLAYER_ERROR_NONE; - } - } else { - LOGE("[%s] PLAYER_ERROR_INVALID_STATE(0x%08x) : current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state); - return PLAYER_ERROR_INVALID_STATE; - } + g_free(ret_buf); + return ret; } int player_pause(player_h player) { - LOGI("[%s] Start", __FUNCTION__); PLAYER_INSTANCE_CHECK(player); - player_s *handle = (player_s *)player; - PLAYER_STATE_CHECK(handle, PLAYER_STATE_PLAYING); + int ret = PLAYER_ERROR_NONE; + muse_player_api_e api = MUSE_PLAYER_API_PAUSE; + player_cli_s *pc = (player_cli_s *)player; + char *ret_buf = NULL; - int ret = mm_player_pause(handle->mm_handle); - if (ret != MM_ERROR_NONE) { - return __player_convert_error_code(ret, (char *)__FUNCTION__); - } else { - handle->state = PLAYER_STATE_PAUSED; - LOGI("[%s] End", __FUNCTION__); - return PLAYER_ERROR_NONE; - } + LOGD("ENTER"); + + player_msg_send(api, pc, 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"); - player_s *handle = (player_s *)player; - if (!__player_state_validate(handle, PLAYER_STATE_READY)) { - LOGE("[%s] PLAYER_ERROR_INVALID_STATE(0x%08x) : current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state); - return PLAYER_ERROR_INVALID_STATE; - } - if (handle->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); + int ret = PLAYER_ERROR_NONE; + muse_player_api_e api = MUSE_PLAYER_API_SET_PLAY_POSITION; + player_cli_s *pc = (player_cli_s *)player; + char *ret_buf = NULL; + int pos = millisecond; + + LOGD("ENTER"); + + if (pc->cb_info->user_cb[MUSE_PLAYER_EVENT_TYPE_SEEK]) { + LOGE("PLAYER_ERROR_SEEK_FAILED (0x%08x) : seeking...", PLAYER_ERROR_SEEK_FAILED); return PLAYER_ERROR_SEEK_FAILED; } else { - LOGI("[%s] Event type : %d, pos : %d ", __FUNCTION__, _PLAYER_EVENT_TYPE_SEEK, millisecond); - handle->user_cb[_PLAYER_EVENT_TYPE_SEEK] = callback; - handle->user_data[_PLAYER_EVENT_TYPE_SEEK] = user_data; + LOGI("Event type : %d, pos : %d ", MUSE_PLAYER_EVENT_TYPE_SEEK, millisecond); + pc->cb_info->user_cb[MUSE_PLAYER_EVENT_TYPE_SEEK] = callback; + pc->cb_info->user_data[MUSE_PLAYER_EVENT_TYPE_SEEK] = user_data; } - int accurated = accurate ? 1 : 0; - int ret = mm_player_set_attribute(handle->mm_handle, NULL, "accurate_seek", accurated, (char *)NULL); - if (ret != MM_ERROR_NONE) - return __player_convert_error_code(ret, (char *)__FUNCTION__); - ret = mm_player_set_position(handle->mm_handle, MM_PLAYER_POS_FORMAT_TIME, millisecond); - if (ret != MM_ERROR_NONE) { - handle->user_cb[_PLAYER_EVENT_TYPE_SEEK] = NULL; - handle->user_data[_PLAYER_EVENT_TYPE_SEEK] = NULL; - return __player_convert_error_code(ret, (char *)__FUNCTION__); - } else { - return PLAYER_ERROR_NONE; - } + player_msg_send2(api, pc, ret_buf, ret, INT, pos, INT, accurate); + + if (ret != PLAYER_ERROR_NONE) + set_null_user_cb(pc->cb_info, MUSE_PLAYER_EVENT_TYPE_SEEK); + + 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); - player_s *handle = (player_s *)player; - if (!__player_state_validate(handle, PLAYER_STATE_READY)) { - LOGE("[%s] PLAYER_ERROR_INVALID_STATE(0x%08x) : current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state); - return PLAYER_ERROR_INVALID_STATE; - } - unsigned long pos; - int ret = mm_player_get_position(handle->mm_handle, MM_PLAYER_POS_FORMAT_TIME, &pos); - if (ret != MM_ERROR_NONE) { - return __player_convert_error_code(ret, (char *)__FUNCTION__); - } else { - *millisecond = (int)pos; - return PLAYER_ERROR_NONE; +{ + PLAYER_INSTANCE_CHECK(player); + PLAYER_NULL_ARG_CHECK(millisecond); + + int ret = PLAYER_ERROR_NONE; + muse_player_api_e api = MUSE_PLAYER_API_GET_PLAY_POSITION; + player_cli_s *pc = (player_cli_s *)player; + int pos; + char *ret_buf = NULL; + + LOGD("ENTER"); + + player_msg_send(api, pc, 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); - player_s *handle = (player_s *)player; + int ret = PLAYER_ERROR_NONE; + muse_player_api_e api = MUSE_PLAYER_API_SET_MUTE; + player_cli_s *pc = (player_cli_s *)player; + char *ret_buf = NULL; + int mute = (int)muted; - int ret = mm_player_set_mute(handle->mm_handle, muted); - if (ret != MM_ERROR_NONE) - return __player_convert_error_code(ret, (char *)__FUNCTION__); - else - return PLAYER_ERROR_NONE; + LOGD("ENTER"); + + player_msg_send1(api, pc, ret_buf, ret, INT, mute); + g_free(ret_buf); + return ret; } -int player_is_muted(player_h player, bool *muted) +int player_is_muted(player_h player, bool * muted) { PLAYER_INSTANCE_CHECK(player); PLAYER_NULL_ARG_CHECK(muted); - player_s *handle = (player_s *)player; + int ret = PLAYER_ERROR_NONE; + muse_player_api_e api = MUSE_PLAYER_API_IS_MUTED; + player_cli_s *pc = (player_cli_s *)player; + char *ret_buf = NULL; + int mute = -1; - int _mute; - int ret = mm_player_get_mute(handle->mm_handle, &_mute); - if (ret != MM_ERROR_NONE) { - return __player_convert_error_code(ret, (char *)__FUNCTION__); - } else { - if (_mute) - *muted = TRUE; - else - *muted = FALSE; - return PLAYER_ERROR_NONE; + LOGD("ENTER"); + + player_msg_send(api, pc, 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); - player_s *handle = (player_s *)player; + int ret = PLAYER_ERROR_NONE; + muse_player_api_e api = MUSE_PLAYER_API_SET_LOOPING; + player_cli_s *pc = (player_cli_s *)player; + char *ret_buf = NULL; - int value = 0; - if (looping == TRUE) - value = -1; - - int ret = mm_player_set_attribute(handle->mm_handle, NULL, MM_PLAYER_PLAYBACK_COUNT, value, (char *)NULL); + LOGD("ENTER"); - if (ret != MM_ERROR_NONE) - return __player_convert_error_code(ret, (char *)__FUNCTION__); - else - return PLAYER_ERROR_NONE; + player_msg_send1(api, pc, ret_buf, ret, INT, looping); + g_free(ret_buf); + return ret; } -int player_is_looping(player_h player, bool *looping) +int player_is_looping(player_h player, bool *plooping) { PLAYER_INSTANCE_CHECK(player); - PLAYER_NULL_ARG_CHECK(looping); - player_s *handle = (player_s *)player; - int count; + PLAYER_NULL_ARG_CHECK(plooping); + int ret = PLAYER_ERROR_NONE; + muse_player_api_e api = MUSE_PLAYER_API_IS_LOOPING; + player_cli_s *pc = (player_cli_s *)player; + char *ret_buf = NULL; + int looping = 0; - int ret = mm_player_get_attribute(handle->mm_handle, NULL, MM_PLAYER_PLAYBACK_COUNT, &count, (char *)NULL); - if (ret != MM_ERROR_NONE) { - return __player_convert_error_code(ret, (char *)__FUNCTION__); - } else { - if (count == -1) - *looping = TRUE; - else - *looping = FALSE; + LOGD("ENTER"); - return PLAYER_ERROR_NONE; + player_msg_send(api, pc, 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 *duration) +int player_get_duration(player_h player, int *pduration) { PLAYER_INSTANCE_CHECK(player); - PLAYER_NULL_ARG_CHECK(duration); - player_s *handle = (player_s *)player; - if (!__player_state_validate(handle, PLAYER_STATE_READY)) { - LOGE("[%s] PLAYER_ERROR_INVALID_STATE(0x%08x) : current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state); - return PLAYER_ERROR_INVALID_STATE; - } - int _duration; - int ret = mm_player_get_attribute(handle->mm_handle, NULL, MM_PLAYER_CONTENT_DURATION, &_duration, (char *)NULL); - if (ret != MM_ERROR_NONE) { - return __player_convert_error_code(ret, (char *)__FUNCTION__); - } else { - *duration = _duration; - /* LOGI("[%s] duration : %d",__FUNCTION__,_duration); */ - return PLAYER_ERROR_NONE; + PLAYER_NULL_ARG_CHECK(pduration); + int ret = PLAYER_ERROR_NONE; + muse_player_api_e api = MUSE_PLAYER_API_GET_DURATION; + player_cli_s *pc = (player_cli_s *)player; + char *ret_buf = NULL; + int duration = 0; + + LOGD("ENTER"); + + player_msg_send(api, pc, 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); - player_s *handle = (player_s *)player; + int ret = PLAYER_ERROR_NONE; + muse_player_api_e api = MUSE_PLAYER_API_SET_DISPLAY; + player_cli_s *pc = (player_cli_s *)player; + char *ret_buf = NULL; Evas_Object *obj = NULL; const char *object_type = NULL; - void *set_handle = NULL; #ifdef HAVE_WAYLAND - void *set_wl_display = NULL; + wl_win_msg_type wl_win; + char *wl_win_msg = (char *)&wl_win; + unsigned int wl_surface_id; + struct wl_surface *wl_surface; + struct wl_display *wl_display; Ecore_Wl_Window *wl_window = NULL; - int wl_window_x = 0; - int wl_window_y = 0; - int wl_window_width = 0; - int wl_window_height = 0; +#else + unsigned int xhandle = 0; #endif - int ret; - if (type != PLAYER_DISPLAY_TYPE_NONE && display == NULL) { - LOGE("display type[%d] is not NONE, but display handle is NULL", type); - return PLAYER_ERROR_INVALID_PARAMETER; - } + LOGD("ENTER"); - if (handle->is_set_pixmap_cb) { - if (handle->state < PLAYER_STATE_READY) { - /* just set below and go to "changing surface case" */ - handle->is_set_pixmap_cb = false; - } else { - LOGE("[%s] pixmap callback was set, try it again after calling player_unprepare()", __FUNCTION__, PLAYER_ERROR_INVALID_OPERATION); - LOGE("[%s] PLAYER_ERROR_INVALID_OPERATION(0x%08x)", __FUNCTION__, PLAYER_ERROR_INVALID_OPERATION); - return PLAYER_ERROR_INVALID_OPERATION; - } - } + if (type != PLAYER_DISPLAY_TYPE_NONE) { + obj = (Evas_Object *)display; + if (!obj) + return PLAYER_ERROR_INVALID_PARAMETER; - void *temp = NULL; - if (type == PLAYER_DISPLAY_TYPE_NONE) { - /* NULL surface */ - handle->display_handle = 0; - handle->display_type = PLAYER_DISPLAY_TYPE_NONE; - set_handle = NULL; - } else { - /* get handle from overlay or evas surface */ - obj = (Evas_Object *) display; object_type = evas_object_type_get(obj); if (object_type) { - temp = handle->display_handle; 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_window_x, &wl_window_y, &wl_window_width, &wl_window_height); - LOGI("get window rectangle: x(%d) y(%d) width(%d) height(%d)", wl_window_x, wl_window_y, wl_window_width, wl_window_height); + 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); + if(player_set_evas_object_cb(player, obj) != MM_ERROR_NONE){ + LOGW("fail to set evas object callback"); + } - /* get wl_surface */ - handle->display_handle = (void *)ecore_wl_window_surface_get(wl_window); - set_handle = handle->display_handle; + wl_window = elm_win_wl_window_get(obj); + wl_surface = (struct wl_surface *) ecore_wl_window_surface_get(wl_window); /* get wl_display */ - handle->wl_display = (void *)ecore_wl_display_get(); - set_wl_display = handle->wl_display; + wl_display = (struct wl_display *) ecore_wl_display_get(); + + if (!pc->wlclient) { + ret = _wlclient_create(&pc->wlclient); + if ( ret != MM_ERROR_NONE) { + LOGE("Wayland client create failure"); + return ret; + } + } + if (wl_surface && wl_display){ + LOGD ("surface = %p, wl_display = %p", wl_surface, wl_display); + wl_surface_id = _wlclient_get_wl_window_wl_surface_id (pc->wlclient, wl_surface, wl_display); + LOGD ("wl_surface_id = %d", wl_surface_id); + wl_win.wl_surface_id = wl_surface_id; + LOGD ("wl_win.wl_surface_id = %d", wl_win.wl_surface_id); + } + if (pc->wlclient) { + g_free(pc->wlclient); + pc->wlclient = NULL; + } #else - /* HAVE_X11 */ /* x window overlay surface */ - LOGI("X overlay surface type"); - handle->display_handle = (void *)(uintptr_t)elm_win_xwindow_get(obj); - set_handle = &(handle->display_handle); + LOGI("overlay surface type"); + xhandle = elm_win_xwindow_get(obj); #endif } #ifdef TIZEN_MOBILE else if (type == PLAYER_DISPLAY_TYPE_EVAS && !strcmp(object_type, "image")) { /* evas object surface */ LOGI("evas surface type"); - handle->display_handle = display; - set_handle = display; + 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); } #endif - else { - LOGE("invalid surface type"); + else return PLAYER_ERROR_INVALID_PARAMETER; - } - } else { - LOGE("falied to get evas object type from %p", obj); + } else return PLAYER_ERROR_INVALID_PARAMETER; - } } - - /* set display handle */ - if (handle->display_type == PLAYER_DISPLAY_TYPE_NONE || type == handle->display_type) { - /* first time or same type */ - ret = mm_player_set_attribute(handle->mm_handle, NULL, "display_surface_type", __player_convet_display_type(type), #ifdef HAVE_WAYLAND - "wl_display", set_wl_display, sizeof(void *), -#endif - "display_overlay", set_handle, sizeof(player_display_h), (char *)NULL); - - if (ret != MM_ERROR_NONE) { - handle->display_handle = temp; - LOGE("[%s] Failed to display surface change :%d", __FUNCTION__, ret); - } else { - if (type != PLAYER_DISPLAY_TYPE_NONE) { - handle->display_type = type; - LOGI("[%s] video display has been changed- type :%d, addr : 0x%x", __FUNCTION__, handle->display_type, handle->display_handle); - } else - LOGI("NULL surface"); - } -#ifdef HAVE_WAYLAND - ret = mm_player_set_attribute(handle->mm_handle, NULL, "wl_window_render_x", wl_window_x, "wl_window_render_y", wl_window_y, "wl_window_render_width", wl_window_width, "wl_window_render_height", wl_window_height, (char *)NULL); - - if (ret != MM_ERROR_NONE) { - handle->display_handle = temp; - LOGE("[%s] Failed to set wl_window render rectangle :%d", __FUNCTION__, ret); - } + else { /* PLAYER_DISPLAY_TYPE_NONE */ + 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, pc, ret_buf, ret, wl_win_msg, sizeof(wl_win_msg_type), sizeof(char)); +#else + player_msg_send2(api, pc, ret_buf, ret, INT, type, INT, xhandle); #endif - } else { - /* changing surface case */ - if (handle->state >= PLAYER_STATE_READY) { - LOGE("[%s] it is not available to change display surface from %d to %d", __FUNCTION__, handle->display_type, type); - return PLAYER_ERROR_INVALID_OPERATION; - } - ret = mm_player_change_videosink(handle->mm_handle, __player_convet_display_type(type), set_handle); - if (ret != MM_ERROR_NONE) { - handle->display_handle = temp; - if (ret == MM_ERROR_NOT_SUPPORT_API) { - LOGE("[%s] change video sink is not available.", __FUNCTION__); - ret = PLAYER_ERROR_NONE; - } else { - LOGE("[%s] Failed to display surface change :%d", __FUNCTION__, ret); - } - } else { - handle->display_type = type; - LOGI("[%s] video display has been changed- type :%d, addr : 0x%x", __FUNCTION__, handle->display_type, handle->display_handle); - } - } - if (ret != MM_ERROR_NONE) { - handle->display_type = PLAYER_DISPLAY_TYPE_NONE; - return __player_convert_error_code(ret, (char *)__FUNCTION__); - } else { - return PLAYER_ERROR_NONE; - } + g_free(ret_buf); + return ret; } int player_set_display_mode(player_h player, player_display_mode_e mode) { PLAYER_INSTANCE_CHECK(player); - player_s *handle = (player_s *)player; - LOGI("[%s] mode:%d", __FUNCTION__, mode); + int ret = PLAYER_ERROR_NONE; + muse_player_api_e api = MUSE_PLAYER_API_SET_DISPLAY_MODE; + player_cli_s *pc = (player_cli_s *)player; + char *ret_buf = NULL; - int ret = mm_player_set_attribute(handle->mm_handle, NULL, "display_method", mode, (char *)NULL); - if (ret != MM_ERROR_NONE) - return __player_convert_error_code(ret, (char *)__FUNCTION__); - else - return PLAYER_ERROR_NONE; + LOGD("ENTER"); + player_msg_send1(api, pc, ret_buf, ret, INT, mode); + g_free(ret_buf); + return ret; } -int player_get_display_mode(player_h player, player_display_mode_e *mode) +int player_get_display_mode(player_h player, player_display_mode_e *pmode) { PLAYER_INSTANCE_CHECK(player); - PLAYER_NULL_ARG_CHECK(mode); - player_s *handle = (player_s *)player; - int ret = mm_player_get_attribute(handle->mm_handle, NULL, "display_method", mode, (char *)NULL); + PLAYER_NULL_ARG_CHECK(pmode); + int ret = PLAYER_ERROR_NONE; +// player_cli_s *pc = (player_cli_s *)player; + int mode = -1; + + LOGD("ENTER"); + +#if 0 + ret = mm_player_get_attribute(INT_HANDLE(pc), NULL, "display_method", &mode, NULL); if (ret != MM_ERROR_NONE) return __player_convert_error_code(ret, (char *)__FUNCTION__); - else - return PLAYER_ERROR_NONE; +#endif + *pmode = mode; + return ret; } int player_set_playback_rate(player_h player, float rate) { - LOGI("[%s] rate : %0.1f", __FUNCTION__, rate); PLAYER_INSTANCE_CHECK(player); PLAYER_CHECK_CONDITION(rate >= -5.0 && rate <= 5.0, PLAYER_ERROR_INVALID_PARAMETER, "PLAYER_ERROR_INVALID_PARAMETER"); - player_s *handle = (player_s *)player; - - if (!__player_state_validate(handle, PLAYER_STATE_READY)) { - LOGE("[%s] PLAYER_ERROR_INVALID_STATE(0x%08x) : current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state); - return PLAYER_ERROR_INVALID_STATE; - } + int ret = PLAYER_ERROR_NONE; + muse_player_api_e api = MUSE_PLAYER_API_SET_PLAYBACK_RATE; + player_cli_s *pc = (player_cli_s *)player; + char *ret_buf = NULL; - int ret = mm_player_set_play_speed(handle->mm_handle, rate, FALSE); + LOGD("ENTER"); - switch (ret) { - case MM_ERROR_NONE: - case MM_ERROR_PLAYER_NO_OP: - ret = PLAYER_ERROR_NONE; - break; - case MM_ERROR_NOT_SUPPORT_API: - case MM_ERROR_PLAYER_SEEK: - LOGE("[%s] PLAYER_ERROR_INVALID_OPERATION(0x%08x) : seek error", __FUNCTION__, PLAYER_ERROR_INVALID_OPERATION); - ret = PLAYER_ERROR_INVALID_OPERATION; - break; - default: - return __player_convert_error_code(ret, (char *)__FUNCTION__); - } + player_msg_send1(api, pc, 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); - player_s *handle = (player_s *)player; + int ret = PLAYER_ERROR_NONE; + muse_player_api_e api = MUSE_PLAYER_API_SET_DISPLAY_ROTATION; + player_cli_s *pc = (player_cli_s *)player; + char *ret_buf = NULL; - int ret = mm_player_set_attribute(handle->mm_handle, NULL, MM_PLAYER_VIDEO_ROTATION, rotation, (char *)NULL); - if (ret != MM_ERROR_NONE) - return __player_convert_error_code(ret, (char *)__FUNCTION__); - else - return PLAYER_ERROR_NONE; + LOGD("ENTER"); + player_msg_send1(api, pc, ret_buf, ret, INT, rotation); + g_free(ret_buf); + return ret; } -int player_get_display_rotation(player_h player, player_display_rotation_e *rotation) +int player_get_display_rotation(player_h player, player_display_rotation_e *protation) { PLAYER_INSTANCE_CHECK(player); - PLAYER_NULL_ARG_CHECK(rotation); - player_s *handle = (player_s *)player; - int ret = mm_player_get_attribute(handle->mm_handle, NULL, MM_PLAYER_VIDEO_ROTATION, rotation, (char *)NULL); + PLAYER_NULL_ARG_CHECK(protation); + int ret = PLAYER_ERROR_NONE; +// player_cli_s *pc = (player_cli_s *)player; + int rotation = -1; + + LOGD("ENTER"); + +#ifdef PREV_PLAYER + ret = mm_player_get_attribute(INT_HANDLE(pc), NULL, "display_rotation", &rotation, NULL); if (ret != MM_ERROR_NONE) return __player_convert_error_code(ret, (char *)__FUNCTION__); - else - return PLAYER_ERROR_NONE; +#endif + *protation = rotation; + + return ret; } int player_set_display_visible(player_h player, bool visible) { PLAYER_INSTANCE_CHECK(player); - player_s *handle = (player_s *)player; - + int ret = PLAYER_ERROR_NONE; +#if 0 + player_cli_s *pc = (player_cli_s *)player; int value = 0; + + LOGD("ENTER"); if (visible == TRUE) value = 1; - - int ret = mm_player_set_attribute(handle->mm_handle, NULL, "display_visible", value, (char *)NULL); - if (ret != MM_ERROR_NONE) { + ret = mm_player_set_attribute(INT_HANDLE(pc), NULL, "display_visible", value, NULL); + if (ret != MM_ERROR_NONE) return __player_convert_error_code(ret, (char *)__FUNCTION__); - } else { - handle->is_display_visible = visible; - return PLAYER_ERROR_NONE; - } +#endif + return ret; } -int player_is_display_visible(player_h player, bool *visible) +int player_is_display_visible(player_h player, bool *pvisible) { PLAYER_INSTANCE_CHECK(player); - PLAYER_NULL_ARG_CHECK(visible); - player_s *handle = (player_s *)player; - int count; - int ret = mm_player_get_attribute(handle->mm_handle, NULL, "display_visible", &count, (char *)NULL); - if (ret != MM_ERROR_NONE) { + PLAYER_NULL_ARG_CHECK(pvisible); + int ret = PLAYER_ERROR_NONE; +// player_cli_s *pc = (player_cli_s *)player; + int value = 0; + + LOGD("ENTER"); +#ifdef PREV_PLAYER + ret = mm_player_get_attribute(INT_HANDLE(pc), NULL, "display_visible", &value, NULL); + if (ret != MM_ERROR_NONE) return __player_convert_error_code(ret, (char *)__FUNCTION__); - } else { - if (count == 0) - *visible = FALSE; + else +#endif + { + if (value) + *pvisible = TRUE; else - *visible = TRUE; - - return PLAYER_ERROR_NONE; + *pvisible = FALSE; } + return ret; } -int player_get_content_info(player_h player, player_content_info_e key, char **value) +int player_get_content_info(player_h player, player_content_info_e key, char **pvalue) { PLAYER_INSTANCE_CHECK(player); - PLAYER_NULL_ARG_CHECK(value); - player_s *handle = (player_s *)player; - if (!__player_state_validate(handle, PLAYER_STATE_READY)) { - LOGE("[%s] PLAYER_ERROR_INVALID_STATE (0x%08x) : current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state); - return PLAYER_ERROR_INVALID_STATE; - } - - char *attr = NULL; - char *val = NULL; - int val_len = 0; - - switch (key) { - case PLAYER_CONTENT_INFO_ALBUM: - attr = MM_PLAYER_TAG_ALBUM; - break; - case PLAYER_CONTENT_INFO_ARTIST: - attr = MM_PLAYER_TAG_ARTIST; - break; - case PLAYER_CONTENT_INFO_AUTHOR: - attr = MM_PLAYER_TAG_AUTHOUR; - break; - case PLAYER_CONTENT_INFO_GENRE: - attr = MM_PLAYER_TAG_GENRE; - break; - case PLAYER_CONTENT_INFO_TITLE: - attr = MM_PLAYER_TAG_TITLE; - break; - case PLAYER_CONTENT_INFO_YEAR: - attr = MM_PLAYER_TAG_DATE; - break; - default: - attr = NULL; - } + PLAYER_NULL_ARG_CHECK(pvalue); + int ret = PLAYER_ERROR_NONE; + muse_player_api_e api = MUSE_PLAYER_API_GET_CONTENT_INFO; + player_cli_s *pc = (player_cli_s *)player; + char *ret_buf = NULL; + char value[MUSE_MSG_MAX_LENGTH] = {0, }; - int ret = mm_player_get_attribute(handle->mm_handle, NULL, attr, &val, &val_len, (char *)NULL); - if (ret != MM_ERROR_NONE) { - return __player_convert_error_code(ret, (char *)__FUNCTION__); - } else { - *value = NULL; - if (val != NULL) - *value = strndup(val, val_len); - else - *value = strndup("", 0); + LOGD("ENTER"); - if (*value == NULL) { - LOGE("[%s] PLAYER_ERROR_OUT_OF_MEMORY(0x%08x) : fail to strdup ", __FUNCTION__, PLAYER_ERROR_OUT_OF_MEMORY); - return PLAYER_ERROR_OUT_OF_MEMORY; - } - return PLAYER_ERROR_NONE; + player_msg_send1(api, pc, ret_buf, ret, INT, key); + if (ret == PLAYER_ERROR_NONE) { + player_msg_get_string(value, ret_buf); + *pvalue = strndup(value, MUSE_MSG_MAX_LENGTH); } + g_free(ret_buf); + return ret; } -int player_get_codec_info(player_h player, char **audio_codec, char **video_codec) +int player_get_codec_info(player_h player, char **paudio_codec, char **pvideo_codec) { PLAYER_INSTANCE_CHECK(player); - PLAYER_NULL_ARG_CHECK(audio_codec); - PLAYER_NULL_ARG_CHECK(video_codec); - player_s *handle = (player_s *)player; - if (!__player_state_validate(handle, PLAYER_STATE_READY)) { - LOGE("[%s] PLAYER_ERROR_INVALID_STATE (0x%08x) : current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state); - return PLAYER_ERROR_INVALID_STATE; - } - - char *audio = NULL; - int audio_len = 0; - char *video = NULL; - int video_len = 0; - - int ret = mm_player_get_attribute(handle->mm_handle, NULL, MM_PLAYER_AUDIO_CODEC, &audio, &audio_len, MM_PLAYER_VIDEO_CODEC, &video, &video_len, (char *)NULL); - if (ret != MM_ERROR_NONE) { - return __player_convert_error_code(ret, (char *)__FUNCTION__); - } else { - *audio_codec = NULL; - if (audio != NULL) - *audio_codec = strndup(audio, audio_len); - else - *audio_codec = strndup("", 0); + PLAYER_NULL_ARG_CHECK(paudio_codec); + PLAYER_NULL_ARG_CHECK(pvideo_codec); + int ret = PLAYER_ERROR_NONE; + muse_player_api_e api = MUSE_PLAYER_API_GET_CODEC_INFO; + player_cli_s *pc = (player_cli_s *)player; + char *ret_buf = NULL; + char video_codec[MUSE_MSG_MAX_LENGTH] = {0, }; + char audio_codec[MUSE_MSG_MAX_LENGTH] = {0, }; - *video_codec = NULL; - if (video != NULL) - *video_codec = strndup(video, video_len); - else - *video_codec = strndup("", 0); + LOGD("ENTER"); - return PLAYER_ERROR_NONE; + player_msg_send(api, pc, 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, MUSE_MSG_MAX_LENGTH); + *paudio_codec = strndup(audio_codec, MUSE_MSG_MAX_LENGTH); } + g_free(ret_buf); + return ret; } -int player_get_audio_stream_info(player_h player, int *sample_rate, int *channel, int *bit_rate) +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(sample_rate); - PLAYER_NULL_ARG_CHECK(channel); - PLAYER_NULL_ARG_CHECK(bit_rate); - player_s *handle = (player_s *)player; - if (!__player_state_validate(handle, PLAYER_STATE_READY)) { - LOGE("[%s] PLAYER_ERROR_INVALID_STATE (0x%08x) : current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state); - return PLAYER_ERROR_INVALID_STATE; - } - int ret = mm_player_get_attribute(handle->mm_handle, NULL, MM_PLAYER_AUDIO_SAMPLERATE, sample_rate, MM_PLAYER_AUDIO_CHANNEL, channel, MM_PLAYER_AUDIO_BITRATE, bit_rate, (char *)NULL); - if (ret != MM_ERROR_NONE) - return __player_convert_error_code(ret, (char *)__FUNCTION__); + PLAYER_NULL_ARG_CHECK(psample_rate); + PLAYER_NULL_ARG_CHECK(pchannel); + PLAYER_NULL_ARG_CHECK(pbit_rate); + int ret = PLAYER_ERROR_NONE; + muse_player_api_e api = MUSE_PLAYER_API_GET_AUDIO_STREAM_INFO; + player_cli_s *pc = (player_cli_s *)player; + char *ret_buf = NULL; + int sample_rate = 0; + int channel = 0; + int bit_rate = 0; + + LOGD("ENTER"); - return PLAYER_ERROR_NONE; + player_msg_send(api, pc, 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 *fps, int *bit_rate) +int player_get_video_stream_info(player_h player, int *pfps, int *pbit_rate) { PLAYER_INSTANCE_CHECK(player); - PLAYER_NULL_ARG_CHECK(fps); - PLAYER_NULL_ARG_CHECK(bit_rate); - player_s *handle = (player_s *)player; - if (!__player_state_validate(handle, PLAYER_STATE_READY)) { - LOGE("[%s] PLAYER_ERROR_INVALID_STATE (0x%08x) : current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state); - return PLAYER_ERROR_INVALID_STATE; - } - int ret = mm_player_get_attribute(handle->mm_handle, NULL, "content_video_fps", fps, "content_video_bitrate", bit_rate, (char *)NULL); - if (ret != MM_ERROR_NONE) - return __player_convert_error_code(ret, (char *)__FUNCTION__); + PLAYER_NULL_ARG_CHECK(pfps); + PLAYER_NULL_ARG_CHECK(pbit_rate); + int ret = PLAYER_ERROR_NONE; + muse_player_api_e api = MUSE_PLAYER_API_GET_VIDEO_STREAM_INFO; + player_cli_s *pc = (player_cli_s *)player; + char *ret_buf = NULL; + int fps = 0; + int bit_rate = 0; - return PLAYER_ERROR_NONE; + LOGD("ENTER"); + + player_msg_send(api, pc, 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 *width, int *height) +int player_get_video_size(player_h player, int *pwidth, int *pheight) { PLAYER_INSTANCE_CHECK(player); - PLAYER_NULL_ARG_CHECK(width); - PLAYER_NULL_ARG_CHECK(height); - player_s *handle = (player_s *)player; - if (!__player_state_validate(handle, PLAYER_STATE_READY)) { - LOGE("[%s] PLAYER_ERROR_INVALID_STATE (0x%08x) : current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state); - return PLAYER_ERROR_INVALID_STATE; - } - int w; - int h; - int ret = mm_player_get_attribute(handle->mm_handle, NULL, MM_PLAYER_VIDEO_WIDTH, &w, MM_PLAYER_VIDEO_HEIGHT, &h, (char *)NULL); - if (ret != MM_ERROR_NONE) { - return __player_convert_error_code(ret, (char *)__FUNCTION__); - } else { - *width = w; - *height = h; - LOGI("[%s] width : %d, height : %d", __FUNCTION__, w, h); - return PLAYER_ERROR_NONE; + PLAYER_NULL_ARG_CHECK(pwidth); + PLAYER_NULL_ARG_CHECK(pheight); + int ret = PLAYER_ERROR_NONE; + muse_player_api_e api = MUSE_PLAYER_API_GET_VIDEO_SIZE; + player_cli_s *pc = (player_cli_s *)player; + char *ret_buf = NULL; + int width = 0; + int height = 0; + + LOGD("ENTER"); + + player_msg_send(api, pc, 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 **album_art, int *size) +int player_get_album_art(player_h player, void **palbum_art, int *psize) { PLAYER_INSTANCE_CHECK(player); - PLAYER_NULL_ARG_CHECK(size); - player_s *handle = (player_s *)player; - if (!__player_state_validate(handle, PLAYER_STATE_READY)) { - LOGE("[%s] PLAYER_ERROR_INVALID_STATE (0x%08x) : current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state); - return PLAYER_ERROR_INVALID_STATE; - } + PLAYER_NULL_ARG_CHECK(palbum_art); + PLAYER_NULL_ARG_CHECK(psize); + int ret = PLAYER_ERROR_NONE; + muse_player_api_e api = MUSE_PLAYER_API_GET_ALBUM_ART; + player_cli_s *pc = (player_cli_s *)player; + char *ret_buf = NULL; + char *album_art; + int size = 0; - int ret = mm_player_get_attribute(handle->mm_handle, NULL, "tag_album_cover", album_art, size, (char *)NULL); - if (ret != MM_ERROR_NONE) - return __player_convert_error_code(ret, (char *)__FUNCTION__); + LOGD("ENTER"); - return PLAYER_ERROR_NONE; + player_msg_send(api, pc, 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 *count) +int player_audio_effect_get_equalizer_bands_count(player_h player, int *pcount) { PLAYER_INSTANCE_CHECK(player); - PLAYER_NULL_ARG_CHECK(count); - player_s *handle = (player_s *)player; + PLAYER_NULL_ARG_CHECK(pcount); + int ret = PLAYER_ERROR_NONE; + muse_player_api_e api = MUSE_PLAYER_API_AUDIO_EFFECT_GET_EQUALIZER_BANDS_COUNT; + player_cli_s *pc = (player_cli_s *)player; + char *ret_buf = NULL; + int count; - int ret = mm_player_audio_effect_custom_get_eq_bands_number(handle->mm_handle, count); - if (ret != MM_ERROR_NONE) - return __player_convert_error_code(ret, (char *)__FUNCTION__); - else - return PLAYER_ERROR_NONE; + LOGD("ENTER"); + + player_msg_send(api, pc, 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); - player_s *handle = (player_s *)player; + int ret = PLAYER_ERROR_NONE; + muse_player_api_e api = MUSE_PLAYER_API_AUDIO_EFFECT_SET_EQUALIZER_ALL_BANDS; + player_cli_s *pc = (player_cli_s *)player; + char *ret_buf = NULL; + + LOGD("ENTER"); + + player_msg_send_array(api, pc, ret_buf, ret, band_levels, length, sizeof(int)); + + g_free(ret_buf); + return ret; - int ret = mm_player_audio_effect_custom_set_level_eq_from_list(handle->mm_handle, band_levels, length); - if (ret != MM_ERROR_NONE) { - return __player_convert_error_code(ret, (char *)__FUNCTION__); - } else { - ret = mm_player_audio_effect_custom_apply(handle->mm_handle); - return (ret == MM_ERROR_NONE) ? PLAYER_ERROR_NONE : __player_convert_error_code(ret, (char *)__FUNCTION__); - } } int player_audio_effect_set_equalizer_band_level(player_h player, int index, int level) { PLAYER_INSTANCE_CHECK(player); - player_s *handle = (player_s *)player; + int ret = PLAYER_ERROR_NONE; + muse_player_api_e api = MUSE_PLAYER_API_AUDIO_EFFECT_SET_EQUALIZER_BAND_LEVEL; + player_cli_s *pc = (player_cli_s *)player; + char *ret_buf = NULL; - int ret = mm_player_audio_effect_custom_set_level(handle->mm_handle, MM_AUDIO_EFFECT_CUSTOM_EQ, index, level); - if (ret != MM_ERROR_NONE) { - return __player_convert_error_code(ret, (char *)__FUNCTION__); - } else { - ret = mm_player_audio_effect_custom_apply(handle->mm_handle); - return (ret == MM_ERROR_NONE) ? PLAYER_ERROR_NONE : __player_convert_error_code(ret, (char *)__FUNCTION__); - } + LOGD("ENTER"); + + player_msg_send2(api, pc, 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 *level) +int player_audio_effect_get_equalizer_band_level(player_h player, int index, int *plevel) { PLAYER_INSTANCE_CHECK(player); - PLAYER_NULL_ARG_CHECK(level); - player_s *handle = (player_s *)player; + PLAYER_NULL_ARG_CHECK(plevel); + int ret = PLAYER_ERROR_NONE; + muse_player_api_e api = MUSE_PLAYER_API_AUDIO_EFFECT_GET_EQUALIZER_BAND_LEVEL; + player_cli_s *pc = (player_cli_s *)player; + char *ret_buf = NULL; + int level; - int ret = mm_player_audio_effect_custom_get_level(handle->mm_handle, MM_AUDIO_EFFECT_CUSTOM_EQ, index, level); - if (ret != MM_ERROR_NONE) - return __player_convert_error_code(ret, (char *)__FUNCTION__); - else - return PLAYER_ERROR_NONE; + LOGD("ENTER"); + + player_msg_send1(api, pc, 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 *min, int *max) +int player_audio_effect_get_equalizer_level_range(player_h player, int *pmin, int *pmax) { PLAYER_INSTANCE_CHECK(player); - PLAYER_NULL_ARG_CHECK(min); - PLAYER_NULL_ARG_CHECK(max); - player_s *handle = (player_s *)player; + PLAYER_NULL_ARG_CHECK(pmin); + PLAYER_NULL_ARG_CHECK(pmax); + int ret = PLAYER_ERROR_NONE; + muse_player_api_e api = MUSE_PLAYER_API_AUDIO_EFFECT_GET_EQUALIZER_LEVEL_RANGE; + player_cli_s *pc = (player_cli_s *)player; + char *ret_buf = NULL; + int min, max; - int ret = mm_player_audio_effect_custom_get_level_range(handle->mm_handle, MM_AUDIO_EFFECT_CUSTOM_EQ, min, max); - if (ret != MM_ERROR_NONE) - return __player_convert_error_code(ret, (char *)__FUNCTION__); - else - return PLAYER_ERROR_NONE; + LOGD("ENTER"); + + player_msg_send(api, pc, 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 *frequency) +int player_audio_effect_get_equalizer_band_frequency(player_h player, int index, int *pfrequency) { PLAYER_INSTANCE_CHECK(player); - PLAYER_NULL_ARG_CHECK(frequency); - player_s *handle = (player_s *)player; + PLAYER_NULL_ARG_CHECK(pfrequency); + int ret = PLAYER_ERROR_NONE; + muse_player_api_e api = MUSE_PLAYER_API_AUDIO_EFFECT_GET_EQUALIZER_BAND_FREQUENCY; + player_cli_s *pc = (player_cli_s *)player; + char *ret_buf = NULL; + int frequency; - int ret = mm_player_audio_effect_custom_get_eq_bands_freq(handle->mm_handle, index, frequency); - if (ret != MM_ERROR_NONE) - return __player_convert_error_code(ret, (char *)__FUNCTION__); - else - return PLAYER_ERROR_NONE; + LOGD("ENTER"); + + player_msg_send1(api, pc, 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 *range) +int player_audio_effect_get_equalizer_band_frequency_range(player_h player, int index, int *prange) { PLAYER_INSTANCE_CHECK(player); - PLAYER_NULL_ARG_CHECK(range); - player_s *handle = (player_s *)player; + PLAYER_NULL_ARG_CHECK(prange); + int ret = PLAYER_ERROR_NONE; + muse_player_api_e api = MUSE_PLAYER_API_AUDIO_EFFECT_GET_EQUALIZER_BAND_FREQUENCY_RANGE; + player_cli_s *pc = (player_cli_s *)player; + char *ret_buf = NULL; + int range; - int ret = mm_player_audio_effect_custom_get_eq_bands_width(handle->mm_handle, index, range); - if (ret != MM_ERROR_NONE) - return __player_convert_error_code(ret, (char *)__FUNCTION__); - else - return PLAYER_ERROR_NONE; + LOGD("ENTER"); + + player_msg_send1(api, pc, 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); - player_s *handle = (player_s *)player; + int ret = PLAYER_ERROR_NONE; + muse_player_api_e api = MUSE_PLAYER_API_AUDIO_EFFECT_EQUALIZER_CLEAR; + player_cli_s *pc = (player_cli_s *)player; + char *ret_buf = NULL; - int ret = mm_player_audio_effect_custom_clear_eq_all(handle->mm_handle); - if (ret != MM_ERROR_NONE) { - return __player_convert_error_code(ret, (char *)__FUNCTION__); - } else { - ret = mm_player_audio_effect_custom_apply(handle->mm_handle); - return (ret == MM_ERROR_NONE) ? PLAYER_ERROR_NONE : __player_convert_error_code(ret, (char *)__FUNCTION__); - } + LOGD("ENTER"); + + player_msg_send(api, pc, ret_buf, ret); + g_free(ret_buf); + return ret; } -int player_audio_effect_equalizer_is_available(player_h player, bool *available) +int player_audio_effect_equalizer_is_available(player_h player, bool * pavailable) { PLAYER_INSTANCE_CHECK(player); - PLAYER_NULL_ARG_CHECK(available); - player_s *handle = (player_s *)player; + PLAYER_NULL_ARG_CHECK(pavailable); + int ret = PLAYER_ERROR_NONE; + muse_player_api_e api = MUSE_PLAYER_API_AUDIO_EFFECT_EQUALIZER_IS_AVAILABLE; + player_cli_s *pc = (player_cli_s *)player; + char *ret_buf = NULL; + int available; - int ret = mm_player_is_supported_custom_effect_type(handle->mm_handle, MM_AUDIO_EFFECT_CUSTOM_EQ); - if (ret != MM_ERROR_NONE) - *available = FALSE; - else - *available = TRUE; - return PLAYER_ERROR_NONE; + LOGD("ENTER"); + + player_msg_send(api, pc, 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); - player_s *handle = (player_s *)player; + int ret = PLAYER_ERROR_NONE; + muse_player_api_e api = MUSE_PLAYER_API_SET_SUBTITLE_PATH; + player_cli_s *pc = (player_cli_s *)player; + char *ret_buf = NULL; - if ((path == NULL) && (handle->state != PLAYER_STATE_IDLE)) - return PLAYER_ERROR_INVALID_PARAMETER; + LOGD("ENTER"); - int ret = mm_player_set_external_subtitle_path(handle->mm_handle, path); - if (ret != MM_ERROR_NONE) - return __player_convert_error_code(ret, (char *)__FUNCTION__); - else - return PLAYER_ERROR_NONE; + player_msg_send1(api, pc, 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); - /* PLAYER_CHECK_CONDITION(millisecond>=0 ,PLAYER_ERROR_INVALID_PARAMETER ,"PLAYER_ERROR_INVALID_PARAMETER" ); */ - player_s *handle = (player_s *)player; - if (!__player_state_validate(handle, PLAYER_STATE_PLAYING)) { - LOGE("[%s] PLAYER_ERROR_INVALID_STATE(0x%08x) : current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state); - return PLAYER_ERROR_INVALID_STATE; - } + int ret = PLAYER_ERROR_NONE; + muse_player_api_e api = MUSE_PLAYER_API_SET_SUBTITLE_POSITION_OFFSET; + player_cli_s *pc = (player_cli_s *)player; + char *ret_buf = NULL; - int ret = mm_player_adjust_subtitle_position(handle->mm_handle, MM_PLAYER_POS_FORMAT_TIME, millisecond); - if (ret != MM_ERROR_NONE) - return __player_convert_error_code(ret, (char *)__FUNCTION__); - else - return PLAYER_ERROR_NONE; + LOGD("ENTER"); + + player_msg_send1(api, pc, 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); - if (!_player_network_availability_check()) - return PLAYER_ERROR_FEATURE_NOT_SUPPORTED_ON_DEVICE; + int ret = PLAYER_ERROR_NONE; + muse_player_api_e api = MUSE_PLAYER_API_SET_PROGRESSIVE_DOWNLOAD_PATH; + player_cli_s *pc = (player_cli_s *)player; + char *ret_buf = NULL; - player_s *handle = (player_s *)player; - PLAYER_STATE_CHECK(handle, PLAYER_STATE_IDLE); + LOGD("ENTER"); - int ret = mm_player_set_attribute(handle->mm_handle, NULL, "pd_mode", MM_PLAYER_PD_MODE_URI, "pd_location", path, strlen(path), (char *)NULL); - if (ret != MM_ERROR_NONE) { - return __player_convert_error_code(ret, (char *)__FUNCTION__); - } else { - handle->is_progressive_download = 1; - return PLAYER_ERROR_NONE; - } + player_msg_send1(api, pc, ret_buf, ret, STRING, path); + g_free(ret_buf); + return ret; } -int player_get_progressive_download_status(player_h player, unsigned long *current, unsigned long *total_size) +int player_get_progressive_download_status(player_h player, unsigned long *pcurrent, unsigned long *ptotal_size) { - PLAYER_INSTANCE_CHECK(player); - PLAYER_NULL_ARG_CHECK(current); - PLAYER_NULL_ARG_CHECK(total_size); - player_s *handle = (player_s *)player; - if (handle->state != PLAYER_STATE_PLAYING && handle->state != PLAYER_STATE_PAUSED) { - LOGE("[%s] PLAYER_ERROR_INVALID_STATE(0x%08x) : current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state); - return PLAYER_ERROR_INVALID_STATE; - } - guint64 _current; - guint64 _total; - int ret = mm_player_get_pd_status(handle->mm_handle, &_current, &_total); - if (ret != MM_ERROR_NONE) { - return __player_convert_error_code(ret, (char *)__FUNCTION__); - } else { - *current = _current; - *total_size = _total; - return PLAYER_ERROR_NONE; + PLAYER_NULL_ARG_CHECK(pcurrent); + PLAYER_NULL_ARG_CHECK(ptotal_size); + int ret = PLAYER_ERROR_NONE; + muse_player_api_e api = MUSE_PLAYER_API_GET_PROGRESSIVE_DOWNLOAD_STATUS; + player_cli_s *pc = (player_cli_s *)player; + char *ret_buf = NULL; + unsigned long current, total_size; + + LOGD("ENTER"); + + player_msg_send(api, pc, ret_buf, ret); + if (ret == PLAYER_ERROR_NONE) { + player_msg_get_type(current, ret_buf, POINTER); + player_msg_get_type(total_size, ret_buf, POINTER); + *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); - - player_s *handle = (player_s *)player; - if (handle->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); + int ret = PLAYER_ERROR_NONE; + muse_player_api_e api = MUSE_PLAYER_API_CAPTURE_VIDEO; + player_cli_s *pc = (player_cli_s *)player; + char *ret_buf = NULL; + + LOGD("ENTER"); + if (pc->cb_info->user_cb[MUSE_PLAYER_EVENT_TYPE_CAPTURE]) { + LOGE("PLAYER_ERROR_VIDEO_CAPTURE_FAILED (0x%08x) : capturing...", PLAYER_ERROR_VIDEO_CAPTURE_FAILED); return PLAYER_ERROR_VIDEO_CAPTURE_FAILED; } else { - LOGI("[%s] Event type : %d ", __FUNCTION__, _PLAYER_EVENT_TYPE_CAPTURE); - handle->user_cb[_PLAYER_EVENT_TYPE_CAPTURE] = callback; - handle->user_data[_PLAYER_EVENT_TYPE_CAPTURE] = user_data; + LOGI("Event type : %d ", MUSE_PLAYER_EVENT_TYPE_CAPTURE); + pc->cb_info->user_cb[MUSE_PLAYER_EVENT_TYPE_CAPTURE] = callback; + pc->cb_info->user_data[MUSE_PLAYER_EVENT_TYPE_CAPTURE] = user_data; } - if (handle->state >= PLAYER_STATE_READY) { - int ret = mm_player_do_video_capture(handle->mm_handle); - if (ret == MM_ERROR_PLAYER_NO_OP) { - handle->user_cb[_PLAYER_EVENT_TYPE_CAPTURE] = NULL; - handle->user_data[_PLAYER_EVENT_TYPE_CAPTURE] = NULL; - LOGE("[%s] PLAYER_ERROR_INVALID_OPERATION (0x%08x) : video display must be set : %d", __FUNCTION__, PLAYER_ERROR_INVALID_OPERATION, handle->display_type); - return PLAYER_ERROR_INVALID_OPERATION; - } - if (ret != MM_ERROR_NONE) { - handle->user_cb[_PLAYER_EVENT_TYPE_CAPTURE] = NULL; - handle->user_data[_PLAYER_EVENT_TYPE_CAPTURE] = NULL; - return __player_convert_error_code(ret, (char *)__FUNCTION__); - } else - return PLAYER_ERROR_NONE; - } else { - LOGE("[%s] PLAYER_ERROR_INVALID_STATE (0x%08x) : current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state); - handle->user_cb[_PLAYER_EVENT_TYPE_CAPTURE] = NULL; - handle->user_data[_PLAYER_EVENT_TYPE_CAPTURE] = NULL; - return PLAYER_ERROR_INVALID_STATE; - } + player_msg_send(api, pc, ret_buf, ret); + + if (ret != PLAYER_ERROR_NONE) + set_null_user_cb(pc->cb_info, MUSE_PLAYER_EVENT_TYPE_CAPTURE); + + g_free(ret_buf); + return ret; } int player_set_streaming_cookie(player_h player, const char *cookie, int size) @@ -2424,14 +2342,16 @@ 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"); - player_s *handle = (player_s *)player; - PLAYER_STATE_CHECK(handle, PLAYER_STATE_IDLE); + int ret = PLAYER_ERROR_NONE; + muse_player_api_e api = MUSE_PLAYER_API_SET_STREAMING_COOKIE; + player_cli_s *pc = (player_cli_s *)player; + char *ret_buf = NULL; - int ret = mm_player_set_attribute(handle->mm_handle, NULL, "streaming_cookie", cookie, size, (char *)NULL); - if (ret != MM_ERROR_NONE) - return __player_convert_error_code(ret, (char *)__FUNCTION__); - else - return PLAYER_ERROR_NONE; + LOGD("ENTER"); + + player_msg_send2(api, pc, 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) @@ -2439,639 +2359,627 @@ int player_set_streaming_user_agent(player_h player, const char *user_agent, int PLAYER_INSTANCE_CHECK(player); PLAYER_NULL_ARG_CHECK(user_agent); PLAYER_CHECK_CONDITION(size >= 0, PLAYER_ERROR_INVALID_PARAMETER, "PLAYER_ERROR_INVALID_PARAMETER"); - player_s *handle = (player_s *)player; - PLAYER_STATE_CHECK(handle, PLAYER_STATE_IDLE); + int ret = PLAYER_ERROR_NONE; + muse_player_api_e api = MUSE_PLAYER_API_SET_STREAMING_COOKIE; + player_cli_s *pc = (player_cli_s *)player; + char *ret_buf = NULL; - int ret = mm_player_set_attribute(handle->mm_handle, NULL, "streaming_user_agent", user_agent, size, (char *)NULL); - if (ret != MM_ERROR_NONE) - return __player_convert_error_code(ret, (char *)__FUNCTION__); - else - return PLAYER_ERROR_NONE; + LOGD("ENTER"); + + player_msg_send2(api, pc, ret_buf, ret, STRING, user_agent, INT, size); + g_free(ret_buf); + return ret; } -int player_get_streaming_download_progress(player_h player, int *start, int *current) +int player_get_streaming_download_progress(player_h player, int *pstart, int *pcurrent) { PLAYER_INSTANCE_CHECK(player); - PLAYER_NULL_ARG_CHECK(start); - PLAYER_NULL_ARG_CHECK(current); - player_s *handle = (player_s *)player; - if (handle->state != PLAYER_STATE_PLAYING && handle->state != PLAYER_STATE_PAUSED) { - LOGE("[%s] PLAYER_ERROR_INVALID_STATE(0x%08x) : current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state); - return PLAYER_ERROR_INVALID_STATE; - } - unsigned long _current = 0; - unsigned long _start = 0; - int ret = mm_player_get_buffer_position(handle->mm_handle, MM_PLAYER_POS_FORMAT_PERCENT, &_start, &_current); - if (ret != MM_ERROR_NONE) { - return __player_convert_error_code(ret, (char *)__FUNCTION__); - } else { - *start = (int)_start; - *current = (int)_current; - return PLAYER_ERROR_NONE; + PLAYER_NULL_ARG_CHECK(pstart); + PLAYER_NULL_ARG_CHECK(pcurrent); + int ret = PLAYER_ERROR_NONE; + muse_player_api_e api = MUSE_PLAYER_API_GET_STREAMING_DOWNLOAD_PROGRESS; + player_cli_s *pc = (player_cli_s *)player; + char *ret_buf = NULL; + int start, current; + + LOGD("ENTER"); + + player_msg_send(api, pc, 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); + return __set_callback(MUSE_PLAYER_EVENT_TYPE_COMPLETE, player, callback, user_data); } int player_unset_completed_cb(player_h player) { - return __unset_callback(_PLAYER_EVENT_TYPE_COMPLETE, player); + return __unset_callback(MUSE_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); + return __set_callback(MUSE_PLAYER_EVENT_TYPE_INTERRUPT, player, callback, user_data); } int player_unset_interrupted_cb(player_h player) { - return __unset_callback(_PLAYER_EVENT_TYPE_INTERRUPT, player); + return __unset_callback(MUSE_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); + return __set_callback(MUSE_PLAYER_EVENT_TYPE_ERROR, player, callback, user_data); } int player_unset_error_cb(player_h player) { - return __unset_callback(_PLAYER_EVENT_TYPE_ERROR, player); + return __unset_callback(MUSE_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); + return __set_callback(MUSE_PLAYER_EVENT_TYPE_BUFFERING, player, callback, user_data); } int player_unset_buffering_cb(player_h player) { - return __unset_callback(_PLAYER_EVENT_TYPE_BUFFERING, player); + return __unset_callback(MUSE_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); + return __set_callback(MUSE_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); + return __unset_callback(MUSE_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); - if (!_player_network_availability_check()) - return PLAYER_ERROR_FEATURE_NOT_SUPPORTED_ON_DEVICE; + int ret = PLAYER_ERROR_NONE; + player_cli_s *pc = (player_cli_s *)player; + muse_player_api_e api = MUSE_PLAYER_API_SET_CALLBACK; + char *ret_buf = NULL; + muse_player_event_e type = MUSE_PLAYER_EVENT_TYPE_PD; + int set = 1; - player_s *handle = (player_s *)player; + LOGD("ENTER"); - if (handle->state != PLAYER_STATE_IDLE && handle->state != PLAYER_STATE_READY) { - LOGE("[%s] PLAYER_ERROR_INVALID_STATE(0x%08x) : current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state); - return PLAYER_ERROR_INVALID_STATE; - } + player_msg_send2(api, pc, ret_buf, ret, INT, type, INT, set); - int ret = mm_player_set_pd_message_callback(handle->mm_handle, __pd_message_callback, (void *)handle); - if (ret != MM_ERROR_NONE) - return __player_convert_error_code(ret, (char *)__FUNCTION__); + 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); + } - handle->user_cb[_PLAYER_EVENT_TYPE_PD] = callback; - handle->user_data[_PLAYER_EVENT_TYPE_PD] = user_data; - LOGI("[%s] Event type : %d ", __FUNCTION__, _PLAYER_EVENT_TYPE_PD); - return PLAYER_ERROR_NONE; + g_free(ret_buf); + return ret; } int player_unset_progressive_download_message_cb(player_h player) { PLAYER_INSTANCE_CHECK(player); - player_s *handle = (player_s *)player; + int ret = PLAYER_ERROR_NONE; + player_cli_s *pc = (player_cli_s *)player; + muse_player_api_e api = MUSE_PLAYER_API_SET_CALLBACK; + char *ret_buf = NULL; + muse_player_event_e type = MUSE_PLAYER_EVENT_TYPE_PD; + int set = 0; - handle->user_cb[_PLAYER_EVENT_TYPE_PD] = NULL; - handle->user_data[_PLAYER_EVENT_TYPE_PD] = NULL; - LOGI("[%s] Event type : %d ", __FUNCTION__, _PLAYER_EVENT_TYPE_PD); + LOGD("ENTER"); + + set_null_user_cb_lock(pc->cb_info, type); + + player_msg_send2(api, pc, ret_buf, ret, INT, type, INT, set); + + g_free(ret_buf); + return ret; - int ret = mm_player_set_pd_message_callback(handle->mm_handle, NULL, NULL); - if (ret != MM_ERROR_NONE) - return __player_convert_error_code(ret, (char *)__FUNCTION__); - else - 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; + muse_player_api_e api = MUSE_PLAYER_API_SET_CALLBACK; + char *ret_buf = NULL; + muse_player_event_e type = MUSE_PLAYER_EVENT_TYPE_MEDIA_PACKET_VIDEO_FRAME; + int set = 1; - player_s *handle = (player_s *)player; - if (handle->state != PLAYER_STATE_IDLE) { - LOGE("[%s] PLAYER_ERROR_INVALID_STATE(0x%08x) : current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state); - return PLAYER_ERROR_INVALID_STATE; - } - - mm_player_enable_media_packet_video_stream(handle->mm_handle, TRUE); + LOGD("ENTER"); - int ret = mm_player_set_video_stream_callback(handle->mm_handle, __video_stream_callback, (void *)handle); - if (ret != MM_ERROR_NONE) - return __player_convert_error_code(ret, (char *)__FUNCTION__); + player_msg_send2(api, pc, ret_buf, ret, INT, type, INT, set); - handle->user_cb[_PLAYER_EVENT_TYPE_MEDIA_PACKET_VIDEO_FRAME] = callback; - handle->user_data[_PLAYER_EVENT_TYPE_MEDIA_PACKET_VIDEO_FRAME] = user_data; - LOGI("Event type : %d ", _PLAYER_EVENT_TYPE_MEDIA_PACKET_VIDEO_FRAME); + if (ret == PLAYER_ERROR_NONE) { + pc->cb_info->user_cb[MUSE_PLAYER_EVENT_TYPE_MEDIA_PACKET_VIDEO_FRAME] = callback; + pc->cb_info->user_data[MUSE_PLAYER_EVENT_TYPE_MEDIA_PACKET_VIDEO_FRAME] = user_data; + LOGI("Event type : %d ", MUSE_PLAYER_EVENT_TYPE_MEDIA_PACKET_VIDEO_FRAME); + } - return PLAYER_ERROR_NONE; + g_free(ret_buf); + return ret; } int player_unset_media_packet_video_frame_decoded_cb(player_h player) { PLAYER_INSTANCE_CHECK(player); - player_s *handle = (player_s *)player; - handle->user_cb[_PLAYER_EVENT_TYPE_MEDIA_PACKET_VIDEO_FRAME] = NULL; - handle->user_data[_PLAYER_EVENT_TYPE_MEDIA_PACKET_VIDEO_FRAME] = NULL; - LOGI("Event type : %d ", _PLAYER_EVENT_TYPE_MEDIA_PACKET_VIDEO_FRAME); + int ret = PLAYER_ERROR_NONE; + player_cli_s *pc = (player_cli_s *)player; + muse_player_api_e api = MUSE_PLAYER_API_SET_CALLBACK; + char *ret_buf = NULL; + muse_player_event_e type = MUSE_PLAYER_EVENT_TYPE_MEDIA_PACKET_VIDEO_FRAME; + int set = 0; - int ret = mm_player_set_video_stream_callback(handle->mm_handle, NULL, NULL); - if (ret != MM_ERROR_NONE) - return __player_convert_error_code(ret, (char *)__FUNCTION__); - else - return PLAYER_ERROR_NONE; -} - -static bool __video_stream_changed_callback(void *user_data) -{ - player_s *handle = (player_s *)user_data; - _player_event_e event_type = _PLAYER_EVENT_TYPE_VIDEO_STREAM_CHANGED; - - LOGE("[%s] event type %d", __FUNCTION__, event_type); - - if (handle->user_cb[event_type]) { - int width = 0, height = 0, fps = 0, bit_rate = 0; - int ret = mm_player_get_attribute(handle->mm_handle, NULL, - MM_PLAYER_VIDEO_WIDTH, &width, - MM_PLAYER_VIDEO_HEIGHT, &height, - "content_video_fps", &fps, - "content_video_bitrate", &bit_rate, (char *)NULL); + LOGD("ENTER"); - if (ret != MM_ERROR_NONE) { - LOGE("[%s] get attr is failed", __FUNCTION__); - return FALSE; - } + set_null_user_cb_lock(pc->cb_info, type); - ((player_video_stream_changed_cb)handle->user_cb[event_type])(width, height, fps, bit_rate, handle->user_data[event_type]); - } else { - LOGE("[%s] video stream changed cb was not set.", __FUNCTION__); - return FALSE; - } + player_msg_send2(api, pc, ret_buf, ret, INT, type, INT, set); - return TRUE; + 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) { - int ret; PLAYER_INSTANCE_CHECK(player); PLAYER_NULL_ARG_CHECK(callback); - player_s *handle = (player_s *)player; + int ret = PLAYER_ERROR_NONE; + player_cli_s *pc = (player_cli_s *)player; + muse_player_api_e api = MUSE_PLAYER_API_SET_CALLBACK; + char *ret_buf = NULL; + muse_player_event_e type = MUSE_PLAYER_EVENT_TYPE_VIDEO_STREAM_CHANGED; + int set = 1; - if (handle->state != PLAYER_STATE_IDLE) { - LOGE("[%s] PLAYER_ERROR_INVALID_STATE(0x%08x) : current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state); - return PLAYER_ERROR_INVALID_STATE; - } + LOGD("ENTER"); - ret = mm_player_set_video_stream_changed_callback(handle->mm_handle, (mm_player_stream_changed_callback)__video_stream_changed_callback, (void *)handle); + player_msg_send2(api, pc, ret_buf, ret, INT, type, INT, set); - if (ret != MM_ERROR_NONE) - return __player_convert_error_code(ret, (char *)__FUNCTION__); + 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); + } - return __set_callback(_PLAYER_EVENT_TYPE_VIDEO_STREAM_CHANGED, player, callback, user_data); + g_free(ret_buf); + return ret; } int player_unset_video_stream_changed_cb(player_h player) { - int ret; PLAYER_INSTANCE_CHECK(player); - player_s *handle = (player_s *)player; - - __unset_callback(_PLAYER_EVENT_TYPE_VIDEO_STREAM_CHANGED, player); - - ret = mm_player_set_video_stream_changed_callback(handle->mm_handle, NULL, NULL); - if (ret != MM_ERROR_NONE) - return __player_convert_error_code(ret, (char *)__FUNCTION__); - else - return PLAYER_ERROR_NONE; -} - -static bool __media_stream_buffer_status_callback(player_stream_type_e type, player_media_stream_buffer_status_e status, unsigned long long bytes, void *user_data) -{ - player_s *handle = (player_s *)user_data; - _player_event_e event_type; - - if (type == PLAYER_STREAM_TYPE_AUDIO) - event_type = _PLAYER_EVENT_TYPE_MEDIA_STREAM_AUDIO_BUFFER_STATUS; - else if (type == PLAYER_STREAM_TYPE_VIDEO) - event_type = _PLAYER_EVENT_TYPE_MEDIA_STREAM_VIDEO_BUFFER_STATUS; - else - return FALSE; - - LOGE("[%s] event type %d", __FUNCTION__, event_type); + int ret = PLAYER_ERROR_NONE; + player_cli_s *pc = (player_cli_s *)player; + muse_player_api_e api = MUSE_PLAYER_API_SET_CALLBACK; + char *ret_buf = NULL; + muse_player_event_e type = MUSE_PLAYER_EVENT_TYPE_VIDEO_STREAM_CHANGED; + int set = 0; - if (handle->user_cb[event_type]) { - ((player_media_stream_buffer_status_cb)handle->user_cb[event_type])(status, handle->user_data[event_type]); - } else { - LOGE("[%s][type:%d] buffer status cb was not set.", __FUNCTION__, type); - return FALSE; - } - - return TRUE; -} - -static bool __media_stream_seek_data_callback(player_stream_type_e type, unsigned long long offset, void *user_data) -{ - player_s *handle = (player_s *)user_data; - _player_event_e event_type; - - if (type == PLAYER_STREAM_TYPE_AUDIO) - event_type = _PLAYER_EVENT_TYPE_MEDIA_STREAM_AUDIO_SEEK; - else if (type == PLAYER_STREAM_TYPE_VIDEO) - event_type = _PLAYER_EVENT_TYPE_MEDIA_STREAM_VIDEO_SEEK; - else - return FALSE; + LOGD("ENTER"); - LOGE("[%s] event type %d", __FUNCTION__, event_type); + set_null_user_cb_lock(pc->cb_info, type); - if (handle->user_cb[event_type]) { - ((player_media_stream_seek_cb)handle->user_cb[event_type])(offset, handle->user_data[event_type]); - } else { - LOGE("[%s][type:%d] seek cb was not set.", __FUNCTION__, type); - return FALSE; - } + player_msg_send2(api, pc, ret_buf, ret, INT, type, INT, set); - return TRUE; + g_free(ret_buf); + return ret; } -int player_set_media_stream_buffer_status_cb(player_h player, player_stream_type_e type, player_media_stream_buffer_status_cb callback, void *user_data) +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) { - int ret; PLAYER_INSTANCE_CHECK(player); PLAYER_NULL_ARG_CHECK(callback); - player_s *handle = (player_s *)player; - - if (handle->state != PLAYER_STATE_IDLE) { - LOGE("[%s] PLAYER_ERROR_INVALID_STATE(0x%08x) : current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state); - return PLAYER_ERROR_INVALID_STATE; - } - /* the type can be expaned with default and text. */ - if ((type != PLAYER_STREAM_TYPE_VIDEO) && (type != PLAYER_STREAM_TYPE_AUDIO)) { - LOGE("[%s] PLAYER_ERROR_INVALID_PARAMETER(type : %d)", __FUNCTION__, type); + int ret = PLAYER_ERROR_NONE; + player_cli_s *pc = (player_cli_s *)player; + muse_player_api_e api = MUSE_PLAYER_API_SET_CALLBACK; + char *ret_buf = NULL; + muse_player_event_e type; + int set = 1; + + LOGD("ENTER"); + + if (stream_type == PLAYER_STREAM_TYPE_VIDEO) + type = MUSE_PLAYER_EVENT_TYPE_MEDIA_STREAM_VIDEO_BUFFER_STATUS; + else if (stream_type == PLAYER_STREAM_TYPE_AUDIO) + type = MUSE_PLAYER_EVENT_TYPE_MEDIA_STREAM_AUDIO_BUFFER_STATUS; + else { + LOGE("PLAYER_ERROR_INVALID_PARAMETER(type : %d)", stream_type); return PLAYER_ERROR_INVALID_PARAMETER; } - ret = mm_player_set_media_stream_buffer_status_callback(handle->mm_handle, type, (mm_player_media_stream_buffer_status_callback)__media_stream_buffer_status_callback, (void *)handle); + player_msg_send2(api, pc, ret_buf, ret, INT, type, INT, set); - if (ret != MM_ERROR_NONE) - return __player_convert_error_code(ret, (char *)__FUNCTION__); + 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); + } - if (type == PLAYER_STREAM_TYPE_VIDEO) - return __set_callback(_PLAYER_EVENT_TYPE_MEDIA_STREAM_VIDEO_BUFFER_STATUS, player, callback, user_data); - else - return __set_callback(_PLAYER_EVENT_TYPE_MEDIA_STREAM_AUDIO_BUFFER_STATUS, player, callback, user_data); + g_free(ret_buf); + return ret; } -int player_unset_media_stream_buffer_status_cb(player_h player, player_stream_type_e type) +int player_unset_media_stream_buffer_status_cb(player_h player, player_stream_type_e stream_type) { - int ret; PLAYER_INSTANCE_CHECK(player); - player_s *handle = (player_s *)player; + int ret = PLAYER_ERROR_NONE; + player_cli_s *pc = (player_cli_s *)player; + muse_player_api_e api = MUSE_PLAYER_API_SET_CALLBACK; + char *ret_buf = NULL; + muse_player_event_e type; + int set = 0; - if (type == PLAYER_STREAM_TYPE_VIDEO) - __unset_callback(_PLAYER_EVENT_TYPE_MEDIA_STREAM_VIDEO_BUFFER_STATUS, player); - else if (type == PLAYER_STREAM_TYPE_AUDIO) - __unset_callback(_PLAYER_EVENT_TYPE_MEDIA_STREAM_AUDIO_BUFFER_STATUS, player); - else + LOGD("ENTER"); + + if (stream_type == PLAYER_STREAM_TYPE_VIDEO) + type = MUSE_PLAYER_EVENT_TYPE_MEDIA_STREAM_VIDEO_BUFFER_STATUS; + else if (stream_type == PLAYER_STREAM_TYPE_AUDIO) + type = MUSE_PLAYER_EVENT_TYPE_MEDIA_STREAM_AUDIO_BUFFER_STATUS; + else { + LOGE("PLAYER_ERROR_INVALID_PARAMETER(type : %d)", stream_type); return PLAYER_ERROR_INVALID_PARAMETER; + } - ret = mm_player_set_media_stream_buffer_status_callback(handle->mm_handle, type, NULL, NULL); - if (ret != MM_ERROR_NONE) - return __player_convert_error_code(ret, (char *)__FUNCTION__); - else - return PLAYER_ERROR_NONE; + set_null_user_cb_lock(pc->cb_info, type); + + player_msg_send2(api, pc, 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 type, player_media_stream_seek_cb callback, void *user_data) +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) { - int ret; PLAYER_INSTANCE_CHECK(player); PLAYER_NULL_ARG_CHECK(callback); - player_s *handle = (player_s *)player; - - if (handle->state != PLAYER_STATE_IDLE) { - LOGE("[%s] PLAYER_ERROR_INVALID_STATE(0x%08x) : current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state); - return PLAYER_ERROR_INVALID_STATE; - } - /* the type can be expaned with default and text. */ - if ((type != PLAYER_STREAM_TYPE_VIDEO) && (type != PLAYER_STREAM_TYPE_AUDIO)) { - LOGE("[%s] PLAYER_ERROR_INVALID_PARAMETER(type : %d)", __FUNCTION__, type); + int ret = PLAYER_ERROR_NONE; + player_cli_s *pc = (player_cli_s *)player; + muse_player_api_e api = MUSE_PLAYER_API_SET_CALLBACK; + char *ret_buf = NULL; + muse_player_event_e type; + int set = 1; + + LOGD("ENTER"); + + if (stream_type == PLAYER_STREAM_TYPE_VIDEO) + type = MUSE_PLAYER_EVENT_TYPE_MEDIA_STREAM_VIDEO_SEEK; + else if (stream_type == PLAYER_STREAM_TYPE_AUDIO) + type = MUSE_PLAYER_EVENT_TYPE_MEDIA_STREAM_AUDIO_SEEK; + else { + LOGE("PLAYER_ERROR_INVALID_PARAMETER(type : %d)", stream_type); return PLAYER_ERROR_INVALID_PARAMETER; } - ret = mm_player_set_media_stream_seek_data_callback(handle->mm_handle, type, (mm_player_media_stream_seek_data_callback)__media_stream_seek_data_callback, (void *)handle); + player_msg_send2(api, pc, ret_buf, ret, INT, type, INT, set); - if (ret != MM_ERROR_NONE) - return __player_convert_error_code(ret, (char *)__FUNCTION__); + 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); + } - if (type == PLAYER_STREAM_TYPE_VIDEO) - return __set_callback(_PLAYER_EVENT_TYPE_MEDIA_STREAM_VIDEO_SEEK, player, callback, user_data); - else - return __set_callback(_PLAYER_EVENT_TYPE_MEDIA_STREAM_AUDIO_SEEK, player, callback, user_data); + g_free(ret_buf); + return ret; } -int player_unset_media_stream_seek_cb(player_h player, player_stream_type_e type) +int player_unset_media_stream_seek_cb(player_h player, player_stream_type_e stream_type) { - int ret; PLAYER_INSTANCE_CHECK(player); - player_s *handle = (player_s *)player; + int ret = PLAYER_ERROR_NONE; + player_cli_s *pc = (player_cli_s *)player; + muse_player_api_e api = MUSE_PLAYER_API_SET_CALLBACK; + char *ret_buf = NULL; + muse_player_event_e type; + int set = 0; - if (type == PLAYER_STREAM_TYPE_VIDEO) - __unset_callback(_PLAYER_EVENT_TYPE_MEDIA_STREAM_VIDEO_SEEK, player); - else if (type == PLAYER_STREAM_TYPE_AUDIO) - __unset_callback(_PLAYER_EVENT_TYPE_MEDIA_STREAM_AUDIO_SEEK, player); - else + LOGD("ENTER"); + + if (stream_type == PLAYER_STREAM_TYPE_VIDEO) + type = MUSE_PLAYER_EVENT_TYPE_MEDIA_STREAM_VIDEO_SEEK; + else if (stream_type == PLAYER_STREAM_TYPE_AUDIO) + type = MUSE_PLAYER_EVENT_TYPE_MEDIA_STREAM_AUDIO_SEEK; + else { + LOGE("PLAYER_ERROR_INVALID_PARAMETER(type : %d)", stream_type); return PLAYER_ERROR_INVALID_PARAMETER; + } - ret = mm_player_set_media_stream_seek_data_callback(handle->mm_handle, type, NULL, NULL); - if (ret != MM_ERROR_NONE) - return __player_convert_error_code(ret, (char *)__FUNCTION__); - else - return PLAYER_ERROR_NONE; + set_null_user_cb_lock(pc->cb_info, type); + + player_msg_send2(api, pc, 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_s *handle = (player_s *)player; + PLAYER_NULL_ARG_CHECK(packet); + int ret = PLAYER_ERROR_NONE; + player_cli_s *pc = (player_cli_s *)player; + muse_player_api_e api = MUSE_PLAYER_API_PUSH_MEDIA_STREAM; + 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); + media_packet_get_flags(packet, &push_media.flags); + + 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(pc->cb_info->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_CHECK_CONDITION(handle->error_code == PLAYER_ERROR_NONE, PLAYER_ERROR_NOT_SUPPORTED_FILE, "can't support this format"); + player_msg_send_array(api, pc, 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, pc, 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) { + muse_core_ipc_push_data(pc->cb_info->data_fd, buf, push_media.size, push_media.pts); + player_msg_send_array(api, pc, ret_buf, ret, push_media_msg, msg_size, sizeof(char)); + } - int ret = mm_player_submit_packet(handle->mm_handle, packet); + LOGD("ret_buf %s", ret_buf); - if (ret != MM_ERROR_NONE) - return __player_convert_error_code(ret, (char *)__FUNCTION__); - else - return PLAYER_ERROR_NONE; +#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) { - int ret; PLAYER_INSTANCE_CHECK(player); - player_s *handle = (player_s *)player; - PLAYER_STATE_CHECK(handle, PLAYER_STATE_IDLE); - - if (type == PLAYER_STREAM_TYPE_VIDEO) - ret = mm_player_set_video_info(handle->mm_handle, format); - else if (type == PLAYER_STREAM_TYPE_AUDIO) - ret = mm_player_set_audio_info(handle->mm_handle, format); - else - return PLAYER_ERROR_INVALID_PARAMETER; - - if (ret != MM_ERROR_NONE) - return __player_convert_error_code(ret, (char *)__FUNCTION__); - else - return PLAYER_ERROR_NONE; - - return PLAYER_ERROR_NONE; + g_return_val_if_fail(format, PLAYER_ERROR_INVALID_OPERATION); + int ret = PLAYER_ERROR_NONE; + player_cli_s *pc = (player_cli_s *)player; + muse_player_api_e api = MUSE_PLAYER_API_SET_MEDIA_STREAM_INFO; + 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, pc, 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, pc, 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; + int ret = PLAYER_ERROR_NONE; PLAYER_INSTANCE_CHECK(player); - player_s *handle = (player_s *)player; - if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) { - LOGE("[%s] PLAYER_ERROR_INVALID_STATE(0x%08x) : current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state); - return PLAYER_ERROR_INVALID_STATE; - } + player_cli_s *pc = (player_cli_s *)player; + muse_player_api_e api = MUSE_PLAYER_API_SET_MEDIA_STREAM_BUFFER_MAX_SIZE; + char *ret_buf = NULL; - ret = mm_player_set_media_stream_buffer_max_size(handle->mm_handle, type, max_size); + LOGD("ENTER"); - if (ret != MM_ERROR_NONE) - return __player_convert_error_code(ret, (char *)__FUNCTION__); - else - return PLAYER_ERROR_NONE; + player_msg_send2(api, pc, 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 *max_size) +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(max_size); - player_s *handle = (player_s *)player; + PLAYER_NULL_ARG_CHECK(pmax_size); + player_cli_s *pc = (player_cli_s *)player; + muse_player_api_e api = MUSE_PLAYER_API_GET_MEDIA_STREAM_BUFFER_MAX_SIZE; + char *ret_buf = NULL; + unsigned long long max_size; - unsigned long long _max_size; - int ret = mm_player_get_media_stream_buffer_max_size(handle->mm_handle, type, &_max_size); - if (ret != MM_ERROR_NONE) { - return __player_convert_error_code(ret, (char *)__FUNCTION__); - } else { - *max_size = _max_size; - return PLAYER_ERROR_NONE; + LOGD("ENTER"); + + player_msg_send1(api, pc, 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; + int ret = PLAYER_ERROR_NONE; PLAYER_INSTANCE_CHECK(player); - player_s *handle = (player_s *)player; - if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) { - LOGE("[%s] PLAYER_ERROR_INVALID_STATE(0x%08x) : current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state); - return PLAYER_ERROR_INVALID_STATE; - } - - ret = mm_player_set_media_stream_buffer_min_percent(handle->mm_handle, type, percent); + player_cli_s *pc = (player_cli_s *)player; + muse_player_api_e api = MUSE_PLAYER_API_SET_MEDIA_STREAM_BUFFER_MIN_THRESHOLD; + char *ret_buf = NULL; - if (ret != MM_ERROR_NONE) - return __player_convert_error_code(ret, (char *)__FUNCTION__); - else - return PLAYER_ERROR_NONE; -} + LOGD("ENTER"); -int player_get_media_stream_buffer_min_threshold(player_h player, player_stream_type_e type, unsigned int *percent) -{ - PLAYER_INSTANCE_CHECK(player); - PLAYER_NULL_ARG_CHECK(percent); - player_s *handle = (player_s *)player; + player_msg_send2(api, pc, ret_buf, ret, INT, type, INT, percent); - unsigned int _value; - int ret = mm_player_get_media_stream_buffer_min_percent(handle->mm_handle, type, &_value); - if (ret != MM_ERROR_NONE) { - return __player_convert_error_code(ret, (char *)__FUNCTION__); - } else { - *percent = _value; - return PLAYER_ERROR_NONE; - } + g_free(ret_buf); + return ret; } -#if 0 -int player_set_subtitle_stream_info(player_h player, player_subtitle_stream_info_s *info) +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_s *handle = (player_s *)player; + PLAYER_NULL_ARG_CHECK(ppercent); + player_cli_s *pc = (player_cli_s *)player; + muse_player_api_e api = MUSE_PLAYER_API_GET_MEDIA_STREAM_BUFFER_MIN_THRESHOLD; + char *ret_buf = NULL; + uint percent; - int ret = mm_player_set_subtitle_info(handle->mm_handle, (MMPlayerSubtitleStreamInfo *)info); + LOGD("ENTER"); - if (ret != MM_ERROR_NONE) - return __player_convert_error_code(ret, (char *)__FUNCTION__); - else - return PLAYER_ERROR_NONE; + player_msg_send1(api, pc, ret_buf, ret, INT, type); + if (ret == PLAYER_ERROR_NONE) { + player_msg_get(percent, ret_buf); + *ppercent = percent; + } - return PLAYER_ERROR_NONE; + g_free(ret_buf); + return ret; } -#endif -int player_get_track_count(player_h player, player_stream_type_e type, int *count) +int player_get_track_count(player_h player, player_stream_type_e type, int *pcount) { PLAYER_INSTANCE_CHECK(player); - PLAYER_NULL_ARG_CHECK(count); - player_s *handle = (player_s *)player; + PLAYER_NULL_ARG_CHECK(pcount); + int ret = PLAYER_ERROR_NONE; + player_cli_s *pc = (player_cli_s *)player; + muse_player_api_e api = MUSE_PLAYER_API_GET_TRACK_COUNT; + char *ret_buf = NULL; + int count; - if (!__player_state_validate(handle, PLAYER_STATE_READY)) { - LOGE("[%s] PLAYER_ERROR_INVALID_STATE (0x%08x) : current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state); - return PLAYER_ERROR_INVALID_STATE; - } + LOGD("ENTER"); - MMPlayerTrackType track_type = 0; - switch (type) { - case PLAYER_STREAM_TYPE_AUDIO: - track_type = MM_PLAYER_TRACK_TYPE_AUDIO; - break; - case PLAYER_STREAM_TYPE_TEXT: - track_type = MM_PLAYER_TRACK_TYPE_TEXT; - break; - default: - LOGE("invalid stream type %d", type); - return PLAYER_ERROR_INVALID_PARAMETER; + player_msg_send1(api, pc, ret_buf, ret, INT, type); + if (ret == PLAYER_ERROR_NONE) { + player_msg_get(count, ret_buf); + *pcount = count; } - int ret = mm_player_get_track_count(handle->mm_handle, track_type, count); - if (ret != MM_ERROR_NONE) - return __player_convert_error_code(ret, (char *)__FUNCTION__); - - return PLAYER_ERROR_NONE; + g_free(ret_buf); + return ret; } -int player_get_current_track(player_h player, player_stream_type_e type, int *index) +int player_get_current_track(player_h player, player_stream_type_e type, int *pindex) { PLAYER_INSTANCE_CHECK(player); - PLAYER_NULL_ARG_CHECK(index); - player_s *handle = (player_s *)player; + PLAYER_NULL_ARG_CHECK(pindex); + int ret = PLAYER_ERROR_NONE; + player_cli_s *pc = (player_cli_s *)player; + muse_player_api_e api = MUSE_PLAYER_API_GET_CURRENT_TRACK; + char *ret_buf = NULL; + int index; - if (!__player_state_validate(handle, PLAYER_STATE_READY)) { - LOGE("[%s] PLAYER_ERROR_INVALID_STATE (0x%08x) : current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state); - return PLAYER_ERROR_INVALID_STATE; - } + LOGD("ENTER"); - MMPlayerTrackType track_type = 0; - switch (type) { - case PLAYER_STREAM_TYPE_AUDIO: - track_type = MM_PLAYER_TRACK_TYPE_AUDIO; - break; - case PLAYER_STREAM_TYPE_TEXT: - track_type = MM_PLAYER_TRACK_TYPE_TEXT; - break; - default: - LOGE("invalid stream type %d", type); - return PLAYER_ERROR_INVALID_PARAMETER; + player_msg_send1(api, pc, ret_buf, ret, INT, type); + if (ret == PLAYER_ERROR_NONE) { + player_msg_get(index, ret_buf); + *pindex = index; } - int ret = mm_player_get_current_track(handle->mm_handle, track_type, index); - if (ret != MM_ERROR_NONE) - return __player_convert_error_code(ret, (char *)__FUNCTION__); - - return PLAYER_ERROR_NONE; + g_free(ret_buf); + return ret; } int player_select_track(player_h player, player_stream_type_e type, int index) { PLAYER_INSTANCE_CHECK(player); - PLAYER_CHECK_CONDITION(index >= 0, PLAYER_ERROR_INVALID_PARAMETER, "PLAYER_ERROR_INVALID_PARAMETER"); - player_s *handle = (player_s *)player; + int ret = PLAYER_ERROR_NONE; + player_cli_s *pc = (player_cli_s *)player; + muse_player_api_e api = MUSE_PLAYER_API_SELECT_TRACK; + char *ret_buf = NULL; - if (!__player_state_validate(handle, PLAYER_STATE_READY)) { - LOGE("[%s] PLAYER_ERROR_INVALID_STATE (0x%08x) : current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state); - return PLAYER_ERROR_INVALID_STATE; - } - - MMPlayerTrackType track_type = 0; - switch (type) { - case PLAYER_STREAM_TYPE_AUDIO: - track_type = MM_PLAYER_TRACK_TYPE_AUDIO; - break; - case PLAYER_STREAM_TYPE_TEXT: - track_type = MM_PLAYER_TRACK_TYPE_TEXT; - break; - default: - LOGE("invalid stream type %d", type); - return PLAYER_ERROR_INVALID_PARAMETER; - } + LOGD("ENTER"); - int ret = mm_player_select_track(handle->mm_handle, track_type, index); - if (ret != MM_ERROR_NONE) - return __player_convert_error_code(ret, (char *)__FUNCTION__); + player_msg_send2(api, pc, ret_buf, ret, INT, type, INT, index); - return PLAYER_ERROR_NONE; + g_free(ret_buf); + return ret; } -int player_get_track_language_code(player_h player, player_stream_type_e type, int index, char **code) +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(code); - player_s *handle = (player_s *)player; - if (!__player_state_validate(handle, PLAYER_STATE_READY)) { - LOGE("[%s] PLAYER_ERROR_INVALID_STATE (0x%08x) : current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state); - return PLAYER_ERROR_INVALID_STATE; - } - - char *language_code = NULL; - MMPlayerTrackType track_type = 0; - switch (type) { - case PLAYER_STREAM_TYPE_AUDIO: - track_type = MM_PLAYER_TRACK_TYPE_AUDIO; - break; - case PLAYER_STREAM_TYPE_VIDEO: - track_type = MM_PLAYER_TRACK_TYPE_VIDEO; - break; - case PLAYER_STREAM_TYPE_TEXT: - track_type = MM_PLAYER_TRACK_TYPE_TEXT; - break; - default: - LOGE("invalid stream type %d", type); - return PLAYER_ERROR_INVALID_PARAMETER; - } + PLAYER_NULL_ARG_CHECK(pcode); + int ret = PLAYER_ERROR_NONE; + player_cli_s *pc = (player_cli_s *)player; + muse_player_api_e api = MUSE_PLAYER_API_GET_TRACK_LANGUAGE_CODE; + char *ret_buf = NULL; + char code[MUSE_MSG_MAX_LENGTH] = {0, }; + const int code_len = 2; - int ret = mm_player_get_track_language_code(handle->mm_handle, track_type, index, &language_code); - if (ret != MM_ERROR_NONE) { - if (language_code != NULL) - free(language_code); + LOGD("ENTER"); - language_code = NULL; - return __player_convert_error_code(ret, (char *)__FUNCTION__); - } else { - int code_len = 0; - *code = NULL; - if (language_code != NULL && strncmp(language_code, "und", 3)) { - code_len = 2; - *code = strndup(language_code, code_len); - } else { - code_len = 3; - *code = strndup("und", code_len); - } - - if (language_code) - free(language_code); - - language_code = NULL; - return PLAYER_ERROR_NONE; + player_msg_send2(api, pc, 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/src/player_internal.c b/src/player_internal.c index 93da242..bb389fd 100644 --- a/src/player_internal.c +++ b/src/player_internal.c @@ -17,194 +17,227 @@ #include #include #include +#include +#include +#include +#include #include - -#include -#include -#include -#include -#include -#include -#include - -/* -* Internal Macros -*/ -#define PLAYER_SET_CALLBACK(event_type, handle, callback, user_data) \ -do { \ - PLAYER_INSTANCE_CHECK(handle); \ - PLAYER_NULL_ARG_CHECK(callback); \ - handle->user_cb[event_type] = callback; \ - handle->user_data[event_type] = user_data; \ - LOGI("[%s] Event type : %d ", __FUNCTION__, event_type); \ -} while (0) \ - -bool __audio_stream_callback_ex(MMPlayerAudioStreamDataType *stream, void *user_data) -{ - player_s *handle = (player_s *)user_data; - - if (!__player_state_validate(handle, PLAYER_STATE_READY)) { - LOGE("[%s] PLAYER_ERROR_INVALID_STATE(0x%08x) : current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state); - return TRUE; - } - - if (handle->user_cb[_PLAYER_EVENT_TYPE_AUDIO_FRAME]) - ((player_audio_pcm_extraction_cb)handle->user_cb[_PLAYER_EVENT_TYPE_AUDIO_FRAME])((player_audio_raw_data_s *)stream, handle->user_data[_PLAYER_EVENT_TYPE_AUDIO_FRAME]); - return TRUE; -} +#include +#include +#include +#include "player_private.h" +#include "player_internal.h" int player_set_pcm_extraction_mode(player_h player, bool sync, player_audio_pcm_extraction_cb callback, void *user_data) { PLAYER_INSTANCE_CHECK(player); PLAYER_NULL_ARG_CHECK(callback); - player_s *handle = (player_s *)player; - int ret = MM_ERROR_NONE; + int ret = PLAYER_ERROR_NONE; + muse_player_api_e api = MUSE_PLAYER_API_SET_PCM_EXTRACTION_MODE; + player_cli_s *pc = (player_cli_s *)player; + char *ret_buf = NULL; + muse_player_event_e event = MUSE_PLAYER_EVENT_TYPE_AUDIO_FRAME; - PLAYER_STATE_CHECK(handle, PLAYER_STATE_IDLE); + LOGD("ENTER"); - ret = mm_player_set_attribute(handle->mm_handle, NULL, "pcm_extraction", TRUE, "pcm_extraction_start_msec", 0, "pcm_extraction_end_msec", 0, NULL); - if (ret != MM_ERROR_NONE) - return __player_convert_error_code(ret, (char *)__FUNCTION__); + player_msg_send1(api, pc, ret_buf, ret, INT, sync); - ret = mm_player_set_audio_stream_callback_ex(handle->mm_handle, sync, __audio_stream_callback_ex, (void *)handle); - if (ret != MM_ERROR_NONE) - return __player_convert_error_code(ret, (char *)__FUNCTION__); + if (ret == PLAYER_ERROR_NONE) { + pc->cb_info->user_cb[event] = callback; + pc->cb_info->user_data[event] = user_data; + LOGI("Event type : %d ", event); + } - PLAYER_SET_CALLBACK(_PLAYER_EVENT_TYPE_AUDIO_FRAME, handle, callback, user_data); - return PLAYER_ERROR_NONE; + g_free(ret_buf); + return ret; } int player_set_pcm_spec(player_h player, const char *format, int samplerate, int channel) { PLAYER_INSTANCE_CHECK(player); + int ret = PLAYER_ERROR_NONE; + muse_player_api_e api = MUSE_PLAYER_API_SET_PCM_SPEC; + player_cli_s *pc = (player_cli_s *)player; + char *ret_buf = NULL; - player_s *handle = (player_s *)player; - int ret = MM_ERROR_NONE; + LOGD("ENTER"); - LOGE("[%s] player_set_pcm_spec %s %d %d", __FUNCTION__, format, samplerate, channel); - ret = mm_player_set_attribute(handle->mm_handle, NULL, "pcm_audioformat", format, strlen(format), NULL); - if (ret != MM_ERROR_NONE) - return __player_convert_error_code(ret, (char *)__FUNCTION__); + player_msg_send3(api, pc, ret_buf, ret, STRING, format, INT, samplerate, INT, channel); - ret = mm_player_set_pcm_spec(handle->mm_handle, samplerate, channel); - if (ret != MM_ERROR_NONE) - return __player_convert_error_code(ret, (char *)__FUNCTION__); - - return PLAYER_ERROR_NONE; + g_free(ret_buf); + return ret; } int player_set_streaming_playback_rate(player_h player, float rate) { - LOGI("[%s] rate : %0.1f", __FUNCTION__, rate); PLAYER_INSTANCE_CHECK(player); - player_s *handle = (player_s *) player; + int ret = PLAYER_ERROR_NONE; + muse_player_api_e api = MUSE_PLAYER_API_SET_STREAMING_PLAYBACK_RATE; + player_cli_s *pc = (player_cli_s *)player; + char *ret_buf = NULL; + + LOGD("ENTER"); - if (!__player_state_validate(handle, PLAYER_STATE_READY)) { - LOGE("[%s] PLAYER_ERROR_INVALID_STATE(0x%08x) : current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state); - return PLAYER_ERROR_INVALID_STATE; + player_msg_send1(api, pc, ret_buf, ret, DOUBLE, rate); + g_free(ret_buf); + return ret; +} + +int player_set_media_stream_buffer_status_cb_ex(player_h player, player_stream_type_e stream_type, player_media_stream_buffer_status_cb_ex 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; + muse_player_api_e api = MUSE_PLAYER_API_SET_CALLBACK; + char *ret_buf = NULL; + muse_player_event_e type; + int set = 1; + + LOGD("ENTER"); + + if (stream_type == PLAYER_STREAM_TYPE_VIDEO) + type = MUSE_PLAYER_EVENT_TYPE_MEDIA_STREAM_VIDEO_BUFFER_STATUS_WITH_INFO; + else if (stream_type == PLAYER_STREAM_TYPE_AUDIO) + type = MUSE_PLAYER_EVENT_TYPE_MEDIA_STREAM_AUDIO_BUFFER_STATUS_WITH_INFO; + else { + LOGE("PLAYER_ERROR_INVALID_PARAMETER(type : %d)", stream_type); + return PLAYER_ERROR_INVALID_PARAMETER; } - int ret = mm_player_set_play_speed(handle->mm_handle, rate, TRUE); - - switch (ret) { - case MM_ERROR_NONE: - case MM_ERROR_PLAYER_NO_OP: - ret = PLAYER_ERROR_NONE; - break; - case MM_ERROR_NOT_SUPPORT_API: - case MM_ERROR_PLAYER_SEEK: - LOGE("[%s] PLAYER_ERROR_INVALID_OPERATION(0x%08x) : seek error", __FUNCTION__, PLAYER_ERROR_INVALID_OPERATION); - ret = PLAYER_ERROR_INVALID_OPERATION; - break; - default: - return __player_convert_error_code(ret, (char *)__FUNCTION__); + player_msg_send2(api, pc, 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; } -static bool __media_stream_buffer_status_callback_ex(player_stream_type_e type, player_media_stream_buffer_status_e status, unsigned long long bytes, void *user_data) +static void set_null_user_cb(callback_cb_info_s *cb_info, muse_player_event_e event) { - player_s *handle = (player_s *)user_data; - _player_event_e event_type; - - if (type == PLAYER_STREAM_TYPE_AUDIO) - event_type = _PLAYER_EVENT_TYPE_MEDIA_STREAM_AUDIO_BUFFER_STATUS_WITH_INFO; - else if (type == PLAYER_STREAM_TYPE_VIDEO) - event_type = _PLAYER_EVENT_TYPE_MEDIA_STREAM_VIDEO_BUFFER_STATUS_WITH_INFO; - else - return FALSE; - - LOGE("[%s] event type %d, status %d, bytes %llu", __FUNCTION__, event_type, status, bytes); - - if (handle->user_cb[event_type]) { - ((player_media_stream_buffer_status_cb_ex)handle->user_cb[event_type])(status, bytes, handle->user_data[event_type]); - } else { - LOGE("[%s][type:%d] buffer status cb was not set.", __FUNCTION__, type); - return FALSE; + if (cb_info && event < MUSE_PLAYER_EVENT_TYPE_NUM) { + cb_info->user_cb[event] = NULL; + cb_info->user_data[event] = NULL; } - - return TRUE; } +static void set_null_user_cb_lock(callback_cb_info_s *cb_info, muse_player_event_e event) +{ + bool lock = g_thread_self() != cb_info->event_queue.thread; -int player_set_media_stream_buffer_status_cb_ex(player_h player, player_stream_type_e type, player_media_stream_buffer_status_cb_ex callback, void *user_data) + if (lock) + g_mutex_lock(&cb_info->event_queue.mutex); + + set_null_user_cb(cb_info, event); + + if (lock) + g_mutex_unlock(&cb_info->event_queue.mutex); +} + +int player_unset_media_stream_buffer_status_cb_ex(player_h player, player_stream_type_e stream_type) { - int ret; PLAYER_INSTANCE_CHECK(player); - PLAYER_NULL_ARG_CHECK(callback); - player_s *handle = (player_s *)player; - _player_event_e event_type; - - if (handle->state != PLAYER_STATE_IDLE) { - LOGE("[%s] PLAYER_ERROR_INVALID_STATE(0x%08x) : current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state); - return PLAYER_ERROR_INVALID_STATE; - } - /* the type can be expaned with default and text. */ - if ((type != PLAYER_STREAM_TYPE_VIDEO) && (type != PLAYER_STREAM_TYPE_AUDIO)) { - LOGE("[%s] PLAYER_ERROR_INVALID_PARAMETER(type : %d)", __FUNCTION__, type); + int ret = PLAYER_ERROR_NONE; + player_cli_s *pc = (player_cli_s *)player; + muse_player_api_e api = MUSE_PLAYER_API_SET_CALLBACK; + char *ret_buf = NULL; + muse_player_event_e type; + int set = 0; + + LOGD("ENTER"); + + if (stream_type == PLAYER_STREAM_TYPE_VIDEO) + type = MUSE_PLAYER_EVENT_TYPE_MEDIA_STREAM_VIDEO_BUFFER_STATUS_WITH_INFO; + else if (stream_type == PLAYER_STREAM_TYPE_AUDIO) + type = MUSE_PLAYER_EVENT_TYPE_MEDIA_STREAM_AUDIO_BUFFER_STATUS_WITH_INFO; + else { + LOGE("PLAYER_ERROR_INVALID_PARAMETER(type : %d)", stream_type); return PLAYER_ERROR_INVALID_PARAMETER; } - ret = mm_player_set_media_stream_buffer_status_callback(handle->mm_handle, type, (mm_player_media_stream_buffer_status_callback)__media_stream_buffer_status_callback_ex, (void *)handle); + set_null_user_cb_lock(pc->cb_info, type); + + player_msg_send2(api, pc, ret_buf, ret, INT, type, INT, set); + + g_free(ret_buf); + return ret; +} + +static void __evas_resize_cb (void *data, Evas *e, Evas_Object *eo, void *event_info) +{ + + player_cli_s *pc = (player_cli_s *)data; + wl_win_msg_type wl_win; + char *wl_win_msg = (char *)&wl_win; + char *ret_buf = NULL; + muse_player_api_e api = MUSE_PLAYER_API_RESIZE_VIDEO_RENDER_RECT; + int ret = PLAYER_ERROR_NONE; + LOGD("ret =%d",ret); - if (ret != MM_ERROR_NONE) - return __player_convert_error_code(ret, (char *)__FUNCTION__); + evas_object_geometry_get(eo, &wl_win.wl_window_x, &wl_win.wl_window_y, &wl_win.wl_window_width, &wl_win.wl_window_height); + LOGD("get window rectangle: x(%d) y(%d) width(%d) height(%d)", + wl_win.wl_window_x, wl_win.wl_window_y, wl_win.wl_window_width, wl_win.wl_window_height); - if (type == PLAYER_STREAM_TYPE_VIDEO) - event_type = _PLAYER_EVENT_TYPE_MEDIA_STREAM_VIDEO_BUFFER_STATUS_WITH_INFO; - else - event_type = _PLAYER_EVENT_TYPE_MEDIA_STREAM_AUDIO_BUFFER_STATUS_WITH_INFO; + wl_win.type = 0; /*init but not use */ + wl_win.wl_surface_id = 0; /*init but not use */ - LOGI("[%s] Event type : %d ", __FUNCTION__, type); + player_msg_send_array(api, pc, ret_buf, ret, wl_win_msg, sizeof(wl_win_msg_type), sizeof(char)); - handle->user_cb[event_type] = callback; - handle->user_data[event_type] = user_data; + g_free(ret_buf); + return; - return PLAYER_ERROR_NONE; } -int player_unset_media_stream_buffer_status_cb_ex(player_h player, player_stream_type_e type) +static void __evas_del_cb (void *data, Evas *e, Evas_Object *eo, void *event_info) { - int ret; + + player_cli_s *pc = (player_cli_s *)data; + + evas_object_event_callback_del (eo, EVAS_CALLBACK_RESIZE, __evas_resize_cb); + evas_object_event_callback_del (eo, EVAS_CALLBACK_DEL, __evas_del_cb); + + LOGD("evas callback del %p", eo); + pc->have_evas_callback = FALSE; + + return; +} + +int player_set_evas_object_cb(player_h player, Evas_Object * eo) +{ + PLAYER_INSTANCE_CHECK(player); - player_s *handle = (player_s *)player; - _player_event_e event_type; - - if (type == PLAYER_STREAM_TYPE_VIDEO) - event_type = _PLAYER_EVENT_TYPE_MEDIA_STREAM_VIDEO_BUFFER_STATUS_WITH_INFO; - else if (type == PLAYER_STREAM_TYPE_AUDIO) - event_type = _PLAYER_EVENT_TYPE_MEDIA_STREAM_AUDIO_BUFFER_STATUS_WITH_INFO; - else - return PLAYER_ERROR_INVALID_PARAMETER; + return_val_if_fail(eo != NULL, MM_ERROR_INVALID_ARGUMENT); + + player_cli_s *pc = (player_cli_s *)player; - handle->user_cb[event_type] = NULL; - handle->user_data[event_type] = NULL; + if(pc->have_evas_callback && pc->eo == eo) { + LOGW("evas object had callback already %p", pc->eo); + return MM_ERROR_UNKNOWN; + } + pc->eo = eo; + evas_object_event_callback_add (eo, EVAS_CALLBACK_RESIZE, __evas_resize_cb, player); + evas_object_event_callback_add (eo, EVAS_CALLBACK_DEL, __evas_del_cb, player); + LOGD("evas callback add %p", pc->eo); + pc->have_evas_callback = TRUE; + + return MM_ERROR_NONE; +} + +int player_unset_evas_object_cb(player_h player) +{ + PLAYER_INSTANCE_CHECK(player); + player_cli_s *pc = (player_cli_s *)player; + return_val_if_fail(pc->eo != NULL, MM_ERROR_INVALID_ARGUMENT); - LOGI("[%s] Event type : %d ", __FUNCTION__, type); + evas_object_event_callback_del (pc->eo, EVAS_CALLBACK_RESIZE, __evas_resize_cb); + evas_object_event_callback_del (pc->eo, EVAS_CALLBACK_DEL, __evas_del_cb); + LOGD("evas callback del %p", pc->eo); + pc->eo = NULL; + pc->have_evas_callback = FALSE; - ret = mm_player_set_media_stream_buffer_status_callback(handle->mm_handle, type, NULL, NULL); - if (ret != MM_ERROR_NONE) - return __player_convert_error_code(ret, (char *)__FUNCTION__); - else - return PLAYER_ERROR_NONE; + return MM_ERROR_NONE; } diff --git a/src/player_priv.c b/src/player_priv.c deleted file mode 100644 index 912bba7..0000000 --- a/src/player_priv.c +++ /dev/null @@ -1,350 +0,0 @@ -/* -* 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 -#include -#include - -/* -* Implementation for mused -*/ -int player_set_shm_stream_path_for_mused(player_h player, const char *stream_path) -{ - PLAYER_INSTANCE_CHECK(player); - PLAYER_NULL_ARG_CHECK(stream_path); - - player_s *handle = (player_s *)player; - - if (mm_player_set_shm_stream_path(handle->mm_handle, stream_path) - != MM_ERROR_NONE) { - LOGE("Fail to set attribute stream path"); - return PLAYER_ERROR_INVALID_OPERATION; - } - return PLAYER_ERROR_NONE; -} - -static MMDisplaySurfaceType __player_mused_convet_display_type(player_display_type_e type) -{ - switch (type) { - case PLAYER_DISPLAY_TYPE_OVERLAY: - return PLAYER_DISPLAY_TYPE_OVERLAY; -#ifdef TIZEN_MOBILE - case PLAYER_DISPLAY_TYPE_EVAS: - return MM_DISPLAY_SURFACE_REMOTE; -#endif - case PLAYER_DISPLAY_TYPE_NONE: - return MM_DISPLAY_SURFACE_NULL; - default: - return MM_DISPLAY_SURFACE_NULL; - } -} - -#ifdef HAVE_WAYLAND -int player_resize_video_render_rect(player_h player, int x, int y, int w, int h) -{ - PLAYER_INSTANCE_CHECK(player); - player_s *handle = (player_s *)player; - int ret; - - LOGD(""); - - ret = mm_player_set_attribute(handle->mm_handle, NULL, "wl_window_render_x", x, "wl_window_render_y", y, "wl_window_render_width", w, "wl_window_render_height", h, (char *)NULL); - - if (ret != MM_ERROR_NONE) { - handle->display_type = PLAYER_DISPLAY_TYPE_NONE; - return __player_convert_error_code(ret, (char *)__FUNCTION__); - } else { - return PLAYER_ERROR_NONE; - } -} - -int player_set_display_wl_for_mused(player_h player, player_display_type_e type, unsigned int wl_surface_id, int x, int y, int w, int h) -{ - PLAYER_INSTANCE_CHECK(player); - player_s *handle = (player_s *)player; - void *set_handle = NULL; - MMDisplaySurfaceType mmType = __player_mused_convet_display_type(type); - MMDisplaySurfaceType mmClientType = MM_DISPLAY_SURFACE_NULL; - MMPlayerPipelineType mmPipelineType = MM_PLAYER_PIPELINE_SERVER; - - int ret; - if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) { - LOGE("[%s] PLAYER_ERROR_INVALID_STATE(0x%08x) : current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state); - return PLAYER_ERROR_INVALID_STATE; - } - if (handle->is_set_pixmap_cb) { - if (handle->state < PLAYER_STATE_READY) { - /* just set below and go to "changing surface case" */ - handle->is_set_pixmap_cb = false; - } else { - LOGE("[%s] pixmap callback was set, try it again after calling player_unprepare()", __FUNCTION__, PLAYER_ERROR_INVALID_OPERATION); - LOGE("[%s] PLAYER_ERROR_INVALID_OPERATION(0x%08x)", __FUNCTION__, PLAYER_ERROR_INVALID_OPERATION); - return PLAYER_ERROR_INVALID_OPERATION; - } - } - - void *temp = NULL; - if (type == PLAYER_DISPLAY_TYPE_NONE) { - /* NULL surface */ - handle->display_handle = 0; - handle->display_type = type; - set_handle = NULL; - } else { - /* get handle from overlay or evas surface */ - temp = handle->display_handle; - if (type == PLAYER_DISPLAY_TYPE_OVERLAY) { - LOGI("Wayland overlay surface type"); - LOGI("wl_surface_id %d", wl_surface_id); - handle->display_handle = (void *)(uintptr_t)wl_surface_id; - set_handle = &(handle->display_handle); - mmClientType = MM_DISPLAY_SURFACE_OVERLAY; -#ifdef TIZEN_MOBILE - } else if (type == PLAYER_DISPLAY_TYPE_EVAS) { - LOGI("Evas surface type"); - set_handle = &(handle->display_handle); - mmClientType = MM_DISPLAY_SURFACE_EVAS; -#endif - } else { - LOGE("invalid surface type"); - return PLAYER_ERROR_INVALID_PARAMETER; - } - } - - /* set display handle */ - if (handle->display_type == PLAYER_DISPLAY_TYPE_NONE || type == handle->display_type) { - /* first time or same type */ - LOGW("first time or same type"); - ret = mm_player_set_attribute(handle->mm_handle, NULL, "display_surface_type", mmType, "display_surface_client_type", mmClientType, "display_overlay", set_handle, sizeof(wl_surface_id), "pipeline_type", mmPipelineType, NULL); - - if (ret != MM_ERROR_NONE) { - handle->display_handle = temp; - LOGE("[%s] Failed to display surface change :%d", __FUNCTION__, ret); - } else { - if (type != PLAYER_DISPLAY_TYPE_NONE) { - handle->display_type = type; - LOGI("[%s] video display has been changed- type :%d, addr : 0x%x", __FUNCTION__, handle->display_type, handle->display_handle); - } else - LOGI("NULL surface"); - } - LOGI("get window rectangle: x(%d) y(%d) width(%d) height(%d)", x, y, w, h); - ret = mm_player_set_attribute(handle->mm_handle, NULL, "wl_window_render_x", x, "wl_window_render_y", y, "wl_window_render_width", w, "wl_window_render_height", h, (char *)NULL); - - if (ret != MM_ERROR_NONE) { - handle->display_handle = temp; - LOGE("[%s] Failed to set wl_window render rectangle :%d", __FUNCTION__, ret); - } - } else { - /* changing surface case */ - ret = mm_player_change_videosink(handle->mm_handle, mmType, set_handle); - if (ret != MM_ERROR_NONE) { - handle->display_handle = temp; - if (ret == MM_ERROR_NOT_SUPPORT_API) { - LOGE("[%s] change video sink is not available.", __FUNCTION__); - ret = PLAYER_ERROR_NONE; - } else { - LOGE("[%s] Failed to display surface change :%d", __FUNCTION__, ret); - } - } else { - handle->display_type = type; - LOGI("[%s] video display has been changed- type :%d, addr : 0x%x", __FUNCTION__, handle->display_type, handle->display_handle); - } - } - - if (ret != MM_ERROR_NONE) { - handle->display_type = PLAYER_DISPLAY_TYPE_NONE; - return __player_convert_error_code(ret, (char *)__FUNCTION__); - } else { - return PLAYER_ERROR_NONE; - } -} - -#else - -int player_set_display_for_mused(player_h player, player_display_type_e type, unsigned int xhandle) -{ - PLAYER_INSTANCE_CHECK(player); - player_s *handle = (player_s *)player; - void *set_handle = NULL; - MMDisplaySurfaceType mmType = __player_mused_convet_display_type(type); - - int ret; - if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) { - LOGE("[%s] PLAYER_ERROR_INVALID_STATE(0x%08x) : current state - %d", __FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state); - return PLAYER_ERROR_INVALID_STATE; - } - - if (handle->is_set_pixmap_cb) { - if (handle->state < PLAYER_STATE_READY) { - /* just set below and go to "changing surface case" */ - handle->is_set_pixmap_cb = false; - } else { - LOGE("[%s] pixmap callback was set, try it again after calling player_unprepare()", __FUNCTION__, PLAYER_ERROR_INVALID_OPERATION); - LOGE("[%s] PLAYER_ERROR_INVALID_OPERATION(0x%08x)", __FUNCTION__, PLAYER_ERROR_INVALID_OPERATION); - return PLAYER_ERROR_INVALID_OPERATION; - } - } - - void *temp = NULL; - if (type == PLAYER_DISPLAY_TYPE_NONE) { - /* NULL surface */ - handle->display_handle = 0; - handle->display_type = PLAYER_DISPLAY_TYPE_NONE; - set_handle = NULL; - } else { - /* get handle from overlay or evas surface */ - temp = handle->display_handle; - if (type == PLAYER_DISPLAY_TYPE_OVERLAY/* && !strcmp(object_type, "elm_win") */) { - /* x window overlay surface */ - LOGI("overlay surface type"); - handle->display_handle = (void *)(uintptr_t)xhandle; - set_handle = &(handle->display_handle); - } else { - LOGE("invalid surface type"); - return PLAYER_ERROR_INVALID_PARAMETER; - } - } - - /* set display handle */ - if (handle->display_type == PLAYER_DISPLAY_TYPE_NONE || type == handle->display_type) { - /* first time or same type */ - ret = mm_player_set_attribute(handle->mm_handle, NULL, "display_surface_type", mmType, "display_overlay", set_handle, sizeof(xhandle), NULL); - - if (ret != MM_ERROR_NONE) { - handle->display_handle = temp; - LOGE("[%s] Failed to display surface change :%d", __FUNCTION__, ret); - } else { - if (type != PLAYER_DISPLAY_TYPE_NONE) { - handle->display_type = type; - LOGI("[%s] video display has been changed- type :%d, addr : 0x%x", __FUNCTION__, handle->display_type, handle->display_handle); - } else - LOGI("NULL surface"); - } - } else { - /* changing surface case */ - ret = mm_player_change_videosink(handle->mm_handle, mmType, set_handle); - if (ret != MM_ERROR_NONE) { - handle->display_handle = temp; - if (ret == MM_ERROR_NOT_SUPPORT_API) { - LOGE("[%s] change video sink is not available.", __FUNCTION__); - ret = PLAYER_ERROR_NONE; - } else { - LOGE("[%s] Failed to display surface change :%d", __FUNCTION__, ret); - } - } else { - handle->display_type = type; - LOGI("[%s] video display has been changed- type :%d, addr : 0x%x", __FUNCTION__, handle->display_type, handle->display_handle); - } - } - - if (ret != MM_ERROR_NONE) { - handle->display_type = PLAYER_DISPLAY_TYPE_NONE; - return __player_convert_error_code(ret, (char *)__FUNCTION__); - } else { - return PLAYER_ERROR_NONE; - } -} -#endif - -int player_set_audio_policy_info_for_mused(player_h player, char *stream_type, int stream_index) -{ - PLAYER_INSTANCE_CHECK(player); - player_s *handle = (player_s *)player; - int ret; - - PLAYER_STATE_CHECK(handle, PLAYER_STATE_IDLE); - - ret = mm_player_set_attribute(handle->mm_handle, NULL, "sound_stream_type", stream_type, strlen(stream_type), "sound_stream_index", stream_index, NULL); - - if (ret != MM_ERROR_NONE) - return __player_convert_error_code(ret, (char *)__FUNCTION__); - else - return PLAYER_ERROR_NONE; -} - -int player_get_raw_video_caps(player_h player, char **caps) -{ - int ret; - PLAYER_INSTANCE_CHECK(player); - PLAYER_NULL_ARG_CHECK(caps); - player_s *handle = (player_s *)player; - - ret = mm_player_get_raw_video_caps(handle->mm_handle, caps); - if (ret != MM_ERROR_NONE) - return __player_convert_error_code(ret, (char *)__FUNCTION__); - - return PLAYER_ERROR_NONE; -} - -int player_set_video_bin_created_cb(player_h player, player_video_bin_created_cb callback, void *user_data) -{ - PLAYER_INSTANCE_CHECK(player); - PLAYER_NULL_ARG_CHECK(callback); - int type = _PLAYER_EVENT_TYPE_VIDEO_BIN_CREATED; - - player_s *handle = (player_s *)player; - handle->user_cb[type] = callback; - handle->user_data[type] = user_data; - LOGI("[%s] Event type : %d ", __FUNCTION__, type); - return PLAYER_ERROR_NONE; -} - -int player_unset_video_bin_created_cb(player_h player) -{ - PLAYER_INSTANCE_CHECK(player); - player_s *handle = (player_s *)player; - int type = _PLAYER_EVENT_TYPE_VIDEO_BIN_CREATED; - - handle->user_cb[type] = NULL; - handle->user_data[type] = NULL; - LOGI("[%s] Event type : %d ", __FUNCTION__, type); - return PLAYER_ERROR_NONE; -} - -int player_sound_register(player_h player, int pid) -{ - PLAYER_INSTANCE_CHECK(player); - player_s *handle = (player_s *)player; - int ret; - - PLAYER_STATE_CHECK(handle, PLAYER_STATE_IDLE); - - ret = mm_player_sound_register(handle->mm_handle, pid); - if (ret != MM_ERROR_NONE) - return __player_convert_error_code(ret, (char *)__FUNCTION__); - - return PLAYER_ERROR_NONE; -} - -int player_is_streaming(player_h player, bool *is_streaming) -{ - PLAYER_INSTANCE_CHECK(player); - player_s *handle = (player_s *)player; - - int ret = mm_player_is_streaming(handle->mm_handle, is_streaming); - if (ret != MM_ERROR_NONE) - return __player_convert_error_code(ret, (char *)__FUNCTION__); - return PLAYER_ERROR_NONE; -} diff --git a/src/player_wayland.c b/src/player_wayland.c new file mode 100644 index 0000000..0acb78f --- /dev/null +++ b/src/player_wayland.c @@ -0,0 +1,150 @@ +/* +* 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 "player_wayland.h" + +#ifdef LOG_TAG +#undef LOG_TAG +#endif +#define LOG_TAG "TIZEN_N_PLAYER" + + + +#define goto_if_fail(expr,label) \ +{ \ + if (!(expr)) { \ + debug_error(" failed [%s]\n", #expr); \ + goto label; \ + } \ +} + +void handle_resource_id(void *data, struct tizen_resource *tizen_resource, uint32_t id) +{ + unsigned int *wl_surface_id = data; + + *wl_surface_id = id; + + LOGD("[CLIENT] got wl_surface_id(%d) from server\n", id); +} + +static const struct tizen_resource_listener tz_resource_listener = +{ + handle_resource_id, +}; + +static void +handle_global(void *data, struct wl_registry *registry, + uint32_t name, const char *interface, uint32_t version) +{ + return_if_fail (data != NULL); + wl_client *wlclient = data; + + if (strcmp(interface, "tizen_surface") == 0) + { + LOGD("binding tizen_surface"); + wlclient->tz_surface = wl_registry_bind(registry, name, &tizen_surface_interface, version); + return_if_fail (wlclient->tz_surface != NULL); + } +} + +static const struct wl_registry_listener registry_listener = +{ + handle_global, +}; + +int _wlclient_create (wl_client ** wlclient) +{ + wl_client *ptr = NULL; + + ptr = g_malloc0 (sizeof (wl_client)); + if (!ptr) { + LOGE ("Cannot allocate memory for wlclient\n"); + goto ERROR; + } else { + *wlclient = ptr; + LOGD ("Success create wlclient(%p)", *wlclient); + } + return MM_ERROR_NONE; + +ERROR: + *wlclient = NULL; + return MM_ERROR_PLAYER_NO_FREE_SPACE; +} + + +int _wlclient_get_wl_window_wl_surface_id (wl_client * wlclient, struct wl_surface *surface, struct wl_display *display) +{ + goto_if_fail (wlclient != NULL, failed); + goto_if_fail (surface != NULL, failed); + goto_if_fail (display != NULL, failed); + + unsigned int wl_surface_id = 0; + + wlclient->display = display; + goto_if_fail (wlclient->display != NULL, failed); + + wlclient->registry = wl_display_get_registry(wlclient->display); + goto_if_fail (wlclient->registry != NULL, failed); + + wl_registry_add_listener(wlclient->registry, ®istry_listener, wlclient); + wl_display_dispatch(wlclient->display); + wl_display_roundtrip(wlclient->display); + + /* check global objects */ + goto_if_fail (wlclient->tz_surface != NULL, failed); + + /* Get wl_surface_id which is unique in a entire systemw. */ + wlclient->tz_resource = tizen_surface_get_tizen_resource(wlclient->tz_surface, surface); + goto_if_fail (wlclient->tz_resource != NULL, failed); + + tizen_resource_add_listener(wlclient->tz_resource, &tz_resource_listener, &wl_surface_id); + wl_display_roundtrip(wlclient->display); + goto_if_fail (wl_surface_id > 0, failed); + + _wlclient_finalize(wlclient); + + return wl_surface_id; + +failed: + LOGE ("Failed to get wl_surface_id"); + + return 0; +} + +void _wlclient_finalize (wl_client * wlclient) +{ + LOGD ("start finalize wlclient"); + return_if_fail (wlclient != NULL) + + if (wlclient->tz_surface) + tizen_surface_destroy(wlclient->tz_surface); + + if (wlclient->tz_resource) + tizen_resource_destroy(wlclient->tz_resource); + + /* destroy registry */ + if (wlclient->registry) + wl_registry_destroy(wlclient->registry); + return; +} + diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index bb93d6a..a3c46f3 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -11,15 +11,12 @@ IF(WAYLAND_SUPPORT) SET(WIN_PKG "${WIN_PKG} ecore-wayland") ENDIF(WAYLAND_SUPPORT) INCLUDE(FindPkgConfig) -pkg_check_modules(${fw_test} REQUIRED libtbm mm-player appcore-efl elementary ecore evas capi-media-sound-manager ${WIN_PKG}) - - +pkg_check_modules(${fw_test} REQUIRED appcore-efl elementary ecore evas capi-media-sound-manager ${WIN_PKG}) FOREACH(flag ${${fw_test}_CFLAGS}) SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}") ENDFOREACH(flag) -SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS} -Wno-deprecated-declarations") -SET(CMAKE_EXE_LINKER_FLAGS "-Wl,--as-needed -Wl,--rpath=/usr/lib/gstreamer-1.0") +SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS} -pie") IF(WAYLAND_SUPPORT) ADD_DEFINITIONS("-DHAVE_WAYLAND") @@ -34,7 +31,7 @@ FOREACH(src ${sources}) GET_FILENAME_COMPONENT(src_name ${src} NAME_WE) MESSAGE("${src_name}") ADD_EXECUTABLE(${src_name} ${src}) - TARGET_LINK_LIBRARIES(${src_name} legacy-capi-media-player ${${fw_test}_LDFLAGS}) + TARGET_LINK_LIBRARIES(${src_name} capi-media-player ${${fw_test}_LDFLAGS}) INSTALL(TARGETS ${src_name} DESTINATION bin) ENDFOREACH() diff --git a/test/legacy_player_es_push_test.c b/test/player_es_push_test.c similarity index 95% rename from test/legacy_player_es_push_test.c rename to test/player_es_push_test.c index ad76ff8..9159719 100644 --- a/test/legacy_player_es_push_test.c +++ b/test/player_es_push_test.c @@ -153,7 +153,8 @@ static void create_base_gui(appdata_s *ad) elm_config_preferred_engine_set("3d"); /* Window */ - ad->win = create_win(PACKAGE); /* elm_win_util_standard_add(PACKAGE, PACKAGE); */ + /* elm_win_util_standard_add(PACKAGE, PACKAGE); */ + ad->win = create_win(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); */ @@ -200,7 +201,7 @@ static int app_pause(void *data) } if (ad->player_handle == NULL) { - LOGE("player_handle is NULL"); + g_print("player_handle is NULL"); return -1; } @@ -216,7 +217,7 @@ static int app_pause(void *data) ret = player_unprepare(ad->player_handle); if (ret != PLAYER_ERROR_NONE) { - LOGE("player_unprepare failed : 0x%x", ret); + g_print("player_unprepare failed : 0x%x", ret); return false; } @@ -229,7 +230,7 @@ static int app_pause(void *data) /* destroy player handle */ ret = player_destroy(ad->player_handle); if (ret != PLAYER_ERROR_NONE) { - LOGE("player_destroy failed : 0x%x", ret); + g_print("player_destroy failed : 0x%x", ret); return false; } @@ -263,7 +264,7 @@ static void _player_prepared_cb(void *user_data) LOGD("done"); } -int bytestream2nalunit(FILE *fd, unsigned char *nal) +int bytestream2nalunit(FILE * fd, unsigned char *nal) { int nal_length = 0; size_t result; @@ -280,19 +281,17 @@ int bytestream2nalunit(FILE *fd, unsigned char *nal) result = fread(buffer, 1, read_size, fd); if (result != read_size) - return -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; @@ -325,7 +324,6 @@ int bytestream2nalunit(FILE *fd, unsigned char *nal) } else { for (i = 0; i < zero_count; i++) nal[nal_length++] = 0; - nal[nal_length++] = val; zero_count = 0; } @@ -359,16 +357,11 @@ static void feed_eos_data(appdata_s *appdata) LOGD("push EOS"); - if (media_packet_create_alloc(ad->video_fmt, NULL, NULL, &ad->video_pkt) != MEDIA_PACKET_ERROR_NONE) { + if (media_packet_create(ad->video_fmt, NULL, NULL, &ad->video_pkt) != MEDIA_PACKET_ERROR_NONE) { LOGE("media_packet_create_alloc failed\n"); return; } - if (media_packet_set_buffer_size(ad->video_pkt, (uint64_t)0) != MEDIA_PACKET_ERROR_NONE) { - LOGE("media_packet_set_buffer_size failed\n"); - return; - } - media_packet_set_flags(ad->video_pkt, MEDIA_PACKET_END_OF_STREAM); if (player_push_media_stream(ad->player_handle, ad->video_pkt) != PLAYER_ERROR_NONE) LOGE("fail to push media packet\n"); @@ -383,7 +376,7 @@ static bool feed_video_data(appdata_s *appdata) { bool ret = FALSE; int read = 0; - static guint64 pts = 0L; + static unsigned long long pts = 0L; void *buf_data_ptr = NULL; appdata_s *ad = appdata; @@ -413,7 +406,13 @@ static bool feed_video_data(appdata_s *appdata) goto ERROR; } else if (read < 0) { LOGD("push EOS"); - media_packet_set_buffer_size(ad->video_pkt, (uint64_t)0); + media_packet_destroy(ad->video_pkt); + ad->video_pkt = NULL; + + if (media_packet_create(ad->video_fmt, NULL, NULL, &ad->video_pkt) != MEDIA_PACKET_ERROR_NONE) { + LOGE("media_packet_create failed\n"); + goto ERROR; + } media_packet_set_flags(ad->video_pkt, MEDIA_PACKET_END_OF_STREAM); if (player_push_media_stream(ad->player_handle, ad->video_pkt) != PLAYER_ERROR_NONE) LOGE("fail to push media packet\n"); @@ -443,7 +442,6 @@ static void feed_video_data_thread_func(void *data) while (TRUE) { static int frame_count = 0; - if (frame_count < ES_DEFAULT_NUMBER_OF_FEED) { if (!feed_video_data(ad)) break; diff --git a/test/legacy_player_media_packet_test.c b/test/player_media_packet_test.c similarity index 95% rename from test/legacy_player_media_packet_test.c rename to test/player_media_packet_test.c index 4cb37e5..9c4dfdf 100644 --- a/test/legacy_player_media_packet_test.c +++ b/test/player_media_packet_test.c @@ -134,6 +134,7 @@ static void _media_packet_video_decoded_cb(media_packet_h packet, void *user_dat if (ad->pipe == NULL) { media_packet_destroy(packet); LOGW("release media packet immediately"); + g_mutex_unlock(&ad->buffer_lock); return; } @@ -155,7 +156,7 @@ 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; -#if _CAN_USE_NATIVE_SURFACE_TBM +#ifdef _CAN_USE_NATIVE_SURFACE_TBM Evas_Native_Surface surf; #endif tbm_surface_info_s suf_info; @@ -206,7 +207,7 @@ static void pipe_cb(void *data, void *buf, unsigned int len) g_mutex_unlock(&ad->buffer_lock); -#if _CAN_USE_NATIVE_SURFACE_TBM +#ifdef _CAN_USE_NATIVE_SURFACE_TBM /* Set tbm surface to image native surface */ memset(&surf, 0x0, sizeof(surf)); surf.version = EVAS_NATIVE_SURFACE_VERSION; @@ -286,7 +287,7 @@ static int app_pause(void *data) } if (ad->player_handle == NULL) { - printf("player_handle is NULL"); + g_print("player_handle is NULL"); return -1; } @@ -331,15 +332,21 @@ static int app_pause(void *data) g_mutex_unlock(&ad->buffer_lock); + ret = player_unset_media_packet_video_frame_decoded_cb(ad->player_handle); + if (ret != PLAYER_ERROR_NONE) { + g_print("player_unset_media_packet_video_frame_decoded_cb failed : 0x%x", ret); + return false; + } + ret = player_unprepare(ad->player_handle); if (ret != PLAYER_ERROR_NONE) { - printf("player_unprepare failed : 0x%x", ret); + g_print("player_unprepare failed : 0x%x", ret); return false; } ret = player_destroy(ad->player_handle); if (ret != PLAYER_ERROR_NONE) { - printf("player_destroy failed : 0x%x", ret); + g_print("player_destroy failed : 0x%x", ret); return false; } diff --git a/test/legacy_player_test.c b/test/player_test.c similarity index 78% rename from test/legacy_player_test.c rename to test/player_test.c index 44fbf5b..63ccd53 100644 --- a/test/legacy_player_test.c +++ b/test/player_test.c @@ -28,10 +28,23 @@ #include #include #endif +#ifdef _ACTIVATE_EOM_ +#include +#endif + +#ifdef PACKAGE +#undef PACKAGE +#endif #define PACKAGE "player_test" -#define MAX_STRING_LEN 2048 + +#ifdef LOG_TAG +#undef LOG_TAG +#endif +#define LOG_TAG "PLAYER_TEST" + +#define MAX_STRING_LEN 2048 #define MMTS_SAMPLELIST_INI_DEFAULT_PATH "/opt/etc/mmts_filelist.ini" -#define PLAYER_TEST_DUMP_PATH_PREFIX "/home/owner/content/dump_pcm_" +#define PLAYER_TEST_DUMP_PATH_PREFIX "/home/owner/content/dump_pcm_" #define INI_SAMPLE_LIST_MAX 9 #define DEFAULT_HTTP_TIMEOUT -1 @@ -49,7 +62,9 @@ static media_format_h g_audio_fmt = NULL; static media_packet_h g_video_pkt = NULL; static media_format_h g_video_fmt = NULL; -/* #define DUMP_OUTBUF 1 */ +static int _save(unsigned char *src, int length); + +#define DUMP_OUTBUF 1 #if DUMP_OUTBUF FILE *fp_out1 = NULL; FILE *fp_out2 = NULL; @@ -75,48 +90,46 @@ enum { CURRENT_STATUS_SUBTITLE_FILENAME, CURRENT_STATUS_AUDIO_EQUALIZER, CURRENT_STATUS_PLAYBACK_RATE, + CURRENT_STATUS_STREAMING_PLAYBACK_RATE, CURRENT_STATUS_SWITCH_SUBTITLE, }; #define MAX_HANDLE 20 /* for video display */ -Evas_Object *g_xid; -Evas_Object *g_eo_win; -Evas_Object *g_eo[MAX_HANDLE] = {0, }; - -int g_current_surface_type = PLAYER_DISPLAY_TYPE_OVERLAY; +static Evas_Object *g_xid; +#ifdef _ACTIVATE_EOM_ +static Evas_Object *g_external_xid; +#endif +static Evas_Object *selected_xid; +static Evas_Object *g_eo[MAX_HANDLE] = {0, }; -struct appdata { +static int g_current_surface_type = PLAYER_DISPLAY_TYPE_OVERLAY; +typedef struct { Evas_Object *win; - Evas_Object *bg; - Evas_Object *rect; + Evas_Object *layout_main; /* layout widget based on EDJ */ #ifdef HAVE_X11 Ecore_X_Window xid; #elif HAVE_WAYLAND unsigned int xid; #endif - Evas_Object *layout_main; /* layout widget based on EDJ */ /* add more variables here */ -}; - -static Evas_Object *create_bg(Evas_Object * pParent) -{ - if (!pParent) - return NULL; +#ifdef _ACTIVATE_EOM_ + int hdmi_output_id; +#endif +} appdata; - Evas_Object *pObj = NULL; +static appdata ad; +static player_h g_player[MAX_HANDLE] = {0, }; - pObj = elm_bg_add(pParent); - evas_object_size_hint_weight_set(pObj, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); - elm_win_resize_object_add(pParent, pObj); - evas_object_color_set(pObj, 0, 0, 0, 0); - evas_object_show(pObj); - return pObj; -} +int g_handle_num = 1; +int g_menu_state = CURRENT_STATUS_MAINMENU; +char g_file_list[9][256]; +gboolean quit_pushing; +sound_stream_info_h g_stream_info_h = NULL; -static void win_del(void *data, Evas_Object * obj, void *event) +static void win_del(void *data, Evas_Object *obj, void *event) { elm_exit(); } @@ -145,7 +158,7 @@ static Evas_Object *create_win(const char *name) return eo; } -static Evas_Object *create_image_object(Evas_Object * eo_parent) +static Evas_Object *create_image_object(Evas_Object *eo_parent) { if (!eo_parent) return NULL; @@ -158,30 +171,231 @@ static Evas_Object *create_image_object(Evas_Object * eo_parent) return eo; } -static Evas_Object *create_render_rect(Evas_Object * pParent) +void create_render_rect_and_bg(Evas_Object *win) { - if (!pParent) - return NULL; + if (!win) { + g_print("no win"); + return; + } + Evas_Object *bg, *rect; - Evas *pEvas = evas_object_evas_get(pParent); - Evas_Object *pObj = evas_object_rectangle_add(pEvas); - if (pObj == NULL) - return NULL; + 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); +} +#ifdef _ACTIVATE_EOM_ +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; +} - 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); +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; - return pObj; + 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(); + } +} +#endif static int app_create(void *data) { - struct appdata *ad = data; + appdata *ad = data; Evas_Object *win = NULL; - +#ifdef _ACTIVATE_EOM_ + eom_output_mode_e output_mode = EOM_OUTPUT_MODE_NONE; +#endif /* use gl backend */ elm_config_preferred_engine_set("3d"); @@ -190,10 +404,9 @@ static int app_create(void *data) if (win == NULL) return -1; ad->win = win; - g_eo_win = win; - ad->bg = create_bg(ad->win); - ad->rect = create_render_rect(ad->win); - g_xid = ad->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); @@ -202,13 +415,47 @@ static int app_create(void *data) elm_win_activate(win); evas_object_show(win); +#ifdef _ACTIVATE_EOM_ + /* 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); +#endif return 0; } static int app_terminate(void *data) { - struct appdata *ad = data; + appdata *ad = data; int i = 0; for (i = 0; i < MAX_HANDLE; i++) { @@ -217,11 +464,26 @@ static int app_terminate(void *data) g_eo[i] = NULL; } } - if (g_eo_win) { - evas_object_del(g_eo_win); - g_eo_win = NULL; + if (g_xid) { + evas_object_del(g_xid); + g_xid = NULL; + } +#ifdef _ACTIVATE_EOM_ + if (g_external_xid) { + evas_object_del(g_external_xid); + g_external_xid = NULL; } +#endif ad->win = NULL; + selected_xid = NULL; +#ifdef _ACTIVATE_EOM_ + 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(); +#endif return 0; } @@ -230,15 +492,6 @@ struct appcore_ops ops = { .terminate = app_terminate, }; -struct 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; -sound_stream_info_h g_stream_info_h = NULL; - static void prepared_cb(void *user_data) { g_print("[Player_Test] prepared_cb!!!!\n"); @@ -254,10 +507,10 @@ static void _audio_frame_decoded_cb_ex(player_audio_raw_data_s *audio_raw_frame, 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); + if (audio_raw->channel_mask == 1 && fp_out1) + fwrite((guint8 *)audio_raw->data, 1, audio_raw->size, fp_out1); + else if (audio_raw->channel_mask == 2 && fp_out2) + fwrite((guint8 *)audio_raw->data, 1, audio_raw->size, fp_out2); #endif } @@ -298,7 +551,6 @@ static void audio_frame_decoded_cb(unsigned char *data, unsigned int size, void 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); } @@ -312,17 +564,17 @@ static void subtitle_updated_cb(unsigned long duration, char *text, void *user_d 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); } -int _save(unsigned char *src, int length) +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, "ALBUM_ART_IMAGE_%d", WRITE_COUNT); + snprintf(filename, 256, "IMAGE_client%d", WRITE_COUNT); WRITE_COUNT++; fp = fopen(filename, "w+"); if (fp == NULL) { @@ -353,7 +605,6 @@ static void reset_display() g_eo[i] = NULL; } } - } static void input_filename(char *filename) @@ -361,7 +612,7 @@ static void input_filename(char *filename) int len = strlen(filename); int i = 0; - if (len < 0 || len > MAX_STRING_LEN) + if (len < 0 || len > MAX_STRING_LEN - 1) return; for (i = 0; i < g_handle_num; i++) { @@ -376,6 +627,7 @@ static void input_filename(char *filename) } strncpy(g_uri, filename, len); + g_uri[len] = '\0'; #if 0 /* ned(APPSRC_TEST) */ @@ -400,11 +652,12 @@ static void input_filename(char *filename) /* 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]", ret); + g_print("player_get_state returned [%d]\n", ret); g_print("1. After player_create() - Current State : %d \n", state); } } @@ -418,7 +671,7 @@ static void player_set_memory_buffer_test() 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); + 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); @@ -431,7 +684,7 @@ 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; + static unsigned long long pts = 0L; FILE *fp = NULL; guint8 *buff_ptr = NULL; @@ -444,10 +697,12 @@ static void buffer_need_video_data_cb(unsigned int size, void *user_data) 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); @@ -456,24 +711,22 @@ static void buffer_need_video_data_cb(unsigned int size, void *user_data) fp = fopen(fptsname, "rb"); if (fp) { int pts_len = 0; - pts_len = fread(&pts, 1, sizeof(guint64), fp); - if (pts_len != sizeof(guint64)) + pts_len = fread(&pts, 1, sizeof(unsigned long long), fp); + if (pts_len != sizeof(unsigned long long)) 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); + buff_ptr = (guint8 *)g_malloc0(1048576); if (!buff_ptr) { g_print("no free space\n"); fclose(fp); fp = NULL; return; } - real_read_len = fread(buff_ptr, 1, size, fp); fclose(fp); fp = NULL; @@ -498,7 +751,7 @@ static void buffer_need_video_data_cb(unsigned int size, void *user_data) if (media_packet_set_pts(g_video_pkt, (uint64_t)pts) != MEDIA_PACKET_ERROR_NONE) goto EXIT; - if (media_packet_set_buffer_size(g_video_pkt, (uint64_t) real_read_len) != MEDIA_PACKET_ERROR_NONE) + if (media_packet_set_buffer_size(g_video_pkt, (uint64_t)real_read_len) != MEDIA_PACKET_ERROR_NONE) goto EXIT; memcpy(src, buff_ptr, real_read_len); @@ -532,22 +785,22 @@ static void buffer_need_audio_data_cb(unsigned int size, void *user_data) 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; + static unsigned long long audio_pts = 0; + unsigned long long audio_dur = 21333333; fp = fopen(fname, "rb"); if (fp) { - buff_ptr = (guint8 *) g_malloc0(1048576); + buff_ptr = (guint8 *)g_malloc0(1048576); if (!buff_ptr) { g_print("no free space\n"); fclose(fp); fp = NULL; return; } - real_read_len = fread(buff_ptr, 1, size, fp); fclose(fp); fp = NULL; @@ -572,7 +825,7 @@ static void buffer_need_audio_data_cb(unsigned int size, void *user_data) if (media_packet_set_pts(g_audio_pkt, (uint64_t)audio_pts) != MEDIA_PACKET_ERROR_NONE) goto EXIT; - if (media_packet_set_buffer_size(g_audio_pkt, (uint64_t) real_read_len) != MEDIA_PACKET_ERROR_NONE) + if (media_packet_set_buffer_size(g_audio_pkt, (uint64_t)real_read_len) != MEDIA_PACKET_ERROR_NONE) goto EXIT; memcpy(src, buff_ptr, real_read_len); @@ -582,7 +835,6 @@ static void buffer_need_audio_data_cb(unsigned int size, void *user_data) #endif audio_pts += audio_dur; - EXIT: if (buff_ptr) { g_free(buff_ptr); @@ -626,7 +878,7 @@ static void set_content_info(bool is_push_mode) /* audio--aac--StarWars.mp4 */ /* audio_info->mime = g_strdup("audio/mpeg"); */ /* audio_info->version = 2; */ - /* audio_info->user_info = 0;*/ /* raw */ + /* audio_info->user_info = 0; */ /* raw */ #endif #ifdef _ES_PULL_ @@ -656,7 +908,7 @@ static void _player_prepare(bool async) 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(g_xid)); + 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]); @@ -689,11 +941,11 @@ static void _player_prepare(bool async) set_content_info(TRUE); async = TRUE; is_es_push_mode = TRUE; - } #ifdef _ES_PULL_ - else + } else { set_content_info(FALSE); #endif + } } if (g_current_surface_type == PLAYER_DISPLAY_TYPE_OVERLAY) { @@ -728,6 +980,7 @@ static void _player_prepare(bool async) if (is_es_push_mode) pthread_create(&g_feed_video_thread_id, NULL, (void *)feed_video_data_thread_func, NULL); + } static void _player_unprepare() @@ -738,6 +991,7 @@ static void _player_unprepare() 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); @@ -776,6 +1030,7 @@ static void _player_unprepare() } } } + /* attention! surface(evas) -> unprepare -> surface(evas) : evas object will disappear. */ reset_display(); memset(g_subtitle_uri, 0, sizeof(g_subtitle_uri)); player_state_e state; @@ -835,6 +1090,10 @@ static void _player_play() int bRet = FALSE; int i = 0; if (g_current_surface_type == PLAYER_DISPLAY_TYPE_OVERLAY) { +#ifdef _ACTIVATE_EOM_ + /* for checking external display.... */ + player_set_display(g_player[0], g_current_surface_type, GET_DISPLAY(selected_xid)); +#endif bRet = player_start(g_player[0]); g_print("player_start returned [%d]", bRet); } else { @@ -872,6 +1131,10 @@ static void _player_resume() int bRet = FALSE; int i = 0; if (g_current_surface_type == PLAYER_DISPLAY_TYPE_OVERLAY) { +#ifdef _ACTIVATE_EOM_ + /* for checking external display.... */ + player_set_display(g_player[0], PLAYER_DISPLAY_TYPE_OVERLAY, GET_DISPLAY(selected_xid)); +#endif bRet = player_start(g_player[0]); g_print("player_start returned [%d]", bRet); } else { @@ -910,6 +1173,14 @@ static void _player_set_progressive_download() player_set_progressive_download_message_cb(g_player[0], progress_down_cb, (void *)g_player[0]); } +static void _player_get_progressive_download_status() +{ + int bRet; + unsigned long curr, total; + bRet = player_get_progressive_download_status(g_player[0], &curr, &total); + g_print("player_get_progressive_download_status return[%d] ==> [Player_Test] progressive download status : %lu/%lu\n", bRet, curr, total); +} + static void set_volume(float volume) { if (player_set_volume(g_player[0], volume, volume) != PLAYER_ERROR_NONE) @@ -978,10 +1249,15 @@ static void set_position(int position) g_print("failed to set position\n"); } -static void set_playback_rate(float rate) +static void set_playback_rate(float rate, bool streaming) { - if (player_set_playback_rate(g_player[0], rate) != PLAYER_ERROR_NONE) - g_print("failed to set playback rate\n"); + if (streaming) { + if (player_set_streaming_playback_rate(g_player[0], rate) != PLAYER_ERROR_NONE) + g_print("failed to set streaming playback rate\n"); + } else { + if (player_set_playback_rate(g_player[0], rate) != PLAYER_ERROR_NONE) + g_print("failed to set playback rate\n"); + } } static void get_duration() @@ -993,14 +1269,6 @@ static void get_duration() g_print(" ==> [Player_Test] Duration: [%d ] msec\n", duration); } -static int get_download_progress() -{ - int ret; - int start=0, current=0; - ret = player_get_streaming_download_progress(g_player[0], &start, ¤t); - g_print(" ==> [Player_Test] download progress: [%d ~ %d]\n", start, current); - return ret; -} static void audio_frame_decoded_cb_ex() { int ret; @@ -1020,7 +1288,7 @@ static void audio_frame_decoded_cb_ex() static void set_pcm_spec() { - int ret; + 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); @@ -1092,7 +1360,7 @@ static void set_looping(bool looping) } } -static void get_looping(bool * looping) +static void get_looping(bool *looping) { player_is_looping(g_player[0], looping); g_print(" ==> [Player_Test] looping = %d\n", *looping); @@ -1102,7 +1370,10 @@ static void change_surface(int option) { player_display_type_e surface_type = 0; int ret = PLAYER_ERROR_NONE; - +#ifdef _ACTIVATE_EOM_ + int hdmi_output_id; + eom_output_mode_e output_mode; +#endif switch (option) { case 0: /* X surface */ @@ -1134,35 +1405,63 @@ static void change_surface(int option) if (ret) g_print("failed to player_get_state(), ret(0x%x)\n", ret); - /* state check */ - if (player_state == PLAYER_STATE_NONE || player_state == PLAYER_STATE_IDLE) { - reset_display(); + reset_display(); - if (surface_type == PLAYER_DISPLAY_TYPE_OVERLAY) { - g_xid = g_eo_win; - ret = player_set_display(g_player[0], surface_type, GET_DISPLAY(g_xid)); - } else { - 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_eo_win); - 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 (surface_type == PLAYER_DISPLAY_TYPE_OVERLAY) { +#ifdef _ACTIVATE_EOM_ + 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) { +#endif + 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; } +#ifdef _ACTIVATE_EOM_ + } else { + /* for external */ } - if (ret) { - g_print("failed to set display, surface_type(%d)\n", surface_type); - return; - } - g_current_surface_type = surface_type; +#endif + ret = player_set_display(g_player[0], surface_type, GET_DISPLAY(selected_xid)); } else { - g_print("could not change surface type, current_state(%d)\n", player_state); + 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; } @@ -1199,7 +1498,7 @@ static void set_display_visible(bool visible) g_print("failed to player_set_x11_display_visible\n"); } -static void get_display_visible(bool * visible) +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); @@ -1325,7 +1624,6 @@ static void decoding_audio() 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 } @@ -1339,7 +1637,9 @@ static void set_audio_eq(int value) 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)) + 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); } } @@ -1500,15 +1800,19 @@ void _interpret_main_menu(char *cmd) } } else if (len == 2) { if (strncmp(cmd, "pr", 2) == 0) { - _player_prepare(FALSE); /* sync */ + /* sync */ + _player_prepare(FALSE); } else if (strncmp(cmd, "pa", 2) == 0) { - _player_prepare(TRUE); /* async */ + /* async */ + _player_prepare(TRUE); } 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, "gp", 2) == 0) { + _player_get_progressive_download_status(); } else if (strncmp(cmd, "mp", 2) == 0) { g_memory_playback = (g_memory_playback ? FALSE : TRUE); g_print("memory playback = %d\n", g_memory_playback); @@ -1524,13 +1828,14 @@ void _interpret_main_menu(char *cmd) audio_frame_decoded_cb_ex(); } else if (strncmp(cmd, "X4", 2) == 0) { set_pcm_spec(); - } else if (strncmp(cmd, "dp", 2) == 0) { - get_download_progress(); } else { g_print("unknown menu \n"); } } else { - g_print("unknown menu \n"); + if (strncmp(cmd, "trs", 3) == 0) + g_menu_state = CURRENT_STATUS_STREAMING_PLAYBACK_RATE; + else + g_print("unknown menu \n"); } } @@ -1570,7 +1875,6 @@ void display_sub_basic() g_print("l. Get Position\n"); g_print("[trick] tr. set playback rate\n"); g_print("[duration] m. Get Duration\n"); - g_print("[buffering] dp. Get Download Progress\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"); @@ -1585,6 +1889,7 @@ void display_sub_basic() 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("gp. Get Progressive Download status\n"); 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"); @@ -1629,7 +1934,7 @@ static void displaymenu() 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) { + } else if (g_menu_state == CURRENT_STATUS_PLAYBACK_RATE || g_menu_state == CURRENT_STATUS_STREAMING_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; @@ -1853,7 +2158,14 @@ static void interpret(char *cmd) case CURRENT_STATUS_PLAYBACK_RATE: { float rate = atof(cmd); - set_playback_rate(rate); + set_playback_rate(rate, FALSE); + reset_menu_state(); + } + break; + case CURRENT_STATUS_STREAMING_PLAYBACK_RATE: + { + float rate = atof(cmd); + set_playback_rate(rate, TRUE); reset_menu_state(); } break; @@ -1887,10 +2199,10 @@ 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); + g_io_add_watch(stdin_channel, G_IO_IN, (GIOFunc)input, NULL); displaymenu(); - memset(&ad, 0x0, sizeof(struct appdata)); + memset(&ad, 0x0, sizeof(appdata)); ops.data = &ad; return appcore_efl_main(PACKAGE, &argc, &argv, &ops); -- 2.7.4