Modify enumeration name about mediademuxer_state

[Version] 0.1.8
[Profile] Common
[Issue Type] Modify enumeration

Change-Id: I851d705debeaac986e15ccc5645435858914098f

diff --git a/include/mediademuxer.h b/include/mediademuxer.h
index b358bcc..6e08f4c 100755 (executable)
--- a/include/mediademuxer.h
+++ b/include/mediademuxer.h
@@ -47,10 +47,10 @@ typedef struct mediademuxer_s *mediademuxer_h;
  * @since_tizen 3.0
  */
 typedef enum {
-       MEDIADEMUXER_NONE,              /**< The mediademuxer is not created */
-       MEDIADEMUXER_IDLE,                      /**< The mediademuxer is created, but not prepared */
-       MEDIADEMUXER_READY,             /**< The mediademuxer is ready to demux media */
-       MEDIADEMUXER_DEMUXING           /**< The mediademuxer is demuxing media */
+       MEDIADEMUXER_STATE_NONE,                /**< The mediademuxer is not created */
+       MEDIADEMUXER_STATE_IDLE,                /**< The mediademuxer is created, but not prepared */
+       MEDIADEMUXER_STATE_READY,               /**< The mediademuxer is ready to demux media */
+       MEDIADEMUXER_STATE_DEMUXING             /**< The mediademuxer is demuxing media */
 } mediademuxer_state;
 
 /**
@@ -58,7 +58,7 @@ typedef enum {
  * @since_tizen 3.0
  */
 typedef enum {
-       MEDIADEMUXER_ERROR_NONE = TIZEN_ERROR_NONE,     /*< Successful */
+       MEDIADEMUXER_ERROR_NONE = TIZEN_ERROR_NONE,     /**< Successful */
        MEDIADEMUXER_ERROR_OUT_OF_MEMORY = TIZEN_ERROR_OUT_OF_MEMORY,   /**< Out of memory */
        MEDIADEMUXER_ERROR_INVALID_PARAMETER = TIZEN_ERROR_INVALID_PARAMETER,   /**< Invalid parameter */
        MEDIADEMUXER_ERROR_INVALID_OPERATION = TIZEN_ERROR_INVALID_OPERATION,   /**< Invalid operation */
@@ -295,7 +295,7 @@ int mediademuxer_unselect_track(mediademuxer_h demuxer, int track_index);
  * @retval #MEDIADEMUXER_ERROR_INVALID_STATE Invalid state
  * @retval #MEDIADEMUXER_ERROR_INVALID_OPERATION Invalid Operation
  * @pre The media demuxer state must be set to #MEDIADEMUXER_STATE_DEMUXING.
- * @post The media demuxer state will be in  #MEDIADEMUXER_READY.
+ * @post The media demuxer state will be in  #MEDIADEMUXER_STATE_READY.
  * @see mediademuxer_start()
  * @see mediademuxer_unprepare()
  * */

diff --git a/packaging/capi-mediademuxer.spec b/packaging/capi-mediademuxer.spec
index d2fff33..bea7234 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.7
+Version:    0.1.8
 Release:    1
 Group:      Multimedia/API
 License:    Apache-2.0

diff --git a/src/mediademuxer.c b/src/mediademuxer.c
index e2c67c1..8545c6e 100755 (executable)
--- a/src/mediademuxer.c
+++ b/src/mediademuxer.c
@@ -44,7 +44,7 @@ int mediademuxer_create(mediademuxer_h *demuxer)
                handle = (mediademuxer_s *) g_malloc(sizeof(mediademuxer_s));
                if (handle != NULL) {
                        memset(handle, 0, sizeof(mediademuxer_s));
-                       handle->demux_state = MEDIADEMUXER_NONE;
+                       handle->demux_state = MEDIADEMUXER_STATE_NONE;
                } else {
                        MD_E("[CoreAPI][%s] DEMUXER_ERROR_OUT_OF_MEMORY(0x%08x)",
                                __FUNCTION__, MEDIADEMUXER_ERROR_OUT_OF_MEMORY);
@@ -76,7 +76,7 @@ int mediademuxer_create(mediademuxer_h *demuxer)
                        (mediademuxer_eos_cb) _mediademuxer_eos_cb,
                        handle);
 
-       handle->demux_state = MEDIADEMUXER_IDLE;
+       handle->demux_state = MEDIADEMUXER_STATE_IDLE;
        return MEDIADEMUXER_ERROR_NONE;
 }
 
