From 30d8701e652ee30bfa455bfd3dd2b09262317382 Mon Sep 17 00:00:00 2001 From: Sejun Park Date: Mon, 24 Oct 2016 15:22:19 +0900 Subject: [PATCH 01/16] Added internal API for static loading ini when binding c# API Change-Id: Id4e51da2d93957fd2735f93ae47aabcdc66ebdd3 --- include/media_codec_ini.h | 6 +- include/media_codec_internal.h | 54 ++++++++ include/media_codec_port.h | 42 +++++- include/media_codec_spec_emul.h | 3 + packaging/capi-media-codec.spec | 2 +- src/media_codec.c | 2 +- src/media_codec_internal.c | 110 +++++++++++++++ src/media_codec_port.c | 297 ++++++++++++++++++++++++++++++---------- test/media_codec_test.c | 86 +++++++++++- 9 files changed, 521 insertions(+), 81 deletions(-) create mode 100755 include/media_codec_internal.h create mode 100755 src/media_codec_internal.c diff --git a/include/media_codec_ini.h b/include/media_codec_ini.h index b51404e..ba0704f 100755 --- a/include/media_codec_ini.h +++ b/include/media_codec_ini.h @@ -66,7 +66,9 @@ struct _codec_t { /* @ mark means the item has tested */ struct _mc_ini_t { - int codec_list; + gboolean loaded; + gint codec_list; + gint num_supported_codecs; port_mode port_type; /* general */ gchar port_name[MEDIA_CODEC_INI_MAX_STRLEN]; @@ -107,6 +109,8 @@ media_codec_port = GST_PORT \n\ \n\ " +extern mc_ini_t mc_ini; + int mc_ini_load(mc_ini_t *ini); media_format_mimetype_e _mc_convert_media_format_str_to_int(char *sformat); diff --git a/include/media_codec_internal.h b/include/media_codec_internal.h new file mode 100755 index 0000000..87eac43 --- /dev/null +++ b/include/media_codec_internal.h @@ -0,0 +1,54 @@ +/* +* Copyright (c) 2016 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_CODEC_INTERNAL_H__ +#define __TIZEN_MEDIA_CODEC_INTERNAL_H__ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/** +* @file media_codec_internal.h +* @brief This file contains the internal capi media codec API. +*/ + +/** +* @addtogroup CAPI_MEDIA_CODEC_MODULE +* @{ +*/ + +/** + * @brief Retrieves all supported codecs by invoking callback function once for each supported codecs. + * @since_tizen 3.0 + * @param[in] callback The callback function to invoke + * @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 #MEDIACODEC_ERROR_NONE Successful + * @retval #MEDIACODEC_ERROR_INVALID_PARAMETER Invalid parameter + * @see mediacodec_foreach_supported_codec() + */ +int mediacodec_foreach_supported_codec_static(mediacodec_supported_codec_cb callback, void *user_data); + +/** + * @} + */ +#ifdef __cplusplus +} +#endif +#endif /*__TIZEN_MEDIA_CODEC_INTERNAL_H__*/ diff --git a/include/media_codec_port.h b/include/media_codec_port.h index 2b7ec12..30937c2 100755 --- a/include/media_codec_port.h +++ b/include/media_codec_port.h @@ -86,6 +86,38 @@ typedef enum { MC_OUT_OF_MEMORY = -20, /**< when memory is not allocated */ } mc_ret_e; +typedef enum { + NONE, + L16, + ALAW, + ULAW, + AMR_NB, + AMR_WB, + G729, + AAC_LC, + AAC_HE, + AAC_HE_PS, + MP3, + VORBIS, + FLAC, + WMAV1, + WMAV2, + WMAPRO, + WMALSL, + H261, + H263, + H264, + MJPEG, + MPEG1, + MPEG2, + MPEG4, + HEVC, + VP8, + VP9, + VC1, + CODEC_NR_ITEMS +} codec_type_e; + /*--------------------------------------------------------------------------- | GLOBAL DATA TYPE DEFINITIONS: | ---------------------------------------------------------------------------*/ @@ -175,7 +207,6 @@ struct _mc_handle_t { bool is_hw; bool is_prepared; - GList *supported_codecs; mediacodec_port_type_e port_type; mediacodec_codec_type_e codec_id; mc_vendor_e vendor; @@ -195,11 +226,10 @@ struct _mc_handle_t { mc_codec_map_t encoder_map[MEDIA_CODEC_MAX_CODEC_TYPE]; mc_codec_map_t decoder_map[MEDIA_CODEC_MAX_CODEC_TYPE]; - int num_supported_codecs; int num_supported_decoder; int num_supported_encoder; - mc_ini_t ini; + mc_ini_t *ini; }; /*=========================================================================================== @@ -249,12 +279,16 @@ int mc_unset_eos_cb(MMHandleType mediacodec); int mc_set_buffer_status_cb(MMHandleType mediacodec, mediacodec_buffer_status_cb callback, void* user_data); int mc_unset_buffer_status_cb(MMHandleType mediacodec); int mc_set_supported_codec_cb(MMHandleType mediacodec, mediacodec_supported_codec_cb callback, void* user_data); -int _mediacodec_foreach_supported_codec(MMHandleType mediacodec, mediacodec_supported_codec_cb callback, void* user_data); +int _mediacodec_foreach_supported_codec(mediacodec_supported_codec_cb callback, void* user_data); void _mc_create_codec_map_from_ini(mc_handle_t *mc_handle, mc_codec_spec_t *spec_emul); +void _mc_create_codec_map_from_ini_static(mc_ini_t *ini, mc_codec_spec_t *spec_emul); void _mc_create_decoder_map_from_ini(mc_handle_t *mc_handle); void _mc_create_encoder_map_from_ini(mc_handle_t *mc_handle); +const int simple_to_codec_type_enumeration(codec_type_e codec_id); +const int codec_type_to_simple_enumeration(mediacodec_codec_type_e media_codec_id); + #ifdef __cplusplus } #endif diff --git a/include/media_codec_spec_emul.h b/include/media_codec_spec_emul.h index 4fc7f6f..96bb3fb 100755 --- a/include/media_codec_spec_emul.h +++ b/include/media_codec_spec_emul.h @@ -23,6 +23,8 @@ extern "C" { #include +#define MEDIA_CODEC_MAX_CODEC_TYPE 100 + enum {DECODER, ENCODER}; enum {SOFTWARE, HARDWARE}; @@ -48,6 +50,7 @@ struct _mc_codec_map_t { mc_codec_type_t type; }; +extern mc_codec_spec_t spec_emul[MEDIA_CODEC_MAX_CODEC_TYPE]; #ifdef __cplusplus } diff --git a/packaging/capi-media-codec.spec b/packaging/capi-media-codec.spec index 94a969c..92cb31b 100755 --- a/packaging/capi-media-codec.spec +++ b/packaging/capi-media-codec.spec @@ -1,6 +1,6 @@ Name: capi-media-codec Summary: A Media Codec library in Tizen Native API -Version: 0.4.3 +Version: 0.5.0 Release: 0 Group: Multimedia/API License: Apache-2.0 diff --git a/src/media_codec.c b/src/media_codec.c index c8d6e20..22cd3d8 100755 --- a/src/media_codec.c +++ b/src/media_codec.c @@ -479,7 +479,7 @@ int mediacodec_foreach_supported_codec(mediacodec_h mediacodec, mediacodec_suppo handle->supported_codec_cb_userdata = user_data; LOGD("set supported_codec_cb(%p)", callback); - int ret = _mediacodec_foreach_supported_codec(handle->mc_handle, callback, handle); + int ret = _mediacodec_foreach_supported_codec(callback, handle); if (ret != MEDIACODEC_ERROR_NONE) return __convert_error_code(ret, (char *)__FUNCTION__); diff --git a/src/media_codec_internal.c b/src/media_codec_internal.c new file mode 100755 index 0000000..bdf24a5 --- /dev/null +++ b/src/media_codec_internal.c @@ -0,0 +1,110 @@ +#include +#include +#include +#include +#include +#include + +mc_codec_spec_t spec_emul[MEDIA_CODEC_MAX_CODEC_TYPE]; +mc_ini_t mc_ini; + +int __convert_error_code_internal(int code, char *func_name) +{ + int ret = MEDIACODEC_ERROR_INVALID_OPERATION; + char *msg = "MEDIACOODEC_INVALID_OPERATION"; + + switch (code) { + case MC_ERROR_NONE: + ret = MEDIACODEC_ERROR_NONE; + msg = "MEDIACODEC_ERROR_NONE"; + break; + case MC_PARAM_ERROR: + case MC_INVALID_ARG: + ret = MEDIACODEC_ERROR_INVALID_PARAMETER; + msg = "MEDIACODEC_ERROR_INVALID_PARAMETER"; + break; + case MC_PERMISSION_DENIED: + ret = MEDIACODEC_ERROR_PERMISSION_DENIED; + msg = "MEDIACODEC_ERROR_PERMISSION_DENIED"; + break; + case MC_INVALID_STATUS: + ret = MEDIACODEC_ERROR_INVALID_STATE; + msg = "MEDIACODEC_ERROR_INVALID_STATE"; + break; + case MC_NOT_SUPPORTED: + ret = MEDIACODEC_ERROR_NOT_SUPPORTED_ON_DEVICE; + msg = "MEDIACODEC_ERROR_NOT_SUPPORTED_ON_DEVICE"; + break; + case MC_ERROR: + case MC_INTERNAL_ERROR: + case MC_HW_ERROR: + ret = MEDIACODEC_ERROR_INVALID_OPERATION; + msg = "MEDIACODEC_ERROR_INVALID_OPERATION"; + break; + case MC_INVALID_STREAM: + ret = MEDIACODEC_ERROR_INVALID_STREAM; + msg = "MEDIACODEC_ERROR_INVALID_STREAM"; + break; + case MC_CODEC_NOT_FOUND: + ret = MEDIACODEC_ERROR_CODEC_NOT_FOUND; + msg = "MEDIACODEC_ERROR_CODEC_NOT_FOUND"; + break; + case MC_ERROR_DECODE: + ret = MEDIACODEC_ERROR_DECODE; + msg = "MEDIACODEC_ERROR_DECODE"; + break; + case MC_INVALID_IN_BUF: + ret = MEDIACODEC_ERROR_INVALID_INBUFFER; + msg = "MEDIACODEC_ERROR_INVALID_INBUFFER"; + break; + case MC_INVALID_OUT_BUF: + ret = MEDIACODEC_ERROR_INVALID_OUTBUFFER; + msg = "MEDIACODEC_ERROR_INVALID_OUTBUFFER"; + break; + case MC_NOT_INITIALIZED: + ret = MEDIACODEC_ERROR_NOT_INITIALIZED; + msg = "MEDIACODEC_ERROR_NOT_INITIALIZED"; + break; + case MC_OUTPUT_BUFFER_EMPTY: + case MC_OUTPUT_BUFFER_OVERFLOW: + ret = MEDIACODEC_ERROR_BUFFER_NOT_AVAILABLE; + msg = "MEDIACODEC_ERROR_BUFFER_NOT_AVAILABLE"; + break; + case MC_OUT_OF_MEMORY: + ret = MEDIACODEC_ERROR_OUT_OF_MEMORY; + msg = "MEDIACODEC_ERROR_OUT_OF_MEMORY"; + break; + default: + ret = MEDIACODEC_ERROR_INTERNAL; + msg = "MEDIACODEC_ERROR_INTERNAL"; + break; + } + LOGD("[%s] %s(0x%08x) : core fw error(0x%x)", func_name, msg, ret, code); + return ret; +} + +int mediacodec_foreach_supported_codec_static(mediacodec_supported_codec_cb callback, void *user_data) +{ + int ret; + + if (!mc_ini.loaded) { + ret = mc_ini_load(&mc_ini); + if (ret != MC_ERROR_NONE) + goto ERROR; + + mc_ini.loaded = TRUE; + } + + _mc_create_codec_map_from_ini_static(&mc_ini, spec_emul); + + LOGD("set supported_codec_cb(%p)", callback); + ret = _mediacodec_foreach_supported_codec(callback, user_data); + + if (ret != MEDIACODEC_ERROR_NONE) + return __convert_error_code_internal(ret, (char *)__FUNCTION__); + else + return MEDIACODEC_ERROR_NONE; + +ERROR: + return MEDIACODEC_ERROR_INVALID_PARAMETER; +} diff --git a/src/media_codec_port.c b/src/media_codec_port.c index 76e49cc..83b618f 100755 --- a/src/media_codec_port.c +++ b/src/media_codec_port.c @@ -26,13 +26,13 @@ #include #include -static mc_codec_spec_t spec_emul[MEDIA_CODEC_MAX_CODEC_TYPE]; +mc_ini_t mc_ini; +mc_codec_spec_t spec_emul[MEDIA_CODEC_MAX_CODEC_TYPE]; int mc_create(MMHandleType *mediacodec) { mc_handle_t *new_mediacodec = NULL; int ret = MC_ERROR_NONE; - int i; /* alloc mediacodec structure */ new_mediacodec = (mc_handle_t *)g_malloc(sizeof(mc_handle_t)); @@ -43,7 +43,6 @@ int mc_create(MMHandleType *mediacodec) goto ERROR; } memset(new_mediacodec, 0, sizeof(mc_handle_t)); - memset(spec_emul, 0, sizeof(mc_codec_spec_t)*MEDIA_CODEC_MAX_CODEC_TYPE); new_mediacodec->is_encoder = false; new_mediacodec->is_video = false; @@ -54,23 +53,23 @@ int mc_create(MMHandleType *mediacodec) new_mediacodec->ports[0] = NULL; new_mediacodec->ports[1] = NULL; - new_mediacodec->num_supported_codecs = 0; new_mediacodec->num_supported_decoder = 0; new_mediacodec->num_supported_encoder = 0; new_mediacodec->core = NULL; + new_mediacodec->ini = &mc_ini; /* load ini files */ - ret = mc_ini_load(&new_mediacodec->ini); - if (ret != MC_ERROR_NONE) - goto ERROR; - _mc_create_codec_map_from_ini(new_mediacodec, spec_emul); + if (!mc_ini.loaded) { + ret = mc_ini_load(&mc_ini); + if (ret != MC_ERROR_NONE) + goto ERROR; - for (i = 0; i < new_mediacodec->num_supported_codecs; i++) { - new_mediacodec->supported_codecs = - g_list_append(new_mediacodec->supported_codecs, GINT_TO_POINTER(spec_emul[i].codec_id)); + mc_ini.loaded = TRUE; } + _mc_create_codec_map_from_ini(new_mediacodec, spec_emul); + /* create decoder map from ini */ _mc_create_decoder_map_from_ini(new_mediacodec); @@ -106,7 +105,6 @@ int mc_destroy(MMHandleType mediacodec) } mc_handle->is_prepared = false; - g_list_free(mc_handle->supported_codecs); /* free mediacodec structure */ if (mc_handle) { @@ -138,13 +136,13 @@ int mc_set_codec(MMHandleType mediacodec, mediacodec_codec_type_e codec_id, int if (!GET_IS_HW(flags) && !GET_IS_SW(flags)) flags |= MEDIACODEC_SUPPORT_TYPE_SW; - for (i = 0; i < mc_handle->num_supported_codecs; i++) { + for (i = 0; i < mc_handle->ini->num_supported_codecs; i++) { if ((codec_id == spec_emul[i].codec_id) && (flags == spec_emul[i].codec_type)) break; } - LOGD("support_list : %d, i : %d", mc_handle->num_supported_codecs, i); + LOGD("support_list : %d, i : %d", mc_handle->ini->num_supported_codecs, i); - if (i == mc_handle->num_supported_codecs) + if (i == mc_handle->ini->num_supported_codecs) return MC_NOT_SUPPORTED; mc_handle->port_type = spec_emul[i].port_type; @@ -682,37 +680,31 @@ int mc_set_supported_codec_cb(MMHandleType mediacodec, mediacodec_supported_code return ret; } -int _mediacodec_foreach_supported_codec(MMHandleType mediacodec, mediacodec_supported_codec_cb callback, void *user_data) +int _mediacodec_foreach_supported_codec(mediacodec_supported_codec_cb callback, void *user_data) { - int ret = MC_ERROR_NONE; - mc_handle_t *mc_handle = (mc_handle_t *)mediacodec; - int codecs_num; - gpointer tmp; + int ret = MEDIACODEC_NONE; + int i; + int index; - if (!mc_handle) { - LOGE("fail invaild param\n"); - return MC_INVALID_ARG; - } + gboolean codec[CODEC_NR_ITEMS] = {0,}; - if (mc_handle->supported_codecs) { - codecs_num = g_list_length(mc_handle->supported_codecs); - LOGD("supported_codecs : %d", codecs_num); + for (i = 0; i < mc_ini.num_supported_codecs; i++) { + index = codec_type_to_simple_enumeration(spec_emul[i].codec_id); + codec[index] = TRUE; + } - while (codecs_num) { - tmp = g_list_nth_data(mc_handle->supported_codecs, codecs_num - 1); - if (tmp) { - if (!callback(GPOINTER_TO_INT(tmp), user_data)) { - ret = MEDIACODEC_ERROR_INTERNAL; - goto CALLBACK_ERROR; - } + for (i = 0; i < CODEC_NR_ITEMS; i++) { + if (codec[i]) { + index = simple_to_codec_type_enumeration(i); + if (!callback(index, user_data)) { + goto CALLBACK_ERROR; } - codecs_num--; } + } - if (!callback(-1, user_data)) { - ret = MEDIACODEC_ERROR_INTERNAL; - goto CALLBACK_ERROR; - } + if (!callback(-1, user_data)) { + ret = MEDIACODEC_ERROR_INTERNAL; + goto CALLBACK_ERROR; } CALLBACK_ERROR: @@ -752,25 +744,25 @@ int mc_get_packet_pool(MMHandleType mediacodec, media_packet_pool_h *pool) void _mc_create_decoder_map_from_ini(mc_handle_t *mediacodec) { int indx = 0, count = 0; - int codec_list = mediacodec->ini.codec_list; + int codec_list = mediacodec->ini->codec_list; for (indx = 0; indx < codec_list; indx++) { - if (strcmp(mediacodec->ini.codec[indx].codec_info[0].name, "")) { - mediacodec->decoder_map[count].id = mediacodec->ini.codec[indx].codec_id; + if (strcmp(mediacodec->ini->codec[indx].codec_info[0].name, "")) { + mediacodec->decoder_map[count].id = mediacodec->ini->codec[indx].codec_id; mediacodec->decoder_map[count].hardware = 1; /* hardware */ - mediacodec->decoder_map[count].type.factory_name = mediacodec->ini.codec[indx].codec_info[0].name; - mediacodec->decoder_map[count].type.mime = mediacodec->ini.codec[indx].codec_info[0].mime; + mediacodec->decoder_map[count].type.factory_name = mediacodec->ini->codec[indx].codec_info[0].name; + mediacodec->decoder_map[count].type.mime = mediacodec->ini->codec[indx].codec_info[0].mime; mediacodec->decoder_map[count].type.out_format = - _mc_convert_media_format_str_to_int(mediacodec->ini.codec[indx].codec_info[0].format); + _mc_convert_media_format_str_to_int(mediacodec->ini->codec[indx].codec_info[0].format); count++; } - if (strcmp(mediacodec->ini.codec[indx].codec_info[2].name, "")) { - mediacodec->decoder_map[count].id = mediacodec->ini.codec[indx].codec_id; + if (strcmp(mediacodec->ini->codec[indx].codec_info[2].name, "")) { + mediacodec->decoder_map[count].id = mediacodec->ini->codec[indx].codec_id; mediacodec->decoder_map[count].hardware = 0; /* software */ - mediacodec->decoder_map[count].type.factory_name = mediacodec->ini.codec[indx].codec_info[2].name; - mediacodec->decoder_map[count].type.mime = mediacodec->ini.codec[indx].codec_info[2].mime; + mediacodec->decoder_map[count].type.factory_name = mediacodec->ini->codec[indx].codec_info[2].name; + mediacodec->decoder_map[count].type.mime = mediacodec->ini->codec[indx].codec_info[2].mime; mediacodec->decoder_map[count].type.out_format = - _mc_convert_media_format_str_to_int(mediacodec->ini.codec[indx].codec_info[2].format); + _mc_convert_media_format_str_to_int(mediacodec->ini->codec[indx].codec_info[2].format); count++; } } @@ -782,26 +774,26 @@ void _mc_create_decoder_map_from_ini(mc_handle_t *mediacodec) void _mc_create_encoder_map_from_ini(mc_handle_t *mediacodec) { int indx = 0, count = 0; - int codec_list = mediacodec->ini.codec_list; + int codec_list = mediacodec->ini->codec_list; for (indx = 0; indx < codec_list; indx++) { - if (strcmp(mediacodec->ini.codec[indx].codec_info[1].name, "")) { - mediacodec->encoder_map[count].id = mediacodec->ini.codec[indx].codec_id; + if (strcmp(mediacodec->ini->codec[indx].codec_info[1].name, "")) { + mediacodec->encoder_map[count].id = mediacodec->ini->codec[indx].codec_id; mediacodec->encoder_map[count].hardware = 1; - mediacodec->encoder_map[count].type.factory_name = mediacodec->ini.codec[indx].codec_info[1].name; - mediacodec->encoder_map[count].type.mime = mediacodec->ini.codec[indx].codec_info[1].mime; + mediacodec->encoder_map[count].type.factory_name = mediacodec->ini->codec[indx].codec_info[1].name; + mediacodec->encoder_map[count].type.mime = mediacodec->ini->codec[indx].codec_info[1].mime; mediacodec->encoder_map[count].type.out_format = - _mc_convert_media_format_str_to_int(mediacodec->ini.codec[indx].codec_info[1].format); + _mc_convert_media_format_str_to_int(mediacodec->ini->codec[indx].codec_info[1].format); count++; } - if (strcmp(mediacodec->ini.codec[indx].codec_info[3].name, "")) { - mediacodec->encoder_map[count].id = mediacodec->ini.codec[indx].codec_id; + if (strcmp(mediacodec->ini->codec[indx].codec_info[3].name, "")) { + mediacodec->encoder_map[count].id = mediacodec->ini->codec[indx].codec_id; mediacodec->encoder_map[count].hardware = 0; - mediacodec->encoder_map[count].type.factory_name = mediacodec->ini.codec[indx].codec_info[3].name; - mediacodec->encoder_map[count].type.mime = mediacodec->ini.codec[indx].codec_info[3].mime; + mediacodec->encoder_map[count].type.factory_name = mediacodec->ini->codec[indx].codec_info[3].name; + mediacodec->encoder_map[count].type.mime = mediacodec->ini->codec[indx].codec_info[3].mime; mediacodec->encoder_map[count].type.out_format = - _mc_convert_media_format_str_to_int(mediacodec->ini.codec[indx].codec_info[3].format); + _mc_convert_media_format_str_to_int(mediacodec->ini->codec[indx].codec_info[3].format); count++; } } @@ -812,38 +804,201 @@ void _mc_create_encoder_map_from_ini(mc_handle_t *mediacodec) void _mc_create_codec_map_from_ini(mc_handle_t *mediacodec, mc_codec_spec_t *spec_emul) { int indx = 0, count = 0; - int codec_list = mediacodec->ini.codec_list; + int codec_list = mediacodec->ini->codec_list; for (indx = 0; indx < codec_list; indx++) { - if (strcmp(mediacodec->ini.codec[indx].codec_info[0].name, "")) { - spec_emul[count].codec_id = mediacodec->ini.codec[indx].codec_id; + if (strcmp(mediacodec->ini->codec[indx].codec_info[0].name, "")) { + spec_emul[count].codec_id = mediacodec->ini->codec[indx].codec_id; spec_emul[count].codec_type = MEDIACODEC_DECODER | MEDIACODEC_SUPPORT_TYPE_HW; spec_emul[count].port_type = MEDIACODEC_PORT_TYPE_GST; count++; } - if (strcmp(mediacodec->ini.codec[indx].codec_info[1].name, "")) { - spec_emul[count].codec_id = mediacodec->ini.codec[indx].codec_id; + if (strcmp(mediacodec->ini->codec[indx].codec_info[1].name, "")) { + spec_emul[count].codec_id = mediacodec->ini->codec[indx].codec_id; spec_emul[count].codec_type = MEDIACODEC_ENCODER | MEDIACODEC_SUPPORT_TYPE_HW; spec_emul[count].port_type = MEDIACODEC_PORT_TYPE_GST; count++; } - if (strcmp(mediacodec->ini.codec[indx].codec_info[2].name, "")) { - spec_emul[count].codec_id = mediacodec->ini.codec[indx].codec_id; + if (strcmp(mediacodec->ini->codec[indx].codec_info[2].name, "")) { + spec_emul[count].codec_id = mediacodec->ini->codec[indx].codec_id; spec_emul[count].codec_type = MEDIACODEC_DECODER | MEDIACODEC_SUPPORT_TYPE_SW; spec_emul[count].port_type = MEDIACODEC_PORT_TYPE_GST; count++; } - if (strcmp(mediacodec->ini.codec[indx].codec_info[3].name, "")) { - spec_emul[count].codec_id = mediacodec->ini.codec[indx].codec_id; + if (strcmp(mediacodec->ini->codec[indx].codec_info[3].name, "")) { + spec_emul[count].codec_id = mediacodec->ini->codec[indx].codec_id; spec_emul[count].codec_type = MEDIACODEC_ENCODER | MEDIACODEC_SUPPORT_TYPE_SW; spec_emul[count].port_type = MEDIACODEC_PORT_TYPE_GST; count++; } } - mediacodec->num_supported_codecs = count; + mediacodec->ini->num_supported_codecs = count; LOGE("supported codecs :%d", count); return; } +void _mc_create_codec_map_from_ini_static(mc_ini_t *ini, mc_codec_spec_t *spec_emul) +{ + int indx = 0, count = 0; + int codec_list = ini->codec_list; + for (indx = 0; indx < codec_list; indx++) { + if (strcmp(ini->codec[indx].codec_info[0].name, "")) { + spec_emul[count].codec_id = ini->codec[indx].codec_id; + spec_emul[count].codec_type = MEDIACODEC_DECODER | MEDIACODEC_SUPPORT_TYPE_HW; + spec_emul[count].port_type = MEDIACODEC_PORT_TYPE_GST; + count++; + } + if (strcmp(ini->codec[indx].codec_info[1].name, "")) { + spec_emul[count].codec_id = ini->codec[indx].codec_id; + spec_emul[count].codec_type = MEDIACODEC_ENCODER | MEDIACODEC_SUPPORT_TYPE_HW; + spec_emul[count].port_type = MEDIACODEC_PORT_TYPE_GST; + count++; + } + if (strcmp(ini->codec[indx].codec_info[2].name, "")) { + spec_emul[count].codec_id = ini->codec[indx].codec_id; + spec_emul[count].codec_type = MEDIACODEC_DECODER | MEDIACODEC_SUPPORT_TYPE_SW; + spec_emul[count].port_type = MEDIACODEC_PORT_TYPE_GST; + count++; + } + if (strcmp(ini->codec[indx].codec_info[3].name, "")) { + spec_emul[count].codec_id = ini->codec[indx].codec_id; + spec_emul[count].codec_type = MEDIACODEC_ENCODER | MEDIACODEC_SUPPORT_TYPE_SW; + spec_emul[count].port_type = MEDIACODEC_PORT_TYPE_GST; + count++; + } + } + + ini->num_supported_codecs = count; + LOGE("supported codecs :%d", count); + return; +} + +const int codec_type_to_simple_enumeration(mediacodec_codec_type_e media_codec_id) +{ + guint media_codec_id_u = (guint)media_codec_id; + + switch (media_codec_id_u) { + case MEDIACODEC_L16: + return L16; + case MEDIACODEC_ALAW: + return ALAW; + case MEDIACODEC_ULAW: + return ULAW; + case MEDIACODEC_AMR_NB: + return AMR_NB; + case MEDIACODEC_AMR_WB: + return AMR_WB; + case MEDIACODEC_G729: + return G729; + case MEDIACODEC_AAC_LC: + return AAC_LC; + case MEDIACODEC_AAC_HE: + return AAC_HE; + case MEDIACODEC_AAC_HE_PS: + return AAC_HE_PS; + case MEDIACODEC_MP3: + return MP3; + case MEDIACODEC_VORBIS: + return VORBIS; + case MEDIACODEC_FLAC: + return FLAC; + case MEDIACODEC_WMAV1: + return WMAV1; + case MEDIACODEC_WMAV2: + return WMAV2; + case MEDIACODEC_WMAPRO: + return WMAPRO; + case MEDIACODEC_WMALSL: + return WMALSL; + case MEDIACODEC_H261: + return H261; + case MEDIACODEC_H263: + return H263; + case MEDIACODEC_H264: + return H264; + case MEDIACODEC_MJPEG: + return MJPEG; + case MEDIACODEC_MPEG1: + return MPEG1; + case MEDIACODEC_MPEG2: + return MPEG2; + case MEDIACODEC_MPEG4: + return MPEG4; + case MEDIACODEC_HEVC: + return HEVC; + case MEDIACODEC_VP8: + return VP8; + case MEDIACODEC_VP9: + return VP9; + case MEDIACODEC_VC1: + return VC1; + default: + return NONE; + } +} + +const int simple_to_codec_type_enumeration(codec_type_e codec_id) +{ + guint codec_id_u = (guint)codec_id; + + switch (codec_id_u) { + case L16: + return MEDIACODEC_L16; + case ALAW: + return MEDIACODEC_ALAW; + case ULAW: + return MEDIACODEC_ULAW; + case AMR_NB: + return MEDIACODEC_AMR_NB; + case AMR_WB: + return MEDIACODEC_AMR_WB; + case G729: + return MEDIACODEC_G729; + case AAC_LC: + return MEDIACODEC_AAC_LC; + case AAC_HE: + return MEDIACODEC_AAC_HE; + case AAC_HE_PS: + return MEDIACODEC_AAC_HE_PS; + case MP3: + return MEDIACODEC_MP3; + case VORBIS: + return MEDIACODEC_VORBIS; + case FLAC: + return MEDIACODEC_FLAC; + case WMAV1: + return MEDIACODEC_WMAV1; + case WMAV2: + return MEDIACODEC_WMAV2; + case WMAPRO: + return MEDIACODEC_WMAPRO; + case WMALSL: + return MEDIACODEC_WMALSL; + case H261: + return MEDIACODEC_H261; + case H263: + return MEDIACODEC_H263; + case H264: + return MEDIACODEC_H264; + case MJPEG: + return MEDIACODEC_MJPEG; + case MPEG1: + return MEDIACODEC_MPEG1; + case MPEG2: + return MEDIACODEC_MPEG2; + case MPEG4: + return MEDIACODEC_MPEG4; + case HEVC: + return MEDIACODEC_HEVC; + case VP8: + return MEDIACODEC_VP8; + case VP9: + return MEDIACODEC_VP9; + case VC1: + return MEDIACODEC_VC1; + default: + return NONE; + } +} diff --git a/test/media_codec_test.c b/test/media_codec_test.c index 949f4ef..d5ab042 100755 --- a/test/media_codec_test.c +++ b/test/media_codec_test.c @@ -21,13 +21,14 @@ #include #include +#include +#include +#include #include #include #include #include -#include -#include -#include +#include #define PACKAGE "media_codec_test" #define MAX_HANDLE 4 @@ -182,6 +183,7 @@ static void mc_hex_dump(char *desc, void *addr, int len); static void decoder_output_dump(App *app, media_packet_h pkt); static void output_dump(App *app, media_packet_h pkt); /* */ +const char* codec_type_to_string(mediacodec_codec_type_e media_codec_id); void (*extractor)(App *app, unsigned char** data, int *size, bool *have_frame); @@ -1228,10 +1230,19 @@ static bool _mediacodec_eos_cb(void *user_data) return TRUE; } +void _foreach_cb(mediacodec_codec_type_e codec_type, void *user_data) +{ + printf ("codec type : %x %s\n", codec_type, codec_type_to_string(codec_type)); + return; +} + static void _mediacodec_prepare(App *app, bool frame_all) { int ret; + printf("supported codec lists -internal-\n"); + mediacodec_foreach_supported_codec_static((mediacodec_supported_codec_cb)_foreach_cb, app); + /* create instance */ ret = mediacodec_create(&app->mc_handle[0]); if (ret != MEDIACODEC_ERROR_NONE) { @@ -1290,6 +1301,8 @@ static void _mediacodec_prepare(App *app, bool frame_all) } /* set callback */ + printf("supported codec lists\n"); + mediacodec_foreach_supported_codec(app->mc_handle[0], (mediacodec_supported_codec_cb)_foreach_cb, app); mediacodec_set_input_buffer_used_cb(app->mc_handle[0], (mediacodec_input_buffer_used_cb)_mediacodec_inbuf_used_cb, NULL); mediacodec_set_output_buffer_available_cb(app->mc_handle[0], (mediacodec_output_buffer_available_cb) _mediacodec_outbuf_available_cb, app); if (frame_all) @@ -1311,6 +1324,8 @@ static void _mediacodec_prepare(App *app, bool frame_all) g_print("mediacodec_get_packet_pool failed\n"); return; } + g_print("mediacodec start\n"); + return; } @@ -1974,3 +1989,68 @@ static void output_dump(App *app, media_packet_h pkt) fclose(fp); } + +const char* codec_type_to_string(mediacodec_codec_type_e media_codec_id) +{ + guint media_codec_id_u = (guint)media_codec_id; + + switch (media_codec_id_u) { + case MEDIACODEC_L16: + return "L16"; + case MEDIACODEC_ALAW: + return "ALAW"; + case MEDIACODEC_ULAW: + return "ULAW"; + case MEDIACODEC_AMR_NB: + return "AMR_NB"; + case MEDIACODEC_AMR_WB: + return "AMR_WB"; + case MEDIACODEC_G729: + return "G729"; + case MEDIACODEC_AAC_LC: + return "AAC_LC"; + case MEDIACODEC_AAC_HE: + return "AAC_HE"; + case MEDIACODEC_AAC_HE_PS: + return "AAC_HE_PS"; + case MEDIACODEC_MP3: + return "MP3"; + case MEDIACODEC_VORBIS: + return "VORBIS"; + case MEDIACODEC_FLAC: + return "FLAC"; + case MEDIACODEC_WMAV1: + return "WMAV1"; + case MEDIACODEC_WMAV2: + return "WMAV2"; + case MEDIACODEC_WMAPRO: + return "WMAPRO"; + case MEDIACODEC_WMALSL: + return "WMALSL"; + case MEDIACODEC_H261: + return "H261"; + case MEDIACODEC_H263: + return "H263"; + case MEDIACODEC_H264: + return "H264"; + case MEDIACODEC_MJPEG: + return "MJPEG"; + case MEDIACODEC_MPEG1: + return "MPEG1"; + case MEDIACODEC_MPEG2: + return "MPEG2"; + case MEDIACODEC_MPEG4: + return "MPEG4"; + case MEDIACODEC_HEVC: + return "HEVC"; + case MEDIACODEC_VP8: + return "VP8"; + case MEDIACODEC_VP9: + return "VP9"; + case MEDIACODEC_VC1: + return "VC1"; + default: + return "NONE"; + } +} + -- 2.7.4 From 517944d3da992cd4bba87978a6e4a72385926c12 Mon Sep 17 00:00:00 2001 From: Sejun Park Date: Tue, 25 Oct 2016 19:00:24 +0900 Subject: [PATCH 02/16] changed printf to g_print Change-Id: I171c5ff58a0ee561f74934f4ac21c47c644c64ac --- test/media_codec_test.c | 47 ++++++++++++++++++++++------------------------- 1 file changed, 22 insertions(+), 25 deletions(-) diff --git a/test/media_codec_test.c b/test/media_codec_test.c index d5ab042..c1fda89 100755 --- a/test/media_codec_test.c +++ b/test/media_codec_test.c @@ -191,7 +191,7 @@ int g_menu_state = CURRENT_STATUS_MAINMENU; static int _create_app(void *data) { - printf("My app is going alive!\n"); + g_print("My app is going alive!\n"); App *app = (App*)data; g_mutex_init(&app->lock); @@ -200,7 +200,7 @@ static int _create_app(void *data) static int _terminate_app(void *data) { - printf("My app is going gone!\n"); + g_print("My app is going gone!\n"); App *app = (App*)data; g_mutex_clear(&app->lock); @@ -941,18 +941,18 @@ static void _mediacodec_process_input(App *app) if (have_frame) { #ifdef USE_POOL if (media_packet_pool_acquire_packet(pkt_pool, &pkt, -1) != MEDIA_PACKET_ERROR_NONE) { - fprintf(stderr, "media_packet_pool_aquire_packet failed\n"); + g_print("media_packet_pool_aquire_packet failed\n"); return; } #else if (media_packet_create_alloc(fmt, NULL, NULL, &pkt) != MEDIA_PACKET_ERROR_NONE) { - fprintf(stderr, "media_packet_create_alloc failed\n"); + g_print("media_packet_create_alloc failed\n"); return; } #endif if (media_packet_set_pts(pkt, (uint64_t)(pts)) != MEDIA_PACKET_ERROR_NONE) { - fprintf(stderr, "media_packet_set_pts failed\n"); + g_print("media_packet_set_pts failed\n"); return; } @@ -1061,17 +1061,17 @@ static gboolean read_data(App *app) if (have_frame) { #ifdef USE_POOL if (media_packet_pool_acquire_packet(pkt_pool, &pkt, -1) != MEDIA_PACKET_ERROR_NONE) { - fprintf(stderr, "media_packet_pool_aquire_packet failed\n"); + g_print("media_packet_pool_aquire_packet failed\n"); return FALSE; } #else if (media_packet_create_alloc(fmt, NULL, NULL, &pkt) != MEDIA_PACKET_ERROR_NONE) { - fprintf(stderr, "media_packet_create_alloc failed\n"); + g_print("media_packet_create_alloc failed\n"); return FALSE; } #endif if (media_packet_set_pts(pkt, (uint64_t)(pts)) != MEDIA_PACKET_ERROR_NONE) { - fprintf(stderr, "media_packet_set_pts failed\n"); + g_print("media_packet_set_pts failed\n"); return FALSE; } @@ -1232,7 +1232,7 @@ static bool _mediacodec_eos_cb(void *user_data) void _foreach_cb(mediacodec_codec_type_e codec_type, void *user_data) { - printf ("codec type : %x %s\n", codec_type, codec_type_to_string(codec_type)); + g_print("codec type : %x %s\n", codec_type, codec_type_to_string(codec_type)); return; } @@ -1240,7 +1240,7 @@ static void _mediacodec_prepare(App *app, bool frame_all) { int ret; - printf("supported codec lists -internal-\n"); + g_print("supported codec lists -internal-\n"); mediacodec_foreach_supported_codec_static((mediacodec_supported_codec_cb)_foreach_cb, app); /* create instance */ @@ -1301,7 +1301,7 @@ static void _mediacodec_prepare(App *app, bool frame_all) } /* set callback */ - printf("supported codec lists\n"); + g_print("supported codec lists\n"); mediacodec_foreach_supported_codec(app->mc_handle[0], (mediacodec_supported_codec_cb)_foreach_cb, app); mediacodec_set_input_buffer_used_cb(app->mc_handle[0], (mediacodec_input_buffer_used_cb)_mediacodec_inbuf_used_cb, NULL); mediacodec_set_output_buffer_available_cb(app->mc_handle[0], (mediacodec_output_buffer_available_cb) _mediacodec_outbuf_available_cb, app); @@ -1324,7 +1324,7 @@ static void _mediacodec_prepare(App *app, bool frame_all) g_print("mediacodec_get_packet_pool failed\n"); return; } - g_print("mediacodec start\n"); + g_print("\n\nmediacodec start\n\n"); return; } @@ -1441,19 +1441,16 @@ static void _mediacodec_destroy(App *app) #ifdef USE_POOL if (media_packet_pool_deallocate(pkt_pool) != MEDIA_PACKET_ERROR_NONE) { - fprintf(stderr, "media_packet_pool_deallocatet failed\n"); - g_print("PKT POOL deallocation failed \n"); + g_print("media_packet_pool_deallocatet failed\n"); return; } - g_print("PKT POOL deallocated! \n"); if (media_packet_pool_destroy(pkt_pool) != MEDIA_PACKET_ERROR_NONE) { - fprintf(stderr, " media_packet_pool_destroy failed\n"); - g_print("PKT POOL destroy failed \n"); + g_print(" media_packet_pool_destroy failed\n"); return; } - g_print("PKT POOL destroyed! \n"); + g_print("media packet pool destroyed! \n"); #endif mediacodec_destroy(app->mc_handle[0]); } @@ -1842,18 +1839,18 @@ void mc_hex_dump(char *desc, void *addr, int len) unsigned char *pc = (unsigned char *)addr; if (desc != NULL) - printf("%s:\n", desc); + g_print("%s:\n", desc); for (i = 0; i < len; i++) { if ((i % 16) == 0) { if (i != 0) - printf(" %s\n", buff); + g_print(" %s\n", buff); - printf(" %04x ", i); + g_print(" %04x ", i); } - printf(" %02x", pc[i]); + g_print(" %02x", pc[i]); if ((pc[i] < 0x20) || (pc[i] > 0x7e)) buff[i % 16] = '.'; @@ -1863,10 +1860,10 @@ void mc_hex_dump(char *desc, void *addr, int len) } while ((i % 16) != 0) { - printf(" "); + g_print(" "); i++; } - printf(" %s\n", buff); + g_print(" %s\n", buff); } static void decoder_output_dump(App *app, media_packet_h pkt) @@ -1884,7 +1881,7 @@ static void decoder_output_dump(App *app, media_packet_h pkt) media_packet_get_video_plane_data_ptr(pkt, 0, &temp); media_packet_get_video_stride_width(pkt, 0, &stride_width); media_packet_get_video_stride_height(pkt, 0, &stride_height); - printf("stride : %d, %d\n", stride_width, stride_height); + g_print("stride : %d, %d\n", stride_width, stride_height); for (i = 0; i < app->height; i++) { ret = fwrite(temp, app->width, 1, fp); -- 2.7.4 From 86e79380520efa9e3491ee66ffb0014e66da9669 Mon Sep 17 00:00:00 2001 From: Sejun Park Date: Mon, 24 Oct 2016 15:22:19 +0900 Subject: [PATCH 03/16] Added internal API for static loading ini when binding c# API Change-Id: Id4e51da2d93957fd2735f93ae47aabcdc66ebdd3 --- include/media_codec_ini.h | 6 +- include/media_codec_internal.h | 54 ++++++++ include/media_codec_port.h | 42 +++++- include/media_codec_spec_emul.h | 3 + packaging/capi-media-codec.spec | 2 +- src/media_codec.c | 2 +- src/media_codec_internal.c | 110 +++++++++++++++ src/media_codec_port.c | 297 ++++++++++++++++++++++++++++++---------- test/media_codec_test.c | 86 +++++++++++- 9 files changed, 521 insertions(+), 81 deletions(-) create mode 100755 include/media_codec_internal.h create mode 100755 src/media_codec_internal.c diff --git a/include/media_codec_ini.h b/include/media_codec_ini.h index b51404e..ba0704f 100755 --- a/include/media_codec_ini.h +++ b/include/media_codec_ini.h @@ -66,7 +66,9 @@ struct _codec_t { /* @ mark means the item has tested */ struct _mc_ini_t { - int codec_list; + gboolean loaded; + gint codec_list; + gint num_supported_codecs; port_mode port_type; /* general */ gchar port_name[MEDIA_CODEC_INI_MAX_STRLEN]; @@ -107,6 +109,8 @@ media_codec_port = GST_PORT \n\ \n\ " +extern mc_ini_t mc_ini; + int mc_ini_load(mc_ini_t *ini); media_format_mimetype_e _mc_convert_media_format_str_to_int(char *sformat); diff --git a/include/media_codec_internal.h b/include/media_codec_internal.h new file mode 100755 index 0000000..87eac43 --- /dev/null +++ b/include/media_codec_internal.h @@ -0,0 +1,54 @@ +/* +* Copyright (c) 2016 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_CODEC_INTERNAL_H__ +#define __TIZEN_MEDIA_CODEC_INTERNAL_H__ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/** +* @file media_codec_internal.h +* @brief This file contains the internal capi media codec API. +*/ + +/** +* @addtogroup CAPI_MEDIA_CODEC_MODULE +* @{ +*/ + +/** + * @brief Retrieves all supported codecs by invoking callback function once for each supported codecs. + * @since_tizen 3.0 + * @param[in] callback The callback function to invoke + * @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 #MEDIACODEC_ERROR_NONE Successful + * @retval #MEDIACODEC_ERROR_INVALID_PARAMETER Invalid parameter + * @see mediacodec_foreach_supported_codec() + */ +int mediacodec_foreach_supported_codec_static(mediacodec_supported_codec_cb callback, void *user_data); + +/** + * @} + */ +#ifdef __cplusplus +} +#endif +#endif /*__TIZEN_MEDIA_CODEC_INTERNAL_H__*/ diff --git a/include/media_codec_port.h b/include/media_codec_port.h index 2b7ec12..30937c2 100755 --- a/include/media_codec_port.h +++ b/include/media_codec_port.h @@ -86,6 +86,38 @@ typedef enum { MC_OUT_OF_MEMORY = -20, /**< when memory is not allocated */ } mc_ret_e; +typedef enum { + NONE, + L16, + ALAW, + ULAW, + AMR_NB, + AMR_WB, + G729, + AAC_LC, + AAC_HE, + AAC_HE_PS, + MP3, + VORBIS, + FLAC, + WMAV1, + WMAV2, + WMAPRO, + WMALSL, + H261, + H263, + H264, + MJPEG, + MPEG1, + MPEG2, + MPEG4, + HEVC, + VP8, + VP9, + VC1, + CODEC_NR_ITEMS +} codec_type_e; + /*--------------------------------------------------------------------------- | GLOBAL DATA TYPE DEFINITIONS: | ---------------------------------------------------------------------------*/ @@ -175,7 +207,6 @@ struct _mc_handle_t { bool is_hw; bool is_prepared; - GList *supported_codecs; mediacodec_port_type_e port_type; mediacodec_codec_type_e codec_id; mc_vendor_e vendor; @@ -195,11 +226,10 @@ struct _mc_handle_t { mc_codec_map_t encoder_map[MEDIA_CODEC_MAX_CODEC_TYPE]; mc_codec_map_t decoder_map[MEDIA_CODEC_MAX_CODEC_TYPE]; - int num_supported_codecs; int num_supported_decoder; int num_supported_encoder; - mc_ini_t ini; + mc_ini_t *ini; }; /*=========================================================================================== @@ -249,12 +279,16 @@ int mc_unset_eos_cb(MMHandleType mediacodec); int mc_set_buffer_status_cb(MMHandleType mediacodec, mediacodec_buffer_status_cb callback, void* user_data); int mc_unset_buffer_status_cb(MMHandleType mediacodec); int mc_set_supported_codec_cb(MMHandleType mediacodec, mediacodec_supported_codec_cb callback, void* user_data); -int _mediacodec_foreach_supported_codec(MMHandleType mediacodec, mediacodec_supported_codec_cb callback, void* user_data); +int _mediacodec_foreach_supported_codec(mediacodec_supported_codec_cb callback, void* user_data); void _mc_create_codec_map_from_ini(mc_handle_t *mc_handle, mc_codec_spec_t *spec_emul); +void _mc_create_codec_map_from_ini_static(mc_ini_t *ini, mc_codec_spec_t *spec_emul); void _mc_create_decoder_map_from_ini(mc_handle_t *mc_handle); void _mc_create_encoder_map_from_ini(mc_handle_t *mc_handle); +const int simple_to_codec_type_enumeration(codec_type_e codec_id); +const int codec_type_to_simple_enumeration(mediacodec_codec_type_e media_codec_id); + #ifdef __cplusplus } #endif diff --git a/include/media_codec_spec_emul.h b/include/media_codec_spec_emul.h index 4fc7f6f..96bb3fb 100755 --- a/include/media_codec_spec_emul.h +++ b/include/media_codec_spec_emul.h @@ -23,6 +23,8 @@ extern "C" { #include +#define MEDIA_CODEC_MAX_CODEC_TYPE 100 + enum {DECODER, ENCODER}; enum {SOFTWARE, HARDWARE}; @@ -48,6 +50,7 @@ struct _mc_codec_map_t { mc_codec_type_t type; }; +extern mc_codec_spec_t spec_emul[MEDIA_CODEC_MAX_CODEC_TYPE]; #ifdef __cplusplus } diff --git a/packaging/capi-media-codec.spec b/packaging/capi-media-codec.spec index 94a969c..92cb31b 100755 --- a/packaging/capi-media-codec.spec +++ b/packaging/capi-media-codec.spec @@ -1,6 +1,6 @@ Name: capi-media-codec Summary: A Media Codec library in Tizen Native API -Version: 0.4.3 +Version: 0.5.0 Release: 0 Group: Multimedia/API License: Apache-2.0 diff --git a/src/media_codec.c b/src/media_codec.c index c8d6e20..22cd3d8 100755 --- a/src/media_codec.c +++ b/src/media_codec.c @@ -479,7 +479,7 @@ int mediacodec_foreach_supported_codec(mediacodec_h mediacodec, mediacodec_suppo handle->supported_codec_cb_userdata = user_data; LOGD("set supported_codec_cb(%p)", callback); - int ret = _mediacodec_foreach_supported_codec(handle->mc_handle, callback, handle); + int ret = _mediacodec_foreach_supported_codec(callback, handle); if (ret != MEDIACODEC_ERROR_NONE) return __convert_error_code(ret, (char *)__FUNCTION__); diff --git a/src/media_codec_internal.c b/src/media_codec_internal.c new file mode 100755 index 0000000..bdf24a5 --- /dev/null +++ b/src/media_codec_internal.c @@ -0,0 +1,110 @@ +#include +#include +#include +#include +#include +#include + +mc_codec_spec_t spec_emul[MEDIA_CODEC_MAX_CODEC_TYPE]; +mc_ini_t mc_ini; + +int __convert_error_code_internal(int code, char *func_name) +{ + int ret = MEDIACODEC_ERROR_INVALID_OPERATION; + char *msg = "MEDIACOODEC_INVALID_OPERATION"; + + switch (code) { + case MC_ERROR_NONE: + ret = MEDIACODEC_ERROR_NONE; + msg = "MEDIACODEC_ERROR_NONE"; + break; + case MC_PARAM_ERROR: + case MC_INVALID_ARG: + ret = MEDIACODEC_ERROR_INVALID_PARAMETER; + msg = "MEDIACODEC_ERROR_INVALID_PARAMETER"; + break; + case MC_PERMISSION_DENIED: + ret = MEDIACODEC_ERROR_PERMISSION_DENIED; + msg = "MEDIACODEC_ERROR_PERMISSION_DENIED"; + break; + case MC_INVALID_STATUS: + ret = MEDIACODEC_ERROR_INVALID_STATE; + msg = "MEDIACODEC_ERROR_INVALID_STATE"; + break; + case MC_NOT_SUPPORTED: + ret = MEDIACODEC_ERROR_NOT_SUPPORTED_ON_DEVICE; + msg = "MEDIACODEC_ERROR_NOT_SUPPORTED_ON_DEVICE"; + break; + case MC_ERROR: + case MC_INTERNAL_ERROR: + case MC_HW_ERROR: + ret = MEDIACODEC_ERROR_INVALID_OPERATION; + msg = "MEDIACODEC_ERROR_INVALID_OPERATION"; + break; + case MC_INVALID_STREAM: + ret = MEDIACODEC_ERROR_INVALID_STREAM; + msg = "MEDIACODEC_ERROR_INVALID_STREAM"; + break; + case MC_CODEC_NOT_FOUND: + ret = MEDIACODEC_ERROR_CODEC_NOT_FOUND; + msg = "MEDIACODEC_ERROR_CODEC_NOT_FOUND"; + break; + case MC_ERROR_DECODE: + ret = MEDIACODEC_ERROR_DECODE; + msg = "MEDIACODEC_ERROR_DECODE"; + break; + case MC_INVALID_IN_BUF: + ret = MEDIACODEC_ERROR_INVALID_INBUFFER; + msg = "MEDIACODEC_ERROR_INVALID_INBUFFER"; + break; + case MC_INVALID_OUT_BUF: + ret = MEDIACODEC_ERROR_INVALID_OUTBUFFER; + msg = "MEDIACODEC_ERROR_INVALID_OUTBUFFER"; + break; + case MC_NOT_INITIALIZED: + ret = MEDIACODEC_ERROR_NOT_INITIALIZED; + msg = "MEDIACODEC_ERROR_NOT_INITIALIZED"; + break; + case MC_OUTPUT_BUFFER_EMPTY: + case MC_OUTPUT_BUFFER_OVERFLOW: + ret = MEDIACODEC_ERROR_BUFFER_NOT_AVAILABLE; + msg = "MEDIACODEC_ERROR_BUFFER_NOT_AVAILABLE"; + break; + case MC_OUT_OF_MEMORY: + ret = MEDIACODEC_ERROR_OUT_OF_MEMORY; + msg = "MEDIACODEC_ERROR_OUT_OF_MEMORY"; + break; + default: + ret = MEDIACODEC_ERROR_INTERNAL; + msg = "MEDIACODEC_ERROR_INTERNAL"; + break; + } + LOGD("[%s] %s(0x%08x) : core fw error(0x%x)", func_name, msg, ret, code); + return ret; +} + +int mediacodec_foreach_supported_codec_static(mediacodec_supported_codec_cb callback, void *user_data) +{ + int ret; + + if (!mc_ini.loaded) { + ret = mc_ini_load(&mc_ini); + if (ret != MC_ERROR_NONE) + goto ERROR; + + mc_ini.loaded = TRUE; + } + + _mc_create_codec_map_from_ini_static(&mc_ini, spec_emul); + + LOGD("set supported_codec_cb(%p)", callback); + ret = _mediacodec_foreach_supported_codec(callback, user_data); + + if (ret != MEDIACODEC_ERROR_NONE) + return __convert_error_code_internal(ret, (char *)__FUNCTION__); + else + return MEDIACODEC_ERROR_NONE; + +ERROR: + return MEDIACODEC_ERROR_INVALID_PARAMETER; +} diff --git a/src/media_codec_port.c b/src/media_codec_port.c index 76e49cc..83b618f 100755 --- a/src/media_codec_port.c +++ b/src/media_codec_port.c @@ -26,13 +26,13 @@ #include #include -static mc_codec_spec_t spec_emul[MEDIA_CODEC_MAX_CODEC_TYPE]; +mc_ini_t mc_ini; +mc_codec_spec_t spec_emul[MEDIA_CODEC_MAX_CODEC_TYPE]; int mc_create(MMHandleType *mediacodec) { mc_handle_t *new_mediacodec = NULL; int ret = MC_ERROR_NONE; - int i; /* alloc mediacodec structure */ new_mediacodec = (mc_handle_t *)g_malloc(sizeof(mc_handle_t)); @@ -43,7 +43,6 @@ int mc_create(MMHandleType *mediacodec) goto ERROR; } memset(new_mediacodec, 0, sizeof(mc_handle_t)); - memset(spec_emul, 0, sizeof(mc_codec_spec_t)*MEDIA_CODEC_MAX_CODEC_TYPE); new_mediacodec->is_encoder = false; new_mediacodec->is_video = false; @@ -54,23 +53,23 @@ int mc_create(MMHandleType *mediacodec) new_mediacodec->ports[0] = NULL; new_mediacodec->ports[1] = NULL; - new_mediacodec->num_supported_codecs = 0; new_mediacodec->num_supported_decoder = 0; new_mediacodec->num_supported_encoder = 0; new_mediacodec->core = NULL; + new_mediacodec->ini = &mc_ini; /* load ini files */ - ret = mc_ini_load(&new_mediacodec->ini); - if (ret != MC_ERROR_NONE) - goto ERROR; - _mc_create_codec_map_from_ini(new_mediacodec, spec_emul); + if (!mc_ini.loaded) { + ret = mc_ini_load(&mc_ini); + if (ret != MC_ERROR_NONE) + goto ERROR; - for (i = 0; i < new_mediacodec->num_supported_codecs; i++) { - new_mediacodec->supported_codecs = - g_list_append(new_mediacodec->supported_codecs, GINT_TO_POINTER(spec_emul[i].codec_id)); + mc_ini.loaded = TRUE; } + _mc_create_codec_map_from_ini(new_mediacodec, spec_emul); + /* create decoder map from ini */ _mc_create_decoder_map_from_ini(new_mediacodec); @@ -106,7 +105,6 @@ int mc_destroy(MMHandleType mediacodec) } mc_handle->is_prepared = false; - g_list_free(mc_handle->supported_codecs); /* free mediacodec structure */ if (mc_handle) { @@ -138,13 +136,13 @@ int mc_set_codec(MMHandleType mediacodec, mediacodec_codec_type_e codec_id, int if (!GET_IS_HW(flags) && !GET_IS_SW(flags)) flags |= MEDIACODEC_SUPPORT_TYPE_SW; - for (i = 0; i < mc_handle->num_supported_codecs; i++) { + for (i = 0; i < mc_handle->ini->num_supported_codecs; i++) { if ((codec_id == spec_emul[i].codec_id) && (flags == spec_emul[i].codec_type)) break; } - LOGD("support_list : %d, i : %d", mc_handle->num_supported_codecs, i); + LOGD("support_list : %d, i : %d", mc_handle->ini->num_supported_codecs, i); - if (i == mc_handle->num_supported_codecs) + if (i == mc_handle->ini->num_supported_codecs) return MC_NOT_SUPPORTED; mc_handle->port_type = spec_emul[i].port_type; @@ -682,37 +680,31 @@ int mc_set_supported_codec_cb(MMHandleType mediacodec, mediacodec_supported_code return ret; } -int _mediacodec_foreach_supported_codec(MMHandleType mediacodec, mediacodec_supported_codec_cb callback, void *user_data) +int _mediacodec_foreach_supported_codec(mediacodec_supported_codec_cb callback, void *user_data) { - int ret = MC_ERROR_NONE; - mc_handle_t *mc_handle = (mc_handle_t *)mediacodec; - int codecs_num; - gpointer tmp; + int ret = MEDIACODEC_NONE; + int i; + int index; - if (!mc_handle) { - LOGE("fail invaild param\n"); - return MC_INVALID_ARG; - } + gboolean codec[CODEC_NR_ITEMS] = {0,}; - if (mc_handle->supported_codecs) { - codecs_num = g_list_length(mc_handle->supported_codecs); - LOGD("supported_codecs : %d", codecs_num); + for (i = 0; i < mc_ini.num_supported_codecs; i++) { + index = codec_type_to_simple_enumeration(spec_emul[i].codec_id); + codec[index] = TRUE; + } - while (codecs_num) { - tmp = g_list_nth_data(mc_handle->supported_codecs, codecs_num - 1); - if (tmp) { - if (!callback(GPOINTER_TO_INT(tmp), user_data)) { - ret = MEDIACODEC_ERROR_INTERNAL; - goto CALLBACK_ERROR; - } + for (i = 0; i < CODEC_NR_ITEMS; i++) { + if (codec[i]) { + index = simple_to_codec_type_enumeration(i); + if (!callback(index, user_data)) { + goto CALLBACK_ERROR; } - codecs_num--; } + } - if (!callback(-1, user_data)) { - ret = MEDIACODEC_ERROR_INTERNAL; - goto CALLBACK_ERROR; - } + if (!callback(-1, user_data)) { + ret = MEDIACODEC_ERROR_INTERNAL; + goto CALLBACK_ERROR; } CALLBACK_ERROR: @@ -752,25 +744,25 @@ int mc_get_packet_pool(MMHandleType mediacodec, media_packet_pool_h *pool) void _mc_create_decoder_map_from_ini(mc_handle_t *mediacodec) { int indx = 0, count = 0; - int codec_list = mediacodec->ini.codec_list; + int codec_list = mediacodec->ini->codec_list; for (indx = 0; indx < codec_list; indx++) { - if (strcmp(mediacodec->ini.codec[indx].codec_info[0].name, "")) { - mediacodec->decoder_map[count].id = mediacodec->ini.codec[indx].codec_id; + if (strcmp(mediacodec->ini->codec[indx].codec_info[0].name, "")) { + mediacodec->decoder_map[count].id = mediacodec->ini->codec[indx].codec_id; mediacodec->decoder_map[count].hardware = 1; /* hardware */ - mediacodec->decoder_map[count].type.factory_name = mediacodec->ini.codec[indx].codec_info[0].name; - mediacodec->decoder_map[count].type.mime = mediacodec->ini.codec[indx].codec_info[0].mime; + mediacodec->decoder_map[count].type.factory_name = mediacodec->ini->codec[indx].codec_info[0].name; + mediacodec->decoder_map[count].type.mime = mediacodec->ini->codec[indx].codec_info[0].mime; mediacodec->decoder_map[count].type.out_format = - _mc_convert_media_format_str_to_int(mediacodec->ini.codec[indx].codec_info[0].format); + _mc_convert_media_format_str_to_int(mediacodec->ini->codec[indx].codec_info[0].format); count++; } - if (strcmp(mediacodec->ini.codec[indx].codec_info[2].name, "")) { - mediacodec->decoder_map[count].id = mediacodec->ini.codec[indx].codec_id; + if (strcmp(mediacodec->ini->codec[indx].codec_info[2].name, "")) { + mediacodec->decoder_map[count].id = mediacodec->ini->codec[indx].codec_id; mediacodec->decoder_map[count].hardware = 0; /* software */ - mediacodec->decoder_map[count].type.factory_name = mediacodec->ini.codec[indx].codec_info[2].name; - mediacodec->decoder_map[count].type.mime = mediacodec->ini.codec[indx].codec_info[2].mime; + mediacodec->decoder_map[count].type.factory_name = mediacodec->ini->codec[indx].codec_info[2].name; + mediacodec->decoder_map[count].type.mime = mediacodec->ini->codec[indx].codec_info[2].mime; mediacodec->decoder_map[count].type.out_format = - _mc_convert_media_format_str_to_int(mediacodec->ini.codec[indx].codec_info[2].format); + _mc_convert_media_format_str_to_int(mediacodec->ini->codec[indx].codec_info[2].format); count++; } } @@ -782,26 +774,26 @@ void _mc_create_decoder_map_from_ini(mc_handle_t *mediacodec) void _mc_create_encoder_map_from_ini(mc_handle_t *mediacodec) { int indx = 0, count = 0; - int codec_list = mediacodec->ini.codec_list; + int codec_list = mediacodec->ini->codec_list; for (indx = 0; indx < codec_list; indx++) { - if (strcmp(mediacodec->ini.codec[indx].codec_info[1].name, "")) { - mediacodec->encoder_map[count].id = mediacodec->ini.codec[indx].codec_id; + if (strcmp(mediacodec->ini->codec[indx].codec_info[1].name, "")) { + mediacodec->encoder_map[count].id = mediacodec->ini->codec[indx].codec_id; mediacodec->encoder_map[count].hardware = 1; - mediacodec->encoder_map[count].type.factory_name = mediacodec->ini.codec[indx].codec_info[1].name; - mediacodec->encoder_map[count].type.mime = mediacodec->ini.codec[indx].codec_info[1].mime; + mediacodec->encoder_map[count].type.factory_name = mediacodec->ini->codec[indx].codec_info[1].name; + mediacodec->encoder_map[count].type.mime = mediacodec->ini->codec[indx].codec_info[1].mime; mediacodec->encoder_map[count].type.out_format = - _mc_convert_media_format_str_to_int(mediacodec->ini.codec[indx].codec_info[1].format); + _mc_convert_media_format_str_to_int(mediacodec->ini->codec[indx].codec_info[1].format); count++; } - if (strcmp(mediacodec->ini.codec[indx].codec_info[3].name, "")) { - mediacodec->encoder_map[count].id = mediacodec->ini.codec[indx].codec_id; + if (strcmp(mediacodec->ini->codec[indx].codec_info[3].name, "")) { + mediacodec->encoder_map[count].id = mediacodec->ini->codec[indx].codec_id; mediacodec->encoder_map[count].hardware = 0; - mediacodec->encoder_map[count].type.factory_name = mediacodec->ini.codec[indx].codec_info[3].name; - mediacodec->encoder_map[count].type.mime = mediacodec->ini.codec[indx].codec_info[3].mime; + mediacodec->encoder_map[count].type.factory_name = mediacodec->ini->codec[indx].codec_info[3].name; + mediacodec->encoder_map[count].type.mime = mediacodec->ini->codec[indx].codec_info[3].mime; mediacodec->encoder_map[count].type.out_format = - _mc_convert_media_format_str_to_int(mediacodec->ini.codec[indx].codec_info[3].format); + _mc_convert_media_format_str_to_int(mediacodec->ini->codec[indx].codec_info[3].format); count++; } } @@ -812,38 +804,201 @@ void _mc_create_encoder_map_from_ini(mc_handle_t *mediacodec) void _mc_create_codec_map_from_ini(mc_handle_t *mediacodec, mc_codec_spec_t *spec_emul) { int indx = 0, count = 0; - int codec_list = mediacodec->ini.codec_list; + int codec_list = mediacodec->ini->codec_list; for (indx = 0; indx < codec_list; indx++) { - if (strcmp(mediacodec->ini.codec[indx].codec_info[0].name, "")) { - spec_emul[count].codec_id = mediacodec->ini.codec[indx].codec_id; + if (strcmp(mediacodec->ini->codec[indx].codec_info[0].name, "")) { + spec_emul[count].codec_id = mediacodec->ini->codec[indx].codec_id; spec_emul[count].codec_type = MEDIACODEC_DECODER | MEDIACODEC_SUPPORT_TYPE_HW; spec_emul[count].port_type = MEDIACODEC_PORT_TYPE_GST; count++; } - if (strcmp(mediacodec->ini.codec[indx].codec_info[1].name, "")) { - spec_emul[count].codec_id = mediacodec->ini.codec[indx].codec_id; + if (strcmp(mediacodec->ini->codec[indx].codec_info[1].name, "")) { + spec_emul[count].codec_id = mediacodec->ini->codec[indx].codec_id; spec_emul[count].codec_type = MEDIACODEC_ENCODER | MEDIACODEC_SUPPORT_TYPE_HW; spec_emul[count].port_type = MEDIACODEC_PORT_TYPE_GST; count++; } - if (strcmp(mediacodec->ini.codec[indx].codec_info[2].name, "")) { - spec_emul[count].codec_id = mediacodec->ini.codec[indx].codec_id; + if (strcmp(mediacodec->ini->codec[indx].codec_info[2].name, "")) { + spec_emul[count].codec_id = mediacodec->ini->codec[indx].codec_id; spec_emul[count].codec_type = MEDIACODEC_DECODER | MEDIACODEC_SUPPORT_TYPE_SW; spec_emul[count].port_type = MEDIACODEC_PORT_TYPE_GST; count++; } - if (strcmp(mediacodec->ini.codec[indx].codec_info[3].name, "")) { - spec_emul[count].codec_id = mediacodec->ini.codec[indx].codec_id; + if (strcmp(mediacodec->ini->codec[indx].codec_info[3].name, "")) { + spec_emul[count].codec_id = mediacodec->ini->codec[indx].codec_id; spec_emul[count].codec_type = MEDIACODEC_ENCODER | MEDIACODEC_SUPPORT_TYPE_SW; spec_emul[count].port_type = MEDIACODEC_PORT_TYPE_GST; count++; } } - mediacodec->num_supported_codecs = count; + mediacodec->ini->num_supported_codecs = count; LOGE("supported codecs :%d", count); return; } +void _mc_create_codec_map_from_ini_static(mc_ini_t *ini, mc_codec_spec_t *spec_emul) +{ + int indx = 0, count = 0; + int codec_list = ini->codec_list; + for (indx = 0; indx < codec_list; indx++) { + if (strcmp(ini->codec[indx].codec_info[0].name, "")) { + spec_emul[count].codec_id = ini->codec[indx].codec_id; + spec_emul[count].codec_type = MEDIACODEC_DECODER | MEDIACODEC_SUPPORT_TYPE_HW; + spec_emul[count].port_type = MEDIACODEC_PORT_TYPE_GST; + count++; + } + if (strcmp(ini->codec[indx].codec_info[1].name, "")) { + spec_emul[count].codec_id = ini->codec[indx].codec_id; + spec_emul[count].codec_type = MEDIACODEC_ENCODER | MEDIACODEC_SUPPORT_TYPE_HW; + spec_emul[count].port_type = MEDIACODEC_PORT_TYPE_GST; + count++; + } + if (strcmp(ini->codec[indx].codec_info[2].name, "")) { + spec_emul[count].codec_id = ini->codec[indx].codec_id; + spec_emul[count].codec_type = MEDIACODEC_DECODER | MEDIACODEC_SUPPORT_TYPE_SW; + spec_emul[count].port_type = MEDIACODEC_PORT_TYPE_GST; + count++; + } + if (strcmp(ini->codec[indx].codec_info[3].name, "")) { + spec_emul[count].codec_id = ini->codec[indx].codec_id; + spec_emul[count].codec_type = MEDIACODEC_ENCODER | MEDIACODEC_SUPPORT_TYPE_SW; + spec_emul[count].port_type = MEDIACODEC_PORT_TYPE_GST; + count++; + } + } + + ini->num_supported_codecs = count; + LOGE("supported codecs :%d", count); + return; +} + +const int codec_type_to_simple_enumeration(mediacodec_codec_type_e media_codec_id) +{ + guint media_codec_id_u = (guint)media_codec_id; + + switch (media_codec_id_u) { + case MEDIACODEC_L16: + return L16; + case MEDIACODEC_ALAW: + return ALAW; + case MEDIACODEC_ULAW: + return ULAW; + case MEDIACODEC_AMR_NB: + return AMR_NB; + case MEDIACODEC_AMR_WB: + return AMR_WB; + case MEDIACODEC_G729: + return G729; + case MEDIACODEC_AAC_LC: + return AAC_LC; + case MEDIACODEC_AAC_HE: + return AAC_HE; + case MEDIACODEC_AAC_HE_PS: + return AAC_HE_PS; + case MEDIACODEC_MP3: + return MP3; + case MEDIACODEC_VORBIS: + return VORBIS; + case MEDIACODEC_FLAC: + return FLAC; + case MEDIACODEC_WMAV1: + return WMAV1; + case MEDIACODEC_WMAV2: + return WMAV2; + case MEDIACODEC_WMAPRO: + return WMAPRO; + case MEDIACODEC_WMALSL: + return WMALSL; + case MEDIACODEC_H261: + return H261; + case MEDIACODEC_H263: + return H263; + case MEDIACODEC_H264: + return H264; + case MEDIACODEC_MJPEG: + return MJPEG; + case MEDIACODEC_MPEG1: + return MPEG1; + case MEDIACODEC_MPEG2: + return MPEG2; + case MEDIACODEC_MPEG4: + return MPEG4; + case MEDIACODEC_HEVC: + return HEVC; + case MEDIACODEC_VP8: + return VP8; + case MEDIACODEC_VP9: + return VP9; + case MEDIACODEC_VC1: + return VC1; + default: + return NONE; + } +} + +const int simple_to_codec_type_enumeration(codec_type_e codec_id) +{ + guint codec_id_u = (guint)codec_id; + + switch (codec_id_u) { + case L16: + return MEDIACODEC_L16; + case ALAW: + return MEDIACODEC_ALAW; + case ULAW: + return MEDIACODEC_ULAW; + case AMR_NB: + return MEDIACODEC_AMR_NB; + case AMR_WB: + return MEDIACODEC_AMR_WB; + case G729: + return MEDIACODEC_G729; + case AAC_LC: + return MEDIACODEC_AAC_LC; + case AAC_HE: + return MEDIACODEC_AAC_HE; + case AAC_HE_PS: + return MEDIACODEC_AAC_HE_PS; + case MP3: + return MEDIACODEC_MP3; + case VORBIS: + return MEDIACODEC_VORBIS; + case FLAC: + return MEDIACODEC_FLAC; + case WMAV1: + return MEDIACODEC_WMAV1; + case WMAV2: + return MEDIACODEC_WMAV2; + case WMAPRO: + return MEDIACODEC_WMAPRO; + case WMALSL: + return MEDIACODEC_WMALSL; + case H261: + return MEDIACODEC_H261; + case H263: + return MEDIACODEC_H263; + case H264: + return MEDIACODEC_H264; + case MJPEG: + return MEDIACODEC_MJPEG; + case MPEG1: + return MEDIACODEC_MPEG1; + case MPEG2: + return MEDIACODEC_MPEG2; + case MPEG4: + return MEDIACODEC_MPEG4; + case HEVC: + return MEDIACODEC_HEVC; + case VP8: + return MEDIACODEC_VP8; + case VP9: + return MEDIACODEC_VP9; + case VC1: + return MEDIACODEC_VC1; + default: + return NONE; + } +} diff --git a/test/media_codec_test.c b/test/media_codec_test.c index 949f4ef..d5ab042 100755 --- a/test/media_codec_test.c +++ b/test/media_codec_test.c @@ -21,13 +21,14 @@ #include #include +#include +#include +#include #include #include #include #include -#include -#include -#include +#include #define PACKAGE "media_codec_test" #define MAX_HANDLE 4 @@ -182,6 +183,7 @@ static void mc_hex_dump(char *desc, void *addr, int len); static void decoder_output_dump(App *app, media_packet_h pkt); static void output_dump(App *app, media_packet_h pkt); /* */ +const char* codec_type_to_string(mediacodec_codec_type_e media_codec_id); void (*extractor)(App *app, unsigned char** data, int *size, bool *have_frame); @@ -1228,10 +1230,19 @@ static bool _mediacodec_eos_cb(void *user_data) return TRUE; } +void _foreach_cb(mediacodec_codec_type_e codec_type, void *user_data) +{ + printf ("codec type : %x %s\n", codec_type, codec_type_to_string(codec_type)); + return; +} + static void _mediacodec_prepare(App *app, bool frame_all) { int ret; + printf("supported codec lists -internal-\n"); + mediacodec_foreach_supported_codec_static((mediacodec_supported_codec_cb)_foreach_cb, app); + /* create instance */ ret = mediacodec_create(&app->mc_handle[0]); if (ret != MEDIACODEC_ERROR_NONE) { @@ -1290,6 +1301,8 @@ static void _mediacodec_prepare(App *app, bool frame_all) } /* set callback */ + printf("supported codec lists\n"); + mediacodec_foreach_supported_codec(app->mc_handle[0], (mediacodec_supported_codec_cb)_foreach_cb, app); mediacodec_set_input_buffer_used_cb(app->mc_handle[0], (mediacodec_input_buffer_used_cb)_mediacodec_inbuf_used_cb, NULL); mediacodec_set_output_buffer_available_cb(app->mc_handle[0], (mediacodec_output_buffer_available_cb) _mediacodec_outbuf_available_cb, app); if (frame_all) @@ -1311,6 +1324,8 @@ static void _mediacodec_prepare(App *app, bool frame_all) g_print("mediacodec_get_packet_pool failed\n"); return; } + g_print("mediacodec start\n"); + return; } @@ -1974,3 +1989,68 @@ static void output_dump(App *app, media_packet_h pkt) fclose(fp); } + +const char* codec_type_to_string(mediacodec_codec_type_e media_codec_id) +{ + guint media_codec_id_u = (guint)media_codec_id; + + switch (media_codec_id_u) { + case MEDIACODEC_L16: + return "L16"; + case MEDIACODEC_ALAW: + return "ALAW"; + case MEDIACODEC_ULAW: + return "ULAW"; + case MEDIACODEC_AMR_NB: + return "AMR_NB"; + case MEDIACODEC_AMR_WB: + return "AMR_WB"; + case MEDIACODEC_G729: + return "G729"; + case MEDIACODEC_AAC_LC: + return "AAC_LC"; + case MEDIACODEC_AAC_HE: + return "AAC_HE"; + case MEDIACODEC_AAC_HE_PS: + return "AAC_HE_PS"; + case MEDIACODEC_MP3: + return "MP3"; + case MEDIACODEC_VORBIS: + return "VORBIS"; + case MEDIACODEC_FLAC: + return "FLAC"; + case MEDIACODEC_WMAV1: + return "WMAV1"; + case MEDIACODEC_WMAV2: + return "WMAV2"; + case MEDIACODEC_WMAPRO: + return "WMAPRO"; + case MEDIACODEC_WMALSL: + return "WMALSL"; + case MEDIACODEC_H261: + return "H261"; + case MEDIACODEC_H263: + return "H263"; + case MEDIACODEC_H264: + return "H264"; + case MEDIACODEC_MJPEG: + return "MJPEG"; + case MEDIACODEC_MPEG1: + return "MPEG1"; + case MEDIACODEC_MPEG2: + return "MPEG2"; + case MEDIACODEC_MPEG4: + return "MPEG4"; + case MEDIACODEC_HEVC: + return "HEVC"; + case MEDIACODEC_VP8: + return "VP8"; + case MEDIACODEC_VP9: + return "VP9"; + case MEDIACODEC_VC1: + return "VC1"; + default: + return "NONE"; + } +} + -- 2.7.4 From a23f6b15cb707a75d4fa797673a55f7c062194ce Mon Sep 17 00:00:00 2001 From: Sejun Park Date: Tue, 25 Oct 2016 19:00:24 +0900 Subject: [PATCH 04/16] changed printf to g_print Change-Id: I171c5ff58a0ee561f74934f4ac21c47c644c64ac --- test/media_codec_test.c | 47 ++++++++++++++++++++++------------------------- 1 file changed, 22 insertions(+), 25 deletions(-) diff --git a/test/media_codec_test.c b/test/media_codec_test.c index d5ab042..c1fda89 100755 --- a/test/media_codec_test.c +++ b/test/media_codec_test.c @@ -191,7 +191,7 @@ int g_menu_state = CURRENT_STATUS_MAINMENU; static int _create_app(void *data) { - printf("My app is going alive!\n"); + g_print("My app is going alive!\n"); App *app = (App*)data; g_mutex_init(&app->lock); @@ -200,7 +200,7 @@ static int _create_app(void *data) static int _terminate_app(void *data) { - printf("My app is going gone!\n"); + g_print("My app is going gone!\n"); App *app = (App*)data; g_mutex_clear(&app->lock); @@ -941,18 +941,18 @@ static void _mediacodec_process_input(App *app) if (have_frame) { #ifdef USE_POOL if (media_packet_pool_acquire_packet(pkt_pool, &pkt, -1) != MEDIA_PACKET_ERROR_NONE) { - fprintf(stderr, "media_packet_pool_aquire_packet failed\n"); + g_print("media_packet_pool_aquire_packet failed\n"); return; } #else if (media_packet_create_alloc(fmt, NULL, NULL, &pkt) != MEDIA_PACKET_ERROR_NONE) { - fprintf(stderr, "media_packet_create_alloc failed\n"); + g_print("media_packet_create_alloc failed\n"); return; } #endif if (media_packet_set_pts(pkt, (uint64_t)(pts)) != MEDIA_PACKET_ERROR_NONE) { - fprintf(stderr, "media_packet_set_pts failed\n"); + g_print("media_packet_set_pts failed\n"); return; } @@ -1061,17 +1061,17 @@ static gboolean read_data(App *app) if (have_frame) { #ifdef USE_POOL if (media_packet_pool_acquire_packet(pkt_pool, &pkt, -1) != MEDIA_PACKET_ERROR_NONE) { - fprintf(stderr, "media_packet_pool_aquire_packet failed\n"); + g_print("media_packet_pool_aquire_packet failed\n"); return FALSE; } #else if (media_packet_create_alloc(fmt, NULL, NULL, &pkt) != MEDIA_PACKET_ERROR_NONE) { - fprintf(stderr, "media_packet_create_alloc failed\n"); + g_print("media_packet_create_alloc failed\n"); return FALSE; } #endif if (media_packet_set_pts(pkt, (uint64_t)(pts)) != MEDIA_PACKET_ERROR_NONE) { - fprintf(stderr, "media_packet_set_pts failed\n"); + g_print("media_packet_set_pts failed\n"); return FALSE; } @@ -1232,7 +1232,7 @@ static bool _mediacodec_eos_cb(void *user_data) void _foreach_cb(mediacodec_codec_type_e codec_type, void *user_data) { - printf ("codec type : %x %s\n", codec_type, codec_type_to_string(codec_type)); + g_print("codec type : %x %s\n", codec_type, codec_type_to_string(codec_type)); return; } @@ -1240,7 +1240,7 @@ static void _mediacodec_prepare(App *app, bool frame_all) { int ret; - printf("supported codec lists -internal-\n"); + g_print("supported codec lists -internal-\n"); mediacodec_foreach_supported_codec_static((mediacodec_supported_codec_cb)_foreach_cb, app); /* create instance */ @@ -1301,7 +1301,7 @@ static void _mediacodec_prepare(App *app, bool frame_all) } /* set callback */ - printf("supported codec lists\n"); + g_print("supported codec lists\n"); mediacodec_foreach_supported_codec(app->mc_handle[0], (mediacodec_supported_codec_cb)_foreach_cb, app); mediacodec_set_input_buffer_used_cb(app->mc_handle[0], (mediacodec_input_buffer_used_cb)_mediacodec_inbuf_used_cb, NULL); mediacodec_set_output_buffer_available_cb(app->mc_handle[0], (mediacodec_output_buffer_available_cb) _mediacodec_outbuf_available_cb, app); @@ -1324,7 +1324,7 @@ static void _mediacodec_prepare(App *app, bool frame_all) g_print("mediacodec_get_packet_pool failed\n"); return; } - g_print("mediacodec start\n"); + g_print("\n\nmediacodec start\n\n"); return; } @@ -1441,19 +1441,16 @@ static void _mediacodec_destroy(App *app) #ifdef USE_POOL if (media_packet_pool_deallocate(pkt_pool) != MEDIA_PACKET_ERROR_NONE) { - fprintf(stderr, "media_packet_pool_deallocatet failed\n"); - g_print("PKT POOL deallocation failed \n"); + g_print("media_packet_pool_deallocatet failed\n"); return; } - g_print("PKT POOL deallocated! \n"); if (media_packet_pool_destroy(pkt_pool) != MEDIA_PACKET_ERROR_NONE) { - fprintf(stderr, " media_packet_pool_destroy failed\n"); - g_print("PKT POOL destroy failed \n"); + g_print(" media_packet_pool_destroy failed\n"); return; } - g_print("PKT POOL destroyed! \n"); + g_print("media packet pool destroyed! \n"); #endif mediacodec_destroy(app->mc_handle[0]); } @@ -1842,18 +1839,18 @@ void mc_hex_dump(char *desc, void *addr, int len) unsigned char *pc = (unsigned char *)addr; if (desc != NULL) - printf("%s:\n", desc); + g_print("%s:\n", desc); for (i = 0; i < len; i++) { if ((i % 16) == 0) { if (i != 0) - printf(" %s\n", buff); + g_print(" %s\n", buff); - printf(" %04x ", i); + g_print(" %04x ", i); } - printf(" %02x", pc[i]); + g_print(" %02x", pc[i]); if ((pc[i] < 0x20) || (pc[i] > 0x7e)) buff[i % 16] = '.'; @@ -1863,10 +1860,10 @@ void mc_hex_dump(char *desc, void *addr, int len) } while ((i % 16) != 0) { - printf(" "); + g_print(" "); i++; } - printf(" %s\n", buff); + g_print(" %s\n", buff); } static void decoder_output_dump(App *app, media_packet_h pkt) @@ -1884,7 +1881,7 @@ static void decoder_output_dump(App *app, media_packet_h pkt) media_packet_get_video_plane_data_ptr(pkt, 0, &temp); media_packet_get_video_stride_width(pkt, 0, &stride_width); media_packet_get_video_stride_height(pkt, 0, &stride_height); - printf("stride : %d, %d\n", stride_width, stride_height); + g_print("stride : %d, %d\n", stride_width, stride_height); for (i = 0; i < app->height; i++) { ret = fwrite(temp, app->width, 1, fp); -- 2.7.4 From 1f1dc680de202cf6c4c7a917eb2f82df0f6bf533 Mon Sep 17 00:00:00 2001 From: Sejun Park Date: Mon, 7 Nov 2016 14:37:37 +0900 Subject: [PATCH 05/16] Apply tizen3.0 coding rule Change-Id: Idd7b8da3a1a619b2bcf58ab88092eb8e16947d8c --- src/media_codec_port_gst.c | 8 ++++---- test/media_codec_test.c | 2 +- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/src/media_codec_port_gst.c b/src/media_codec_port_gst.c index 3f181e3..fedaba5 100755 --- a/src/media_codec_port_gst.c +++ b/src/media_codec_port_gst.c @@ -2361,18 +2361,18 @@ static MMVideoBuffer *__mc_gst_make_tbm_buffer(mc_gst_core_t* core, media_packet if (mm_vbuffer->handle.bo[0]) { handle_bo = tbm_bo_get_handle(mm_vbuffer->handle.bo[0], TBM_DEVICE_CPU); - mm_vbuffer->data[0]= handle_bo.ptr; + mm_vbuffer->data[0] = handle_bo.ptr; handle_bo = tbm_bo_get_handle(mm_vbuffer->handle.bo[0], TBM_DEVICE_MM); - mm_vbuffer->handle.dmabuf_fd[0]= handle_bo.u32; + mm_vbuffer->handle.dmabuf_fd[0] = handle_bo.u32; } if (mm_vbuffer->handle.bo[1]) { handle_bo = tbm_bo_get_handle(mm_vbuffer->handle.bo[1], TBM_DEVICE_CPU); - mm_vbuffer->data[1]= handle_bo.ptr; + mm_vbuffer->data[1] = handle_bo.ptr; handle_bo = tbm_bo_get_handle(mm_vbuffer->handle.bo[1], TBM_DEVICE_MM); - mm_vbuffer->handle.dmabuf_fd[1]= handle_bo.u32; + mm_vbuffer->handle.dmabuf_fd[1] = handle_bo.u32; } else { mm_vbuffer->data[1] = mm_vbuffer->data[0] + mm_vbuffer->stride_width[0] * mm_vbuffer->stride_height[0]; } diff --git a/test/media_codec_test.c b/test/media_codec_test.c index c1fda89..2ace30b 100755 --- a/test/media_codec_test.c +++ b/test/media_codec_test.c @@ -979,7 +979,7 @@ static void _mediacodec_process_input(App *app) media_packet_get_video_stride_width(pkt, 1, &stride_width); size = app->width * app->height / 2; - for (i = 0; i< app->height / 2; i++) { + for (i = 0; i < app->height / 2; i++) { memcpy(buf_data_ptr, tmp, app->width); buf_data_ptr += stride_width; tmp += app->width; -- 2.7.4 From c77c3bd6536eae1848c2781c13a8180cd5be7a81 Mon Sep 17 00:00:00 2001 From: Sejun Park Date: Mon, 7 Nov 2016 14:37:37 +0900 Subject: [PATCH 06/16] Apply tizen3.0 coding rule Change-Id: Idd7b8da3a1a619b2bcf58ab88092eb8e16947d8c --- src/media_codec_port_gst.c | 8 ++++---- test/media_codec_test.c | 2 +- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/src/media_codec_port_gst.c b/src/media_codec_port_gst.c index 3f181e3..fedaba5 100755 --- a/src/media_codec_port_gst.c +++ b/src/media_codec_port_gst.c @@ -2361,18 +2361,18 @@ static MMVideoBuffer *__mc_gst_make_tbm_buffer(mc_gst_core_t* core, media_packet if (mm_vbuffer->handle.bo[0]) { handle_bo = tbm_bo_get_handle(mm_vbuffer->handle.bo[0], TBM_DEVICE_CPU); - mm_vbuffer->data[0]= handle_bo.ptr; + mm_vbuffer->data[0] = handle_bo.ptr; handle_bo = tbm_bo_get_handle(mm_vbuffer->handle.bo[0], TBM_DEVICE_MM); - mm_vbuffer->handle.dmabuf_fd[0]= handle_bo.u32; + mm_vbuffer->handle.dmabuf_fd[0] = handle_bo.u32; } if (mm_vbuffer->handle.bo[1]) { handle_bo = tbm_bo_get_handle(mm_vbuffer->handle.bo[1], TBM_DEVICE_CPU); - mm_vbuffer->data[1]= handle_bo.ptr; + mm_vbuffer->data[1] = handle_bo.ptr; handle_bo = tbm_bo_get_handle(mm_vbuffer->handle.bo[1], TBM_DEVICE_MM); - mm_vbuffer->handle.dmabuf_fd[1]= handle_bo.u32; + mm_vbuffer->handle.dmabuf_fd[1] = handle_bo.u32; } else { mm_vbuffer->data[1] = mm_vbuffer->data[0] + mm_vbuffer->stride_width[0] * mm_vbuffer->stride_height[0]; } diff --git a/test/media_codec_test.c b/test/media_codec_test.c index c1fda89..2ace30b 100755 --- a/test/media_codec_test.c +++ b/test/media_codec_test.c @@ -979,7 +979,7 @@ static void _mediacodec_process_input(App *app) media_packet_get_video_stride_width(pkt, 1, &stride_width); size = app->width * app->height / 2; - for (i = 0; i< app->height / 2; i++) { + for (i = 0; i < app->height / 2; i++) { memcpy(buf_data_ptr, tmp, app->width); buf_data_ptr += stride_width; tmp += app->width; -- 2.7.4 From 50a10536b0b223619826a6cc79736d5751691e32 Mon Sep 17 00:00:00 2001 From: Sejun Park Date: Wed, 7 Dec 2016 13:29:59 +0900 Subject: [PATCH 07/16] Modify to be set codecdata Change-Id: Ib7807e50f3dcec8876fde872e0694458392dcc04 --- include/media_codec_port_gst.h | 1 + src/media_codec_port_gst.c | 78 ++++++++++++++++++++---------------------- 2 files changed, 38 insertions(+), 41 deletions(-) diff --git a/include/media_codec_port_gst.h b/include/media_codec_port_gst.h index 56e28f2..64536ad 100755 --- a/include/media_codec_port_gst.h +++ b/include/media_codec_port_gst.h @@ -51,6 +51,7 @@ extern "C" { #define TBM_API_CHANGE #define DEFAULT_DEC_POOL_SIZE 20 #define DEFAULT_ENC_POOL_SIZE 13 +#define CODECDATA_NOT_USE 0x7FFFFFFF #define AAC_CODECDATA_SIZE 16 #define WMA_CODECDATA_SIZE 64 #define VORBIS_CODECDATA_SIZE 4096 diff --git a/src/media_codec_port_gst.c b/src/media_codec_port_gst.c index fedaba5..fc9ddaf 100755 --- a/src/media_codec_port_gst.c +++ b/src/media_codec_port_gst.c @@ -717,53 +717,47 @@ int __mc_set_caps_streamheader(mc_gst_core_t *core, GstMCBuffer*buff, guint stre return ret; } -int __mc_set_caps_codecdata(mc_gst_core_t *core, GstMCBuffer *buff, guint codecdata_size) +int __mc_set_caps_codecdata(mc_gst_core_t *core, GstMCBuffer *buff, guint fixed_size) { int ret = MEDIA_PACKET_ERROR_NONE; - void *buf_data = NULL; - uint64_t buf_size = 0; + void *codec_data = NULL; + unsigned int codec_data_size = 0; GstBuffer *codecdata_buffer; - guint8 *data; + guint8 *data = NULL; GstMapInfo map; - ret = media_packet_get_buffer_size(buff->pkt, &buf_size); - if (ret != MEDIA_PACKET_ERROR_NONE) { - LOGW("buffer size get fail"); - return ret; - } - - ret = media_packet_get_buffer_data_ptr(buff->pkt, &buf_data); - if (ret != MEDIA_PACKET_ERROR_NONE) { - LOGW("buffer size get fail"); - return ret; + media_packet_get_codec_data(buff->pkt, &codec_data, &codec_data_size); + + if (codec_data != NULL) { /* get the codec data from media_packet_get_codec_data() */ + data = g_malloc0(codec_data_size); + memcpy(data, codec_data, codec_data_size); + codecdata_buffer = gst_buffer_new_wrapped(data, codec_data_size); + gst_caps_set_simple(core->caps, "codec_data", GST_TYPE_BUFFER, codecdata_buffer, NULL); + LOGD("set codec data : %" G_GSIZE_FORMAT "", gst_buffer_get_size(codecdata_buffer)); + gst_buffer_unref(codecdata_buffer); + } else { /* get the codec data from media_packet_get_buffer_data_ptr() */ + uint64_t buffer_size; + media_packet_get_buffer_size(buff->pkt, &buffer_size); + media_packet_get_buffer_data_ptr(buff->pkt, &codec_data); + + if (codec_data_size > fixed_size) { + data = g_malloc0(fixed_size); + gst_buffer_map(buff->buffer, &map, GST_MAP_READ); + memcpy(data, map.data, codec_data_size); + codecdata_buffer = gst_buffer_new_wrapped(data, buffer_size); + gst_buffer_unmap(buff->buffer, &map); + gst_caps_set_simple(core->caps, "codec_data", GST_TYPE_BUFFER, codecdata_buffer, NULL); + gst_buffer_unref(codecdata_buffer); + + gst_buffer_replace_memory(buff->buffer, 0, + gst_memory_new_wrapped(GST_MEMORY_FLAG_READONLY, codec_data + fixed_size , buffer_size - fixed_size, 0, + buffer_size - fixed_size, buff, (GDestroyNotify)gst_mediacodec_buffer_finalize)); + LOGD("set codec data from packet: %" G_GSIZE_FORMAT "", gst_buffer_get_size(buff->buffer)); + } } - - LOGD("Set caps for codec_data in mime : %s and codec_id (0x%x)", core->mime, core->codec_id); - - /* Add the codec_data attribute to caps, if we have it */ - data = g_malloc0(codecdata_size); - gst_buffer_map(buff->buffer, &map, GST_MAP_READ); - memcpy(data, map.data, codecdata_size); - codecdata_buffer = gst_buffer_new_wrapped(data, codecdata_size); - gst_buffer_unmap(buff->buffer, &map); - LOGD("setting codec_data from (packet) buf_data used codecdata_size (%d)", codecdata_size); - - gst_caps_set_simple(core->caps, "codec_data", GST_TYPE_BUFFER, codecdata_buffer, NULL); - gst_buffer_unref(codecdata_buffer); - - /* Update gstbuffer's data ptr and size for using previous codec_data..*/ - LOGD("BEFORE : buff->buffer of size %" G_GSIZE_FORMAT "", gst_buffer_get_size(buff->buffer)); - - gst_buffer_replace_memory(buff->buffer, 0, - gst_memory_new_wrapped(GST_MEMORY_FLAG_READONLY, buf_data + codecdata_size , buf_size - codecdata_size, 0, - buf_size - codecdata_size, buff, (GDestroyNotify)gst_mediacodec_buffer_finalize)); - - LOGD("AFTER : buff->buffer of size %" G_GSIZE_FORMAT "", gst_buffer_get_size(buff->buffer)); - return ret; } - int _mc_output_media_packet_new(mc_gst_core_t *core, bool video, bool encoder, media_format_mimetype_e out_mime) { if (media_format_create(&core->output_fmt) != MEDIA_FORMAT_ERROR_NONE) { @@ -1019,6 +1013,11 @@ static int _mc_gst_update_caps(mc_gst_core_t *core, media_packet_h pkt, GstMCBuf "width", G_TYPE_INT, dec_info->width, "height", G_TYPE_INT, dec_info->height, NULL); + + ret = __mc_set_caps_codecdata(core, buff, CODECDATA_NOT_USE); + if (ret != MC_ERROR_NONE) { + LOGW("__mc_set_caps_codecdata failed"); + } } } else { if (core->encoder) { @@ -1045,7 +1044,6 @@ static int _mc_gst_update_caps(mc_gst_core_t *core, media_packet_h pkt, GstMCBuf ret = __mc_set_caps_codecdata(core, buff, AAC_CODECDATA_SIZE); if (ret != MC_ERROR_NONE) { LOGW("__mc_set_caps_codecdata failed"); - return ret; } break; case MEDIACODEC_WMAV1: @@ -1055,7 +1053,6 @@ static int _mc_gst_update_caps(mc_gst_core_t *core, media_packet_h pkt, GstMCBuf ret = __mc_set_caps_codecdata(core, buff, WMA_CODECDATA_SIZE); if (ret != MC_ERROR_NONE) { LOGW("__mc_set_caps_codecdata failed"); - return ret; } break; case MEDIACODEC_VORBIS: @@ -1063,7 +1060,6 @@ static int _mc_gst_update_caps(mc_gst_core_t *core, media_packet_h pkt, GstMCBuf ret = __mc_set_caps_streamheader(core, buff, VORBIS_CODECDATA_SIZE); if (ret != MC_ERROR_NONE) { LOGW("__mc_set_caps_streamheader failed"); - return ret; } break; default: -- 2.7.4 From 0a88019c656e26ee5cbeca0f1dbf23242f3ddffb Mon Sep 17 00:00:00 2001 From: "juan82.liu" Date: Fri, 16 Dec 2016 03:11:10 +0800 Subject: [PATCH 08/16] Patch for split codec_data from first frame Change-Id: I86fa797c3ad6690a6da33aaa8553a08488aabc25 --- include/media_codec_bitstream.h | 2 + src/media_codec_bitstream.c | 92 +++++++++++++++++++++++- src/media_codec_port_gst.c | 156 ++++++++++++++++++++++++++++++++-------- 3 files changed, 220 insertions(+), 30 deletions(-) diff --git a/include/media_codec_bitstream.h b/include/media_codec_bitstream.h index e8af1af..2898146 100755 --- a/include/media_codec_bitstream.h +++ b/include/media_codec_bitstream.h @@ -99,6 +99,8 @@ int _mc_check_valid_h263_frame(unsigned char *p, int size); bool _mc_check_h263_out_bytestream(unsigned char *p, int buf_length, bool* need_sync_flag); int _mc_check_mpeg4_out_bytestream(unsigned char *buf, int buf_length, bool* need_codec_data, bool *need_sync_flag); +int _mc_get_h264_codecdata_size(guint8 *data, int size); + #ifdef __cplusplus } #endif diff --git a/src/media_codec_bitstream.c b/src/media_codec_bitstream.c index e50baeb..373da79 100755 --- a/src/media_codec_bitstream.c +++ b/src/media_codec_bitstream.c @@ -17,6 +17,8 @@ #include #include #include +#include +#include void mc_init_bits(mc_bitstream_t *stream, unsigned char *data, int size) { @@ -182,15 +184,25 @@ int __mc_decode_sps(mc_bitstream_t *pstream, int *width, int *height) return ret; } +int __mc_scan_for_h264_start_codes(const guint8 * data, guint size) +{ + GstByteReader br; + gst_byte_reader_init(&br, data, size); + + /* NALU not empty, so we can at least expect 1 (even 2) bytes following sc */ + return gst_byte_reader_masked_scan_uint32(&br, 0xffffff00, 0x00000100, 0, size); +} + int _mc_check_h264_bytestream(unsigned char *nal, int byte_length, bool port, bool *codec_config, bool *sync_flag, bool *slice) { - int ret = MC_ERROR_NONE; + int ret = 0; /* (ret <= 0)==>>error occured; (ret > 0)==>>codec data size */ int stacked_length = 0; int nal_length = 0; unsigned int syntax = 0; unsigned int state = 0; int count = 0; int nal_unit_type = 0; + int codec_length = 0; mc_bitstream_t pstream; @@ -211,10 +223,12 @@ int _mc_check_h264_bytestream(unsigned char *nal, int byte_length, bool port, bo if ((ret = __mc_decode_sps(&pstream, NULL, NULL)) != MC_ERROR_NONE) return ret; state |= MC_EXIST_SPS; + codec_length += nal_length; break; case NAL_PICTURE_PARAMETER_SET: LOGD("nal_unit_type : PPS"); state |= MC_EXIST_PPS; + codec_length += nal_length; break; case NAL_SLICE_IDR: LOGD("nal_unit_type : IDR"); @@ -231,6 +245,8 @@ int _mc_check_h264_bytestream(unsigned char *nal, int byte_length, bool port, bo stacked_length += nal_length; count++; + LOGD("codec_data length : %d", codec_length); + if ((stacked_length >= byte_length) || count > 5) break; } @@ -257,7 +273,7 @@ int _mc_check_h264_bytestream(unsigned char *nal, int byte_length, bool port, bo *slice = CHECK_VALID_PACKET(state, MC_EXIST_SLICE) ? 1 : 0; } - return ret; + return codec_length; } int _mc_check_valid_h263_frame(unsigned char *p, int size) @@ -367,3 +383,75 @@ bool _mc_check_h263_out_bytestream(unsigned char *p, int buf_length, bool* need_ return TRUE; } +int _mc_get_h264_codecdata_size(guint8 *data, int size) +{ + int offset = 0; + int data_size = 0; + bool is_bytestream = FALSE; + + if ((offset = __mc_scan_for_h264_start_codes(data, size)) == -1) { + /*Packetized Format*/ + is_bytestream = FALSE; + } else { + /*Byte-Stream Format*/ + is_bytestream = TRUE; + } + + if (is_bytestream) { + /*Byte-Stream Format*/ + data_size = _mc_check_h264_bytestream(data, size, 0, NULL, NULL, NULL); + if (data_size <= 0) { + LOGE("No valid SPS/PPS ..."); + return MC_INVALID_IN_BUF; + } + return data_size; + } else { + /*Packetized Format*/ + int num_sps = 0, num_pps = 0; + int nalu_size = 0; + int i = 0; + unsigned int state = 0; + GstBitReader br; + + offset = 0; + /* parse the avcC data */ + if (size < 7) { /* when numSPS==0 and numPPS==0, length is 7 bytes */ + LOGE("If contains codec_data, size should over 7 bytes ..."); + return MC_INVALID_IN_BUF; + } + /* parse the version, this must be 1 */ + if (data[0] != 1) { + LOGE("If contains codec_data, first byte must be 1 ..."); + return MC_INVALID_IN_BUF; + } + + num_sps = data[5] & 0x1f; + offset = 6; + for (i = 0; i < num_sps; i++) { + gst_bit_reader_init(&br, data + offset, size - offset); + nalu_size = gst_bit_reader_get_bits_uint32_unchecked(&br, 2 * 8); + + offset += nalu_size + 2; + state |= MC_EXIST_SPS; + } + + num_pps = data[offset]; + offset++; + + for (i = 0; i < num_pps; i++) { + gst_bit_reader_init(&br, data + offset, size - offset); + nalu_size = gst_bit_reader_get_bits_uint32_unchecked(&br, 2 * 8); + + offset += nalu_size + 2; + state |= MC_EXIST_PPS; + } + + if (CHECK_VALID_PACKET(state, MC_VALID_HEADER)) { + LOGD("Found valid SPS/PPS data...\n"); + return offset; + } + + return MC_INVALID_IN_BUF; + } + +} diff --git a/src/media_codec_port_gst.c b/src/media_codec_port_gst.c index fc9ddaf..d7856a3 100755 --- a/src/media_codec_port_gst.c +++ b/src/media_codec_port_gst.c @@ -60,6 +60,8 @@ static GstMCBuffer *gst_mediacodec_buffer_new(mc_gst_core_t* core, media_packet_ static void gst_mediacodec_buffer_finalize(GstMCBuffer *buffer); static int __mc_set_caps_streamheader(mc_gst_core_t *core, GstMCBuffer*buff, guint streamheader_size); static int __mc_set_caps_codecdata(mc_gst_core_t *core, GstMCBuffer*buff, guint codecdata_size); +static void __mc_push_output_to_queue(mc_gst_core_t *core, media_packet_h out_pkt); +static int __mc_gst_create_eos_packet(media_format_h fmt, media_packet_h *out_pkt); static gint __gst_handle_stream_error(mc_gst_core_t *core, GError *error, GstMessage *message); static gint __gst_transform_gsterror(mc_gst_core_t *core, GstMessage *message, GError *error); @@ -717,9 +719,46 @@ int __mc_set_caps_streamheader(mc_gst_core_t *core, GstMCBuffer*buff, guint stre return ret; } +int __mc_get_codecdata_size(mc_gst_core_t *core, GstMCBuffer *buff, unsigned int *size) +{ + void *data = NULL; + uint64_t data_size = 0; + uint64_t codec_size = 0; + int ret = MC_ERROR_NONE; + + media_packet_get_buffer_size(buff->pkt, &data_size); + media_packet_get_buffer_data_ptr(buff->pkt, &data); + + switch (core->codec_id) { + case MEDIACODEC_H264: + codec_size = _mc_get_h264_codecdata_size(data, data_size); + break; + case MEDIACODEC_H263: + /* Not need codec data */ + codec_size = 0; + break; + case MEDIACODEC_MPEG4: + codec_size = _mc_check_mpeg4_out_bytestream(data, data_size, NULL, NULL); + break; + default: + LOGE("Current not support yet (0x%x) !", core->codec_id); + return MC_NOT_SUPPORTED; + break; + } + + if (codec_size < 0) { + LOGE("No valid codec data!"); + ret = MC_INVALID_IN_BUF; + } + + *size = codec_size; + + return ret; +} + int __mc_set_caps_codecdata(mc_gst_core_t *core, GstMCBuffer *buff, guint fixed_size) { - int ret = MEDIA_PACKET_ERROR_NONE; + int ret = MC_ERROR_NONE; void *codec_data = NULL; unsigned int codec_data_size = 0; GstBuffer *codecdata_buffer; @@ -733,26 +772,35 @@ int __mc_set_caps_codecdata(mc_gst_core_t *core, GstMCBuffer *buff, guint fixed_ memcpy(data, codec_data, codec_data_size); codecdata_buffer = gst_buffer_new_wrapped(data, codec_data_size); gst_caps_set_simple(core->caps, "codec_data", GST_TYPE_BUFFER, codecdata_buffer, NULL); - LOGD("set codec data : %" G_GSIZE_FORMAT "", gst_buffer_get_size(codecdata_buffer)); + LOGD("set codec data : %" G_GSIZE_FORMAT "", gst_buffer_get_size(codecdata_buffer)); gst_buffer_unref(codecdata_buffer); } else { /* get the codec data from media_packet_get_buffer_data_ptr() */ - uint64_t buffer_size; + uint64_t buffer_size = 0; + void *buff_data = NULL; + media_packet_get_buffer_size(buff->pkt, &buffer_size); - media_packet_get_buffer_data_ptr(buff->pkt, &codec_data); + media_packet_get_buffer_data_ptr(buff->pkt, &buff_data); + + ret = __mc_get_codecdata_size(core, buff, &codec_data_size); + LOGD("First Frame contains codec_data_size= %d", codec_data_size); - if (codec_data_size > fixed_size) { - data = g_malloc0(fixed_size); + if ((ret == MC_ERROR_NONE) && (codec_data_size > 0)) { + data = g_malloc0(codec_data_size); gst_buffer_map(buff->buffer, &map, GST_MAP_READ); memcpy(data, map.data, codec_data_size); - codecdata_buffer = gst_buffer_new_wrapped(data, buffer_size); + codecdata_buffer = gst_buffer_new_wrapped(data, codec_data_size); gst_buffer_unmap(buff->buffer, &map); gst_caps_set_simple(core->caps, "codec_data", GST_TYPE_BUFFER, codecdata_buffer, NULL); gst_buffer_unref(codecdata_buffer); - gst_buffer_replace_memory(buff->buffer, 0, - gst_memory_new_wrapped(GST_MEMORY_FLAG_READONLY, codec_data + fixed_size , buffer_size - fixed_size, 0, - buffer_size - fixed_size, buff, (GDestroyNotify)gst_mediacodec_buffer_finalize)); - LOGD("set codec data from packet: %" G_GSIZE_FORMAT "", gst_buffer_get_size(buff->buffer)); + GstMemory *memory = NULL; + memory = gst_buffer_peek_memory(buff->buffer, 0); + gst_memory_resize(memory, codec_data_size, buffer_size - codec_data_size); + LOGD("First frame remained size : %d", gst_buffer_get_size(buff->buffer)); + } else { + if (ret != MC_ERROR_NONE) { + LOGE("No valid codec data in the packet!"); + } } } return ret; @@ -1377,6 +1425,7 @@ static int _mc_link_vtable(mc_gst_core_t *core, mediacodec_codec_type_e id, gboo core->vtable = vdec_h263_sw_vtable; core->caps = gst_caps_new_simple(core->mime, "variant", G_TYPE_STRING, "itu", + "framerate", GST_TYPE_FRACTION, 30, 1, NULL); } } @@ -1417,7 +1466,9 @@ static int _mc_link_vtable(mc_gst_core_t *core, mediacodec_codec_type_e id, gboo core->vtable = vdec_h264_sw_vtable; core->caps = gst_caps_new_simple(core->mime, "alignment", G_TYPE_STRING, "au", - "stream-format", G_TYPE_STRING, "byte-stream", NULL); + "stream-format", G_TYPE_STRING, "byte-stream", + "framerate", GST_TYPE_FRACTION, 30, 1, + NULL); } } break; @@ -1971,6 +2022,32 @@ STATE_CHANGE_FAILED: return MC_ERROR; } +void __mc_push_output_to_queue(mc_gst_core_t *core, media_packet_h out_pkt) +{ + g_mutex_lock(&core->ports[1]->mutex); + + /* push it to output buffer queue */ + g_queue_push_tail(core->ports[1]->queue, out_pkt); + g_cond_broadcast(&core->out_buffer_cond); + g_atomic_int_inc(&core->ftb_count); + + GstBuffer *buffer = NULL; + media_packet_get_extra(out_pkt, (void**)&buffer); + if (buffer) { + LOGD("dq : %d TIMESTAMP = %"GST_TIME_FORMAT " DURATION = %"GST_TIME_FORMAT, + core->ftb_count, GST_TIME_ARGS(GST_BUFFER_TIMESTAMP(buffer)), GST_TIME_ARGS(GST_BUFFER_DURATION(buffer))); + } else { + LOGD("dq : %d ", core->ftb_count); + } + + g_mutex_unlock(&core->ports[1]->mutex); + + if (core->user_cb[_MEDIACODEC_EVENT_TYPE_FILLBUFFER]) { + ((mc_fill_buffer_cb) core->user_cb[_MEDIACODEC_EVENT_TYPE_FILLBUFFER]) + (out_pkt, core->user_data[_MEDIACODEC_EVENT_TYPE_FILLBUFFER]); + } +} + void __mc_gst_buffer_add(GstElement *element, GstBuffer *buffer, GstPad *pad, gpointer data) { guint n; @@ -2011,22 +2088,7 @@ void __mc_gst_buffer_add(GstElement *element, GstBuffer *buffer, GstPad *pad, gp core->need_sync_flag = false; } - g_mutex_lock(&core->ports[1]->mutex); - - /* push it to output buffer queue */ - g_queue_push_tail(core->ports[1]->queue, out_pkt); - g_cond_broadcast(&core->out_buffer_cond); - - g_atomic_int_inc(&core->ftb_count); - LOGD("dq : %d TIMESTAMP = %"GST_TIME_FORMAT " DURATION = %"GST_TIME_FORMAT, - core->ftb_count, GST_TIME_ARGS(GST_BUFFER_TIMESTAMP(buffer)), GST_TIME_ARGS(GST_BUFFER_DURATION(buffer))); - - g_mutex_unlock(&core->ports[1]->mutex); - - if (core->user_cb[_MEDIACODEC_EVENT_TYPE_FILLBUFFER]) { - ((mc_fill_buffer_cb) core->user_cb[_MEDIACODEC_EVENT_TYPE_FILLBUFFER]) - (out_pkt, core->user_data[_MEDIACODEC_EVENT_TYPE_FILLBUFFER]); - } + __mc_push_output_to_queue(core, out_pkt); } else { gst_buffer_unref(buffer); LOGE("Failed to dequeue output packet"); @@ -2180,6 +2242,36 @@ media_packet_h __mc_gst_make_media_packet(mc_gst_core_t *core, unsigned char *da return pkt; } +int __mc_gst_create_eos_packet(media_format_h fmt, media_packet_h *out_pkt) +{ + media_packet_h mediabuf = NULL; + int ret = MC_ERROR_NONE; + + MEDIACODEC_FENTER(); + if (media_packet_create_alloc(fmt, NULL, NULL, &mediabuf)) { + LOGE("media_packet_create_alloc failed\n"); + ret = MC_ERROR; + goto ERROR; + } + + if (media_packet_set_flags(mediabuf, MEDIA_PACKET_END_OF_STREAM)) { + LOGE("unable to set EOS flag\n"); + ret = MC_ERROR; + goto ERROR; + } + + *out_pkt = mediabuf; + MEDIACODEC_FLEAVE(); + + return ret; +ERROR: + if (mediabuf) + media_packet_destroy(mediabuf); + *out_pkt = NULL; + MEDIACODEC_FLEAVE(); + return ret; +} + gboolean __mc_gst_bus_callback(GstBus *bus, GstMessage *msg, gpointer data) { int ret = MC_ERROR_NONE; @@ -2191,6 +2283,14 @@ gboolean __mc_gst_bus_callback(GstBus *bus, GstMessage *msg, gpointer data) case GST_MESSAGE_EOS: _mc_send_eos_signal(core); + media_packet_h out_pkt = NULL; + if (MC_ERROR_NONE == __mc_gst_create_eos_packet(core->output_fmt, &out_pkt)) { + __mc_push_output_to_queue(core, out_pkt); + LOGD("send eos packet."); + } else { + LOGE("failed to create eos packet."); + } + if (core->user_cb[_MEDIACODEC_EVENT_TYPE_EOS]) { LOGD("eos callback invoked"); ((mc_eos_cb) core->user_cb[_MEDIACODEC_EVENT_TYPE_EOS])(core->user_data[_MEDIACODEC_EVENT_TYPE_EOS]); -- 2.7.4 From 76fe3ad5da0e9b3ba3b8319799955aa54353866e Mon Sep 17 00:00:00 2001 From: Zhao Cancan Date: Tue, 20 Dec 2016 01:11:06 -0500 Subject: [PATCH 09/16] fix memory leak in error cases of feed_task function Change-Id: I7adca39677fb64ce0a48880b433baf0b11751c7e --- packaging/capi-media-codec.spec | 2 +- src/media_codec_port_gst.c | 104 ++++++++++++++++++++++++---------------- 2 files changed, 65 insertions(+), 41 deletions(-) diff --git a/packaging/capi-media-codec.spec b/packaging/capi-media-codec.spec index 92cb31b..293d7b8 100755 --- a/packaging/capi-media-codec.spec +++ b/packaging/capi-media-codec.spec @@ -1,6 +1,6 @@ Name: capi-media-codec Summary: A Media Codec library in Tizen Native API -Version: 0.5.0 +Version: 0.5.1 Release: 0 Group: Multimedia/API License: Apache-2.0 diff --git a/src/media_codec_port_gst.c b/src/media_codec_port_gst.c index d7856a3..5d0d5d6 100755 --- a/src/media_codec_port_gst.c +++ b/src/media_codec_port_gst.c @@ -47,7 +47,7 @@ static mc_ret_e _mc_gst_create_pipeline(mc_gst_core_t *core, gchar *factory_name static mc_ret_e _mc_gst_destroy_pipeline(mc_gst_core_t *core); static void __mc_gst_buffer_add(GstElement *element, GstBuffer *buffer, GstPad *pad, gpointer data); static int __mc_output_buffer_finalize_cb(media_packet_h packet, int error_code, void *user_data); -static int _mc_gst_update_caps(mc_gst_core_t *core, media_packet_h pkt, GstMCBuffer* buff, bool codec_config); +static int _mc_gst_update_caps(mc_gst_core_t *core, GstMCBuffer *buff, bool codec_config); static gboolean _mc_update_packet_info(mc_gst_core_t *core, media_format_h fmt); static GstMCBuffer *_mc_gst_media_packet_to_gstbuffer(mc_gst_core_t *core, media_packet_h pkt, bool codec_config); static int _mc_gst_gstbuffer_to_appsrc(mc_gst_core_t *core, GstMCBuffer *buff); @@ -56,12 +56,13 @@ static media_packet_h __mc_gst_make_media_packet(mc_gst_core_t *core, unsigned c static gboolean __mc_gst_bus_callback(GstBus *bus, GstMessage *msg, gpointer data); static GstBusSyncReply __mc_gst_bus_sync_callback(GstBus *bus, GstMessage *msg, gpointer data); static MMVideoBuffer *__mc_gst_make_tbm_buffer(mc_gst_core_t *core, media_packet_h pkt); -static GstMCBuffer *gst_mediacodec_buffer_new(mc_gst_core_t* core, media_packet_h pkt, uint64_t size); +static GstMCBuffer *gst_mediacodec_buffer_new(mc_gst_core_t *core, media_packet_h pkt, uint64_t size); static void gst_mediacodec_buffer_finalize(GstMCBuffer *buffer); -static int __mc_set_caps_streamheader(mc_gst_core_t *core, GstMCBuffer*buff, guint streamheader_size); -static int __mc_set_caps_codecdata(mc_gst_core_t *core, GstMCBuffer*buff, guint codecdata_size); +static int __mc_set_caps_streamheader(mc_gst_core_t *core, GstMCBuffer *buff, guint streamheader_size); +static int __mc_set_caps_codecdata(mc_gst_core_t *core, GstMCBuffer *buff, guint codecdata_size); static void __mc_push_output_to_queue(mc_gst_core_t *core, media_packet_h out_pkt); static int __mc_gst_create_eos_packet(media_format_h fmt, media_packet_h *out_pkt); +static void _mc_gst_handle_input_buffer_used(mc_gst_core_t *core, media_packet_h pkt); static gint __gst_handle_stream_error(mc_gst_core_t *core, GError *error, GstMessage *message); static gint __gst_transform_gsterror(mc_gst_core_t *core, GstMessage *message, GError *error); @@ -185,7 +186,7 @@ int __mc_fill_inbuf_with_mm_video_buffer(mc_gst_core_t *core, media_packet_h pkt ret = media_packet_get_buffer_data_ptr(pkt, &buf_data); if (ret != MEDIA_PACKET_ERROR_NONE) { - LOGW("buffer size get fail"); + LOGW("buffer data get fail"); return MC_ERROR; } @@ -221,7 +222,7 @@ int __mc_fill_input_buffer_with_packet(mc_gst_core_t *core, media_packet_h pkt, ret = media_packet_get_buffer_data_ptr(pkt, &buf_data); if (ret != MEDIA_PACKET_ERROR_NONE) { - LOGW("buffer size get fail"); + LOGW("buffer data get fail"); return MC_ERROR; } @@ -581,7 +582,7 @@ int __mc_set_caps_streamheader(mc_gst_core_t *core, GstMCBuffer*buff, guint stre ret = media_packet_get_buffer_data_ptr(buff->pkt, &buf_data); if (ret != MEDIA_PACKET_ERROR_NONE) { - LOGW("buffer size get fail"); + LOGW("buffer data get fail"); return ret; } @@ -1029,11 +1030,12 @@ gboolean _mc_update_packet_info(mc_gst_core_t *core, media_format_h fmt) return is_updated; } -static int _mc_gst_update_caps(mc_gst_core_t *core, media_packet_h pkt, GstMCBuffer* buff, bool codec_config) +static int _mc_gst_update_caps(mc_gst_core_t *core, GstMCBuffer *buff, bool codec_config) { MEDIACODEC_FENTER(); g_return_val_if_fail(core != NULL, MC_PARAM_ERROR); + g_return_val_if_fail(buff != NULL, MC_PARAM_ERROR); int ret = MC_ERROR_NONE; @@ -1041,7 +1043,7 @@ static int _mc_gst_update_caps(mc_gst_core_t *core, media_packet_h pkt, GstMCBuf if (core->encoder) { mc_encoder_info_t *enc_info = (mc_encoder_info_t *)core->codec_info; - core->format = __mc_get_gst_input_format(pkt, core->is_hw); + core->format = __mc_get_gst_input_format(buff->pkt, core->is_hw); gst_caps_set_simple(core->caps, "format", G_TYPE_STRING, core->format, "width", G_TYPE_INT, enc_info->width, @@ -1053,7 +1055,7 @@ static int _mc_gst_update_caps(mc_gst_core_t *core, media_packet_h pkt, GstMCBuf g_object_set(GST_OBJECT(core->codec), "bitrate", enc_info->bitrate, NULL); else g_object_set(GST_OBJECT(core->codec), "target-bitrate", enc_info->bitrate, NULL); - + LOGD("set bitrate = %d.", enc_info->bitrate); } else { mc_decoder_info_t *dec_info = (mc_decoder_info_t *)core->codec_info; @@ -1140,7 +1142,6 @@ static gpointer feed_task(gpointer data) while (g_atomic_int_get(&core->available_queue->running)) { LOGD("waiting for next input...."); in_buf = _mc_get_input_buffer(core); - if (!in_buf) goto LEAVE; @@ -1160,12 +1161,27 @@ static gpointer feed_task(gpointer data) LOGE("media_packet_is_end_of_stream failed"); goto ERROR; } + /* + * receive an eos packet. For decoder + encoder case, encoder always get tbm surface plane first from input data, + * but eos packet only has flag not valid data, so we don't put it to downstream. + */ + if (eos) { + LOGD("end of stream"); + gst_app_src_end_of_stream(GST_APP_SRC(core->appsrc)); + _mc_wait_for_eos(core); + initiative = true; + + _mc_gst_handle_input_buffer_used(core, in_buf); + goto LEAVE; + } buff = _mc_gst_media_packet_to_gstbuffer(core, in_buf, codec_config); if (!buff) { LOGW("gstbuffer can't make"); goto ERROR; } + /* buff took the ownership of the in_buf, so set in_buf to NULL to aviod double unref */ + in_buf = NULL; if (codec_config) initiative = TRUE; @@ -1173,9 +1189,11 @@ static gpointer feed_task(gpointer data) if (initiative) { GstPad *pad; - ret = _mc_gst_update_caps(core, in_buf, buff, codec_config); + ret = _mc_gst_update_caps(core, buff, codec_config); if (ret != MC_ERROR_NONE) { LOGE("failed to update caps"); + /* unref buff->buffer will invoke the finalize() of GstMcBuffer */ + gst_buffer_unref(buff->buffer); goto ERROR; } @@ -1195,16 +1213,11 @@ static gpointer feed_task(gpointer data) initiative = false; - if (eos) { - LOGD("end of stream"); - gst_app_src_end_of_stream(GST_APP_SRC(core->appsrc)); - _mc_wait_for_eos(core); - initiative = true; - } - - continue; ERROR: + if (in_buf) + _mc_gst_handle_input_buffer_used(core, in_buf); + _mc_gst_set_flush_input(core); if (core->user_cb[_MEDIACODEC_EVENT_TYPE_ERROR]) { @@ -2034,10 +2047,10 @@ void __mc_push_output_to_queue(mc_gst_core_t *core, media_packet_h out_pkt) GstBuffer *buffer = NULL; media_packet_get_extra(out_pkt, (void**)&buffer); if (buffer) { - LOGD("dq : %d TIMESTAMP = %"GST_TIME_FORMAT " DURATION = %"GST_TIME_FORMAT, + LOGD("dq : v(%d)e(%d) %d TIMESTAMP = %"GST_TIME_FORMAT " DURATION = %"GST_TIME_FORMAT, core->video, core->encoder, core->ftb_count, GST_TIME_ARGS(GST_BUFFER_TIMESTAMP(buffer)), GST_TIME_ARGS(GST_BUFFER_DURATION(buffer))); } else { - LOGD("dq : %d ", core->ftb_count); + LOGD("dq : v(%d)e(%d) %d ", core->video, core->encoder, core->ftb_count); } g_mutex_unlock(&core->ports[1]->mutex); @@ -2181,7 +2194,7 @@ gchar *__mc_get_gst_input_format(media_packet_h packet, bool is_hw) return format; } -GstMCBuffer *_mc_gst_media_packet_to_gstbuffer(mc_gst_core_t* core, media_packet_h pkt, bool codec_config) +GstMCBuffer *_mc_gst_media_packet_to_gstbuffer(mc_gst_core_t *core, media_packet_h pkt, bool codec_config) { int ret = MEDIA_PACKET_ERROR_NONE; GstMCBuffer *mc_buffer = NULL; @@ -2198,7 +2211,7 @@ GstMCBuffer *_mc_gst_media_packet_to_gstbuffer(mc_gst_core_t* core, media_packet ret = media_packet_get_buffer_data_ptr(pkt, &buf_data); if (ret != MEDIA_PACKET_ERROR_NONE) { - LOGW("buffer size get fail"); + LOGW("buffer data get fail"); return NULL; } @@ -2208,11 +2221,17 @@ GstMCBuffer *_mc_gst_media_packet_to_gstbuffer(mc_gst_core_t* core, media_packet return NULL; } - LOGD("pkt : %p, buf_size : %d", pkt, (int)buf_size); + LOGD("pkt :v(%d)e(%d) %p, buf_size : %d", core->video, core->encoder, pkt, (int)buf_size); ret = __mc_fill_input_buffer(core, pkt, mc_buffer); if (ret != MC_ERROR_NONE) { LOGW("failed to fill inbuf: %s (ox%08x)", _mc_error_to_string(ret), ret); + /* + * if __mc_fill_input_buffer() failed, no memory appended to mc_buffer->buffer, so gst_mediacodec_buffer_finalize() + * will not be invoked + */ + gst_buffer_unref(mc_buffer->buffer); + free(mc_buffer); return NULL; } @@ -2248,7 +2267,7 @@ int __mc_gst_create_eos_packet(media_format_h fmt, media_packet_h *out_pkt) int ret = MC_ERROR_NONE; MEDIACODEC_FENTER(); - if (media_packet_create_alloc(fmt, NULL, NULL, &mediabuf)) { + if (media_packet_create(fmt, NULL, NULL, &mediabuf)) { LOGE("media_packet_create_alloc failed\n"); ret = MC_ERROR; goto ERROR; @@ -2272,6 +2291,19 @@ ERROR: return ret; } +void _mc_gst_handle_input_buffer_used(mc_gst_core_t *core, media_packet_h pkt) +{ + g_atomic_int_dec_and_test(&core->etb_count); + + if (core && core->user_cb[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER]) { + ((mc_empty_buffer_cb)core->user_cb[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER]) + (pkt, core->user_data[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER]); + } + + if (core) + LOGD("@v(%d)e(%d) input port emptied buffer(%d): %p", core->video, core->encoder, core->etb_count, pkt); +} + gboolean __mc_gst_bus_callback(GstBus *bus, GstMessage *msg, gpointer data) { int ret = MC_ERROR_NONE; @@ -2398,7 +2430,7 @@ static GstBusSyncReply __mc_gst_bus_sync_callback(GstBus *bus, GstMessage *msg, return reply; } -static MMVideoBuffer *__mc_gst_make_tbm_buffer(mc_gst_core_t* core, media_packet_h pkt) +static MMVideoBuffer *__mc_gst_make_tbm_buffer(mc_gst_core_t *core, media_packet_h pkt) { int i; int num_bos; @@ -2488,13 +2520,8 @@ static void gst_mediacodec_buffer_finalize(GstMCBuffer *mc_buffer) mc_gst_core_t *core = (mc_gst_core_t *)mc_buffer->core; - g_atomic_int_dec_and_test(&core->etb_count); - if (core->user_cb[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER]) { - ((mc_empty_buffer_cb) core->user_cb[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER]) - (mc_buffer->pkt, core->user_data[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER]); - } + _mc_gst_handle_input_buffer_used(core, mc_buffer->pkt); - LOGD("@v(%d)e(%d)input port emptied buffer(%d): %p", core->video, core->encoder, core->etb_count, mc_buffer->pkt); free(mc_buffer); mc_buffer = NULL; @@ -2503,7 +2530,7 @@ static void gst_mediacodec_buffer_finalize(GstMCBuffer *mc_buffer) return; } -static GstMCBuffer *gst_mediacodec_buffer_new(mc_gst_core_t* core, media_packet_h pkt, uint64_t size) +static GstMCBuffer *gst_mediacodec_buffer_new(mc_gst_core_t *core, media_packet_h pkt, uint64_t size) { GstMCBuffer *mc_buffer = NULL; @@ -2604,7 +2631,7 @@ static gint __gst_handle_resource_error(mc_gst_core_t *core, int code) return trans_err; } -static gint __gst_handle_stream_error(mc_gst_core_t *core, GError* error, GstMessage * message) +static gint __gst_handle_stream_error(mc_gst_core_t *core, GError *error, GstMessage *message) { gint trans_err = MEDIACODEC_ERROR_NONE; @@ -2637,7 +2664,7 @@ static gint __gst_handle_stream_error(mc_gst_core_t *core, GError* error, GstMes return trans_err; } -static gint __gst_transform_gsterror(mc_gst_core_t *core, GstMessage * message, GError* error) +static gint __gst_transform_gsterror(mc_gst_core_t *core, GstMessage *message, GError *error) { gchar *src_element_name = NULL; GstElement *src_element = NULL; @@ -2725,10 +2752,7 @@ static void _mc_gst_set_flush_input(mc_gst_core_t *core) g_atomic_int_dec_and_test(&core->etb_count); LOGD("%p poped(%d)", pkt, core->etb_count); - if (core->user_cb[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER]) { - ((mc_empty_buffer_cb) core->user_cb[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER]) - (pkt, core->user_data[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER]); - } + _mc_gst_handle_input_buffer_used(core, pkt); } mc_async_queue_flush(core->available_queue->input); -- 2.7.4 From 11333fa2ba322163aeed745a9d1dfbaf7f71b446 Mon Sep 17 00:00:00 2001 From: Sejun Park Date: Fri, 23 Dec 2016 13:56:04 +0900 Subject: [PATCH 10/16] Changed to previous codec data configuration logic Change-Id: I3a7a249c2a6ace6ca9e77171221c6675cb03394a --- src/media_codec_port_gst.c | 26 +++++++++++--------------- 1 file changed, 11 insertions(+), 15 deletions(-) diff --git a/src/media_codec_port_gst.c b/src/media_codec_port_gst.c index 5d0d5d6..3a87d42 100755 --- a/src/media_codec_port_gst.c +++ b/src/media_codec_port_gst.c @@ -782,26 +782,22 @@ int __mc_set_caps_codecdata(mc_gst_core_t *core, GstMCBuffer *buff, guint fixed_ media_packet_get_buffer_size(buff->pkt, &buffer_size); media_packet_get_buffer_data_ptr(buff->pkt, &buff_data); - ret = __mc_get_codecdata_size(core, buff, &codec_data_size); - LOGD("First Frame contains codec_data_size= %d", codec_data_size); - - if ((ret == MC_ERROR_NONE) && (codec_data_size > 0)) { - data = g_malloc0(codec_data_size); + /* For audio, it's necessary to change the offset value of buffer after extracting csd */ + /* it's not necessary to set csd to caps in case of annex-b */ + if (buffer_size > fixed_size) { + data = g_malloc0(fixed_size); gst_buffer_map(buff->buffer, &map, GST_MAP_READ); - memcpy(data, map.data, codec_data_size); - codecdata_buffer = gst_buffer_new_wrapped(data, codec_data_size); + memcpy(data, map.data, fixed_size); + codecdata_buffer = gst_buffer_new_wrapped(data, fixed_size); gst_buffer_unmap(buff->buffer, &map); gst_caps_set_simple(core->caps, "codec_data", GST_TYPE_BUFFER, codecdata_buffer, NULL); gst_buffer_unref(codecdata_buffer); - GstMemory *memory = NULL; - memory = gst_buffer_peek_memory(buff->buffer, 0); - gst_memory_resize(memory, codec_data_size, buffer_size - codec_data_size); - LOGD("First frame remained size : %d", gst_buffer_get_size(buff->buffer)); - } else { - if (ret != MC_ERROR_NONE) { - LOGE("No valid codec data in the packet!"); - } + gst_buffer_replace_memory(buff->buffer, 0, + gst_memory_new_wrapped(GST_MEMORY_FLAG_READONLY, buff_data + fixed_size , buffer_size - fixed_size, 0, + buffer_size - fixed_size, buff, NULL)); + + LOGD("set codec data from packet: %" G_GSIZE_FORMAT "", gst_buffer_get_size(buff->buffer)); } } return ret; -- 2.7.4 From a09f5df82c49a296df57212c8fb0b981fcf55f55 Mon Sep 17 00:00:00 2001 From: Sejun Park Date: Fri, 23 Dec 2016 16:49:26 +0900 Subject: [PATCH 11/16] Modified spelling and typo Change-Id: I7db668f373bc55e23217da22205d91e628733800 --- include/media_codec_port_gst.h | 18 +- packaging/capi-media-codec.spec | 2 +- src/media_codec_port_gst.c | 392 ++++++++++++++++++++-------------------- 3 files changed, 205 insertions(+), 207 deletions(-) diff --git a/include/media_codec_port_gst.h b/include/media_codec_port_gst.h index 64536ad..d0aa50d 100755 --- a/include/media_codec_port_gst.h +++ b/include/media_codec_port_gst.h @@ -154,21 +154,21 @@ struct _GstMCBuffer { GstBuffer *buffer; int buf_size; mc_gst_core_t* core; - media_packet_h pkt; + media_packet_h packet; bool has_imgb; }; enum { fill_inbuf, fill_outbuf }; -int __mc_fill_input_buffer(mc_gst_core_t *core, media_packet_h pkt, GstMCBuffer *buff); -int __mc_fill_output_buffer(mc_gst_core_t *core, void *data, int size, media_packet_h *out_pkt); +int __mc_fill_input_buffer(mc_gst_core_t *core, media_packet_h packet, GstMCBuffer *mcbuffer); +int __mc_fill_output_buffer(mc_gst_core_t *core, void *data, int size, media_packet_h *out_packet); -int __mc_fill_input_buffer_with_packet(mc_gst_core_t *core, media_packet_h pkt, GstMCBuffer *buff); -int __mc_fill_input_buffer_with_venc_packet(mc_gst_core_t *core, media_packet_h pkt, GstMCBuffer *mc_buffer); +int __mc_fill_input_buffer_with_packet(mc_gst_core_t *core, media_packet_h packet, GstMCBuffer *mcbuffer); +int __mc_fill_input_buffer_with_venc_packet(mc_gst_core_t *core, media_packet_h packet, GstMCBuffer *mcbuffer); -int __mc_fill_packet_with_output_buffer(mc_gst_core_t *core, void *data, int size, media_packet_h *out_pkt); -int __mc_fill_venc_packet_with_output_buffer(mc_gst_core_t *core, void *data, int size, media_packet_h *out_pkt); -int __mc_fill_vdec_packet_with_output_buffer(mc_gst_core_t *core, void *data, int size, media_packet_h *pkt); +int __mc_fill_packet_with_output_buffer(mc_gst_core_t *core, void *data, int size, media_packet_h *out_packet); +int __mc_fill_venc_packet_with_output_buffer(mc_gst_core_t *core, void *data, int size, media_packet_h *out_packet); +int __mc_fill_vdec_packet_with_output_buffer(mc_gst_core_t *core, void *data, int size, media_packet_h *packet); mc_gst_core_t *mc_gst_core_new(); void mc_gst_core_free(mc_gst_core_t *core); @@ -184,7 +184,7 @@ mc_ret_e mc_gst_get_output(mc_handle_t *mc_handle, media_packet_h *outbuf, uint6 mc_ret_e mc_gst_flush_buffers(mc_handle_t *mc_handle); -mc_ret_e mc_gst_get_packet_pool(mc_handle_t *mc_handle, media_packet_pool_h *pkt_pool); +mc_ret_e mc_gst_get_packet_pool(mc_handle_t *mc_handle, media_packet_pool_h *packet_pool); #ifdef __cplusplus } diff --git a/packaging/capi-media-codec.spec b/packaging/capi-media-codec.spec index 293d7b8..2665e0c 100755 --- a/packaging/capi-media-codec.spec +++ b/packaging/capi-media-codec.spec @@ -1,6 +1,6 @@ Name: capi-media-codec Summary: A Media Codec library in Tizen Native API -Version: 0.5.1 +Version: 0.5.2 Release: 0 Group: Multimedia/API License: Apache-2.0 diff --git a/src/media_codec_port_gst.c b/src/media_codec_port_gst.c index 3a87d42..9d5c3b2 100755 --- a/src/media_codec_port_gst.c +++ b/src/media_codec_port_gst.c @@ -47,22 +47,22 @@ static mc_ret_e _mc_gst_create_pipeline(mc_gst_core_t *core, gchar *factory_name static mc_ret_e _mc_gst_destroy_pipeline(mc_gst_core_t *core); static void __mc_gst_buffer_add(GstElement *element, GstBuffer *buffer, GstPad *pad, gpointer data); static int __mc_output_buffer_finalize_cb(media_packet_h packet, int error_code, void *user_data); -static int _mc_gst_update_caps(mc_gst_core_t *core, GstMCBuffer *buff, bool codec_config); +static int _mc_gst_update_caps(mc_gst_core_t *core, GstMCBuffer *mcbuffer, bool codec_config); static gboolean _mc_update_packet_info(mc_gst_core_t *core, media_format_h fmt); -static GstMCBuffer *_mc_gst_media_packet_to_gstbuffer(mc_gst_core_t *core, media_packet_h pkt, bool codec_config); -static int _mc_gst_gstbuffer_to_appsrc(mc_gst_core_t *core, GstMCBuffer *buff); +static GstMCBuffer *_mc_gst_media_packet_to_gstbuffer(mc_gst_core_t *core, media_packet_h packet, bool codec_config); +static int _mc_gst_gstbuffer_to_appsrc(mc_gst_core_t *core, GstMCBuffer *mcbuffer); static gchar *__mc_get_gst_input_format(media_packet_h packet, bool is_hw); static media_packet_h __mc_gst_make_media_packet(mc_gst_core_t *core, unsigned char *data, int size); static gboolean __mc_gst_bus_callback(GstBus *bus, GstMessage *msg, gpointer data); static GstBusSyncReply __mc_gst_bus_sync_callback(GstBus *bus, GstMessage *msg, gpointer data); -static MMVideoBuffer *__mc_gst_make_tbm_buffer(mc_gst_core_t *core, media_packet_h pkt); -static GstMCBuffer *gst_mediacodec_buffer_new(mc_gst_core_t *core, media_packet_h pkt, uint64_t size); +static MMVideoBuffer *__mc_gst_make_tbm_buffer(mc_gst_core_t *core, media_packet_h packet); +static GstMCBuffer *gst_mediacodec_buffer_new(mc_gst_core_t *core, media_packet_h packet, uint64_t size); static void gst_mediacodec_buffer_finalize(GstMCBuffer *buffer); -static int __mc_set_caps_streamheader(mc_gst_core_t *core, GstMCBuffer *buff, guint streamheader_size); -static int __mc_set_caps_codecdata(mc_gst_core_t *core, GstMCBuffer *buff, guint codecdata_size); -static void __mc_push_output_to_queue(mc_gst_core_t *core, media_packet_h out_pkt); -static int __mc_gst_create_eos_packet(media_format_h fmt, media_packet_h *out_pkt); -static void _mc_gst_handle_input_buffer_used(mc_gst_core_t *core, media_packet_h pkt); +static int __mc_set_caps_streamheader(mc_gst_core_t *core, GstMCBuffer *mcbuffer, guint streamheader_size); +static int __mc_set_caps_codecdata(mc_gst_core_t *core, GstMCBuffer *mcbuffer, guint codecdata_size); +static void __mc_push_output_to_queue(mc_gst_core_t *core, media_packet_h out_packet); +static int __mc_gst_create_eos_packet(media_format_h fmt, media_packet_h *out_packet); +static void _mc_gst_handle_input_buffer_used(mc_gst_core_t *core, media_packet_h packet); static gint __gst_handle_stream_error(mc_gst_core_t *core, GError *error, GstMessage *message); static gint __gst_transform_gsterror(mc_gst_core_t *core, GstMessage *message, GError *error); @@ -165,12 +165,12 @@ int(*adec_wma_vtable[])() = {&__mc_fill_input_buffer_with_packet, /* * fill_inbuf virtual functions */ -int __mc_fill_input_buffer(mc_gst_core_t *core, media_packet_h pkt, GstMCBuffer *buff) +int __mc_fill_input_buffer(mc_gst_core_t *core, media_packet_h packet, GstMCBuffer *mcbuffer) { - return core->vtable[fill_inbuf](core, pkt, buff); + return core->vtable[fill_inbuf](core, packet, mcbuffer); } -int __mc_fill_inbuf_with_mm_video_buffer(mc_gst_core_t *core, media_packet_h pkt, GstMCBuffer *mc_buffer) +int __mc_fill_inbuf_with_mm_video_buffer(mc_gst_core_t *core, media_packet_h packet, GstMCBuffer *mcbuffer) { int ret = MC_ERROR_NONE; @@ -178,65 +178,65 @@ int __mc_fill_inbuf_with_mm_video_buffer(mc_gst_core_t *core, media_packet_h pkt void *buf_data = NULL; uint64_t buf_size = 0; - ret = media_packet_get_buffer_size(pkt, &buf_size); + ret = media_packet_get_buffer_size(packet, &buf_size); if (ret != MEDIA_PACKET_ERROR_NONE) { - LOGW("buffer size get fail"); + LOGW("buffer size get failed"); return MC_ERROR; } - ret = media_packet_get_buffer_data_ptr(pkt, &buf_data); + ret = media_packet_get_buffer_data_ptr(packet, &buf_data); if (ret != MEDIA_PACKET_ERROR_NONE) { - LOGW("buffer data get fail"); + LOGW("buffer data get failed"); return MC_ERROR; } - mm_vbuffer = __mc_gst_make_tbm_buffer(core, mc_buffer->pkt); + mm_vbuffer = __mc_gst_make_tbm_buffer(core, mcbuffer->packet); if (mm_vbuffer != NULL) { - gst_buffer_prepend_memory(mc_buffer->buffer, + gst_buffer_prepend_memory(mcbuffer->buffer, gst_memory_new_wrapped(GST_MEMORY_FLAG_READONLY, mm_vbuffer, sizeof(*mm_vbuffer), 0, sizeof(*mm_vbuffer), mm_vbuffer, free)); - LOGD("scmn_mm_vbuffer is appended, %d, %d", sizeof(*mm_vbuffer), gst_buffer_n_memory(mc_buffer->buffer)); + LOGD("mm_vbuffer appended, %d, %d", sizeof(*mm_vbuffer), gst_buffer_n_memory(mcbuffer->buffer)); } if (buf_data != NULL) { - gst_buffer_prepend_memory(mc_buffer->buffer, + gst_buffer_prepend_memory(mcbuffer->buffer, gst_memory_new_wrapped(GST_MEMORY_FLAG_READONLY, buf_data, buf_size, 0, - buf_size, mc_buffer, (GDestroyNotify)gst_mediacodec_buffer_finalize)); - LOGD("packet data apended, %d, %d", buf_size, gst_buffer_n_memory(mc_buffer->buffer)); + buf_size, mcbuffer, (GDestroyNotify)gst_mediacodec_buffer_finalize)); + LOGD("packet data apended, %d, %d", buf_size, gst_buffer_n_memory(mcbuffer->buffer)); } return ret; } -int __mc_fill_input_buffer_with_packet(mc_gst_core_t *core, media_packet_h pkt, GstMCBuffer *mc_buffer) +int __mc_fill_input_buffer_with_packet(mc_gst_core_t *core, media_packet_h packet, GstMCBuffer *mcbuffer) { int ret = MC_ERROR_NONE; void *buf_data = NULL; uint64_t buf_size = 0; - ret = media_packet_get_buffer_size(pkt, &buf_size); + ret = media_packet_get_buffer_size(packet, &buf_size); if (ret != MEDIA_PACKET_ERROR_NONE) { - LOGW("buffer size get fail"); + LOGW("buffer size get failed"); return MC_ERROR; } - ret = media_packet_get_buffer_data_ptr(pkt, &buf_data); + ret = media_packet_get_buffer_data_ptr(packet, &buf_data); if (ret != MEDIA_PACKET_ERROR_NONE) { - LOGW("buffer data get fail"); + LOGW("buffer data get failed"); return MC_ERROR; } if (buf_data != NULL) { - gst_buffer_append_memory(mc_buffer->buffer, + gst_buffer_append_memory(mcbuffer->buffer, gst_memory_new_wrapped(GST_MEMORY_FLAG_READONLY, buf_data, buf_size, 0, - buf_size, mc_buffer, (GDestroyNotify)gst_mediacodec_buffer_finalize)); + buf_size, mcbuffer, (GDestroyNotify)gst_mediacodec_buffer_finalize)); LOGD("packet data apended"); } return ret; } -int __mc_fill_input_buffer_with_venc_packet(mc_gst_core_t *core, media_packet_h pkt, GstMCBuffer *mc_buffer) +int __mc_fill_input_buffer_with_venc_packet(mc_gst_core_t *core, media_packet_h packet, GstMCBuffer *mcbuffer) { int ret = MC_ERROR_NONE; void *uv_ptr = NULL; @@ -256,88 +256,86 @@ int __mc_fill_input_buffer_with_venc_packet(mc_gst_core_t *core, media_packet_h width = enc_info->width; height = enc_info->height; - ret = media_packet_get_number_of_video_planes(pkt, &plane_num); + ret = media_packet_get_number_of_video_planes(packet, &plane_num); if (ret != MEDIA_PACKET_ERROR_NONE) { LOGW("media_packet_get_number_of_video_planes failed"); return MC_ERROR; } - ret = media_packet_get_video_plane_data_ptr(pkt, 0, &y_ptr); + ret = media_packet_get_video_plane_data_ptr(packet, 0, &y_ptr); if (ret != MEDIA_PACKET_ERROR_NONE) { LOGW("media_packet_get_video_plane_data_ptr failed"); return MC_ERROR; } - ret = media_packet_get_video_stride_width(pkt, 0, &stride_width); + ret = media_packet_get_video_stride_width(packet, 0, &stride_width); if (ret != MEDIA_PACKET_ERROR_NONE) { LOGW("media_packet_get_video_stride_width failed"); return MC_ERROR; } - ret = media_packet_get_video_stride_height(pkt, 0, &stride_height); + ret = media_packet_get_video_stride_height(packet, 0, &stride_height); if (ret != MEDIA_PACKET_ERROR_NONE) { LOGW("media_packet_get_video_stride_width failed"); return MC_ERROR; } if (!core->is_hw) { - if (width == stride_width) { - mc_buffer->buf_size += stride_width * stride_height; + mcbuffer->buf_size += stride_width * stride_height; for (i = 1; i < plane_num; i++) { - media_packet_get_video_plane_data_ptr(pkt, i, &uv_ptr); - media_packet_get_video_stride_width(pkt, i, &stride_width); - media_packet_get_video_stride_height(pkt, i, &stride_height); + media_packet_get_video_plane_data_ptr(packet, i, &uv_ptr); + media_packet_get_video_stride_width(packet, i, &stride_width); + media_packet_get_video_stride_height(packet, i, &stride_height); buf_size = stride_width * stride_height; - memcpy(y_ptr + mc_buffer->buf_size, uv_ptr, buf_size); - mc_buffer->buf_size += buf_size; - LOGD("plane : %d, buf_size : %d, total : %d", i, buf_size, mc_buffer->buf_size); - + memcpy(y_ptr + mcbuffer->buf_size, uv_ptr, buf_size); + mcbuffer->buf_size += buf_size; + LOGD("plane : %d, buf_size : %d, total : %d", i, buf_size, mcbuffer->buf_size); } } else { for (j = 0; j < height; j++) { - memcpy(y_ptr + mc_buffer->buf_size, y_ptr + stride, width); - mc_buffer->buf_size += width; + memcpy(y_ptr + mcbuffer->buf_size, y_ptr + stride, width); + mcbuffer->buf_size += width; stride += stride_width; } stride = 0; for (i = 1; i < plane_num; i++) { - media_packet_get_video_plane_data_ptr(pkt, i, &uv_ptr); - media_packet_get_video_stride_width(pkt, i, &stride_width); - media_packet_get_video_stride_height(pkt, i, &stride_height); + media_packet_get_video_plane_data_ptr(packet, i, &uv_ptr); + media_packet_get_video_stride_width(packet, i, &stride_width); + media_packet_get_video_stride_height(packet, i, &stride_height); for (j = 0; j < height>>1; j++) { - memcpy(y_ptr + mc_buffer->buf_size, uv_ptr + stride, width>>1); - mc_buffer->buf_size += width>>1; + memcpy(y_ptr + mcbuffer->buf_size, uv_ptr + stride, width>>1); + mcbuffer->buf_size += width>>1; stride += stride_width; } - memcpy(y_ptr + mc_buffer->buf_size, uv_ptr, buf_size); - LOGD("plane : %d, buf_size : %d, total : %d", i, buf_size, mc_buffer->buf_size); - mc_buffer->buf_size += buf_size; + memcpy(y_ptr + mcbuffer->buf_size, uv_ptr, buf_size); + LOGD("plane : %d, buf_size : %d, total : %d", i, buf_size, mcbuffer->buf_size); + mcbuffer->buf_size += buf_size; } } } else { MMVideoBuffer *mm_video_buffer = NULL; - mm_video_buffer = __mc_gst_make_tbm_buffer(core, pkt); + mm_video_buffer = __mc_gst_make_tbm_buffer(core, packet); - gst_buffer_prepend_memory(mc_buffer->buffer, + gst_buffer_prepend_memory(mcbuffer->buffer, gst_memory_new_wrapped(GST_MEMORY_FLAG_READONLY, mm_video_buffer, sizeof(MMVideoBuffer), 0, sizeof(MMVideoBuffer), mm_video_buffer, free)); - LOGD("mm_video_buffer is appended, %d, %d", sizeof(MMVideoBuffer), gst_buffer_n_memory(mc_buffer->buffer)); + LOGD("mm_video_buffer appended, %d, %d", sizeof(MMVideoBuffer), gst_buffer_n_memory(mcbuffer->buffer)); } - gst_buffer_prepend_memory(mc_buffer->buffer, - gst_memory_new_wrapped(GST_MEMORY_FLAG_READONLY, y_ptr, mc_buffer->buf_size, 0, - mc_buffer->buf_size, mc_buffer, (GDestroyNotify)gst_mediacodec_buffer_finalize)); + gst_buffer_prepend_memory(mcbuffer->buffer, + gst_memory_new_wrapped(GST_MEMORY_FLAG_READONLY, y_ptr, mcbuffer->buf_size, 0, + mcbuffer->buf_size, mcbuffer, (GDestroyNotify)gst_mediacodec_buffer_finalize)); return ret; } @@ -347,12 +345,12 @@ int __mc_fill_input_buffer_with_venc_packet(mc_gst_core_t *core, media_packet_h * fill_outbuf virtual functions */ -int __mc_fill_output_buffer(mc_gst_core_t *core, void *data, int size, media_packet_h *out_pkt) +int __mc_fill_output_buffer(mc_gst_core_t *core, void *data, int size, media_packet_h *out_packet) { - return core->vtable[fill_outbuf](core, data, size, out_pkt); + return core->vtable[fill_outbuf](core, data, size, out_packet); } -int __mc_fill_vdec_packet_with_output_buffer(mc_gst_core_t *core, void *data, int size, media_packet_h *pkt) +int __mc_fill_vdec_packet_with_output_buffer(mc_gst_core_t *core, void *data, int size, media_packet_h *packet) { int i; int stride_width; @@ -454,37 +452,37 @@ int __mc_fill_vdec_packet_with_output_buffer(mc_gst_core_t *core, void *data, in if (tsurf) { media_packet_create_from_tbm_surface(core->output_fmt, tsurf, - (media_packet_finalize_cb)__mc_output_buffer_finalize_cb, core, pkt); + (media_packet_finalize_cb)__mc_output_buffer_finalize_cb, core, packet); } return MC_ERROR_NONE; } -int __mc_fill_packet_with_output_buffer(mc_gst_core_t *core, void *data, int size, media_packet_h *out_pkt) +int __mc_fill_packet_with_output_buffer(mc_gst_core_t *core, void *data, int size, media_packet_h *out_packet) { - void *pkt_data = NULL; + void *packet_data = NULL; int ret = MC_ERROR_NONE; g_return_val_if_fail(core != NULL, MC_PARAM_ERROR); if (core->encoder && core->codec_id == MEDIACODEC_AAC) media_format_set_audio_aac_type(core->output_fmt, FALSE); - ret = media_packet_create_alloc(core->output_fmt, __mc_output_buffer_finalize_cb, core, out_pkt); + ret = media_packet_create_alloc(core->output_fmt, __mc_output_buffer_finalize_cb, core, out_packet); if (ret != MEDIA_PACKET_ERROR_NONE) { LOGW("media_packet_create_alloc failed"); return MC_ERROR; } - media_packet_set_buffer_size(*out_pkt, size); - media_packet_get_buffer_data_ptr(*out_pkt, &pkt_data); - memcpy(pkt_data, data, size); + media_packet_set_buffer_size(*out_packet, size); + media_packet_get_buffer_data_ptr(*out_packet, &packet_data); + memcpy(packet_data, data, size); return MC_ERROR_NONE; } -int __mc_fill_venc_packet_with_output_buffer(mc_gst_core_t *core, void *data, int size, media_packet_h *out_pkt) +int __mc_fill_venc_packet_with_output_buffer(mc_gst_core_t *core, void *data, int size, media_packet_h *out_packet) { - void *pkt_data = NULL; + void *packet_data = NULL; bool codec_config = FALSE; bool sync_flag = FALSE; bool slice = FALSE; @@ -512,15 +510,15 @@ int __mc_fill_venc_packet_with_output_buffer(mc_gst_core_t *core, void *data, in } LOGD("codec_config : %d, sync_flag : %d, slice : %d", codec_config, sync_flag, slice); - ret = media_packet_create_alloc(core->output_fmt, __mc_output_buffer_finalize_cb, core, out_pkt); + ret = media_packet_create_alloc(core->output_fmt, __mc_output_buffer_finalize_cb, core, out_packet); if (ret != MEDIA_PACKET_ERROR_NONE) { LOGW("media_packet_create_alloc failed"); return MC_ERROR; } - media_packet_set_buffer_size(*out_pkt, size); - media_packet_get_buffer_data_ptr(*out_pkt, &pkt_data); - memcpy(pkt_data, data, size); + media_packet_set_buffer_size(*out_packet, size); + media_packet_get_buffer_data_ptr(*out_packet, &packet_data); + memcpy(packet_data, data, size); core->need_sync_flag = sync_flag ? 1 : 0; core->need_codec_data = codec_config ? 1 : 0; @@ -563,7 +561,7 @@ static GstCaps *__mc_gst_caps_set_buffer_array(GstCaps * caps, const gchar * nam return caps; } -int __mc_set_caps_streamheader(mc_gst_core_t *core, GstMCBuffer*buff, guint streamheader_size) +int __mc_set_caps_streamheader(mc_gst_core_t *core, GstMCBuffer *mcbuffer, guint streamheader_size) { int ret = MEDIA_PACKET_ERROR_NONE; void *buf_data = NULL; @@ -574,15 +572,15 @@ int __mc_set_caps_streamheader(mc_gst_core_t *core, GstMCBuffer*buff, guint stre guint8 *tmp_buf = NULL; GstMapInfo map; - ret = media_packet_get_buffer_size(buff->pkt, &buf_size); + ret = media_packet_get_buffer_size(mcbuffer->packet, &buf_size); if (ret != MEDIA_PACKET_ERROR_NONE) { - LOGW("buffer size get fail"); + LOGW("buffer size get failed"); return ret; } - ret = media_packet_get_buffer_data_ptr(buff->pkt, &buf_data); + ret = media_packet_get_buffer_data_ptr(mcbuffer->packet, &buf_data); if (ret != MEDIA_PACKET_ERROR_NONE) { - LOGW("buffer data get fail"); + LOGW("buffer data get failed"); return ret; } @@ -712,23 +710,23 @@ int __mc_set_caps_streamheader(mc_gst_core_t *core, GstMCBuffer*buff, guint stre } /* Update gstbuffer's data ptr and size for using previous streamheader.*/ - LOGD("BEFORE : buff->buffer of size %" G_GSIZE_FORMAT "", gst_buffer_get_size(buff->buffer)); - gst_buffer_remove_memory_range(buff->buffer, streamheader_size, -1); - gst_buffer_set_size(buff->buffer, buf_size - streamheader_size); - LOGD("AFTER : buff->buffer of size %" G_GSIZE_FORMAT "", gst_buffer_get_size(buff->buffer)); + LOGD("BEFORE : mcbuffer->buffer of size %" G_GSIZE_FORMAT "", gst_buffer_get_size(mcbuffer->buffer)); + gst_buffer_remove_memory_range(mcbuffer->buffer, streamheader_size, -1); + gst_buffer_set_size(mcbuffer->buffer, buf_size - streamheader_size); + LOGD("AFTER : mcbuffer->buffer of size %" G_GSIZE_FORMAT "", gst_buffer_get_size(mcbuffer->buffer)); return ret; } -int __mc_get_codecdata_size(mc_gst_core_t *core, GstMCBuffer *buff, unsigned int *size) +int __mc_get_codecdata_size(mc_gst_core_t *core, GstMCBuffer *mcbuffer, unsigned int *size) { void *data = NULL; uint64_t data_size = 0; uint64_t codec_size = 0; int ret = MC_ERROR_NONE; - media_packet_get_buffer_size(buff->pkt, &data_size); - media_packet_get_buffer_data_ptr(buff->pkt, &data); + media_packet_get_buffer_size(mcbuffer->packet, &data_size); + media_packet_get_buffer_data_ptr(mcbuffer->packet, &data); switch (core->codec_id) { case MEDIACODEC_H264: @@ -757,7 +755,7 @@ int __mc_get_codecdata_size(mc_gst_core_t *core, GstMCBuffer *buff, unsigned int return ret; } -int __mc_set_caps_codecdata(mc_gst_core_t *core, GstMCBuffer *buff, guint fixed_size) +int __mc_set_caps_codecdata(mc_gst_core_t *core, GstMCBuffer *mcbuffer, guint fixed_size) { int ret = MC_ERROR_NONE; void *codec_data = NULL; @@ -766,7 +764,7 @@ int __mc_set_caps_codecdata(mc_gst_core_t *core, GstMCBuffer *buff, guint fixed_ guint8 *data = NULL; GstMapInfo map; - media_packet_get_codec_data(buff->pkt, &codec_data, &codec_data_size); + media_packet_get_codec_data(mcbuffer->packet, &codec_data, &codec_data_size); if (codec_data != NULL) { /* get the codec data from media_packet_get_codec_data() */ data = g_malloc0(codec_data_size); @@ -779,25 +777,25 @@ int __mc_set_caps_codecdata(mc_gst_core_t *core, GstMCBuffer *buff, guint fixed_ uint64_t buffer_size = 0; void *buff_data = NULL; - media_packet_get_buffer_size(buff->pkt, &buffer_size); - media_packet_get_buffer_data_ptr(buff->pkt, &buff_data); + media_packet_get_buffer_size(mcbuffer->packet, &buffer_size); + media_packet_get_buffer_data_ptr(mcbuffer->packet, &buff_data); /* For audio, it's necessary to change the offset value of buffer after extracting csd */ /* it's not necessary to set csd to caps in case of annex-b */ if (buffer_size > fixed_size) { data = g_malloc0(fixed_size); - gst_buffer_map(buff->buffer, &map, GST_MAP_READ); + gst_buffer_map(mcbuffer->buffer, &map, GST_MAP_READ); memcpy(data, map.data, fixed_size); codecdata_buffer = gst_buffer_new_wrapped(data, fixed_size); - gst_buffer_unmap(buff->buffer, &map); + gst_buffer_unmap(mcbuffer->buffer, &map); gst_caps_set_simple(core->caps, "codec_data", GST_TYPE_BUFFER, codecdata_buffer, NULL); gst_buffer_unref(codecdata_buffer); - gst_buffer_replace_memory(buff->buffer, 0, + gst_buffer_replace_memory(mcbuffer->buffer, 0, gst_memory_new_wrapped(GST_MEMORY_FLAG_READONLY, buff_data + fixed_size , buffer_size - fixed_size, 0, - buffer_size - fixed_size, buff, NULL)); + buffer_size - fixed_size, mcbuffer, NULL)); - LOGD("set codec data from packet: %" G_GSIZE_FORMAT "", gst_buffer_get_size(buff->buffer)); + LOGD("set codec data from packet: %" G_GSIZE_FORMAT "", gst_buffer_get_size(mcbuffer->buffer)); } } return ret; @@ -921,7 +919,7 @@ void mc_gst_core_free(mc_gst_core_t *core) core->ports[1] = NULL; } - LOGD("gst_core(%p) is destroyed", core); + LOGD("gst_core(%p) destroyed", core); g_free(core); MEDIACODEC_FLEAVE(); @@ -946,7 +944,7 @@ mc_gst_port_t *mc_gst_port_new(mc_gst_core_t *core) g_mutex_init(&port->mutex); port->queue = g_queue_new(); - LOGD("gst_port(%p) is created", port); + LOGD("gst_port(%p) created", port); MEDIACODEC_FLEAVE(); return port; @@ -959,7 +957,7 @@ void mc_gst_port_free(mc_gst_port_t *port) g_mutex_clear(&port->mutex); g_queue_free(port->queue); - LOGD("gst_port(%p) is freed", port); + LOGD("gst_port(%p) freed", port); g_free(port); MEDIACODEC_FLEAVE(); @@ -1026,12 +1024,12 @@ gboolean _mc_update_packet_info(mc_gst_core_t *core, media_format_h fmt) return is_updated; } -static int _mc_gst_update_caps(mc_gst_core_t *core, GstMCBuffer *buff, bool codec_config) +static int _mc_gst_update_caps(mc_gst_core_t *core, GstMCBuffer *mcbuffer, bool codec_config) { MEDIACODEC_FENTER(); g_return_val_if_fail(core != NULL, MC_PARAM_ERROR); - g_return_val_if_fail(buff != NULL, MC_PARAM_ERROR); + g_return_val_if_fail(mcbuffer != NULL, MC_PARAM_ERROR); int ret = MC_ERROR_NONE; @@ -1039,7 +1037,7 @@ static int _mc_gst_update_caps(mc_gst_core_t *core, GstMCBuffer *buff, bool code if (core->encoder) { mc_encoder_info_t *enc_info = (mc_encoder_info_t *)core->codec_info; - core->format = __mc_get_gst_input_format(buff->pkt, core->is_hw); + core->format = __mc_get_gst_input_format(mcbuffer->packet, core->is_hw); gst_caps_set_simple(core->caps, "format", G_TYPE_STRING, core->format, "width", G_TYPE_INT, enc_info->width, @@ -1060,7 +1058,7 @@ static int _mc_gst_update_caps(mc_gst_core_t *core, GstMCBuffer *buff, bool code "height", G_TYPE_INT, dec_info->height, NULL); - ret = __mc_set_caps_codecdata(core, buff, CODECDATA_NOT_USE); + ret = __mc_set_caps_codecdata(core, mcbuffer, CODECDATA_NOT_USE); if (ret != MC_ERROR_NONE) { LOGW("__mc_set_caps_codecdata failed"); } @@ -1087,7 +1085,7 @@ static int _mc_gst_update_caps(mc_gst_core_t *core, GstMCBuffer *buff, bool code case MEDIACODEC_AAC: case MEDIACODEC_AAC_HE: case MEDIACODEC_AAC_HE_PS: - ret = __mc_set_caps_codecdata(core, buff, AAC_CODECDATA_SIZE); + ret = __mc_set_caps_codecdata(core, mcbuffer, AAC_CODECDATA_SIZE); if (ret != MC_ERROR_NONE) { LOGW("__mc_set_caps_codecdata failed"); } @@ -1096,14 +1094,14 @@ static int _mc_gst_update_caps(mc_gst_core_t *core, GstMCBuffer *buff, bool code case MEDIACODEC_WMAV2: case MEDIACODEC_WMAPRO: case MEDIACODEC_WMALSL: - ret = __mc_set_caps_codecdata(core, buff, WMA_CODECDATA_SIZE); + ret = __mc_set_caps_codecdata(core, mcbuffer, WMA_CODECDATA_SIZE); if (ret != MC_ERROR_NONE) { LOGW("__mc_set_caps_codecdata failed"); } break; case MEDIACODEC_VORBIS: case MEDIACODEC_FLAC: - ret = __mc_set_caps_streamheader(core, buff, VORBIS_CODECDATA_SIZE); + ret = __mc_set_caps_streamheader(core, mcbuffer, VORBIS_CODECDATA_SIZE); if (ret != MC_ERROR_NONE) { LOGW("__mc_set_caps_streamheader failed"); } @@ -1130,7 +1128,7 @@ static gpointer feed_task(gpointer data) bool eos = FALSE; media_format_h fmt = NULL; media_packet_h in_buf = NULL; - GstMCBuffer *buff = NULL; + GstMCBuffer *mcbuffer = NULL; bool initiative = true; MEDIACODEC_FENTER(); @@ -1171,12 +1169,12 @@ static gpointer feed_task(gpointer data) goto LEAVE; } - buff = _mc_gst_media_packet_to_gstbuffer(core, in_buf, codec_config); - if (!buff) { + mcbuffer = _mc_gst_media_packet_to_gstbuffer(core, in_buf, codec_config); + if (!mcbuffer) { LOGW("gstbuffer can't make"); goto ERROR; } - /* buff took the ownership of the in_buf, so set in_buf to NULL to aviod double unref */ + /* mcbuffer took the ownership of the in_buf, so set in_buf to NULL to aviod double unref */ in_buf = NULL; if (codec_config) @@ -1185,11 +1183,11 @@ static gpointer feed_task(gpointer data) if (initiative) { GstPad *pad; - ret = _mc_gst_update_caps(core, buff, codec_config); + ret = _mc_gst_update_caps(core, mcbuffer, codec_config); if (ret != MC_ERROR_NONE) { LOGE("failed to update caps"); - /* unref buff->buffer will invoke the finalize() of GstMcBuffer */ - gst_buffer_unref(buff->buffer); + /* unref mcbuff->buffer will invoke the finalize() of GstMcBuffer */ + gst_buffer_unref(mcbuffer->buffer); goto ERROR; } @@ -1201,7 +1199,7 @@ static gpointer feed_task(gpointer data) } /* inject buffer */ - ret = _mc_gst_gstbuffer_to_appsrc(core, buff); + ret = _mc_gst_gstbuffer_to_appsrc(core, mcbuffer); if (ret != GST_FLOW_OK) { LOGE("Failed to push gst buffer"); goto ERROR; @@ -1490,16 +1488,16 @@ static int _mc_link_vtable(mc_gst_core_t *core, mediacodec_codec_type_e id, gboo return MC_ERROR_NONE; } -static int _mc_gst_gstbuffer_to_appsrc(mc_gst_core_t *core, GstMCBuffer *buff) +static int _mc_gst_gstbuffer_to_appsrc(mc_gst_core_t *core, GstMCBuffer *mcbuffer) { MEDIACODEC_FENTER(); int ret = MC_ERROR_NONE; LOGD("pushed buffer to appsrc : %p, buffer of size %" G_GSIZE_FORMAT "", - buff->buffer, gst_buffer_get_size(buff->buffer)); + mcbuffer->buffer, gst_buffer_get_size(mcbuffer->buffer)); - ret = gst_app_src_push_buffer(GST_APP_SRC(core->appsrc), buff->buffer); + ret = gst_app_src_push_buffer(GST_APP_SRC(core->appsrc), mcbuffer->buffer); return ret; } @@ -1714,7 +1712,7 @@ mc_ret_e mc_gst_get_output(mc_handle_t *mc_handle, media_packet_h *outbuf, uint6 int ret = MC_ERROR_NONE; mc_gst_core_t *core = NULL; - media_packet_h out_pkt = NULL; + media_packet_h out_packet = NULL; gint64 end_time = -1; gboolean signalled; @@ -1735,14 +1733,14 @@ mc_ret_e mc_gst_get_output(mc_handle_t *mc_handle, media_packet_h *outbuf, uint6 } if (signalled) - out_pkt = g_queue_pop_head(core->ports[1]->queue); + out_packet = g_queue_pop_head(core->ports[1]->queue); else { LOGW("Failed to get buffer"); ret = MC_OUTPUT_BUFFER_EMPTY; } - *outbuf = out_pkt; - LOGI("@%p v(%d)e(%d) got buffer :%p", core, core->video, core->encoder, out_pkt); + *outbuf = out_packet; + LOGI("@%p v(%d)e(%d) got buffer :%p", core, core->video, core->encoder, out_packet); g_mutex_unlock(&core->ports[1]->mutex); @@ -2031,17 +2029,17 @@ STATE_CHANGE_FAILED: return MC_ERROR; } -void __mc_push_output_to_queue(mc_gst_core_t *core, media_packet_h out_pkt) +void __mc_push_output_to_queue(mc_gst_core_t *core, media_packet_h out_packet) { g_mutex_lock(&core->ports[1]->mutex); /* push it to output buffer queue */ - g_queue_push_tail(core->ports[1]->queue, out_pkt); + g_queue_push_tail(core->ports[1]->queue, out_packet); g_cond_broadcast(&core->out_buffer_cond); g_atomic_int_inc(&core->ftb_count); GstBuffer *buffer = NULL; - media_packet_get_extra(out_pkt, (void**)&buffer); + media_packet_get_extra(out_packet, (void**)&buffer); if (buffer) { LOGD("dq : v(%d)e(%d) %d TIMESTAMP = %"GST_TIME_FORMAT " DURATION = %"GST_TIME_FORMAT, core->video, core->encoder, core->ftb_count, GST_TIME_ARGS(GST_BUFFER_TIMESTAMP(buffer)), GST_TIME_ARGS(GST_BUFFER_DURATION(buffer))); @@ -2053,7 +2051,7 @@ void __mc_push_output_to_queue(mc_gst_core_t *core, media_packet_h out_pkt) if (core->user_cb[_MEDIACODEC_EVENT_TYPE_FILLBUFFER]) { ((mc_fill_buffer_cb) core->user_cb[_MEDIACODEC_EVENT_TYPE_FILLBUFFER]) - (out_pkt, core->user_data[_MEDIACODEC_EVENT_TYPE_FILLBUFFER]); + (out_packet, core->user_data[_MEDIACODEC_EVENT_TYPE_FILLBUFFER]); } } @@ -2062,7 +2060,7 @@ void __mc_gst_buffer_add(GstElement *element, GstBuffer *buffer, GstPad *pad, gp guint n; GstMemory *mem; GstMapInfo map = GST_MAP_INFO_INIT; - media_packet_h out_pkt = NULL; + media_packet_h out_packet = NULL; MEDIACODEC_FENTER(); @@ -2077,27 +2075,27 @@ void __mc_gst_buffer_add(GstElement *element, GstBuffer *buffer, GstPad *pad, gp gst_memory_map(mem, &map, GST_MAP_READ); LOGD("n : %d, map.data : %p, map.size : %d", n, map.data, map.size); - out_pkt = __mc_gst_make_media_packet(core, map.data, map.size); + out_packet = __mc_gst_make_media_packet(core, map.data, map.size); - LOGI("@%p(%d) out_pkt : %p", core, core->encoder, out_pkt); + LOGI("@%p(%d) out_packet : %p", core, core->encoder, out_packet); gst_memory_unmap(mem, &map); - if (out_pkt) { - media_packet_set_extra(out_pkt, buffer); - media_packet_set_pts(out_pkt, GST_BUFFER_TIMESTAMP(buffer)); - media_packet_set_duration(out_pkt, GST_BUFFER_DURATION(buffer)); + if (out_packet) { + media_packet_set_extra(out_packet, buffer); + media_packet_set_pts(out_packet, GST_BUFFER_TIMESTAMP(buffer)); + media_packet_set_duration(out_packet, GST_BUFFER_DURATION(buffer)); if (core->need_codec_data) { - media_packet_set_flags(out_pkt, MEDIA_PACKET_CODEC_CONFIG); + media_packet_set_flags(out_packet, MEDIA_PACKET_CODEC_CONFIG); core->need_codec_data = false; } if (core->need_sync_flag) { - media_packet_set_flags(out_pkt, MEDIA_PACKET_SYNC_FRAME); + media_packet_set_flags(out_packet, MEDIA_PACKET_SYNC_FRAME); core->need_sync_flag = false; } - __mc_push_output_to_queue(core, out_pkt); + __mc_push_output_to_queue(core, out_packet); } else { gst_buffer_unref(buffer); LOGE("Failed to dequeue output packet"); @@ -2190,74 +2188,74 @@ gchar *__mc_get_gst_input_format(media_packet_h packet, bool is_hw) return format; } -GstMCBuffer *_mc_gst_media_packet_to_gstbuffer(mc_gst_core_t *core, media_packet_h pkt, bool codec_config) +GstMCBuffer *_mc_gst_media_packet_to_gstbuffer(mc_gst_core_t *core, media_packet_h packet, bool codec_config) { int ret = MEDIA_PACKET_ERROR_NONE; - GstMCBuffer *mc_buffer = NULL; + GstMCBuffer *mcbuffer = NULL; void *buf_data = NULL; uint64_t buf_size = 0; uint64_t pts = 0; uint64_t dur = 0; - ret = media_packet_get_buffer_size(pkt, &buf_size); + ret = media_packet_get_buffer_size(packet, &buf_size); if (ret != MEDIA_PACKET_ERROR_NONE) { LOGW("buffer size get fail"); return NULL; } - ret = media_packet_get_buffer_data_ptr(pkt, &buf_data); + ret = media_packet_get_buffer_data_ptr(packet, &buf_data); if (ret != MEDIA_PACKET_ERROR_NONE) { LOGW("buffer data get fail"); return NULL; } - mc_buffer = gst_mediacodec_buffer_new(core, pkt, buf_size); - if (mc_buffer == NULL) { + mcbuffer = gst_mediacodec_buffer_new(core, packet, buf_size); + if (mcbuffer == NULL) { LOGW("failed to create inbuf"); return NULL; } - LOGD("pkt :v(%d)e(%d) %p, buf_size : %d", core->video, core->encoder, pkt, (int)buf_size); + LOGD("packet :v(%d)e(%d) %p, buf_size : %d", core->video, core->encoder, packet, (int)buf_size); - ret = __mc_fill_input_buffer(core, pkt, mc_buffer); + ret = __mc_fill_input_buffer(core, packet, mcbuffer); if (ret != MC_ERROR_NONE) { LOGW("failed to fill inbuf: %s (ox%08x)", _mc_error_to_string(ret), ret); /* - * if __mc_fill_input_buffer() failed, no memory appended to mc_buffer->buffer, so gst_mediacodec_buffer_finalize() + * if __mc_fill_input_buffer() failed, no memory appended to mcbuffer->buffer, so gst_mediacodec_buffer_finalize() * will not be invoked */ - gst_buffer_unref(mc_buffer->buffer); - free(mc_buffer); + gst_buffer_unref(mcbuffer->buffer); + free(mcbuffer); return NULL; } /* pts */ - media_packet_get_pts(pkt, &pts); - GST_BUFFER_PTS(mc_buffer->buffer) = pts; + media_packet_get_pts(packet, &pts); + GST_BUFFER_PTS(mcbuffer->buffer) = pts; /* duration */ - media_packet_get_duration(pkt, &dur); - GST_BUFFER_DURATION(mc_buffer->buffer) = dur; + media_packet_get_duration(packet, &dur); + GST_BUFFER_DURATION(mcbuffer->buffer) = dur; - return mc_buffer; + return mcbuffer; } media_packet_h __mc_gst_make_media_packet(mc_gst_core_t *core, unsigned char *data, int size) { int ret = MEDIA_PACKET_ERROR_NONE; - media_packet_h pkt = NULL; + media_packet_h packet = NULL; - ret = __mc_fill_output_buffer(core, data, size, &pkt); + ret = __mc_fill_output_buffer(core, data, size, &packet); if (ret != MC_ERROR_NONE) { LOGW("failed to fill outbuf: %s (ox%08x)", _mc_error_to_string(ret), ret); return NULL; } - return pkt; + return packet; } -int __mc_gst_create_eos_packet(media_format_h fmt, media_packet_h *out_pkt) +int __mc_gst_create_eos_packet(media_format_h fmt, media_packet_h *out_packet) { media_packet_h mediabuf = NULL; int ret = MC_ERROR_NONE; @@ -2275,29 +2273,29 @@ int __mc_gst_create_eos_packet(media_format_h fmt, media_packet_h *out_pkt) goto ERROR; } - *out_pkt = mediabuf; + *out_packet = mediabuf; MEDIACODEC_FLEAVE(); return ret; ERROR: if (mediabuf) media_packet_destroy(mediabuf); - *out_pkt = NULL; + *out_packet = NULL; MEDIACODEC_FLEAVE(); return ret; } -void _mc_gst_handle_input_buffer_used(mc_gst_core_t *core, media_packet_h pkt) +void _mc_gst_handle_input_buffer_used(mc_gst_core_t *core, media_packet_h packet) { g_atomic_int_dec_and_test(&core->etb_count); if (core && core->user_cb[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER]) { ((mc_empty_buffer_cb)core->user_cb[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER]) - (pkt, core->user_data[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER]); + (packet, core->user_data[_MEDIACODEC_EVENT_TYPE_EMPTYBUFFER]); } if (core) - LOGD("@v(%d)e(%d) input port emptied buffer(%d): %p", core->video, core->encoder, core->etb_count, pkt); + LOGD("@v(%d)e(%d) input port emptied buffer(%d): %p", core->video, core->encoder, core->etb_count, packet); } gboolean __mc_gst_bus_callback(GstBus *bus, GstMessage *msg, gpointer data) @@ -2311,9 +2309,9 @@ gboolean __mc_gst_bus_callback(GstBus *bus, GstMessage *msg, gpointer data) case GST_MESSAGE_EOS: _mc_send_eos_signal(core); - media_packet_h out_pkt = NULL; - if (MC_ERROR_NONE == __mc_gst_create_eos_packet(core->output_fmt, &out_pkt)) { - __mc_push_output_to_queue(core, out_pkt); + media_packet_h out_packet = NULL; + if (MC_ERROR_NONE == __mc_gst_create_eos_packet(core->output_fmt, &out_packet)) { + __mc_push_output_to_queue(core, out_packet); LOGD("send eos packet."); } else { LOGE("failed to create eos packet."); @@ -2426,7 +2424,7 @@ static GstBusSyncReply __mc_gst_bus_sync_callback(GstBus *bus, GstMessage *msg, return reply; } -static MMVideoBuffer *__mc_gst_make_tbm_buffer(mc_gst_core_t *core, media_packet_h pkt) +static MMVideoBuffer *__mc_gst_make_tbm_buffer(mc_gst_core_t *core, media_packet_h packet) { int i; int num_bos; @@ -2434,7 +2432,7 @@ static MMVideoBuffer *__mc_gst_make_tbm_buffer(mc_gst_core_t *core, media_packet tbm_surface_info_s surface_info; tbm_bo_handle handle_bo; - if (!pkt) { + if (!packet) { LOGE("output is null"); return NULL; } @@ -2447,7 +2445,7 @@ static MMVideoBuffer *__mc_gst_make_tbm_buffer(mc_gst_core_t *core, media_packet } memset(mm_vbuffer, 0x00, sizeof(MMVideoBuffer)); - media_packet_get_tbm_surface(pkt, &surface); + media_packet_get_tbm_surface(packet, &surface); num_bos = tbm_surface_internal_get_num_bos(surface); int err = tbm_surface_get_info((tbm_surface_h)surface, &surface_info); if (err != TBM_SURFACE_ERROR_NONE) { @@ -2507,44 +2505,44 @@ static MMVideoBuffer *__mc_gst_make_tbm_buffer(mc_gst_core_t *core, media_packet return mm_vbuffer; } -static void gst_mediacodec_buffer_finalize(GstMCBuffer *mc_buffer) +static void gst_mediacodec_buffer_finalize(GstMCBuffer *mcbuffer) { MEDIACODEC_FENTER(); - if (!mc_buffer) + if (!mcbuffer) return; - mc_gst_core_t *core = (mc_gst_core_t *)mc_buffer->core; + mc_gst_core_t *core = (mc_gst_core_t *)mcbuffer->core; - _mc_gst_handle_input_buffer_used(core, mc_buffer->pkt); + _mc_gst_handle_input_buffer_used(core, mcbuffer->packet); - free(mc_buffer); - mc_buffer = NULL; + free(mcbuffer); + mcbuffer = NULL; MEDIACODEC_FLEAVE(); return; } -static GstMCBuffer *gst_mediacodec_buffer_new(mc_gst_core_t *core, media_packet_h pkt, uint64_t size) +static GstMCBuffer *gst_mediacodec_buffer_new(mc_gst_core_t *core, media_packet_h packet, uint64_t size) { - GstMCBuffer *mc_buffer = NULL; + GstMCBuffer *mcbuffer = NULL; - mc_buffer = (GstMCBuffer *)malloc(sizeof(*mc_buffer)); + mcbuffer = (GstMCBuffer *)malloc(sizeof(*mcbuffer)); - if (mc_buffer == NULL) { + if (mcbuffer == NULL) { LOGE("malloc fail"); return NULL; } - mc_buffer->buffer = gst_buffer_new(); - mc_buffer->buf_size = 0; + mcbuffer->buffer = gst_buffer_new(); + mcbuffer->buf_size = 0; - LOGD("creating buffer : %p, %p", mc_buffer, mc_buffer->buffer); - mc_buffer->core = core; - mc_buffer->pkt = pkt; + LOGD("creating buffer : %p, %p", mcbuffer, mcbuffer->buffer); + mcbuffer->core = core; + mcbuffer->packet = packet; - return mc_buffer; + return mcbuffer; } static gint __gst_handle_core_error(mc_gst_core_t *core, int code) @@ -2738,17 +2736,17 @@ static int _mc_gst_flush_buffers(mc_gst_core_t *core) static void _mc_gst_set_flush_input(mc_gst_core_t *core) { - media_packet_h pkt = NULL; + media_packet_h packet = NULL; MEDIACODEC_FENTER(); - LOGI("_mc_gst_set_flush_input is called"); + LOGI("_mc_gst_set_flush_input called"); while (!mc_async_queue_is_empty(core->available_queue->input)) { - pkt = mc_async_queue_pop_forced(core->available_queue->input); + packet = mc_async_queue_pop_forced(core->available_queue->input); g_atomic_int_dec_and_test(&core->etb_count); - LOGD("%p poped(%d)", pkt, core->etb_count); + LOGD("%p poped(%d)", packet, core->etb_count); - _mc_gst_handle_input_buffer_used(core, pkt); + _mc_gst_handle_input_buffer_used(core, packet); } mc_async_queue_flush(core->available_queue->input); @@ -2757,19 +2755,19 @@ static void _mc_gst_set_flush_input(mc_gst_core_t *core) static void _mc_gst_set_flush_output(mc_gst_core_t *core) { - media_packet_h pkt = NULL; + media_packet_h packet = NULL; MEDIACODEC_FENTER(); g_mutex_lock(&core->ports[1]->mutex); while (!g_queue_is_empty(core->ports[1]->queue)) { - pkt = g_queue_pop_head(core->ports[1]->queue); + packet = g_queue_pop_head(core->ports[1]->queue); g_atomic_int_dec_and_test(&core->ftb_count); - LOGD("%p poped(%d)", pkt, core->ftb_count); - if (pkt) { - media_packet_destroy(pkt); - LOGD("outpkt destroyed"); - pkt = NULL; + LOGD("%p poped(%d)", packet, core->ftb_count); + if (packet) { + media_packet_destroy(packet); + LOGD("outpacket destroyed"); + packet = NULL; } } g_mutex_unlock(&core->ports[1]->mutex); @@ -3215,7 +3213,7 @@ int _mediacodec_get_mime(mc_gst_core_t *core) return mime; } -mc_ret_e mc_gst_get_packet_pool(mc_handle_t *mc_handle, media_packet_pool_h *pkt_pool) +mc_ret_e mc_gst_get_packet_pool(mc_handle_t *mc_handle, media_packet_pool_h *packet_pool) { int curr_size; int max_size, min_size; @@ -3293,6 +3291,6 @@ mc_ret_e mc_gst_get_packet_pool(mc_handle_t *mc_handle, media_packet_pool_h *pkt media_packet_pool_get_size(pool, &min_size, &max_size, &curr_size); LOGD("curr_size is %d min_size is %d and max_size is %d \n", curr_size, min_size, max_size); - *pkt_pool = pool; + *packet_pool = pool; return MC_ERROR_NONE; } -- 2.7.4 From 51c0b73aa8332c36d2f4a325c8e75b2d7316475d Mon Sep 17 00:00:00 2001 From: Sejun Park Date: Tue, 27 Dec 2016 14:15:06 +0900 Subject: [PATCH 12/16] fixed svace issue Change-Id: I9e66e28b513f7f0de72509dee5681b391a4e426c --- packaging/capi-media-codec.spec | 2 +- src/media_codec_port_gst.c | 37 ------------------------------------- 2 files changed, 1 insertion(+), 38 deletions(-) diff --git a/packaging/capi-media-codec.spec b/packaging/capi-media-codec.spec index 2665e0c..1646be8 100755 --- a/packaging/capi-media-codec.spec +++ b/packaging/capi-media-codec.spec @@ -1,7 +1,7 @@ Name: capi-media-codec Summary: A Media Codec library in Tizen Native API Version: 0.5.2 -Release: 0 +Release: 1 Group: Multimedia/API License: Apache-2.0 Source0: %{name}-%{version}.tar.gz diff --git a/src/media_codec_port_gst.c b/src/media_codec_port_gst.c index 9d5c3b2..71a3749 100755 --- a/src/media_codec_port_gst.c +++ b/src/media_codec_port_gst.c @@ -718,43 +718,6 @@ int __mc_set_caps_streamheader(mc_gst_core_t *core, GstMCBuffer *mcbuffer, guint return ret; } -int __mc_get_codecdata_size(mc_gst_core_t *core, GstMCBuffer *mcbuffer, unsigned int *size) -{ - void *data = NULL; - uint64_t data_size = 0; - uint64_t codec_size = 0; - int ret = MC_ERROR_NONE; - - media_packet_get_buffer_size(mcbuffer->packet, &data_size); - media_packet_get_buffer_data_ptr(mcbuffer->packet, &data); - - switch (core->codec_id) { - case MEDIACODEC_H264: - codec_size = _mc_get_h264_codecdata_size(data, data_size); - break; - case MEDIACODEC_H263: - /* Not need codec data */ - codec_size = 0; - break; - case MEDIACODEC_MPEG4: - codec_size = _mc_check_mpeg4_out_bytestream(data, data_size, NULL, NULL); - break; - default: - LOGE("Current not support yet (0x%x) !", core->codec_id); - return MC_NOT_SUPPORTED; - break; - } - - if (codec_size < 0) { - LOGE("No valid codec data!"); - ret = MC_INVALID_IN_BUF; - } - - *size = codec_size; - - return ret; -} - int __mc_set_caps_codecdata(mc_gst_core_t *core, GstMCBuffer *mcbuffer, guint fixed_size) { int ret = MC_ERROR_NONE; -- 2.7.4 From da85c67174746c8e92925d2fe60dc0f96844881f Mon Sep 17 00:00:00 2001 From: Sejun Park Date: Tue, 10 Jan 2017 18:49:51 +0900 Subject: [PATCH 13/16] fixed build errors due to toolchain upgrade Change-Id: I7fce705cb33d0a3594bc2ce67c8054d96b960018 --- packaging/capi-media-codec.spec | 4 ++-- src/media_codec.c | 3 ++- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/packaging/capi-media-codec.spec b/packaging/capi-media-codec.spec index 1646be8..a7c5699 100755 --- a/packaging/capi-media-codec.spec +++ b/packaging/capi-media-codec.spec @@ -1,7 +1,7 @@ Name: capi-media-codec Summary: A Media Codec library in Tizen Native API -Version: 0.5.2 -Release: 1 +Version: 0.5.3 +Release: 0 Group: Multimedia/API License: Apache-2.0 Source0: %{name}-%{version}.tar.gz diff --git a/src/media_codec.c b/src/media_codec.c index 22cd3d8..45d9454 100755 --- a/src/media_codec.c +++ b/src/media_codec.c @@ -337,7 +337,8 @@ int mediacodec_get_supported_type(mediacodec_h mediacodec, mediacodec_codec_type return __convert_error_code(ret, (char *)__FUNCTION__); else handle->state = MEDIACODEC_STATE_IDLE; - return MEDIACODEC_ERROR_NONE; + + return MEDIACODEC_ERROR_NONE; } int mediacodec_set_input_buffer_used_cb(mediacodec_h mediacodec, mediacodec_input_buffer_used_cb callback, void *user_data) -- 2.7.4 From 95852af79c8874943469ac7f6e18ef0edc65cb90 Mon Sep 17 00:00:00 2001 From: "hk57.kim" Date: Fri, 17 Feb 2017 14:53:43 +0900 Subject: [PATCH 14/16] [4.0] Remove Target_Name Dependency - This is for Tizen 4.0 - We are going to unify repositories as well as build projects. - When you SR this, you need to create JIRA-TRE issue of: : add capi-media-codec-extension-TM1 for TM1 (mobile) (It's add, not replace.) Change-Id: I8c1f38e25323c69ad6dfb41b4a1fdd959df274fb Signed-off-by: hk57.kim --- packaging/capi-media-codec.spec | 91 ++++++++++++++++++++++++++++++++++++++--- 1 file changed, 85 insertions(+), 6 deletions(-) diff --git a/packaging/capi-media-codec.spec b/packaging/capi-media-codec.spec index a7c5699..dd71925 100755 --- a/packaging/capi-media-codec.spec +++ b/packaging/capi-media-codec.spec @@ -1,3 +1,7 @@ +# Do not create provides fro extension-tm1 because the main package +# should anchor any reverse-dependencies +%global __provides_exclude_from ^(.*\\.tm1)$ + Name: capi-media-codec Summary: A Media Codec library in Tizen Native API Version: 0.5.3 @@ -19,13 +23,25 @@ BuildRequires: pkgconfig(gstreamer-plugins-base-1.0) BuildRequires: pkgconfig(gstreamer-app-1.0) BuildRequires: pkgconfig(capi-system-info) BuildRequires: pkgconfig(iniparser) -%if "%{tizen_target_name}" == "TM1" + +%description +A Media Codec library in Tizen Native API + +%ifarch %{arm} +# This is for backward-compatibility. This does not deteriorate 4.0 Configurability +# if mobile || "undefined" +%if "%{?profile}" != "wearable" && "%{?profile}" != "tv" && "%{?profile}" != "ivi" && "%{?profile}" != "common" +%package extension-TM1 +Summary: Extension for mobile TM1 +Requires: %{name} = %{version}-%{release} #!BuildIgnore: kernel-headers BuildConflicts: linux-glibc-devel BuildRequires: kernel-headers-tizen-dev -%endif -%description +%description extension-TM1 +A Media Codec library in Tizen Native API Extension for mobile TM1 +%endif +%endif %package devel @@ -40,9 +56,7 @@ Requires: %{name} = %{version}-%{release} %build -%if "%{tizen_target_name}" == "TM1" -export CFLAGS="$CFLAGS -DTIZEN_PROFILE_LITE" -%endif + %if 0%{?sec_build_binary_debug_enable} export CFLAGS="$CFLAGS -DTIZEN_DEBUG_ENABLE" export CXXFLAGS="$CXXFLAGS -DTIZEN_DEBUG_ENABLE" @@ -52,7 +66,31 @@ export FFLAGS="$FFLAGS -DTIZEN_DEBUG_ENABLE" export CFLAGS="$CFLAGS -DENABLE_FFMPEG_CODEC" %endif export CFLAGS="$CFLAGS -DSYSCONFDIR=\\\"%{_sysconfdir}\\\"" +export CFLAGS_DEFAULT="$CFLAGS" + +%ifarch %{arm} +# This is for backward-compatibility. This does not deteriorate 4.0 Configurability +# if mobile || "undefined" +%if "%{?profile}" != "wearable" && "%{?profile}" != "tv" && "%{?profile}" != "ivi" && "%{?profile}" != "common" +# extension-TM1 +export CFLAGS="$CFLAGS_DEFAULT -DTIZEN_PROFILE_LITE" + +MAJORVER=`echo %{version} | awk 'BEGIN {FS="."}{print $1}'` +%cmake . -DCMAKE_INSTALL_PREFIX=/usr -DFULLVER=%{version} -DMAJORVER=${MAJORVER} + +make %{?jobs:-j%jobs} + +mkdir -p tm1 +%make_install +ls -al %{buildroot}%{_libdir}/libcapi-media-codec.so.* +cp -a %{buildroot}%{_libdir}/libcapi-media-codec.so.* tm1/ + +%endif +%endif + +# common +export CFLAGS="$CFLAGS_DEFAULT" MAJORVER=`echo %{version} | awk 'BEGIN {FS="."}{print $1}'` %cmake . -DCMAKE_INSTALL_PREFIX=/usr -DFULLVER=%{version} -DMAJORVER=${MAJORVER} @@ -68,6 +106,44 @@ cp LICENSE.APLv2 %{buildroot}/usr/share/license/%{name} %make_install + +%ifarch %{arm} +# This is for backward-compatibility. This does not deteriorate 4.0 Configurability +# if mobile || "undefined" +%if "%{?profile}" != "wearable" && "%{?profile}" != "tv" && "%{?profile}" != "ivi" && "%{?profile}" != "common" +# extension-TM1 +pushd tm1 +for FILE in libcapi-media-codec.so.*; do mv "$FILE" "%{buildroot}%{_libdir}/$FILE.tm1"; done +popd + +%post extension-TM1 +pushd %{_libdir} +for FILE in libcapi-media-codec.so.*.tm1; do mv "$FILE" "${FILE%.tm1}"; done +popd +/sbin/ldconfig + +%preun extension-TM1 +case "$1" in + 0) + # This is an un-installation. + pushd %{_libdir} + for FILE in libcapi-media-codec.so.*; do mv "$FILE" "${FILE%.tm1}"; done + popd + /sbin/ldconfig + ;; + 1) + # This is an upgrade. + # Do nothing. + : + ;; +esac + +%files extension-TM1 +%manifest capi-media-codec.manifest +%{_libdir}/libcapi-media-codec.so.*.tm1 +%endif +%endif + %post /sbin/ldconfig @@ -77,6 +153,9 @@ cp LICENSE.APLv2 %{buildroot}/usr/share/license/%{name} %files %manifest capi-media-codec.manifest %{_libdir}/libcapi-media-codec.so.* +%ifarch %{arm} +%exclude %{_libdir}/libcapi-media-codec.so.*.tm1 +%endif %{_datadir}/license/%{name} /usr/bin/* #%{_bindir}/* -- 2.7.4 From 7fd27916ebcaa7c0ae514dda050c44780758c0f7 Mon Sep 17 00:00:00 2001 From: Sejun Park Date: Thu, 23 Mar 2017 16:53:12 +0900 Subject: [PATCH 15/16] changed to %license macro Change-Id: I84d92a0317fcce09ed3564ca7006a399384aff25 --- packaging/capi-media-codec.spec | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/packaging/capi-media-codec.spec b/packaging/capi-media-codec.spec index dd71925..e6ba560 100755 --- a/packaging/capi-media-codec.spec +++ b/packaging/capi-media-codec.spec @@ -99,10 +99,8 @@ make %{?jobs:-j%jobs} %install rm -rf %{buildroot} -mkdir -p %{buildroot}/usr/share/license mkdir -p %{buildroot}/usr/bin cp test/media_codec_test %{buildroot}/usr/bin -cp LICENSE.APLv2 %{buildroot}/usr/share/license/%{name} %make_install @@ -156,7 +154,7 @@ esac %ifarch %{arm} %exclude %{_libdir}/libcapi-media-codec.so.*.tm1 %endif -%{_datadir}/license/%{name} +%license LICENSE.APLv2 /usr/bin/* #%{_bindir}/* -- 2.7.4 From bfc84017d8a88c86b7658f4108da0831fe3fae0c Mon Sep 17 00:00:00 2001 From: "hk57.kim" Date: Wed, 29 Mar 2017 17:25:47 +0900 Subject: [PATCH 16/16] [Tizen] Fix 'Have choice' issue for TM1 - This is for Tizen 4.0. - Fix buildrequires kernel-headers-tizen-dev --> kernel-headers-3.10-sc7730 for TM1 Change-Id: I31e55eacf2877296341c344bdb858a48854690c1 Signed-off-by: hk57.kim --- packaging/capi-media-codec.spec | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packaging/capi-media-codec.spec b/packaging/capi-media-codec.spec index e6ba560..6b69fe1 100755 --- a/packaging/capi-media-codec.spec +++ b/packaging/capi-media-codec.spec @@ -36,7 +36,7 @@ Summary: Extension for mobile TM1 Requires: %{name} = %{version}-%{release} #!BuildIgnore: kernel-headers BuildConflicts: linux-glibc-devel -BuildRequires: kernel-headers-tizen-dev +BuildRequires: kernel-headers-3.10-sc7730 %description extension-TM1 A Media Codec library in Tizen Native API Extension for mobile TM1 -- 2.7.4