Support avi file format

Apply tizen coding rule

[Version] 0.1.11
[Profile] Common, Mobile, Wearable, TV
[Issue Type] Add features

Change-Id: I5da7d4dc269cf3a2934c5af7d16c9e6b30d83936

diff --git a/include/mediademuxer_port.h b/include/mediademuxer_port.h
index 1d671ce..34c805f 100755 (executable)
--- a/include/mediademuxer_port.h
+++ b/include/mediademuxer_port.h
@@ -359,8 +359,8 @@ typedef struct _media_port_demuxer_ops {
        int (*stop)(MMHandleType pHandle);
        int (*unprepare)(MMHandleType pHandle);
        int (*destroy)(MMHandleType pHandle);
-       int (*set_error_cb)(MMHandleType demuxer, md_error_cb callback, void* user_data);
-       int (*set_eos_cb)(MMHandleType demuxer, md_eos_cb callback, void* user_data);
+       int (*set_error_cb)(MMHandleType demuxer, md_error_cb callback, void *user_data);
+       int (*set_eos_cb)(MMHandleType demuxer, md_eos_cb callback, void *user_data);
        int (*get_data)(MMHandleType pHandle, char *buffer);
 } media_port_demuxer_ops;
 

diff --git a/include/mediademuxer_util.h b/include/mediademuxer_util.h
index 7319515..01c0670 100755 (executable)
--- a/include/mediademuxer_util.h
+++ b/include/mediademuxer_util.h
@@ -77,17 +77,21 @@ extern "C" {
 #endif
 
 #define MEDIADEMUXER_CHECK_NULL(x_var) \
-       if (!x_var) { \
-               MD_E("[%s] is NULL\n", #x_var); \
-               return MD_ERROR_INVALID_ARGUMENT; \
-       }
+       do { \
+               if (!x_var) { \
+                       MD_E("[%s] is NULL\n", #x_var); \
+                       return MD_ERROR_INVALID_ARGUMENT; \
+               } \
+       } while (0)
 
 #define MEDIADEMUXER_CHECK_SET_AND_PRINT(x_var, x_cond, ret, ret_val, err_text) \
-       if (x_var != x_cond) { \
-               ret = ret_val; \
-               MD_E("%s\n", #err_text); \
-               goto ERROR; \
-       }
+       do { \
+               if (x_var != x_cond) { \
+                       ret = ret_val; \
+                       MD_E("%s\n", #err_text); \
+                       goto ERROR; \
+               } \
+       } while (0)
 
 #ifdef __cplusplus
 }

diff --git a/packaging/capi-mediademuxer.spec b/packaging/capi-mediademuxer.spec
index e171932..e0ed499 100755 (executable)
--- a/packaging/capi-mediademuxer.spec
+++ b/packaging/capi-mediademuxer.spec
@@ -1,6 +1,6 @@
 Name:       capi-mediademuxer
 Summary:    A Media Demuxer library in Tizen Native API
-Version:    0.1.10
+Version:    0.1.11
 Release:    1
 Group:      Multimedia/API
 License:    Apache-2.0

diff --git a/src/mediademuxer.c b/src/mediademuxer.c
index 8545c6e..35cbc15 100755 (executable)
--- a/src/mediademuxer.c
+++ b/src/mediademuxer.c
@@ -64,17 +64,15 @@ int mediademuxer_create(mediademuxer_h *demuxer)
                handle = NULL;
                return MEDIADEMUXER_ERROR_INVALID_OPERATION;
        } else {
-               *demuxer = (mediademuxer_h) handle;
+               *demuxer = (mediademuxer_h)handle;
                handle->is_stopped = false;
                MD_I("[CoreAPI][%s] new handle : %p", __FUNCTION__, *demuxer);
        }
        /* set callback */
        md_set_error_cb(handle->md_handle,
-                       (mediademuxer_error_cb) _mediademuxer_error_cb,
-                       handle);
+                       (mediademuxer_error_cb)_mediademuxer_error_cb, handle);
        md_set_eos_cb(handle->md_handle,
-                       (mediademuxer_eos_cb) _mediademuxer_eos_cb,
-                       handle);
+                       (mediademuxer_eos_cb)_mediademuxer_eos_cb, handle);
 
        handle->demux_state = MEDIADEMUXER_STATE_IDLE;
        return MEDIADEMUXER_ERROR_NONE;
@@ -86,9 +84,9 @@ int mediademuxer_set_data_source(mediademuxer_h demuxer, const char *path)
        mediademuxer_error_e ret = MEDIADEMUXER_ERROR_NONE;
        DEMUXER_INSTANCE_CHECK(demuxer);
        mediademuxer_s *handle;
-       handle = (mediademuxer_s *)(demuxer);
+       handle = (mediademuxer_s *)demuxer;
        if (handle && path && handle->demux_state == MEDIADEMUXER_STATE_IDLE) {
-               ret = md_set_data_source((MMHandleType) (handle->md_handle), path);
+               ret = md_set_data_source((MMHandleType)handle->md_handle, path);
                if (ret != MEDIADEMUXER_ERROR_NONE) {
                        MD_E("[CoreAPI][%s] DEMUXER_ERROR_INVALID_OPERATION(0x%08x)", __FUNCTION__,
                                MEDIADEMUXER_ERROR_INVALID_PATH);
@@ -116,9 +114,9 @@ int mediademuxer_prepare(mediademuxer_h demuxer)
        mediademuxer_error_e ret = MEDIADEMUXER_ERROR_NONE;
        DEMUXER_INSTANCE_CHECK(demuxer);
        mediademuxer_s *handle;
-       handle = (mediademuxer_s *)(demuxer);
+       handle = (mediademuxer_s *)demuxer;
        if (handle && handle->demux_state == MEDIADEMUXER_STATE_IDLE && handle->eos_cb != NULL) {
-               ret = md_prepare((MMHandleType) (handle->md_handle));
+               ret = md_prepare((MMHandleType)handle->md_handle);
                if (ret != MEDIADEMUXER_ERROR_NONE) {
                        MD_E("[CoreAPI][%s] DEMUXER_ERROR_INVALID_OPERATION(0x%08x)",
                                __FUNCTION__, MEDIADEMUXER_ERROR_INVALID_OPERATION);
@@ -144,9 +142,9 @@ int mediademuxer_get_track_count(mediademuxer_h demuxer, int *count)
        mediademuxer_error_e ret;
        DEMUXER_INSTANCE_CHECK(demuxer);
        mediademuxer_s *handle;
-       handle = (mediademuxer_s *)(demuxer);
+       handle = (mediademuxer_s *)demuxer;
        if (handle && handle->demux_state == MEDIADEMUXER_STATE_READY) {
-               ret = md_get_track_count((MMHandleType) (handle->md_handle), count);
+               ret = md_get_track_count((MMHandleType)handle->md_handle, count);
                if (ret != MEDIADEMUXER_ERROR_NONE) {
                        MD_E("[CoreAPI][%s] DEMUXER_ERROR_INVALID_OPERATION(0x%08x)",
                                __FUNCTION__, MEDIADEMUXER_ERROR_INVALID_OPERATION);
@@ -168,9 +166,9 @@ int mediademuxer_select_track(mediademuxer_h demuxer, int track_index)
        mediademuxer_error_e ret;
        DEMUXER_INSTANCE_CHECK(demuxer);
        mediademuxer_s *handle;
-       handle = (mediademuxer_s *)(demuxer);
+       handle = (mediademuxer_s *)demuxer;
        if (handle && handle->demux_state == MEDIADEMUXER_STATE_READY) {
-               ret = md_select_track((MMHandleType) (handle->md_handle), track_index);
+               ret = md_select_track((MMHandleType)handle->md_handle, track_index);
                if (ret != MEDIADEMUXER_ERROR_NONE) {
                        MD_E("[CoreAPI][%s] DEMUXER_ERROR_INVALID_OPERATION(0x%08x)",
                                __FUNCTION__, MEDIADEMUXER_ERROR_INVALID_OPERATION);
@@ -192,9 +190,9 @@ int mediademuxer_start(mediademuxer_h demuxer)
        mediademuxer_error_e ret;
        DEMUXER_INSTANCE_CHECK(demuxer);
        mediademuxer_s *handle;
-       handle = (mediademuxer_s *)(demuxer);
+       handle = (mediademuxer_s *)demuxer;
        if (handle && handle->demux_state == MEDIADEMUXER_STATE_READY) {
-               ret = md_start((MMHandleType) (handle->md_handle));
+               ret = md_start((MMHandleType)handle->md_handle);
                if (ret != MEDIADEMUXER_ERROR_NONE) {
                        MD_E("[CoreAPI][%s] DEMUXER_ERROR_INVALID_OPERATION(0x%08x)",
                                __FUNCTION__, MEDIADEMUXER_ERROR_INVALID_OPERATION);
@@ -219,14 +217,14 @@ int mediademuxer_get_track_info(mediademuxer_h demuxer, int track_index,
        mediademuxer_error_e ret;
        DEMUXER_INSTANCE_CHECK(demuxer);
        mediademuxer_s *handle;
-       handle = (mediademuxer_s *)(demuxer);
+       handle = (mediademuxer_s *)demuxer;
        if (track_index < 0 || format == NULL) {
                MD_E("Invalid input parameters\n");
                return MEDIADEMUXER_ERROR_INVALID_PARAMETER;
        }
        if (handle && (handle->demux_state == MEDIADEMUXER_STATE_READY
                || handle->demux_state == MEDIADEMUXER_STATE_DEMUXING)) {
-               ret = md_get_track_info((MMHandleType) (handle->md_handle), track_index, format);
+               ret = md_get_track_info((MMHandleType)handle->md_handle, track_index, format);
                if (ret != MEDIADEMUXER_ERROR_NONE) {
                        MD_E("[CoreAPI][%s] DEMUXER_ERROR_INVALID_OPERATION(0x%08x)",
                                __FUNCTION__, MEDIADEMUXER_ERROR_INVALID_OPERATION);
@@ -249,11 +247,11 @@ int mediademuxer_read_sample(mediademuxer_h demuxer, int track_index,
        mediademuxer_error_e ret;
        DEMUXER_INSTANCE_CHECK(demuxer);
        mediademuxer_s *handle;
-       handle = (mediademuxer_s *)(demuxer);
+       handle = (mediademuxer_s *)demuxer;
        if (outbuf == NULL || track_index < 0)
                return MEDIADEMUXER_ERROR_INVALID_PARAMETER;
        if (handle && handle->demux_state == MEDIADEMUXER_STATE_DEMUXING) {
-               ret = md_read_sample((MMHandleType) (handle->md_handle), track_index, outbuf);
+               ret = md_read_sample((MMHandleType)handle->md_handle, track_index, outbuf);
                if (ret != MEDIADEMUXER_ERROR_NONE) {
                        MD_E("[CoreAPI][%s] DEMUXER_ERROR_INVALID_OPERATION(0x%08x)",
                                __FUNCTION__, MEDIADEMUXER_ERROR_INVALID_OPERATION);
@@ -275,9 +273,9 @@ int mediademuxer_seek(mediademuxer_h demuxer, int64_t pos)
        mediademuxer_error_e ret;
        DEMUXER_INSTANCE_CHECK(demuxer);
        mediademuxer_s *handle;
-       handle = (mediademuxer_s *)(demuxer);
+       handle = (mediademuxer_s *)demuxer;
        if (handle && handle->demux_state == MEDIADEMUXER_STATE_DEMUXING) {
-               ret = md_seek((MMHandleType) (handle->md_handle), pos);
+               ret = md_seek((MMHandleType)handle->md_handle, pos);
                if (ret != MEDIADEMUXER_ERROR_NONE) {
                        MD_E("[CoreAPI][%s] DEMUXER_ERROR_INVALID_OPERATION(0x%08x)",
                                __FUNCTION__, MEDIADEMUXER_ERROR_INVALID_OPERATION);
@@ -299,10 +297,10 @@ int mediademuxer_unselect_track(mediademuxer_h demuxer, int track_index)
        mediademuxer_error_e ret;
        DEMUXER_INSTANCE_CHECK(demuxer);
        mediademuxer_s *handle;
-       handle = (mediademuxer_s *)(demuxer);
+       handle = (mediademuxer_s *)demuxer;
        if (handle && (handle->demux_state == MEDIADEMUXER_STATE_READY
                || handle->demux_state == MEDIADEMUXER_STATE_DEMUXING)) {
-               ret = md_unselect_track((MMHandleType) (handle->md_handle), track_index);
+               ret = md_unselect_track((MMHandleType)handle->md_handle, track_index);
                if (ret != MEDIADEMUXER_ERROR_NONE) {
                        MD_E("[CoreAPI][%s] DEMUXER_ERROR_INVALID_OPERATION(0x%08x)",
                                __FUNCTION__, MEDIADEMUXER_ERROR_INVALID_OPERATION);
@@ -324,9 +322,9 @@ int mediademuxer_stop(mediademuxer_h demuxer)
        mediademuxer_error_e ret;
        DEMUXER_INSTANCE_CHECK(demuxer);
        mediademuxer_s *handle;
-       handle = (mediademuxer_s *)(demuxer);
+       handle = (mediademuxer_s *)demuxer;
        if (handle && handle->demux_state == MEDIADEMUXER_STATE_DEMUXING) {
-               ret = md_stop((MMHandleType) (handle->md_handle));
+               ret = md_stop((MMHandleType)handle->md_handle);
                if (ret != MEDIADEMUXER_ERROR_NONE) {
                        MD_E("[CoreAPI][%s] DEMUXER_ERROR_INVALID_OPERATION(0x%08x)",
                                __FUNCTION__, MEDIADEMUXER_ERROR_INVALID_OPERATION);
@@ -349,9 +347,9 @@ int mediademuxer_unprepare(mediademuxer_h demuxer)
        mediademuxer_error_e ret;
        DEMUXER_INSTANCE_CHECK(demuxer);
        mediademuxer_s *handle;
-       handle = (mediademuxer_s *)(demuxer);
+       handle = (mediademuxer_s *)demuxer;
        if (handle && handle->demux_state == MEDIADEMUXER_STATE_READY) {
-               ret = md_unprepare((MMHandleType) (handle->md_handle));
+               ret = md_unprepare((MMHandleType)handle->md_handle);
                if (ret != MEDIADEMUXER_ERROR_NONE) {
                        MD_E("[CoreAPI][%s] DEMUXER_ERROR_INVALID_OPERATION(0x%08x)",
                                __FUNCTION__, MEDIADEMUXER_ERROR_INVALID_OPERATION);
@@ -374,9 +372,9 @@ int mediademuxer_destroy(mediademuxer_h demuxer)
        mediademuxer_error_e ret;
        DEMUXER_INSTANCE_CHECK(demuxer);
        mediademuxer_s *handle;
-       handle = (mediademuxer_s *)(demuxer);
+       handle = (mediademuxer_s *)demuxer;
        if (handle && handle->demux_state == MEDIADEMUXER_STATE_IDLE) {
-               ret = md_destroy(handle->md_handle);
+               ret = md_destroy((MMHandleType)handle->md_handle);
                if (ret != MEDIADEMUXER_ERROR_NONE) {
                        MD_E("[CoreAPI][%s] DEMUXER_ERROR_INVALID_OPERATION(0x%08x)",
                                __FUNCTION__, MEDIADEMUXER_ERROR_INVALID_OPERATION);
@@ -399,7 +397,7 @@ int mediademuxer_get_state(mediademuxer_h demuxer, mediademuxer_state *state)
 {
        mediademuxer_error_e ret = MEDIADEMUXER_ERROR_NONE;
        DEMUXER_INSTANCE_CHECK(demuxer);
-       mediademuxer_s *handle = (mediademuxer_s *)(demuxer);
+       mediademuxer_s *handle = (mediademuxer_s *)demuxer;
        if (state != NULL) {
                *state = handle->demux_state;
        } else {
@@ -415,7 +413,7 @@ int mediademuxer_set_error_cb(mediademuxer_h demuxer,
 {
        DEMUXER_INSTANCE_CHECK(demuxer);
        mediademuxer_s *handle;
-       handle = (mediademuxer_s *)(demuxer);
+       handle = (mediademuxer_s *)demuxer;
        if (handle->demux_state != MEDIADEMUXER_STATE_IDLE)
                return MEDIADEMUXER_ERROR_INVALID_STATE;
        handle->error_cb = callback;
@@ -428,7 +426,7 @@ int mediademuxer_unset_error_cb(mediademuxer_h demuxer)
 {
        DEMUXER_INSTANCE_CHECK(demuxer);
        mediademuxer_s *handle;
-       handle = (mediademuxer_s *)(demuxer);
+       handle = (mediademuxer_s *)demuxer;
        if (handle->demux_state != MEDIADEMUXER_STATE_IDLE)
                return MEDIADEMUXER_ERROR_INVALID_STATE;
        handle->error_cb = NULL;
@@ -443,7 +441,7 @@ static gboolean _mediademuxer_error_cb(mediademuxer_error_e error, void *user_da
                MD_I("_mediademuxer_error_cb: ERROR %d to report. But call back is not set\n", error);
                return 0;
        }
-       mediademuxer_s * handle = (mediademuxer_s *) user_data;
+       mediademuxer_s * handle = (mediademuxer_s *)user_data;
        if (handle->demux_state != MEDIADEMUXER_STATE_IDLE)
                return MEDIADEMUXER_ERROR_INVALID_STATE;
        if (handle->error_cb)
@@ -458,7 +456,7 @@ int mediademuxer_set_eos_cb(mediademuxer_h demuxer,
 {
        DEMUXER_INSTANCE_CHECK(demuxer);
        mediademuxer_s *handle;
-       handle = (mediademuxer_s *)(demuxer);
+       handle = (mediademuxer_s *)demuxer;
        if (handle->demux_state != MEDIADEMUXER_STATE_IDLE)
                return MEDIADEMUXER_ERROR_INVALID_STATE;
        handle->eos_cb = callback;
@@ -471,7 +469,7 @@ int mediademuxer_unset_eos_cb(mediademuxer_h demuxer)
 {
        DEMUXER_INSTANCE_CHECK(demuxer);
        mediademuxer_s *handle;
-       handle = (mediademuxer_s *)(demuxer);
+       handle = (mediademuxer_s *)demuxer;
        if (handle->demux_state != MEDIADEMUXER_STATE_IDLE)
                return MEDIADEMUXER_ERROR_INVALID_STATE;
        handle->eos_cb = NULL;

diff --git a/src/mediademuxer_port.c b/src/mediademuxer_port.c
index 7abee84..2a503de 100755 (executable)
--- a/src/mediademuxer_port.c
+++ b/src/mediademuxer_port.c
@@ -61,13 +61,13 @@ int md_create(MMHandleType *demuxer)
        media_port_demuxer_ops *pOps = NULL;
        md_handle_t *new_demuxer = NULL;
        MEDIADEMUXER_FENTER();
-       new_demuxer = (md_handle_t *) g_malloc(sizeof(md_handle_t));
+       new_demuxer = (md_handle_t *)g_malloc(sizeof(md_handle_t));
        MD_I("md_create allocatiing new_demuxer %p:\n", new_demuxer);
        MEDIADEMUXER_CHECK_NULL(new_demuxer);
        memset(new_demuxer, 0, sizeof(md_handle_t));
 
        /* alloc ops structure */
-       pOps = (media_port_demuxer_ops *) g_malloc(sizeof(media_port_demuxer_ops));
+       pOps = (media_port_demuxer_ops *)g_malloc(sizeof(media_port_demuxer_ops));
        MEDIADEMUXER_CHECK_NULL(pOps);
 
        new_demuxer->demuxer_ops = pOps;
@@ -86,11 +86,11 @@ int md_create(MMHandleType *demuxer)
        result = pOps->init(&new_demuxer->mdport_handle);
        MEDIADEMUXER_CHECK_SET_AND_PRINT(result, MD_ERROR_NONE, result,
                                                                        MD_NOT_INITIALIZED, "md_create failed");
-       *demuxer = (MMHandleType) new_demuxer;
+       *demuxer = (MMHandleType)new_demuxer;
        MEDIADEMUXER_FLEAVE();
        return result;
 ERROR:
-       *demuxer = (MMHandleType) 0;
+       *demuxer = (MMHandleType)0;
        if (pOps)
                g_free(pOps);
        if (new_demuxer)
@@ -250,7 +250,7 @@ int _md_util_parse(MMHandleType demuxer, const char *type)
        md_handle_t *new_demuxer = NULL;
        MEDIADEMUXER_FENTER();
        MEDIADEMUXER_CHECK_NULL(demuxer);
-       new_demuxer = (md_handle_t *) demuxer;
+       new_demuxer = (md_handle_t *)demuxer;
        lenght_string = strlen(type);
        media_type_string = (char *)g_malloc(sizeof(char) * (lenght_string + 1));
        MEDIADEMUXER_CHECK_NULL(media_type_string);
@@ -303,7 +303,7 @@ ERROR:
 int md_prepare(MMHandleType demuxer)
 {
        int result = MD_ERROR_NONE;
-       md_handle_t *md_handle = (md_handle_t *) demuxer;
+       md_handle_t *md_handle = (md_handle_t *)demuxer;
        MEDIADEMUXER_FENTER();
        MEDIADEMUXER_CHECK_NULL(md_handle);
        media_port_demuxer_ops *pOps = md_handle->demuxer_ops;
@@ -323,7 +323,7 @@ ERROR:
 int md_get_track_count(MMHandleType demuxer, int *count)
 {
        int result = MD_ERROR_NONE;
-       md_handle_t *md_handle = (md_handle_t *) demuxer;
+       md_handle_t *md_handle = (md_handle_t *)demuxer;
        MEDIADEMUXER_FENTER();
        MEDIADEMUXER_CHECK_NULL(md_handle);
        media_port_demuxer_ops *pOps = md_handle->demuxer_ops;
@@ -343,7 +343,7 @@ ERROR:
 int md_select_track(MMHandleType demuxer, int track)
 {
        int result = MD_ERROR_NONE;
-       md_handle_t *md_handle = (md_handle_t *) demuxer;
+       md_handle_t *md_handle = (md_handle_t *)demuxer;
        MEDIADEMUXER_FENTER();
        MEDIADEMUXER_CHECK_NULL(md_handle);
        media_port_demuxer_ops *pOps = md_handle->demuxer_ops;
@@ -362,7 +362,7 @@ ERROR:
 int md_start(MMHandleType demuxer)
 {
        int result = MD_ERROR_NONE;
-       md_handle_t *md_handle = (md_handle_t *) demuxer;
+       md_handle_t *md_handle = (md_handle_t *)demuxer;
        MEDIADEMUXER_FENTER();
        MEDIADEMUXER_CHECK_NULL(md_handle);
        media_port_demuxer_ops *pOps = md_handle->demuxer_ops;
@@ -381,7 +381,7 @@ ERROR:
 int md_get_track_info(MMHandleType demuxer, int track, media_format_h *format)
 {
        int result = MD_ERROR_NONE;
-       md_handle_t *md_handle = (md_handle_t *) demuxer;
+       md_handle_t *md_handle = (md_handle_t *)demuxer;
        MEDIADEMUXER_FENTER();
        MEDIADEMUXER_CHECK_NULL(md_handle);
        media_port_demuxer_ops *pOps = md_handle->demuxer_ops;
@@ -401,7 +401,7 @@ ERROR:
 int md_read_sample(MMHandleType demuxer, int track_indx, media_packet_h *outbuf)
 {
        int result = MD_ERROR_NONE;
-       md_handle_t *md_handle = (md_handle_t *) demuxer;
+       md_handle_t *md_handle = (md_handle_t *)demuxer;
        MEDIADEMUXER_FENTER();
        MEDIADEMUXER_CHECK_NULL(md_handle);
        media_port_demuxer_ops *pOps = md_handle->demuxer_ops;
@@ -423,7 +423,7 @@ ERROR:
 int md_seek(MMHandleType demuxer, int64_t pos)
 {
        int result = MD_ERROR_NONE;
-       md_handle_t *md_handle = (md_handle_t *) demuxer;
+       md_handle_t *md_handle = (md_handle_t *)demuxer;
        MEDIADEMUXER_FENTER();
        MEDIADEMUXER_CHECK_NULL(md_handle);
        media_port_demuxer_ops *pOps = md_handle->demuxer_ops;
@@ -442,7 +442,7 @@ ERROR:
 int md_unselect_track(MMHandleType demuxer, int track)
 {
        int result = MD_ERROR_NONE;
-       md_handle_t *md_handle = (md_handle_t *) demuxer;
+       md_handle_t *md_handle = (md_handle_t *)demuxer;
        MEDIADEMUXER_FENTER();
        MEDIADEMUXER_CHECK_NULL(md_handle);
        media_port_demuxer_ops *pOps = md_handle->demuxer_ops;
@@ -461,7 +461,7 @@ ERROR:
 int md_stop(MMHandleType demuxer)
 {
        int result = MD_ERROR_NONE;
-       md_handle_t *md_handle = (md_handle_t *) demuxer;
+       md_handle_t *md_handle = (md_handle_t *)demuxer;
        MEDIADEMUXER_FENTER();
        MEDIADEMUXER_CHECK_NULL(md_handle);
        media_port_demuxer_ops *pOps = md_handle->demuxer_ops;
@@ -480,7 +480,7 @@ ERROR:
 int md_unprepare(MMHandleType demuxer)
 {
        int result = MD_ERROR_NONE;
-       md_handle_t *md_handle = (md_handle_t *) demuxer;
+       md_handle_t *md_handle = (md_handle_t *)demuxer;
        MEDIADEMUXER_FENTER();
        MEDIADEMUXER_CHECK_NULL(md_handle);
        media_port_demuxer_ops *pOps = md_handle->demuxer_ops;
@@ -499,7 +499,7 @@ ERROR:
 int md_destroy(MMHandleType demuxer)
 {
        int result = MD_ERROR_NONE;
-       md_handle_t *md_handle = (md_handle_t *) demuxer;
+       md_handle_t *md_handle = (md_handle_t *)demuxer;
        MEDIADEMUXER_CHECK_NULL(md_handle);
        MEDIADEMUXER_FENTER();
        media_port_demuxer_ops *pOps = md_handle->demuxer_ops;
@@ -535,7 +535,7 @@ int md_set_error_cb(MMHandleType demuxer,
 {
        MEDIADEMUXER_FENTER();
        int result = MD_ERROR_NONE;
-       md_handle_t *md_handle = (md_handle_t *) demuxer;
+       md_handle_t *md_handle = (md_handle_t *)demuxer;
        MEDIADEMUXER_CHECK_NULL(md_handle);
        media_port_demuxer_ops *pOps = md_handle->demuxer_ops;
        MEDIADEMUXER_CHECK_NULL(pOps);
@@ -555,7 +555,7 @@ int md_set_eos_cb(MMHandleType demuxer,
 {
        MEDIADEMUXER_FENTER();
        int result = MD_ERROR_NONE;
-       md_handle_t *md_handle = (md_handle_t *) demuxer;
+       md_handle_t *md_handle = (md_handle_t *)demuxer;
        MEDIADEMUXER_CHECK_NULL(md_handle);
        media_port_demuxer_ops *pOps = md_handle->demuxer_ops;
        MEDIADEMUXER_CHECK_NULL(pOps);

diff --git a/src/port_gst/mediademuxer_port_gst.c b/src/port_gst/mediademuxer_port_gst.c
index 09c696f..b9d9b4f 100755 (executable)
--- a/src/port_gst/mediademuxer_port_gst.c
+++ b/src/port_gst/mediademuxer_port_gst.c
@@ -42,10 +42,10 @@ static int gst_demuxer_stop(MMHandleType pHandle);
 static int gst_demuxer_unprepare(MMHandleType pHandle);
 static int gst_demuxer_destroy(MMHandleType pHandle);
 static int gst_set_error_cb(MMHandleType pHandle,
-                       gst_error_cb callback, void* user_data);
+                       gst_error_cb callback, void *user_data);
 static int gst_set_eos_cb(MMHandleType pHandle,
                        gst_eos_cb callback, void *user_data);
-static int __gst_eos_callback(int track_num, void* user_data);
+static int __gst_eos_callback(int track_num, void *user_data);
 
 /* Media Demuxer API common */
 static media_port_demuxer_ops def_demux_ops = {
@@ -86,7 +86,7 @@ static int gst_demuxer_init(MMHandleType *pHandle)
        MEDIADEMUXER_FENTER();
        int ret = MD_ERROR_NONE;
        mdgst_handle_t *new_mediademuxer = NULL;
-       new_mediademuxer = (mdgst_handle_t *) g_malloc(sizeof(mdgst_handle_t));
+       new_mediademuxer = (mdgst_handle_t *)g_malloc(sizeof(mdgst_handle_t));
        MD_I("gst_demuxer_init allocating new_mediademuxer:%p\n", new_mediademuxer);
        if (!new_mediademuxer) {
                MD_E("Cannot allocate memory for demuxer\n");
@@ -100,7 +100,7 @@ static int gst_demuxer_init(MMHandleType *pHandle)
        (new_mediademuxer->info).num_subtitle_track = 0;
        (new_mediademuxer->info).num_other_track = 0;
        (new_mediademuxer->info).head = NULL;
-       *pHandle = (MMHandleType) new_mediademuxer;
+       *pHandle = (MMHandleType)new_mediademuxer;
        new_mediademuxer->total_tracks = 0;
        MEDIADEMUXER_FLEAVE();
        return ret;
@@ -139,7 +139,7 @@ gboolean __gst_bus_call(GstBus *bus, GstMessage *msg, gpointer data)
 static void __gst_no_more_pad(GstElement *element, gpointer data)
 {
        MEDIADEMUXER_FENTER();
-       mdgst_handle_t *gst_handle = (mdgst_handle_t *) data;
+       mdgst_handle_t *gst_handle = (mdgst_handle_t *)data;
        int loop_track;
        track_info *head_track = &(gst_handle->info);
        track *head = head_track->head;
@@ -293,7 +293,7 @@ int __gst_add_track_info(GstPad *pad, gchar *name, track **head,
                                MD_E("factory not able to make h264parse");
                                goto ERROR;
                        }
-               } else if(strstr(temp->caps_string, "mpeg")) {
+               } else if (strstr(temp->caps_string, "mpeg")) {
                        parse_element = gst_element_factory_make("mpeg4videoparse", NULL);
                        if (!parse_element) {
                                MD_E("factory not able to make h264parse");
@@ -302,7 +302,7 @@ int __gst_add_track_info(GstPad *pad, gchar *name, track **head,
                        g_object_set(G_OBJECT(parse_element), "config-interval", 1, NULL);
                }
 
-               if(parse_element) {
+               if (parse_element) {
                        gst_bin_add(GST_BIN(pipeline), parse_element);
                        parse_sink_pad = gst_element_get_static_pad(parse_element, "sink");
                        if (!parse_sink_pad) {
@@ -324,16 +324,16 @@ int __gst_add_track_info(GstPad *pad, gchar *name, track **head,
                                MEDIADEMUXER_LINK_PAD(queue_src_pad, apppad, ERROR);
                        }
                }
-       } else if(strstr(name, "audio")) {
+       } else if (strstr(name, "audio")) {
                //Create Parse
                if (strstr(temp->caps_string, "audio/mpeg")) {
                        int mpegversion = 0;
                        GstStructure *structure = NULL;
                        structure = gst_caps_get_structure(temp->caps, 0);
                        gst_structure_get_int (structure, "mpegversion", &mpegversion);
-                       if(mpegversion == 2 || mpegversion == 4)
+                       if (mpegversion == 2 || mpegversion == 4)
                                parse_element = gst_element_factory_make("aacparse", NULL);
-                       else if(mpegversion == 1)
+                       else if (mpegversion == 1)
                                parse_element = gst_element_factory_make("mpegaudioparse", NULL);
                } else if (strstr(temp->caps_string, "application/x-id3")) {
                        parse_element = gst_element_factory_make("mpegaudioparse", NULL);
@@ -412,7 +412,7 @@ static void __gst_on_pad_added(GstElement *element, GstPad *pad, gpointer data)
        MEDIADEMUXER_FENTER();
        MD_I("Dynamic pad created, linking demuxer/decoder\n");
        track *tmp = NULL;
-       mdgst_handle_t *gst_handle = (mdgst_handle_t *) data;
+       mdgst_handle_t *gst_handle = (mdgst_handle_t *)data;
        track_info *head_track = &(gst_handle->info);
        gchar *name = gst_pad_get_name(pad);
        gst_handle->total_tracks++;
@@ -453,7 +453,7 @@ static void __gst_on_pad_added(GstElement *element, GstPad *pad, gpointer data)
 static int __gst_create_audio_only_pipeline(gpointer data,  GstCaps *caps)
 {
        MEDIADEMUXER_FENTER();
-       mdgst_handle_t *gst_handle = (mdgst_handle_t *) data;
+       mdgst_handle_t *gst_handle = (mdgst_handle_t *)data;
        GstPad *pad = NULL;
        GstPad *aud_pad = NULL;
        GstPad *aud_srcpad = NULL;
@@ -601,7 +601,7 @@ static void __gst_cb_typefind(GstElement *tf, guint probability,
                                        GstCaps *caps, gpointer data)
 {
        MEDIADEMUXER_FENTER();
-       mdgst_handle_t *gst_handle = (mdgst_handle_t *) data;
+       mdgst_handle_t *gst_handle = (mdgst_handle_t *)data;
        GstPad *pad = NULL;
        GstPad *demuxer_pad = NULL;
        GstPad *fake_pad = NULL;
@@ -610,12 +610,14 @@ static void __gst_cb_typefind(GstElement *tf, guint probability,
        if (type) {
                MD_I("Media type %s found, probability %d%%\n", type, probability);
                if (strstr(type, "quicktime") || (strstr(type, "audio/x-m4a")) || strstr(type, "x-3gp")
-                               || strstr(type, "ogg") || strstr(type, "flv")) {
+                               || strstr(type, "ogg") || strstr(type, "flv") || strstr(type, "x-msvideo")) {
                        gst_handle->is_valid_container = true;
                        if (strstr(type, "ogg"))
                                gst_handle->demux = gst_element_factory_make("oggdemux", NULL);
                        else if (strstr(type, "flv"))
                                gst_handle->demux = gst_element_factory_make("flvdemux", NULL);
+                       else if (strstr(type, "x-msvideo"))
+                               gst_handle->demux = gst_element_factory_make("avidemux", NULL);
                        else
                                gst_handle->demux = gst_element_factory_make("qtdemux", NULL);
 
@@ -787,7 +789,7 @@ static int gst_demuxer_prepare(MMHandleType pHandle, char *uri)
        MEDIADEMUXER_FENTER();
        int ret = MD_ERROR_NONE;
        MEDIADEMUXER_CHECK_NULL(pHandle);
-       mdgst_handle_t *new_mediademuxer = (mdgst_handle_t *) pHandle;
+       mdgst_handle_t *new_mediademuxer = (mdgst_handle_t *)pHandle;
 
        MD_I("gst_demuxer_prepare Creating pipeline %p", new_mediademuxer);
        ret = _gst_create_pipeline(new_mediademuxer, uri);
@@ -807,7 +809,7 @@ static int gst_demuxer_get_data_count(MMHandleType pHandle, int *count)
        MEDIADEMUXER_FENTER();
        int ret = MD_ERROR_NONE;
        MEDIADEMUXER_CHECK_NULL(pHandle);
-       mdgst_handle_t *new_mediademuxer = (mdgst_handle_t *) pHandle;
+       mdgst_handle_t *new_mediademuxer = (mdgst_handle_t *)pHandle;
 
        *count = (new_mediademuxer->info).num_video_track +
                        (new_mediademuxer->info).num_audio_track +
@@ -838,7 +840,7 @@ static int gst_demuxer_set_track(MMHandleType pHandle, int track)
        MEDIADEMUXER_FENTER();
        int ret = MD_ERROR_NONE;
        MEDIADEMUXER_CHECK_NULL(pHandle);
-       mdgst_handle_t *new_mediademuxer = (mdgst_handle_t *) pHandle;
+       mdgst_handle_t *new_mediademuxer = (mdgst_handle_t *)pHandle;
 
        MD_I("total_tracks (%d) :: selected  track (%d)", new_mediademuxer->total_tracks, track);
        if (track >= new_mediademuxer->total_tracks || track < 0) {
@@ -847,7 +849,7 @@ static int gst_demuxer_set_track(MMHandleType pHandle, int track)
                goto ERROR;
        }
        new_mediademuxer->selected_tracks[track] = true;
-       _gst_set_appsink((((mdgst_handle_t *) pHandle)->info).head, track,
+       _gst_set_appsink((((mdgst_handle_t *)pHandle)->info).head, track,
                                        new_mediademuxer->total_tracks);
        MEDIADEMUXER_FLEAVE();
        return MD_ERROR_NONE;
@@ -884,7 +886,7 @@ static int gst_demuxer_start(MMHandleType pHandle)
        MEDIADEMUXER_FENTER();
        int ret = MD_ERROR_NONE;
        MEDIADEMUXER_CHECK_NULL(pHandle);
-       mdgst_handle_t *gst_handle = (mdgst_handle_t *) pHandle;
+       mdgst_handle_t *gst_handle = (mdgst_handle_t *)pHandle;
 
        int indx;
        for (indx = 0; indx < gst_handle->total_tracks; indx++) {
@@ -895,7 +897,7 @@ static int gst_demuxer_start(MMHandleType pHandle)
                        _gst_demuxer_unset(pHandle, indx);
                */
                if (gst_handle->selected_tracks[indx] != true) {
-                       if (_gst_unlink_unselected_track((((mdgst_handle_t *) pHandle)->info).head, indx) != MD_ERROR_NONE) {
+                       if (_gst_unlink_unselected_track((((mdgst_handle_t *)pHandle)->info).head, indx) != MD_ERROR_NONE) {
                                MD_E("Failed to unlink unselected tracks\n");
                                ret = MD_INTERNAL_ERROR;
                                goto ERROR;
@@ -978,13 +980,7 @@ int _set_mime_video(media_format_h format, track *head)
                goto ERROR;
        }
        if (gst_structure_has_name(struc, "video/x-h264")) {
-               const gchar *version = gst_structure_get_string(struc, "stream-format");
-               if (strncmp(version, "avc", 3) == 0) {
-                       mime_type = MEDIA_FORMAT_H264_SP;
-               } else {
-                       MD_W("Video mime (%s) not supported so far\n", gst_structure_get_name(struc));
-                       goto ERROR;
-               }
+               mime_type = MEDIA_FORMAT_H264_SP;
        } else if (gst_structure_has_name(struc, "video/x-h263")) {
                mime_type = MEDIA_FORMAT_H263;
        } else if (gst_structure_has_name(struc, "video/mpeg")) {
@@ -1117,7 +1113,7 @@ static int gst_demuxer_get_track_info(MMHandleType pHandle,
        MEDIADEMUXER_FENTER();
        int ret = MD_ERROR_NONE;
        MEDIADEMUXER_CHECK_NULL(pHandle);
-       mdgst_handle_t *new_mediademuxer = (mdgst_handle_t *) pHandle;
+       mdgst_handle_t *new_mediademuxer = (mdgst_handle_t *)pHandle;
 
        track *temp = NULL;
        int loop;
@@ -1260,7 +1256,7 @@ static int _gst_copy_buf_to_media_packet(media_packet_h out_pkt,
                        ret = MD_ERROR_UNKNOWN;
                        goto ERROR;
                }
-               if (media_packet_set_codec_data(out_pkt, (void*)codec_data_map.data,
+               if (media_packet_set_codec_data(out_pkt, (void *)codec_data_map.data,
                        (unsigned int)codec_data_map.size)) {
                        MD_E("unable to set the codec data\n");
                        ret = MD_ERROR_UNKNOWN;
@@ -1301,7 +1297,7 @@ static int _gst_demuxer_create_eos_packet(media_format_h fmt, media_packet_h *ou
        MEDIADEMUXER_FLEAVE();
 
        return ret;
-       ERROR:
+ERROR:
        if (mediabuf)
                media_packet_destroy(mediabuf);
        *outbuf = NULL;
@@ -1315,7 +1311,7 @@ static int gst_demuxer_read_sample(MMHandleType pHandle,
        MEDIADEMUXER_FENTER();
        int ret = MD_ERROR_NONE;
        MEDIADEMUXER_CHECK_NULL(pHandle);
-       mdgst_handle_t *demuxer = (mdgst_handle_t *) pHandle;
+       mdgst_handle_t *demuxer = (mdgst_handle_t *)pHandle;
 
        media_packet_h mediabuf = NULL;
        int indx = 0;
@@ -1419,9 +1415,9 @@ static int gst_demuxer_seek(MMHandleType pHandle, gint64 pos1)
 {
        MEDIADEMUXER_FENTER();
        MEDIADEMUXER_CHECK_NULL(pHandle);
-       mdgst_handle_t *gst_handle = (mdgst_handle_t *) pHandle;
+       mdgst_handle_t *gst_handle = (mdgst_handle_t *)pHandle;
 
-       gint64 pos = 0, len = 0;
+       gint64 pos = 0;
        gdouble rate = 1;
        track_info *head_track = &(gst_handle->info);
        track *temp = head_track->head;
@@ -1448,9 +1444,7 @@ static int gst_demuxer_seek(MMHandleType pHandle, gint64 pos1)
 
        pos = pos1 * GST_MSECOND;
 
-       MD_I("\n\n");
-       MD_I("NEW Time: %" GST_TIME_FORMAT " / %" GST_TIME_FORMAT "\r",
-            GST_TIME_ARGS(pos1), GST_TIME_ARGS(len));
+       MD_I("NEW Time: %" GST_TIME_FORMAT, GST_TIME_ARGS(pos));
 
        indx = 0;
        while (temp) {
@@ -1495,7 +1489,7 @@ int _gst_unset_appsink(track *temp, int index, int loop)
                temp = temp->next;
                count++;
        }
-       gst_app_sink_set_max_buffers((GstAppSink *)(temp->appsink), (guint) 0);
+       gst_app_sink_set_max_buffers((GstAppSink *)(temp->appsink), (guint)0);
        gst_app_sink_set_drop((GstAppSink *)(temp->appsink), true);
        MEDIADEMUXER_FLEAVE();
        return ret;
@@ -1506,7 +1500,7 @@ static int gst_demuxer_unset_track(MMHandleType pHandle, int track)
        MEDIADEMUXER_FENTER();
        int ret = MD_ERROR_NONE;
        MEDIADEMUXER_CHECK_NULL(pHandle);
-       mdgst_handle_t *new_mediademuxer = (mdgst_handle_t *) pHandle;
+       mdgst_handle_t *new_mediademuxer = (mdgst_handle_t *)pHandle;
 
        if (track >= new_mediademuxer->total_tracks || track < 0) {
                MD_E("total tracks is less then unselected track, So not support this track");
@@ -1514,7 +1508,7 @@ static int gst_demuxer_unset_track(MMHandleType pHandle, int track)
                goto ERROR;
        }
        new_mediademuxer->selected_tracks[track] = false;
-       _gst_unset_appsink((((mdgst_handle_t *) pHandle)->info).head, track,
+       _gst_unset_appsink((((mdgst_handle_t *)pHandle)->info).head, track,
                                        new_mediademuxer->total_tracks);
        MEDIADEMUXER_FLEAVE();
        return ret;
@@ -1528,7 +1522,7 @@ static int gst_demuxer_stop(MMHandleType pHandle)
        MEDIADEMUXER_FENTER();
        int ret = MD_ERROR_NONE;
        MEDIADEMUXER_CHECK_NULL(pHandle);
-       mdgst_handle_t *gst_handle = (mdgst_handle_t *) pHandle;
+       mdgst_handle_t *gst_handle = (mdgst_handle_t *)pHandle;
 
        MD_I("gst_demuxer_stop pipeine %p", gst_handle);
        if (gst_element_set_state(gst_handle->pipeline, GST_STATE_PAUSED) ==
@@ -1580,7 +1574,7 @@ static int gst_demuxer_unprepare(MMHandleType pHandle)
        MEDIADEMUXER_FENTER();
        int ret = MD_ERROR_NONE;
        MEDIADEMUXER_CHECK_NULL(pHandle);
-       mdgst_handle_t *gst_handle = (mdgst_handle_t *) pHandle;
+       mdgst_handle_t *gst_handle = (mdgst_handle_t *)pHandle;
 
        _gst_clear_struct(gst_handle);
        if (gst_handle->bus_watch_id) {
@@ -1609,7 +1603,7 @@ static int gst_demuxer_destroy(MMHandleType pHandle)
        MEDIADEMUXER_FENTER();
        int ret = MD_ERROR_NONE;
        MEDIADEMUXER_CHECK_NULL(pHandle);
-       mdgst_handle_t *new_mediademuxer = (mdgst_handle_t *) pHandle;
+       mdgst_handle_t *new_mediademuxer = (mdgst_handle_t *)pHandle;
 
        MD_I("gst_demuxer_destroy deallocating new_mediademuxer:%p\n",
             new_mediademuxer);
@@ -1624,7 +1618,7 @@ int gst_set_error_cb(MMHandleType pHandle,
        MEDIADEMUXER_FENTER();
        int ret = MD_ERROR_NONE;
        MEDIADEMUXER_CHECK_NULL(pHandle);
-       mdgst_handle_t *gst_handle = (mdgst_handle_t *) pHandle;
+       mdgst_handle_t *gst_handle = (mdgst_handle_t *)pHandle;
 
        if (gst_handle->user_cb[_GST_EVENT_TYPE_ERROR]) {
                MD_E("Already set mediademuxer_error_cb\n");
@@ -1640,7 +1634,7 @@ int gst_set_error_cb(MMHandleType pHandle,
 
        MD_I("Set event handler callback(cb = %p, data = %p)\n", callback, user_data);
 
-       gst_handle->user_cb[_GST_EVENT_TYPE_ERROR] = (gst_error_cb) callback;
+       gst_handle->user_cb[_GST_EVENT_TYPE_ERROR] = (gst_error_cb)callback;
        gst_handle->user_data[_GST_EVENT_TYPE_ERROR] = user_data;
        MEDIADEMUXER_FLEAVE();
        return MD_ERROR_NONE;
@@ -1654,7 +1648,7 @@ int gst_set_eos_cb(MMHandleType pHandle, gst_eos_cb callback, void *user_data)
        MEDIADEMUXER_FENTER();
        int ret = MD_ERROR_NONE;
        MEDIADEMUXER_CHECK_NULL(pHandle);
-       mdgst_handle_t *gst_handle = (mdgst_handle_t *) pHandle;
+       mdgst_handle_t *gst_handle = (mdgst_handle_t *)pHandle;
 
        if (gst_handle->user_cb[_GST_EVENT_TYPE_EOS]) {
                MD_E("Already set mediademuxer_eos_cb\n");
@@ -1669,7 +1663,7 @@ int gst_set_eos_cb(MMHandleType pHandle, gst_eos_cb callback, void *user_data)
        }
 
        MD_I("Set event handler callback(cb = %p, data = %p)\n", callback, user_data);
-       gst_handle->user_cb[_GST_EVENT_TYPE_EOS] = (gst_eos_cb) callback;
+       gst_handle->user_cb[_GST_EVENT_TYPE_EOS] = (gst_eos_cb)callback;
        gst_handle->user_data[_GST_EVENT_TYPE_EOS] = user_data;
        MEDIADEMUXER_FLEAVE();
        return MD_ERROR_NONE;
@@ -1684,7 +1678,7 @@ static int __gst_eos_callback(int track_num, void* user_data)
                MD_E("Invalid argument");
                return MD_ERROR;
        }
-       mdgst_handle_t *gst_handle = (mdgst_handle_t *) user_data;
+       mdgst_handle_t *gst_handle = (mdgst_handle_t *)user_data;
        if (gst_handle->user_cb[_GST_EVENT_TYPE_EOS])
                ((gst_eos_cb)gst_handle->user_cb[_GST_EVENT_TYPE_EOS])(track_num,
                                        gst_handle->user_data[_GST_EVENT_TYPE_EOS]);

diff --git a/test/mediademuxer_test.c b/test/mediademuxer_test.c
index 4b3f211..f24ec53 100755 (executable)
--- a/test/mediademuxer_test.c
+++ b/test/mediademuxer_test.c
@@ -197,11 +197,11 @@ int test_mediademuxer_set_data_source(mediademuxer_h demuxer, const char *path)
        g_print("test_mediademuxer_set_data_source\n");
 
 #if DEMUXER_OUTPUT_DUMP
-       fp_audio_out = fopen("/opt/usr/dump_audio.out", "wb");
+       fp_audio_out = fopen("/tmp/dump_audio.out", "wb");
        if (fp_audio_out != NULL) {
                validate_dump = true;
-               fp_video_out = fopen("/opt/usr/dump_video.out", "wb");
-               fp_text_out = fopen("/opt/usr/dump_text.out", "wb");
+               fp_video_out = fopen("/tmp/dump_video.out", "wb");
+               fp_text_out = fopen("/tmp/dump_text.out", "wb");
        } else {
                g_print("Error - Cannot open file for file dump, Please chek root\n");
        }