@@ -87,7 +87,7 @@ int mediademuxer_set_data_source(mediademuxer_h demuxer, const char *path)
        DEMUXER_INSTANCE_CHECK(demuxer);
        mediademuxer_s *handle;
        handle = (mediademuxer_s *)(demuxer);
-       if (handle && path && handle->demux_state == MEDIADEMUXER_IDLE) {
+       if (handle && path && handle->demux_state == MEDIADEMUXER_STATE_IDLE) {
                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__,
@@ -100,7 +100,7 @@ int mediademuxer_set_data_source(mediademuxer_h demuxer, const char *path)
                                __FUNCTION__, MEDIADEMUXER_ERROR_INVALID_PATH);
                        return MEDIADEMUXER_ERROR_INVALID_PATH;
                } else {
-                       if (handle->demux_state != MEDIADEMUXER_IDLE)
+                       if (handle->demux_state != MEDIADEMUXER_STATE_IDLE)
                                return MEDIADEMUXER_ERROR_INVALID_STATE;
                        MD_E("[CoreAPI][%s] DEMUXER_ERROR_INVALID_OPERATION(0x%08x)",
                                __FUNCTION__, MEDIADEMUXER_ERROR_INVALID_OPERATION);
@@ -117,17 +117,17 @@ int mediademuxer_prepare(mediademuxer_h demuxer)
        DEMUXER_INSTANCE_CHECK(demuxer);
        mediademuxer_s *handle;
        handle = (mediademuxer_s *)(demuxer);
-       if (handle && handle->demux_state == MEDIADEMUXER_IDLE && handle->eos_cb != NULL) {
+       if (handle && handle->demux_state == MEDIADEMUXER_STATE_IDLE && handle->eos_cb != NULL) {
                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);
                        return MEDIADEMUXER_ERROR_INVALID_OPERATION;
                } else {
-                       handle->demux_state = MEDIADEMUXER_READY;
+                       handle->demux_state = MEDIADEMUXER_STATE_READY;
                }
        } else {
-               if (handle->demux_state != MEDIADEMUXER_IDLE)
+               if (handle->demux_state != MEDIADEMUXER_STATE_IDLE)
                        return MEDIADEMUXER_ERROR_INVALID_STATE;
                if (handle->eos_cb == NULL)
                        MD_E("EOS callback is not set\n");
@@ -145,7 +145,7 @@ int mediademuxer_get_track_count(mediademuxer_h demuxer, int *count)
        DEMUXER_INSTANCE_CHECK(demuxer);
        mediademuxer_s *handle;
        handle = (mediademuxer_s *)(demuxer);
-       if (handle && handle->demux_state == MEDIADEMUXER_READY) {
+       if (handle && handle->demux_state == MEDIADEMUXER_STATE_READY) {
                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)",
@@ -153,7 +153,7 @@ int mediademuxer_get_track_count(mediademuxer_h demuxer, int *count)
                        return MEDIADEMUXER_ERROR_INVALID_OPERATION;
                }
        } else {
-               if (handle->demux_state != MEDIADEMUXER_READY)
+               if (handle->demux_state != MEDIADEMUXER_STATE_READY)
                        return MEDIADEMUXER_ERROR_INVALID_STATE;
                MD_E("[CoreAPI][%s] DEMUXER_ERROR_INVALID_OPERATION(0x%08x)",
                        __FUNCTION__, MEDIADEMUXER_ERROR_INVALID_OPERATION);
@@ -169,7 +169,7 @@ int mediademuxer_select_track(mediademuxer_h demuxer, int track_index)
        DEMUXER_INSTANCE_CHECK(demuxer);
        mediademuxer_s *handle;
        handle = (mediademuxer_s *)(demuxer);
-       if (handle && handle->demux_state == MEDIADEMUXER_READY) {
+       if (handle && handle->demux_state == MEDIADEMUXER_STATE_READY) {
                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)",
@@ -177,7 +177,7 @@ int mediademuxer_select_track(mediademuxer_h demuxer, int track_index)
                        return MEDIADEMUXER_ERROR_INVALID_OPERATION;
                }
        } else {
-               if (handle->demux_state != MEDIADEMUXER_READY)
+               if (handle->demux_state != MEDIADEMUXER_STATE_READY)
                        return MEDIADEMUXER_ERROR_INVALID_STATE;
                MD_E("[CoreAPI][%s] DEMUXER_ERROR_INVALID_OPERATION(0x%08x)",
                        __FUNCTION__, MEDIADEMUXER_ERROR_INVALID_OPERATION);
@@ -193,17 +193,17 @@ int mediademuxer_start(mediademuxer_h demuxer)
        DEMUXER_INSTANCE_CHECK(demuxer);
        mediademuxer_s *handle;
        handle = (mediademuxer_s *)(demuxer);
-       if (handle && handle->demux_state == MEDIADEMUXER_READY) {
+       if (handle && handle->demux_state == MEDIADEMUXER_STATE_READY) {
                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);
                        return MEDIADEMUXER_ERROR_INVALID_OPERATION;
                } else {
-                       handle->demux_state = MEDIADEMUXER_DEMUXING;
+                       handle->demux_state = MEDIADEMUXER_STATE_DEMUXING;
                }
        } else {
-               if (handle->demux_state != MEDIADEMUXER_READY)
+               if (handle->demux_state != MEDIADEMUXER_STATE_READY)
                        return MEDIADEMUXER_ERROR_INVALID_STATE;
                MD_E("[CoreAPI][%s] DEMUXER_ERROR_INVALID_OPERATION(0x%08x)",
                        __FUNCTION__, MEDIADEMUXER_ERROR_INVALID_OPERATION);
@@ -224,8 +224,8 @@ int mediademuxer_get_track_info(mediademuxer_h demuxer, int track_index,
                MD_E("Invalid input parameters\n");
                return MEDIADEMUXER_ERROR_INVALID_PARAMETER;
        }
-       if (handle && (handle->demux_state == MEDIADEMUXER_READY
-               || handle->demux_state == MEDIADEMUXER_DEMUXING)) {
+       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);
                if (ret != MEDIADEMUXER_ERROR_NONE) {
                        MD_E("[CoreAPI][%s] DEMUXER_ERROR_INVALID_OPERATION(0x%08x)",
@@ -233,7 +233,7 @@ int mediademuxer_get_track_info(mediademuxer_h demuxer, int track_index,
                        return MEDIADEMUXER_ERROR_INVALID_OPERATION;
                }
        } else {
-               if (handle->demux_state != MEDIADEMUXER_READY)
+               if (handle->demux_state != MEDIADEMUXER_STATE_READY)
                        return MEDIADEMUXER_ERROR_INVALID_STATE;
                MD_E("[CoreAPI][%s] DEMUXER_ERROR_INVALID_OPERATION(0x%08x)",
                        __FUNCTION__, MEDIADEMUXER_ERROR_INVALID_OPERATION);
@@ -252,7 +252,7 @@ int mediademuxer_read_sample(mediademuxer_h demuxer, int track_index,
        handle = (mediademuxer_s *)(demuxer);
        if (outbuf == NULL || track_index < 0)
                return MEDIADEMUXER_ERROR_INVALID_PARAMETER;
-       if (handle && handle->demux_state == MEDIADEMUXER_DEMUXING) {
+       if (handle && handle->demux_state == MEDIADEMUXER_STATE_DEMUXING) {
                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)",
@@ -260,7 +260,7 @@ int mediademuxer_read_sample(mediademuxer_h demuxer, int track_index,
                        return MEDIADEMUXER_ERROR_INVALID_OPERATION;
                }
        } else {
-               if (handle->demux_state != MEDIADEMUXER_DEMUXING)
+               if (handle->demux_state != MEDIADEMUXER_STATE_DEMUXING)
                        return MEDIADEMUXER_ERROR_INVALID_STATE;
                MD_E("[CoreAPI][%s] DEMUXER_ERROR_INVALID_OPERATION(0x%08x)",
                        __FUNCTION__, MEDIADEMUXER_ERROR_INVALID_OPERATION);
@@ -276,7 +276,7 @@ int mediademuxer_seek(mediademuxer_h demuxer, int64_t pos)
        DEMUXER_INSTANCE_CHECK(demuxer);
        mediademuxer_s *handle;
        handle = (mediademuxer_s *)(demuxer);
-       if (handle && handle->demux_state == MEDIADEMUXER_DEMUXING) {
+       if (handle && handle->demux_state == MEDIADEMUXER_STATE_DEMUXING) {
                ret = md_seek((MMHandleType) (handle->md_handle), pos);
                if (ret != MEDIADEMUXER_ERROR_NONE) {
                        MD_E("[CoreAPI][%s] DEMUXER_ERROR_INVALID_OPERATION(0x%08x)",
@@ -284,7 +284,7 @@ int mediademuxer_seek(mediademuxer_h demuxer, int64_t pos)
                        return MEDIADEMUXER_ERROR_INVALID_OPERATION;
                }
        } else {
-               if (handle->demux_state != MEDIADEMUXER_DEMUXING)
+               if (handle->demux_state != MEDIADEMUXER_STATE_DEMUXING)
                        return MEDIADEMUXER_ERROR_INVALID_STATE;
                MD_E("[CoreAPI][%s] DEMUXER_ERROR_INVALID_OPERATION(0x%08x)",
                        __FUNCTION__, MEDIADEMUXER_ERROR_INVALID_OPERATION);
@@ -300,8 +300,8 @@ int mediademuxer_unselect_track(mediademuxer_h demuxer, int track_index)
        DEMUXER_INSTANCE_CHECK(demuxer);
        mediademuxer_s *handle;
        handle = (mediademuxer_s *)(demuxer);
-       if (handle && (handle->demux_state == MEDIADEMUXER_READY
-               || handle->demux_state == MEDIADEMUXER_DEMUXING)) {
+       if (handle && (handle->demux_state == MEDIADEMUXER_STATE_READY
+               || handle->demux_state == MEDIADEMUXER_STATE_DEMUXING)) {
                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)",
@@ -309,7 +309,7 @@ int mediademuxer_unselect_track(mediademuxer_h demuxer, int track_index)
                        return MEDIADEMUXER_ERROR_INVALID_OPERATION;
                }
        } else {
-               if (handle->demux_state != MEDIADEMUXER_READY)
+               if (handle->demux_state != MEDIADEMUXER_STATE_READY)
                        return MEDIADEMUXER_ERROR_INVALID_STATE;
                MD_E("[CoreAPI][%s] DEMUXER_ERROR_INVALID_OPERATION(0x%08x)",
                        __FUNCTION__, MEDIADEMUXER_ERROR_INVALID_OPERATION);
@@ -325,16 +325,16 @@ int mediademuxer_stop(mediademuxer_h demuxer)
        DEMUXER_INSTANCE_CHECK(demuxer);
        mediademuxer_s *handle;
        handle = (mediademuxer_s *)(demuxer);
-       if (handle && handle->demux_state == MEDIADEMUXER_DEMUXING) {
+       if (handle && handle->demux_state == MEDIADEMUXER_STATE_DEMUXING) {
                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);
                        return MEDIADEMUXER_ERROR_INVALID_OPERATION;
                } else
-                       handle->demux_state = MEDIADEMUXER_READY;
+                       handle->demux_state = MEDIADEMUXER_STATE_READY;
        } else {
-               if (handle->demux_state != MEDIADEMUXER_DEMUXING)
+               if (handle->demux_state != MEDIADEMUXER_STATE_DEMUXING)
                        return MEDIADEMUXER_ERROR_INVALID_STATE;
                MD_E("[CoreAPI][%s] DEMUXER_ERROR_INVALID_OPERATION(0x%08x)",
                        __FUNCTION__, MEDIADEMUXER_ERROR_INVALID_OPERATION);
@@ -350,16 +350,16 @@ int mediademuxer_unprepare(mediademuxer_h demuxer)
        DEMUXER_INSTANCE_CHECK(demuxer);
        mediademuxer_s *handle;
        handle = (mediademuxer_s *)(demuxer);
-       if (handle && handle->demux_state == MEDIADEMUXER_READY) {
+       if (handle && handle->demux_state == MEDIADEMUXER_STATE_READY) {
                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);
                        return MEDIADEMUXER_ERROR_INVALID_OPERATION;
                } else
-                       handle->demux_state = MEDIADEMUXER_IDLE;
+                       handle->demux_state = MEDIADEMUXER_STATE_IDLE;
        } else {
-               if (handle->demux_state != MEDIADEMUXER_READY)
+               if (handle->demux_state != MEDIADEMUXER_STATE_READY)
                        return MEDIADEMUXER_ERROR_INVALID_STATE;
                MD_E("[CoreAPI][%s] DEMUXER_ERROR_INVALID_OPERATION(0x%08x)",
                        __FUNCTION__, MEDIADEMUXER_ERROR_INVALID_OPERATION);
@@ -375,7 +375,7 @@ int mediademuxer_destroy(mediademuxer_h demuxer)
        DEMUXER_INSTANCE_CHECK(demuxer);
        mediademuxer_s *handle;
        handle = (mediademuxer_s *)(demuxer);
-       if (handle && handle->demux_state == MEDIADEMUXER_IDLE) {
+       if (handle && handle->demux_state == MEDIADEMUXER_STATE_IDLE) {
                ret = md_destroy(handle->md_handle);
                if (ret != MEDIADEMUXER_ERROR_NONE) {
                        MD_E("[CoreAPI][%s] DEMUXER_ERROR_INVALID_OPERATION(0x%08x)",
@@ -383,7 +383,7 @@ int mediademuxer_destroy(mediademuxer_h demuxer)
                        return MEDIADEMUXER_ERROR_INVALID_OPERATION;
                } else {
                        MD_E("[CoreAPI][%s] destroy handle : %p", __FUNCTION__, handle);
-                       handle->demux_state = MEDIADEMUXER_NONE;
+                       handle->demux_state = MEDIADEMUXER_STATE_NONE;
                        g_free(handle);
                        handle = NULL;
                }
@@ -416,7 +416,7 @@ int mediademuxer_set_error_cb(mediademuxer_h demuxer,
        DEMUXER_INSTANCE_CHECK(demuxer);
        mediademuxer_s *handle;
        handle = (mediademuxer_s *)(demuxer);
-       if (handle->demux_state != MEDIADEMUXER_IDLE)
+       if (handle->demux_state != MEDIADEMUXER_STATE_IDLE)
                return MEDIADEMUXER_ERROR_INVALID_STATE;
        handle->error_cb = callback;
        handle->error_cb_userdata = user_data;
@@ -429,7 +429,7 @@ int mediademuxer_unset_error_cb(mediademuxer_h demuxer)
        DEMUXER_INSTANCE_CHECK(demuxer);
        mediademuxer_s *handle;
        handle = (mediademuxer_s *)(demuxer);
-       if (handle->demux_state != MEDIADEMUXER_IDLE)
+       if (handle->demux_state != MEDIADEMUXER_STATE_IDLE)
                return MEDIADEMUXER_ERROR_INVALID_STATE;
        handle->error_cb = NULL;
        handle->error_cb_userdata = NULL;
@@ -444,7 +444,7 @@ static gboolean _mediademuxer_error_cb(mediademuxer_error_e error, void *user_da
                return 0;
        }
        mediademuxer_s * handle = (mediademuxer_s *) user_data;
-       if (handle->demux_state != MEDIADEMUXER_IDLE)
+       if (handle->demux_state != MEDIADEMUXER_STATE_IDLE)
                return MEDIADEMUXER_ERROR_INVALID_STATE;
        if (handle->error_cb)
                ((mediademuxer_error_cb)handle->error_cb)(error, handle->error_cb_userdata);
@@ -459,7 +459,7 @@ int mediademuxer_set_eos_cb(mediademuxer_h demuxer,
        DEMUXER_INSTANCE_CHECK(demuxer);
        mediademuxer_s *handle;
        handle = (mediademuxer_s *)(demuxer);
-       if (handle->demux_state != MEDIADEMUXER_IDLE)
+       if (handle->demux_state != MEDIADEMUXER_STATE_IDLE)
                return MEDIADEMUXER_ERROR_INVALID_STATE;
        handle->eos_cb = callback;
        handle->eos_cb_userdata = user_data;
@@ -472,7 +472,7 @@ int mediademuxer_unset_eos_cb(mediademuxer_h demuxer)
        DEMUXER_INSTANCE_CHECK(demuxer);
        mediademuxer_s *handle;
        handle = (mediademuxer_s *)(demuxer);
-       if (handle->demux_state != MEDIADEMUXER_IDLE)
+       if (handle->demux_state != MEDIADEMUXER_STATE_IDLE)
                return MEDIADEMUXER_ERROR_INVALID_STATE;
        handle->eos_cb = NULL;
        handle->eos_cb_userdata = NULL;
@@ -487,7 +487,7 @@ static gboolean _mediademuxer_eos_cb(int track_num, void *user_data)
                return 0;
        }
        mediademuxer_s *handle = (mediademuxer_s *)user_data;
-       if (handle->demux_state != MEDIADEMUXER_DEMUXING)
+       if (handle->demux_state != MEDIADEMUXER_STATE_DEMUXING)
                return MEDIADEMUXER_ERROR_INVALID_STATE;
        if (handle->eos_cb)
                ((mediademuxer_eos_cb)handle->eos_cb)(track_num, handle->eos_cb_userdata);

diff --git a/test/mediademuxer_test.c b/test/mediademuxer_test.c
index 6b10666..4b3f211 100755 (executable)
--- a/test/mediademuxer_test.c
+++ b/test/mediademuxer_test.c
@@ -783,13 +783,13 @@ int test_mediademuxer_get_state()
        g_print("test_mediademuxer_get_state\n");
        mediademuxer_state state;
        if (mediademuxer_get_state(demuxer, &state) == MEDIADEMUXER_ERROR_NONE) {
-               if (state == MEDIADEMUXER_NONE)
+               if (state == MEDIADEMUXER_STATE_NONE)
                        g_print("Mediademuxer_state = NONE\n");
-               else if (state == MEDIADEMUXER_IDLE)
+               else if (state == MEDIADEMUXER_STATE_IDLE)
                        g_print("Mediademuxer_state = IDLE\n");
-               else if (state == MEDIADEMUXER_READY)
+               else if (state == MEDIADEMUXER_STATE_READY)
                        g_print("Mediademuxer_state = READY\n");
-               else if (state == MEDIADEMUXER_DEMUXING)
+               else if (state == MEDIADEMUXER_STATE_DEMUXING)
                        g_print("Mediademuxer_state = DEMUXING\n");
                else
                        g_print("Mediademuxer_state = NOT SUPPORT STATE\n");