Add new field in ini file for sink element

- Added field
: hw_decoder_sink
: hw_encoder_sink
: sw_decoder_sink
: sw_encoder_sink

- Usage
: field = elementname, property=value, ...
: The max number of properties is 5

- Example
hw_decoder_sink = fakesink, enable-last-sample=false, sync=false

[Version] 1.2.2
[Issue Type] New feature

Change-Id: I9fd51afd50dd3d14fd59315506b4d5ad64a70c6d
Signed-off-by: Jeongmo Yang <jm80.yang@samsung.com>

diff --git a/include/media_codec_ini.h b/include/media_codec_ini.h
index dbd7c5edbce1d7f60d34a27b0b6302ec1b58c72c..012a06d15fc3fe26d4759124e8b8f7abe372d245 100644 (file)
--- a/include/media_codec_ini.h
+++ b/include/media_codec_ini.h
@@ -31,6 +31,7 @@ extern "C" {
 #define MEDIA_CODEC_INI_STRLEN          32
 #define MEDIA_CODEC_INI_CNAME_LEN       16
 #define DEFAULT_PORT                    "GST_PORT"
+#define DEFAULT_SINK_NAME               "fakesink"
 #define MEDIA_CODEC_MAX_CODEC_TYPE      100
 #define MEDIA_CODEC_MAX_PROPERTY_EXT    5
 
@@ -72,6 +73,12 @@ typedef enum {
        MEDIA_CODEC_INFO_PROPERTY_EXT_VALUE
 } codec_info;
 
+typedef enum {
+       MEDIA_CODEC_SINK_INFO_NAME = 0,
+       MEDIA_CODEC_SINK_INFO_PROPERTY_NAME,
+       MEDIA_CODEC_SINK_INFO_PROPERTY_VALUE
+} codec_sink_info;
+
 struct _codec_property_t {
        gchar bitrate_name[MEDIA_CODEC_INI_STRLEN];
        gchar ext_name[MEDIA_CODEC_MAX_PROPERTY_EXT][MEDIA_CODEC_INI_STRLEN];
@@ -80,10 +87,12 @@ struct _codec_property_t {
 };
 
 struct _codec_info_t {
-       gchar name[MEDIA_CODEC_INI_STRLEN];
+       gchar codec_name[MEDIA_CODEC_INI_STRLEN];
        gchar mime[MEDIA_CODEC_INI_STRLEN];
        gchar format[MEDIA_CODEC_INI_STRLEN];
-       codec_property_t property;
+       codec_property_t codec_property;
+       gchar sink_name[MEDIA_CODEC_INI_STRLEN];
+       codec_property_t sink_property;
 };
 
 struct _codec_t {

diff --git a/include/media_codec_port_gst.h b/include/media_codec_port_gst.h
index c095adabcf0b4b269081287ac7ff238af0af6745..0e9b4a7b63ee473b32efb0b1032bb9eb8cd427fb 100644 (file)
--- a/include/media_codec_port_gst.h
+++ b/include/media_codec_port_gst.h
@@ -135,7 +135,7 @@ struct _mc_gst_core_t {
        media_format_h output_fmt;
        mc_gst_port_t *ports[2];
        mc_bitstream_t bits;
-       mc_codec_type_t *codec_type;
+       const mc_codec_type_t *codec_type;
 
        mc_aqueue_t *available_queue;
        GQueue *output_queue;

diff --git a/include/media_codec_spec_emul.h b/include/media_codec_spec_emul.h
index 08e0705aabde9c0ab68f0ef9346072b9aad685dc..13a1c641fa65ad8dd09fe143ac35f37aa1f03815 100644 (file)
--- a/include/media_codec_spec_emul.h
+++ b/include/media_codec_spec_emul.h
@@ -40,10 +40,12 @@ struct _mc_codec_spec_t {
 };
 
 struct _mc_codec_type_t {
-       char *factory_name;
-       char *mime;
+       const char *codec_name;
+       const char *mime;
        media_format_mimetype_e out_format;
-       codec_property_t *property;
+       codec_property_t *codec_property;
+       const char *sink_name;
+       codec_property_t *sink_property;
 };
 
 struct _mc_codec_map_t {

diff --git a/packaging/capi-media-codec.spec b/packaging/capi-media-codec.spec
index c78fc1d4a51b96371b01e9b5d4f33275e449ebe4..b7b9ecc39bac59d782ce05877fb6b41052d3ac6b 100644 (file)
--- a/packaging/capi-media-codec.spec
+++ b/packaging/capi-media-codec.spec
@@ -4,7 +4,7 @@
 
 Name:       capi-media-codec
 Summary:    A Media Codec library in Tizen Native API
-Version:    1.2.1
+Version:    1.2.2
 Release:    0
 Group:      Multimedia/API
 License:    Apache-2.0

diff --git a/src/media_codec_ini.c b/src/media_codec_ini.c
index 6c6599850a24c326f2f203e0bfbf09e22f8971a2..1d3c7c2269fcfd50598894ef1e7b83409f182e43 100644 (file)
--- a/src/media_codec_ini.c
+++ b/src/media_codec_ini.c
@@ -95,42 +95,89 @@ do {\
                strncpy(x_item, x_default, MEDIA_CODEC_INI_MAX_STRLEN - 1); \
 } while (0)
 
-#define MEDIA_CODEC_INI_GET_STRING_FROM_LIST(x_dict, x_list, x_ini, x_default) \
+#define MEDIA_CODEC_INI_GET_CODEC_INFO(x_dict, x_list, x_ini, x_default) \
 do {\
        char *token = NULL; \
        char *usr_ptr = NULL; \
        int index = 0; \
        const char *delimiters = " ,"; \
        gchar temp_arr[MEDIA_CODEC_INI_MAX_STRLEN] = {0}; \
+       LOGD("[%s]", x_ini);\
        MEDIA_CODEC_INI_GET_STRING(x_dict, temp_arr, x_ini, x_default); \
-       strncpy(x_list.property.bitrate_name, DEFAULT_HW_ENCODER_PROPERTY_BITRATE_NAME, MEDIA_CODEC_INI_STRLEN - 1); \
+       strncpy(x_list.codec_property.bitrate_name, DEFAULT_HW_ENCODER_PROPERTY_BITRATE_NAME, MEDIA_CODEC_INI_STRLEN - 1); \
        token = strtok_r(temp_arr, delimiters, &usr_ptr); \
        while (token) {\
-               LOGI("index[%d], token[%s]", index, token);\
                switch (index) { \
                case MEDIA_CODEC_INFO_NAME: \
-                       strncpy(x_list.name, token, MEDIA_CODEC_INI_STRLEN - 1); \
+                       strncpy(x_list.codec_name, token, MEDIA_CODEC_INI_STRLEN - 1); \
+                       LOGD("  codec_name[%s]", x_list.codec_name);\
                        break; \
                case MEDIA_CODEC_INFO_MIME: \
                        strncpy(x_list.mime, token, MEDIA_CODEC_INI_STRLEN - 1); \
+                       LOGD("  mime[%s]", x_list.mime);\
                        break; \
                case MEDIA_CODEC_INFO_FORMAT: \
                        strncpy(x_list.format, token, MEDIA_CODEC_INI_STRLEN - 1); \
+                       LOGD("  format[%s]", x_list.format);\
                        break; \
                case MEDIA_CODEC_INFO_PROPERTY_BITRATE_NAME: \
-                       strncpy(x_list.property.bitrate_name, token, MEDIA_CODEC_INI_STRLEN - 1); \
+                       strncpy(x_list.codec_property.bitrate_name, token, MEDIA_CODEC_INI_STRLEN - 1); \
+                       LOGD("  bitrate property name[%s]", x_list.codec_property.bitrate_name);\
                        break; \
                default: \
-                       if (x_list.property.ext_num < MEDIA_CODEC_MAX_PROPERTY_EXT) { \
-                               strncpy(x_list.property.ext_name[x_list.property.ext_num], token, MEDIA_CODEC_INI_STRLEN - 1); \
+                       if (x_list.codec_property.ext_num < MEDIA_CODEC_MAX_PROPERTY_EXT) { \
+                               strncpy(x_list.codec_property.ext_name[x_list.codec_property.ext_num], token, MEDIA_CODEC_INI_STRLEN - 1); \
                                token = strtok_r(NULL, delimiters, &usr_ptr); \
                                if (!token) { \
-                                       LOGW("NULL value for property[%s]", x_list.property.ext_name[x_list.property.ext_num]); \
+                                       LOGW("  NULL value for property[%s]", x_list.codec_property.ext_name[x_list.codec_property.ext_num]); \
                                        break; \
                                } \
-                               LOGI("  token[property value:%s]", token);\
-                               strncpy(x_list.property.ext_value[x_list.property.ext_num], token, MEDIA_CODEC_INI_STRLEN - 1); \
-                               x_list.property.ext_num++; \
+                               strncpy(x_list.codec_property.ext_value[x_list.codec_property.ext_num], token, MEDIA_CODEC_INI_STRLEN - 1); \
+                               LOGD("  codec property[%d] %s -> %s", \
+                                       x_list.codec_property.ext_num, \
+                                       x_list.codec_property.ext_name[x_list.codec_property.ext_num], \
+                                       x_list.codec_property.ext_value[x_list.codec_property.ext_num]); \
+                               x_list.codec_property.ext_num++; \
+                       } else { \
+                               LOGW("unhandled token[%s] from ini", token); \
+                       } \
+                       break; \
+               } \
+               index++;\
+               token = strtok_r(NULL, delimiters, &usr_ptr); \
+       } \
+} while (0)
+
+#define MEDIA_CODEC_INI_GET_SINK_INFO(x_dict, x_list, x_ini, x_default) \
+do {\
+       char *token = NULL; \
+       char *usr_ptr = NULL; \
+       int index = 0; \
+       const char *delimiters = " ,="; \
+       gchar temp_arr[MEDIA_CODEC_INI_MAX_STRLEN] = {0}; \
+       LOGD("[%s]", x_ini);\
+       MEDIA_CODEC_INI_GET_STRING(x_dict, temp_arr, x_ini, x_default); \
+       token = strtok_r(temp_arr, delimiters, &usr_ptr); \
+       while (token) {\
+               switch (index) { \
+               case MEDIA_CODEC_SINK_INFO_NAME: \
+                       strncpy(x_list.sink_name, token, MEDIA_CODEC_INI_STRLEN - 1); \
+                       LOGD("  sink_name[%s]", x_list.sink_name);\
+                       break; \
+               default: \
+                       if (x_list.sink_property.ext_num < MEDIA_CODEC_MAX_PROPERTY_EXT) { \
+                               strncpy(x_list.sink_property.ext_name[x_list.sink_property.ext_num], token, MEDIA_CODEC_INI_STRLEN - 1); \
+                               token = strtok_r(NULL, delimiters, &usr_ptr); \
+                               if (!token) { \
+                                       LOGW("  NULL value for property[%s]", x_list.sink_property.ext_name[x_list.sink_property.ext_num]); \
+                                       break; \
+                               } \
+                               strncpy(x_list.sink_property.ext_value[x_list.sink_property.ext_num], token, MEDIA_CODEC_INI_STRLEN - 1); \
+                               LOGD("  sink property[%d] %s -> %s", \
+                                       x_list.sink_property.ext_num, \
+                                       x_list.sink_property.ext_name[x_list.sink_property.ext_num], \
+                                       x_list.sink_property.ext_value[x_list.sink_property.ext_num]); \
+                               x_list.sink_property.ext_num++; \
                        } else { \
                                LOGW("unhandled token[%s] from ini", token); \
                        } \
@@ -206,11 +253,16 @@ do {\
 #define MEDIA_CODEC_PRINT_LIST(x_list,  x_message) \
 do {\
        int prop_index = 0;\
-       LOGW("%s =", x_message);\
-       LOGW("  %s %s %s", x_list.name, x_list.mime, x_list.format);\
-       LOGW("  bitrate property: %s\n", x_list.property.bitrate_name);\
-       for (prop_index = 0 ; prop_index < x_list.property.ext_num ; prop_index++)\
-               LOGW("  property ext: %s,%s", x_list.property.ext_name[prop_index], x_list.property.ext_value[prop_index]);\
+       if (strlen(x_list.codec_name) > 0) {\
+               LOGI("%s =", x_message);\
+               LOGI("  bitrate property name: %s\n", x_list.codec_property.bitrate_name);\
+               LOGI("  codec: %s, mime: %s, format: %s", x_list.codec_name, x_list.mime, x_list.format);\
+               for (prop_index = 0 ; prop_index < x_list.codec_property.ext_num ; prop_index++)\
+                       LOGI("    property[%d] %s = %s", prop_index, x_list.codec_property.ext_name[prop_index], x_list.codec_property.ext_value[prop_index]);\
+               LOGI("  sink: %s", x_list.sink_name);\
+               for (prop_index = 0 ; prop_index < x_list.sink_property.ext_num ; prop_index++)\
+                       LOGI("    property[%d] %s = %s", prop_index, x_list.sink_property.ext_name[prop_index], x_list.sink_property.ext_value[prop_index]);\
+       }\
 } while (0)
 
 media_format_mimetype_e _mc_convert_media_format_str_to_int(char *sformat)
@@ -372,39 +424,53 @@ int mc_ini_load(mc_ini_t *ini)
                        memset(cname, 0x00, CNAME_SIZE);
                        snprintf(cname, CNAME_SIZE, "%s", general_codec_list[i].cname);
                        int len = strlen(cname);
+
                        ini->codec[i].codec_id =  general_codec_list[i].ctype;
+
                        snprintf(cname+len, CNAME_SIZE - len, "%s", ":hw_decoder");
-                       MEDIA_CODEC_INI_GET_STRING_FROM_LIST(dict, ini->codec[i].codec_info[MEDIA_CODEC_ROLE_HW_DECODER], cname, DEFAULT_VALUE);
+                       MEDIA_CODEC_INI_GET_CODEC_INFO(dict, ini->codec[i].codec_info[MEDIA_CODEC_ROLE_HW_DECODER], cname, DEFAULT_VALUE);
                        snprintf(cname+len, CNAME_SIZE - len, "%s", ":hw_encoder");
-                       MEDIA_CODEC_INI_GET_STRING_FROM_LIST(dict, ini->codec[i].codec_info[MEDIA_CODEC_ROLE_HW_ENCODER], cname, DEFAULT_VALUE);
+                       MEDIA_CODEC_INI_GET_CODEC_INFO(dict, ini->codec[i].codec_info[MEDIA_CODEC_ROLE_HW_ENCODER], cname, DEFAULT_VALUE);
                        snprintf(cname+len, CNAME_SIZE - len, "%s", ":sw_decoder");
-                       MEDIA_CODEC_INI_GET_STRING_FROM_LIST(dict, ini->codec[i].codec_info[MEDIA_CODEC_ROLE_SW_DECODER], cname, DEFAULT_VALUE);
+                       MEDIA_CODEC_INI_GET_CODEC_INFO(dict, ini->codec[i].codec_info[MEDIA_CODEC_ROLE_SW_DECODER], cname, DEFAULT_VALUE);
                        snprintf(cname+len, CNAME_SIZE - len, "%s", ":sw_encoder");
-                       MEDIA_CODEC_INI_GET_STRING_FROM_LIST(dict, ini->codec[i].codec_info[MEDIA_CODEC_ROLE_SW_ENCODER], cname, DEFAULT_VALUE);
+                       MEDIA_CODEC_INI_GET_CODEC_INFO(dict, ini->codec[i].codec_info[MEDIA_CODEC_ROLE_SW_ENCODER], cname, DEFAULT_VALUE);
+
+                       snprintf(cname+len, CNAME_SIZE - len, "%s", ":hw_decoder_sink");
+                       MEDIA_CODEC_INI_GET_SINK_INFO(dict, ini->codec[i].codec_info[MEDIA_CODEC_ROLE_HW_DECODER], cname, DEFAULT_SINK_NAME);
+                       snprintf(cname+len, CNAME_SIZE - len, "%s", ":sw_decoder_sink");
+                       MEDIA_CODEC_INI_GET_SINK_INFO(dict, ini->codec[i].codec_info[MEDIA_CODEC_ROLE_SW_DECODER], cname, DEFAULT_SINK_NAME);
+                       snprintf(cname+len, CNAME_SIZE - len, "%s", ":hw_encoder_sink");
+                       MEDIA_CODEC_INI_GET_SINK_INFO(dict, ini->codec[i].codec_info[MEDIA_CODEC_ROLE_HW_ENCODER], cname, DEFAULT_SINK_NAME);
+                       snprintf(cname+len, CNAME_SIZE - len, "%s", ":sw_encoder_sink");
+                       MEDIA_CODEC_INI_GET_SINK_INFO(dict, ini->codec[i].codec_info[MEDIA_CODEC_ROLE_SW_ENCODER], cname, DEFAULT_SINK_NAME);
                }
        } else {/* if dict is not available just fill the structure with default value */
-
                LOGW("failed to load ini. using hardcoded default\n");
                /* general */
                snprintf(ini->port_name, sizeof(ini->port_name), "%s", DEFAULT_PORT);
                for (i = 0; i < ini->codec_list; i++) {
-                       MEDIA_CODEC_GET_DEFAULT_LIST(ini->codec[i].codec_info[MEDIA_CODEC_ROLE_HW_DECODER].name,   DEFAULT_HW_DECODER_NAME);
+                       MEDIA_CODEC_GET_DEFAULT_LIST(ini->codec[i].codec_info[MEDIA_CODEC_ROLE_HW_DECODER].codec_name,   DEFAULT_HW_DECODER_NAME);
                        MEDIA_CODEC_GET_DEFAULT_LIST(ini->codec[i].codec_info[MEDIA_CODEC_ROLE_HW_DECODER].mime,   DEFAULT_HW_DECODER_MIME);
                        MEDIA_CODEC_GET_DEFAULT_LIST(ini->codec[i].codec_info[MEDIA_CODEC_ROLE_HW_DECODER].format, DEFAULT_HW_DECODER_FORMAT);
+                       MEDIA_CODEC_GET_DEFAULT_LIST(ini->codec[i].codec_info[MEDIA_CODEC_ROLE_HW_DECODER].sink_name, DEFAULT_SINK_NAME);
 
-                       MEDIA_CODEC_GET_DEFAULT_LIST(ini->codec[i].codec_info[MEDIA_CODEC_ROLE_HW_ENCODER].name,   DEFAULT_HW_ENCODER_NAME);
+                       MEDIA_CODEC_GET_DEFAULT_LIST(ini->codec[i].codec_info[MEDIA_CODEC_ROLE_HW_ENCODER].codec_name,   DEFAULT_HW_ENCODER_NAME);
                        MEDIA_CODEC_GET_DEFAULT_LIST(ini->codec[i].codec_info[MEDIA_CODEC_ROLE_HW_ENCODER].mime,   DEFAULT_HW_ENCODER_MIME);
                        MEDIA_CODEC_GET_DEFAULT_LIST(ini->codec[i].codec_info[MEDIA_CODEC_ROLE_HW_ENCODER].format, DEFAULT_HW_ENCODER_FORMAT);
-                       MEDIA_CODEC_GET_DEFAULT_LIST(ini->codec[i].codec_info[MEDIA_CODEC_ROLE_HW_ENCODER].property.bitrate_name, DEFAULT_HW_ENCODER_PROPERTY_BITRATE_NAME);
+                       MEDIA_CODEC_GET_DEFAULT_LIST(ini->codec[i].codec_info[MEDIA_CODEC_ROLE_HW_ENCODER].codec_property.bitrate_name, DEFAULT_HW_ENCODER_PROPERTY_BITRATE_NAME);
+                       MEDIA_CODEC_GET_DEFAULT_LIST(ini->codec[i].codec_info[MEDIA_CODEC_ROLE_HW_ENCODER].sink_name, DEFAULT_SINK_NAME);
 
-                       MEDIA_CODEC_GET_DEFAULT_LIST(ini->codec[i].codec_info[MEDIA_CODEC_ROLE_SW_DECODER].name,   DEFAULT_SW_DECODER_NAME);
+                       MEDIA_CODEC_GET_DEFAULT_LIST(ini->codec[i].codec_info[MEDIA_CODEC_ROLE_SW_DECODER].codec_name,   DEFAULT_SW_DECODER_NAME);
                        MEDIA_CODEC_GET_DEFAULT_LIST(ini->codec[i].codec_info[MEDIA_CODEC_ROLE_SW_DECODER].mime,   DEFAULT_SW_DECODER_MIME);
                        MEDIA_CODEC_GET_DEFAULT_LIST(ini->codec[i].codec_info[MEDIA_CODEC_ROLE_SW_DECODER].format, DEFAULT_SW_DECODER_FORMAT);
+                       MEDIA_CODEC_GET_DEFAULT_LIST(ini->codec[i].codec_info[MEDIA_CODEC_ROLE_SW_DECODER].sink_name, DEFAULT_SINK_NAME);
 
-                       MEDIA_CODEC_GET_DEFAULT_LIST(ini->codec[i].codec_info[MEDIA_CODEC_ROLE_SW_ENCODER].name,   DEFAULT_SW_ENCODER_NAME);
+                       MEDIA_CODEC_GET_DEFAULT_LIST(ini->codec[i].codec_info[MEDIA_CODEC_ROLE_SW_ENCODER].codec_name,   DEFAULT_SW_ENCODER_NAME);
                        MEDIA_CODEC_GET_DEFAULT_LIST(ini->codec[i].codec_info[MEDIA_CODEC_ROLE_SW_ENCODER].mime,   DEFAULT_SW_ENCODER_MIME);
                        MEDIA_CODEC_GET_DEFAULT_LIST(ini->codec[i].codec_info[MEDIA_CODEC_ROLE_SW_ENCODER].format, DEFAULT_SW_ENCODER_FORMAT);
-                       MEDIA_CODEC_GET_DEFAULT_LIST(ini->codec[i].codec_info[MEDIA_CODEC_ROLE_SW_ENCODER].property.bitrate_name, DEFAULT_SW_ENCODER_PROPERTY_BITRATE_NAME);
+                       MEDIA_CODEC_GET_DEFAULT_LIST(ini->codec[i].codec_info[MEDIA_CODEC_ROLE_SW_ENCODER].codec_property.bitrate_name, DEFAULT_SW_ENCODER_PROPERTY_BITRATE_NAME);
+                       MEDIA_CODEC_GET_DEFAULT_LIST(ini->codec[i].codec_info[MEDIA_CODEC_ROLE_SW_ENCODER].sink_name, DEFAULT_SINK_NAME);
                }
        }
 

diff --git a/src/media_codec_port.c b/src/media_codec_port.c
index 45b4390897dd96053a5233eb33d6f71feedb4ac1..13509a63843b00dbddb2aac684634788b7e115e1 100644 (file)
--- a/src/media_codec_port.c
+++ b/src/media_codec_port.c
@@ -887,25 +887,29 @@ void _mc_create_decoder_map_from_ini(mc_handle_t *mediacodec)
        int indx = 0, count = 0;
        int codec_list = mediacodec->ini->codec_list;
        for (indx = 0; indx < codec_list; indx++) {
-               if (strcmp(mediacodec->ini->codec[indx].codec_info[MEDIA_CODEC_ROLE_HW_DECODER].name, "")) {
+               if (strcmp(mediacodec->ini->codec[indx].codec_info[MEDIA_CODEC_ROLE_HW_DECODER].codec_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[MEDIA_CODEC_ROLE_HW_DECODER].name;
+                       mediacodec->decoder_map[count].type.codec_name = mediacodec->ini->codec[indx].codec_info[MEDIA_CODEC_ROLE_HW_DECODER].codec_name;
+                       mediacodec->decoder_map[count].type.sink_name = mediacodec->ini->codec[indx].codec_info[MEDIA_CODEC_ROLE_HW_DECODER].sink_name;
                        mediacodec->decoder_map[count].type.mime = mediacodec->ini->codec[indx].codec_info[MEDIA_CODEC_ROLE_HW_DECODER].mime;
                        mediacodec->decoder_map[count].type.out_format =
                                _mc_convert_media_format_str_to_int(mediacodec->ini->codec[indx].codec_info[MEDIA_CODEC_ROLE_HW_DECODER].format);
-                       mediacodec->decoder_map[count].type.property = &mediacodec->ini->codec[indx].codec_info[MEDIA_CODEC_ROLE_HW_DECODER].property;
+                       mediacodec->decoder_map[count].type.codec_property = &mediacodec->ini->codec[indx].codec_info[MEDIA_CODEC_ROLE_HW_DECODER].codec_property;
+                       mediacodec->decoder_map[count].type.sink_property = &mediacodec->ini->codec[indx].codec_info[MEDIA_CODEC_ROLE_HW_DECODER].sink_property;
                        count++;
                }
 
-               if (strcmp(mediacodec->ini->codec[indx].codec_info[MEDIA_CODEC_ROLE_SW_DECODER].name, "")) {
+               if (strcmp(mediacodec->ini->codec[indx].codec_info[MEDIA_CODEC_ROLE_SW_DECODER].codec_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[MEDIA_CODEC_ROLE_SW_DECODER].name;
+                       mediacodec->decoder_map[count].type.codec_name = mediacodec->ini->codec[indx].codec_info[MEDIA_CODEC_ROLE_SW_DECODER].codec_name;
+                       mediacodec->decoder_map[count].type.sink_name = mediacodec->ini->codec[indx].codec_info[MEDIA_CODEC_ROLE_SW_DECODER].sink_name;
                        mediacodec->decoder_map[count].type.mime = mediacodec->ini->codec[indx].codec_info[MEDIA_CODEC_ROLE_SW_DECODER].mime;
                        mediacodec->decoder_map[count].type.out_format =
                                _mc_convert_media_format_str_to_int(mediacodec->ini->codec[indx].codec_info[MEDIA_CODEC_ROLE_SW_DECODER].format);
-                       mediacodec->decoder_map[count].type.property = &mediacodec->ini->codec[indx].codec_info[MEDIA_CODEC_ROLE_SW_DECODER].property;
+                       mediacodec->decoder_map[count].type.codec_property = &mediacodec->ini->codec[indx].codec_info[MEDIA_CODEC_ROLE_SW_DECODER].codec_property;
+                       mediacodec->decoder_map[count].type.sink_property = &mediacodec->ini->codec[indx].codec_info[MEDIA_CODEC_ROLE_SW_DECODER].sink_property;
                        count++;
                }
        }
@@ -920,25 +924,29 @@ void _mc_create_encoder_map_from_ini(mc_handle_t *mediacodec)
        int codec_list = mediacodec->ini->codec_list;
 
        for (indx = 0; indx < codec_list; indx++) {
-               if (strcmp(mediacodec->ini->codec[indx].codec_info[MEDIA_CODEC_ROLE_HW_ENCODER].name, "")) {
+               if (strcmp(mediacodec->ini->codec[indx].codec_info[MEDIA_CODEC_ROLE_HW_ENCODER].codec_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[MEDIA_CODEC_ROLE_HW_ENCODER].name;
+                       mediacodec->encoder_map[count].type.codec_name = mediacodec->ini->codec[indx].codec_info[MEDIA_CODEC_ROLE_HW_ENCODER].codec_name;
+                       mediacodec->encoder_map[count].type.sink_name = mediacodec->ini->codec[indx].codec_info[MEDIA_CODEC_ROLE_HW_ENCODER].sink_name;
                        mediacodec->encoder_map[count].type.mime = mediacodec->ini->codec[indx].codec_info[MEDIA_CODEC_ROLE_HW_ENCODER].mime;
                        mediacodec->encoder_map[count].type.out_format =
                                _mc_convert_media_format_str_to_int(mediacodec->ini->codec[indx].codec_info[MEDIA_CODEC_ROLE_HW_ENCODER].format);
-                       mediacodec->encoder_map[count].type.property = &mediacodec->ini->codec[indx].codec_info[MEDIA_CODEC_ROLE_HW_ENCODER].property;
+                       mediacodec->encoder_map[count].type.codec_property = &mediacodec->ini->codec[indx].codec_info[MEDIA_CODEC_ROLE_HW_ENCODER].codec_property;
+                       mediacodec->encoder_map[count].type.sink_property = &mediacodec->ini->codec[indx].codec_info[MEDIA_CODEC_ROLE_HW_ENCODER].sink_property;
                        count++;
                }
 
-               if (strcmp(mediacodec->ini->codec[indx].codec_info[MEDIA_CODEC_ROLE_SW_ENCODER].name, "")) {
+               if (strcmp(mediacodec->ini->codec[indx].codec_info[MEDIA_CODEC_ROLE_SW_ENCODER].codec_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[MEDIA_CODEC_ROLE_SW_ENCODER].name;
+                       mediacodec->encoder_map[count].type.codec_name = mediacodec->ini->codec[indx].codec_info[MEDIA_CODEC_ROLE_SW_ENCODER].codec_name;
+                       mediacodec->encoder_map[count].type.sink_name = mediacodec->ini->codec[indx].codec_info[MEDIA_CODEC_ROLE_SW_ENCODER].sink_name;
                        mediacodec->encoder_map[count].type.mime = mediacodec->ini->codec[indx].codec_info[MEDIA_CODEC_ROLE_SW_ENCODER].mime;
                        mediacodec->encoder_map[count].type.out_format =
                                _mc_convert_media_format_str_to_int(mediacodec->ini->codec[indx].codec_info[MEDIA_CODEC_ROLE_SW_ENCODER].format);
-                       mediacodec->encoder_map[count].type.property = &mediacodec->ini->codec[indx].codec_info[MEDIA_CODEC_ROLE_SW_ENCODER].property;
+                       mediacodec->encoder_map[count].type.codec_property = &mediacodec->ini->codec[indx].codec_info[MEDIA_CODEC_ROLE_SW_ENCODER].codec_property;
+                       mediacodec->encoder_map[count].type.sink_property = &mediacodec->ini->codec[indx].codec_info[MEDIA_CODEC_ROLE_SW_ENCODER].sink_property;
                        count++;
                }
        }
@@ -952,25 +960,25 @@ void _mc_create_codec_map_from_ini(mc_handle_t *mediacodec, mc_codec_spec_t *spe
        int codec_list = mediacodec->ini->codec_list;
 
        for (indx = 0; indx < codec_list; indx++) {
-               if (strcmp(mediacodec->ini->codec[indx].codec_info[MEDIA_CODEC_ROLE_HW_DECODER].name, "")) {
+               if (strcmp(mediacodec->ini->codec[indx].codec_info[MEDIA_CODEC_ROLE_HW_DECODER].codec_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[MEDIA_CODEC_ROLE_HW_ENCODER].name, "")) {
+               if (strcmp(mediacodec->ini->codec[indx].codec_info[MEDIA_CODEC_ROLE_HW_ENCODER].codec_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[MEDIA_CODEC_ROLE_SW_DECODER].name, "")) {
+               if (strcmp(mediacodec->ini->codec[indx].codec_info[MEDIA_CODEC_ROLE_SW_DECODER].codec_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[MEDIA_CODEC_ROLE_SW_ENCODER].name, "")) {
+               if (strcmp(mediacodec->ini->codec[indx].codec_info[MEDIA_CODEC_ROLE_SW_ENCODER].codec_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;
@@ -989,25 +997,25 @@ void _mc_create_codec_map_from_ini_static(mc_ini_t *ini, mc_codec_spec_t *spec_e
        int codec_list = ini->codec_list;
 
        for (indx = 0; indx < codec_list; indx++) {
-               if (strcmp(ini->codec[indx].codec_info[MEDIA_CODEC_ROLE_HW_DECODER].name, "")) {
+               if (strcmp(ini->codec[indx].codec_info[MEDIA_CODEC_ROLE_HW_DECODER].codec_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[MEDIA_CODEC_ROLE_HW_ENCODER].name, "")) {
+               if (strcmp(ini->codec[indx].codec_info[MEDIA_CODEC_ROLE_HW_ENCODER].codec_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[MEDIA_CODEC_ROLE_SW_DECODER].name, "")) {
+               if (strcmp(ini->codec[indx].codec_info[MEDIA_CODEC_ROLE_SW_DECODER].codec_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[MEDIA_CODEC_ROLE_SW_ENCODER].name, "")) {
+               if (strcmp(ini->codec[indx].codec_info[MEDIA_CODEC_ROLE_SW_ENCODER].codec_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;

diff --git a/src/media_codec_port_gst.c b/src/media_codec_port_gst.c
index da12e49e8ddf69cd01c70397e573294bbe2ac26e..c6c0910f7940280ed8d926884d59e1fba00c3020 100644 (file)
--- a/src/media_codec_port_gst.c
+++ b/src/media_codec_port_gst.c
@@ -41,7 +41,7 @@ static media_packet_h _mc_get_input_buffer(mc_gst_core_t *core);
 
 static gboolean __mc_gst_init_gstreamer();
 static int _mc_output_media_packet_new(mc_gst_core_t *core, bool video, bool encoder, media_format_mimetype_e out_mime);
-static mc_ret_e _mc_gst_create_pipeline(mc_gst_core_t *core, const gchar *factory_name);
+static mc_ret_e _mc_gst_create_pipeline(mc_gst_core_t *core, const gchar *codec_name, const gchar *sink_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);
@@ -1411,10 +1411,10 @@ static gpointer feed_task(gpointer data)
                                        core->ports[in_port_index]->port_def.info.video.bitrate : \
                                        core->ports[in_port_index]->port_def.info.audio.bitrate;
 
-                               g_object_set(core->codec, core->codec_type->property->bitrate_name, bitrate, NULL);
+                               g_object_set(core->codec, core->codec_type->codec_property->bitrate_name, bitrate, NULL);
 
                                LOGI("bitrate[property:%s,v:%d] %d updated",
-                                       core->codec_type->property->bitrate_name, core->video, bitrate);
+                                       core->codec_type->codec_property->bitrate_name, core->video, bitrate);
                        }
 
                        is_format_change = FALSE;
@@ -1921,10 +1921,11 @@ mc_ret_e mc_gst_prepare(mc_handle_t *mc_handle)
        bool video;
        bool encoder;
        bool hardware;
-       gchar *factory_name = NULL;
+       const gchar *codec_name = NULL;
+       const gchar *sink_name = NULL;
        media_format_mimetype_e out_mime;
        mediacodec_codec_type_e id;
-       mc_codec_map_t *codec_map;
+       const mc_codec_map_t *codec_map;
 
        MEDIACODEC_FENTER();
 
@@ -1946,7 +1947,8 @@ mc_ret_e mc_gst_prepare(mc_handle_t *mc_handle)
        if (i == num_supported_codec)
                return MC_NOT_SUPPORTED;
 
-       factory_name = codec_map[i].type.factory_name;
+       codec_name = codec_map[i].type.codec_name;
+       sink_name = codec_map[i].type.sink_name;
        out_mime = codec_map[i].type.out_format;
 
        /* gst_core create */
@@ -1972,7 +1974,7 @@ mc_ret_e mc_gst_prepare(mc_handle_t *mc_handle)
        }
 
        LOGD("@%p(%p) core is initializing...v(%d)e(%d)", mc_handle, new_core, new_core->video, new_core->encoder);
-       LOGD("factory name : %s, output_fmt : %x", factory_name, out_mime);
+       LOGD("codec:%s, sink:%s, output_fmt: 0x%x", codec_name, sink_name, out_mime);
 
        /* create media_packet for output fmt */
        ret = _mc_output_media_packet_new(new_core, video, encoder, out_mime);
@@ -1991,7 +1993,7 @@ mc_ret_e mc_gst_prepare(mc_handle_t *mc_handle)
        }
 
        /* create basic core elements */
-       ret = _mc_gst_create_pipeline(new_core, factory_name);
+       ret = _mc_gst_create_pipeline(new_core, codec_name, sink_name);
        if (ret != MC_ERROR_NONE) {
                LOGE("failed to create pipeline");
                return ret;
@@ -2374,7 +2376,7 @@ static GstPadProbeReturn __dump_probe(GstPad *pad, GstPadProbeInfo *info, gpoint
 #endif /* TIZEN_FEATURE_ENABLE_DUMP_SOURCE */
 
 
-mc_ret_e _mc_gst_create_pipeline(mc_gst_core_t *core, const gchar *factory_name)
+mc_ret_e _mc_gst_create_pipeline(mc_gst_core_t *core, const gchar *codec_name, const gchar *sink_name)
 {
        int i = 0;
        int bitrate = 0;
@@ -2391,7 +2393,7 @@ mc_ret_e _mc_gst_create_pipeline(mc_gst_core_t *core, const gchar *factory_name)
                        return MC_NOT_INITIALIZED;
                }
 
-               core->codec = gst_element_factory_make(factory_name, NULL);
+               core->codec = gst_element_factory_make(codec_name, NULL);
                if (!core->codec) {
                        LOGE("codec element create fail");
                        goto ERROR;
@@ -2441,9 +2443,9 @@ mc_ret_e _mc_gst_create_pipeline(mc_gst_core_t *core, const gchar *factory_name)
                        goto ERROR;
                }
 
-               core->fakesink = gst_element_factory_make("fakesink", NULL);
+               core->fakesink = gst_element_factory_make(sink_name, NULL);
                if (!core->fakesink) {
-                       LOGE("fakesink create fail");
+                       LOGE("sink:%s create fail", sink_name);
                        goto ERROR;
                }
 
@@ -2531,21 +2533,31 @@ mc_ret_e _mc_gst_create_pipeline(mc_gst_core_t *core, const gchar *factory_name)
                                bitrate = core->ports[in_port_index]->port_def.info.audio.bitrate;
 
                        LOGI("set encoder bitrate[property:%s,v:%d] %d",
-                               core->codec_type->property->bitrate_name, core->video, bitrate);
+                               core->codec_type->codec_property->bitrate_name, core->video, bitrate);
 
                        g_object_set(core->codec,
-                               core->codec_type->property->bitrate_name, bitrate,
+                               core->codec_type->codec_property->bitrate_name, bitrate,
                                NULL);
                }
 
-               for (i = 0 ; i < core->codec_type->property->ext_num ; i++) {
-                       LOGI("set property [%s] -> [%s]",
-                               core->codec_type->property->ext_name[i],
-                               core->codec_type->property->ext_value[i]);
+               for (i = 0 ; i < core->codec_type->codec_property->ext_num ; i++) {
+                       LOGI("set codec property [%s] -> [%s]",
+                               core->codec_type->codec_property->ext_name[i],
+                               core->codec_type->codec_property->ext_value[i]);
 
                        gst_util_set_object_arg((GObject *)core->codec,
-                               core->codec_type->property->ext_name[i],
-                               core->codec_type->property->ext_value[i]);
+                               core->codec_type->codec_property->ext_name[i],
+                               core->codec_type->codec_property->ext_value[i]);
+               }
+
+               for (i = 0 ; i < core->codec_type->sink_property->ext_num ; i++) {
+                       LOGI("set sink property [%s] -> [%s]",
+                               core->codec_type->sink_property->ext_name[i],
+                               core->codec_type->sink_property->ext_value[i]);
+
+                       gst_util_set_object_arg((GObject *)core->fakesink,
+                               core->codec_type->sink_property->ext_name[i],
+                               core->codec_type->sink_property->ext_value[i]);
                }
 
                /* set state PLAYING */