Fixed gst_critical error during prepare

[1] Fixed "GStreamer-CRITICAL **: gst_caps_from_string: assertion 'string' failed" error during prepare.
[2] Add \n for MX_E when needed

Change-Id: I77d88dd7f698a7e897ed6dba45e40256d2dad575
Signed-off-by: Mahesh Kondiparthi <kd.mahesh@samsung.com>

diff --git a/include/mediamuxer_private.h b/include/mediamuxer_private.h
index 881167d..f2fa12b 100755 (executable)
--- a/include/mediamuxer_private.h
+++ b/include/mediamuxer_private.h
@@ -33,7 +33,7 @@ extern "C" {
        do { \
                if (condition) { \
                } else { \
-                       MX_E("[%s] %s(0x%08x)", __FUNCTION__, msg, error); \
+                       MX_E("[%s] %s(0x%08x)\n", __FUNCTION__, msg, error); \
                        return error; \
                } \
        } while (0)

diff --git a/src/mediamuxer.c b/src/mediamuxer.c
index 0630115..41edf3d 100644 (file)
--- a/src/mediamuxer.c
+++ b/src/mediamuxer.c
@@ -43,14 +43,14 @@ int mediamuxer_create(mediamuxer_h *muxer)
                memset(handle, 0, sizeof(mediamuxer_s));
                handle->muxer_state = MEDIAMUXER_STATE_NONE;
        } else {
-               MX_E("[CoreAPI][%s] MUXER_ERROR_OUT_OF_MEMORY(0x%08x)",
+               MX_E("[CoreAPI][%s] MUXER_ERROR_OUT_OF_MEMORY(0x%08x)\n",
                     __FUNCTION__, MEDIAMUXER_ERROR_OUT_OF_MEMORY);
                return MEDIAMUXER_ERROR_OUT_OF_MEMORY;
        }
 
        ret = mx_create(&handle->mx_handle);
        if (ret != MEDIAMUXER_ERROR_NONE) {
-               MX_E("[CoreAPI][%s] MUXER_ERROR_INVALID_OPERATION(0x%08x)",
+               MX_E("[CoreAPI][%s] MUXER_ERROR_INVALID_OPERATION(0x%08x)\n",
                     __FUNCTION__, MEDIAMUXER_ERROR_INVALID_OPERATION);
                free(handle);
                handle = NULL;
@@ -94,7 +94,7 @@ int mediamuxer_set_data_sink(mediamuxer_h muxer, char *path, mediamuxer_output_f
        if (handle->muxer_state == MEDIAMUXER_STATE_IDLE) {
                ret = mx_set_data_sink(handle->mx_handle, path, format);
                if (ret != MEDIAMUXER_ERROR_NONE) {
-                       MX_E("[CoreAPI][%s] MUXER_ERROR_INVALID_OPERATION(0x%08x)",
+                       MX_E("[CoreAPI][%s] MUXER_ERROR_INVALID_OPERATION(0x%08x)\n",
                             __FUNCTION__, MEDIAMUXER_ERROR_INVALID_OPERATION);
                        handle->muxer_state = MEDIAMUXER_STATE_NONE;
                        ret = MEDIAMUXER_ERROR_INVALID_OPERATION;
@@ -103,7 +103,7 @@ int mediamuxer_set_data_sink(mediamuxer_h muxer, char *path, mediamuxer_output_f
                             __FUNCTION__, handle);
                }
        } else {
-               MX_E("[CoreAPI][%s] MEDIAMUXER_ERROR_INVALID_STATE(0x%08x)",
+               MX_E("[CoreAPI][%s] MEDIAMUXER_ERROR_INVALID_STATE(0x%08x)\n",
                        __FUNCTION__, MEDIAMUXER_ERROR_INVALID_STATE);
                handle->muxer_state = MEDIAMUXER_STATE_NONE;
                ret = MEDIAMUXER_ERROR_INVALID_STATE;
@@ -121,7 +121,7 @@ int mediamuxer_add_track(mediamuxer_h muxer, media_format_h media_format, int *t
        if (handle->muxer_state == MEDIAMUXER_STATE_IDLE) {
                ret = mx_add_track(handle->mx_handle, media_format, track_index);
                if (ret != MEDIAMUXER_ERROR_NONE) {
-                       MX_E("[CoreAPI][%s] MUXER_ERROR_INVALID_OPERATION(0x%08x)",
+                       MX_E("[CoreAPI][%s] MUXER_ERROR_INVALID_OPERATION(0x%08x)\n",
                             __FUNCTION__, MEDIAMUXER_ERROR_INVALID_OPERATION);
                        ret = MEDIAMUXER_ERROR_INVALID_OPERATION;
                } else {
@@ -129,7 +129,7 @@ int mediamuxer_add_track(mediamuxer_h muxer, media_format_h media_format, int *t
                             handle);
                }
        } else {
-               MX_E("[CoreAPI][%s] MEDIAMUXER_ERROR_INVALID_STATE(0x%08x)",
+               MX_E("[CoreAPI][%s] MEDIAMUXER_ERROR_INVALID_STATE(0x%08x)\n",
                     __FUNCTION__, MEDIAMUXER_ERROR_INVALID_STATE);
                ret = MEDIAMUXER_ERROR_INVALID_STATE;
        }
@@ -145,7 +145,7 @@ int mediamuxer_prepare(mediamuxer_h muxer)
        if (handle->muxer_state == MEDIAMUXER_STATE_IDLE) {
                ret = mx_prepare(handle->mx_handle);
                if (ret != MEDIAMUXER_ERROR_NONE) {
-                       MX_E("[CoreAPI][%s] MUXER_ERROR_INVALID_OPERATION(0x%08x)",
+                       MX_E("[CoreAPI][%s] MUXER_ERROR_INVALID_OPERATION(0x%08x)\n",
                             __FUNCTION__, MEDIAMUXER_ERROR_INVALID_OPERATION);
                        ret = MEDIAMUXER_ERROR_INVALID_OPERATION;
                } else {
@@ -153,7 +153,7 @@ int mediamuxer_prepare(mediamuxer_h muxer)
                             __FUNCTION__, handle);
                }
        } else {
-               MX_E("[CoreAPI][%s] MEDIAMUXER_ERROR_INVALID_STATE(0x%08x)",
+               MX_E("[CoreAPI][%s] MEDIAMUXER_ERROR_INVALID_STATE(0x%08x)\n",
                     __FUNCTION__, MEDIAMUXER_ERROR_INVALID_STATE);
                return MEDIAMUXER_ERROR_INVALID_STATE;
        }
@@ -171,7 +171,7 @@ int mediamuxer_start(mediamuxer_h muxer)
        if (handle->muxer_state == MEDIAMUXER_STATE_READY) {
                ret = mx_start(handle->mx_handle);
                if (ret != MEDIAMUXER_ERROR_NONE) {
-                       MX_E("[CoreAPI][%s] MUXER_ERROR_INVALID_OPERATION(0x%08x)",
+                       MX_E("[CoreAPI][%s] MUXER_ERROR_INVALID_OPERATION(0x%08x)\n",
                             __FUNCTION__, MEDIAMUXER_ERROR_INVALID_OPERATION);
                        ret = MEDIAMUXER_ERROR_INVALID_OPERATION;
                } else {
@@ -179,7 +179,7 @@ int mediamuxer_start(mediamuxer_h muxer)
                             __FUNCTION__, handle);
                }
        } else {
-               MX_E("[CoreAPI][%s] MEDIAMUXER_ERROR_INVALID_STATE(0x%08x)",
+               MX_E("[CoreAPI][%s] MEDIAMUXER_ERROR_INVALID_STATE(0x%08x)\n",
                     __FUNCTION__, MEDIAMUXER_ERROR_INVALID_STATE);
                return MEDIAMUXER_ERROR_INVALID_STATE;
        }
@@ -209,7 +209,7 @@ int mediamuxer_write_sample(mediamuxer_h muxer, int track_index, media_packet_h
                             __FUNCTION__, handle);
                }
        } else {
-               MX_E("[CoreAPI][%s] MEDIAMUXER_ERROR_INVALID_STATE(0x%08x)",
+               MX_E("[CoreAPI][%s] MEDIAMUXER_ERROR_INVALID_STATE(0x%08x)\n",
                     __FUNCTION__, MEDIAMUXER_ERROR_INVALID_STATE);
                return MEDIAMUXER_ERROR_INVALID_STATE;
        }
@@ -240,7 +240,7 @@ int mediamuxer_close_track(mediamuxer_h muxer, int track_index)
                             __FUNCTION__, handle);
                }
        } else {
-               MX_E("[CoreAPI][%s] MEDIAMUXER_ERROR_INVALID_STATE(0x%08x)",
+               MX_E("[CoreAPI][%s] MEDIAMUXER_ERROR_INVALID_STATE(0x%08x)\n",
                     __FUNCTION__, MEDIAMUXER_ERROR_INVALID_STATE);
                ret = MEDIAMUXER_ERROR_INVALID_STATE;
        }
@@ -266,7 +266,7 @@ int mediamuxer_pause(mediamuxer_h muxer)
                             __FUNCTION__, handle);
                }
        } else {
-               MX_E("[CoreAPI][%s] MEDIAMUXER_ERROR_INVALID_STATE(0x%08x)",
+               MX_E("[CoreAPI][%s] MEDIAMUXER_ERROR_INVALID_STATE(0x%08x)\n",
                     __FUNCTION__, MEDIAMUXER_ERROR_INVALID_STATE);
                return MEDIAMUXER_ERROR_INVALID_STATE;
        }
@@ -293,7 +293,7 @@ int mediamuxer_resume(mediamuxer_h muxer)
                             __FUNCTION__, handle);
                }
        } else {
-               MX_E("[CoreAPI][%s] MEDIAMUXER_ERROR_INVALID_STATE(0x%08x)",
+               MX_E("[CoreAPI][%s] MEDIAMUXER_ERROR_INVALID_STATE(0x%08x)\n",
                     __FUNCTION__, MEDIAMUXER_ERROR_INVALID_STATE);
                return MEDIAMUXER_ERROR_INVALID_STATE;
        }
@@ -312,7 +312,7 @@ int mediamuxer_stop(mediamuxer_h muxer)
                || handle->muxer_state == MEDIAMUXER_STATE_PAUSED) {
                ret = mx_stop(handle->mx_handle);
                if (ret != MEDIAMUXER_ERROR_NONE) {
-                       MX_E("[CoreAPI][%s] MUXER_ERROR_INVALID_OPERATION(0x%08x)",
+                       MX_E("[CoreAPI][%s] MUXER_ERROR_INVALID_OPERATION(0x%08x)\n",
                             __FUNCTION__, MEDIAMUXER_ERROR_INVALID_OPERATION);
                        ret = MEDIAMUXER_ERROR_INVALID_OPERATION;
                } else {
@@ -320,7 +320,7 @@ int mediamuxer_stop(mediamuxer_h muxer)
                             __FUNCTION__, handle);
                }
        } else {
-               MX_E("[CoreAPI][%s] MEDIAMUXER_ERROR_INVALID_STATE(0x%08x)",
+               MX_E("[CoreAPI][%s] MEDIAMUXER_ERROR_INVALID_STATE(0x%08x)\n",
                     __FUNCTION__, MEDIAMUXER_ERROR_INVALID_STATE);
                return MEDIAMUXER_ERROR_INVALID_STATE;
        }
@@ -349,7 +349,7 @@ int mediamuxer_unprepare(mediamuxer_h muxer)
                             __FUNCTION__, handle);
                }
        } else {
-               MX_E("[CoreAPI][%s] MEDIAMUXER_ERROR_INVALID_STATE(0x%08x)",
+               MX_E("[CoreAPI][%s] MEDIAMUXER_ERROR_INVALID_STATE(0x%08x)\n",
                     __FUNCTION__, MEDIAMUXER_ERROR_INVALID_STATE);
                return MEDIAMUXER_ERROR_INVALID_STATE;
        }
@@ -368,7 +368,7 @@ int mediamuxer_destroy(mediamuxer_h muxer)
        if (handle->muxer_state == MEDIAMUXER_STATE_IDLE) {
                ret = mx_destroy(handle->mx_handle);
                if (ret != MEDIAMUXER_ERROR_NONE) {
-                       MX_E("[CoreAPI][%s] MUXER_ERROR_INVALID_OPERATION(0x%08x)",
+                       MX_E("[CoreAPI][%s] MUXER_ERROR_INVALID_OPERATION(0x%08x)\n",
                             __FUNCTION__, MEDIAMUXER_ERROR_INVALID_OPERATION);
                        ret = MEDIAMUXER_ERROR_INVALID_OPERATION;
                } else {
@@ -376,7 +376,7 @@ int mediamuxer_destroy(mediamuxer_h muxer)
                             handle);
                }
        } else {
-               MX_E("[CoreAPI][%s] MEDIAMUXER_ERROR_INVALID_STATE(0x%08x)",
+               MX_E("[CoreAPI][%s] MEDIAMUXER_ERROR_INVALID_STATE(0x%08x)\n",
                     __FUNCTION__, MEDIAMUXER_ERROR_INVALID_STATE);
                return MEDIAMUXER_ERROR_INVALID_STATE;
        }
@@ -394,7 +394,7 @@ int mediamuxer_get_state(mediamuxer_h muxer, mediamuxer_state_e *state)
        if (state != NULL) {
                *state = handle->muxer_state;
        } else {
-               MX_E("[CoreAPI][%s] MUXER_ERROR_INVALID_OPERATION(0x%08x)",
+               MX_E("[CoreAPI][%s] MUXER_ERROR_INVALID_OPERATION(0x%08x)\n",
                        __FUNCTION__, MEDIAMUXER_ERROR_INVALID_OPERATION);
                ret = MEDIAMUXER_ERROR_INVALID_OPERATION;
        }

diff --git a/src/mediamuxer_ini.c b/src/mediamuxer_ini.c
index 2e34173..1d52a73 100644 (file)
--- a/src/mediamuxer_ini.c
+++ b/src/mediamuxer_ini.c
@@ -189,7 +189,7 @@ static void _mx_ini_check_ini_status(void)
                             (int)ini_buff.st_size);
 
                        if (g_remove(MEDIAMUXER_INI_DEFAULT_PATH) == -1)
-                               MX_E("failed to delete corrupted ini");
+                               MX_E("failed to delete corrupted ini\n");
                }
        }
 }

diff --git a/src/port_gst/mediamuxer_port_gst.c b/src/port_gst/mediamuxer_port_gst.c
index 3439ce5..c7f4459 100644 (file)
--- a/src/port_gst/mediamuxer_port_gst.c
+++ b/src/port_gst/mediamuxer_port_gst.c
@@ -422,7 +422,7 @@ mx_ret_e _gst_create_pipeline(mxgst_handle_t *gst_handle)
                && gst_handle->muxed_format != MEDIAMUXER_CONTAINER_FORMAT_WAV
                && gst_handle->muxed_format != MEDIAMUXER_CONTAINER_FORMAT_AMR_NB
                && gst_handle->muxed_format != MEDIAMUXER_CONTAINER_FORMAT_AMR_WB) {
-               MX_E("Unsupported container-format. Currently suports only MP4, 3GP, WAV & AMR");
+               MX_E("Unsupported container-format. Currently suports only MP4, 3GP, WAV & AMR\n");
                ret = MEDIAMUXER_ERROR_INVALID_PATH;
                goto ERROR;
        } else {
@@ -449,7 +449,7 @@ mx_ret_e _gst_create_pipeline(mxgst_handle_t *gst_handle)
                gst_bin_add_many(GST_BIN(gst_handle->pipeline), gst_handle->muxer, gst_handle->sink, NULL);
 
                if (!gst_element_link(gst_handle->muxer, gst_handle->sink))
-                       MX_E("muxer-sink link failed");
+                       MX_E("muxer-sink link failed\n");
 
                if (gst_handle->track_info.video_track_cnt) { /* Video track(s) exist */
                        for (current = gst_handle->track_info.track_head; current; current = current->next) {
@@ -482,9 +482,6 @@ mx_ret_e _gst_create_pipeline(mxgst_handle_t *gst_handle)
 
                                        gst_bin_add_many(GST_BIN(gst_handle->pipeline), current->appsrc, current->parser, NULL);
 
-                                       /* Set video caps for corresponding src elements */
-                                       g_object_set(current->appsrc, "caps", gst_caps_from_string(current->caps), NULL);
-
 #ifdef ASYCHRONOUS_WRITE
                                        /* ToDo: Use a function pointer, and create independent fucntions to each track */
                                        MX_I("\nRegistering video callback for cur->tr_ind = %d\n", current->track_index);
@@ -506,7 +503,7 @@ mx_ret_e _gst_create_pipeline(mxgst_handle_t *gst_handle)
                                        vid_src = gst_element_get_static_pad(current->parser, "src");
 
                                        if (gst_pad_link(vid_src, video_pad) != GST_PAD_LINK_OK)
-                                               MX_E("video parser to muxer link failed");
+                                               MX_E("video parser to muxer link failed\n");
 
                                        gst_object_unref(GST_OBJECT(vid_src));
                                        gst_object_unref(GST_OBJECT(video_pad));
@@ -552,8 +549,6 @@ mx_ret_e _gst_create_pipeline(mxgst_handle_t *gst_handle)
                                                }
                                                gst_bin_add_many(GST_BIN(gst_handle->pipeline), current->parser, NULL);
                                        }
-                                       /* Set video caps for corresponding src elements */
-                                       g_object_set(current->appsrc, "caps", gst_caps_from_string(current->caps), NULL);
 
 #ifdef ASYCHRONOUS_WRITE
                                        /* ToDo: Use a function pointer, and create independent fucntions to each track */
@@ -583,7 +578,7 @@ mx_ret_e _gst_create_pipeline(mxgst_handle_t *gst_handle)
                                                aud_src = gst_element_get_static_pad(current->parser, "src");
 
                                                if (gst_pad_link(aud_src, audio_pad) != GST_PAD_LINK_OK)
-                                                       MX_E("audio parser to muxer link failed");
+                                                       MX_E("audio parser to muxer link failed\n");
 
                                                gst_object_unref(GST_OBJECT(aud_src));
                                                gst_object_unref(GST_OBJECT(audio_pad));
@@ -817,7 +812,7 @@ int _gst_set_caps(MMHandleType pHandle, media_packet_h packet, int track_index)
        case MEDIA_FORMAT_AUDIO:
                /* Following check is safe but not mandatory. */
                if ((current->track_index)%NO_OF_TRACK_TYPES != 1) {
-                       MX_E("\n\nThis is not an audio track_index. Track_index is not in 3*n+1 format\n\n");
+                       MX_E("This is not an audio track_index. Track_index is not in 3*n+1 format\n");
                        goto ERROR;
                }
 
@@ -915,7 +910,7 @@ int _gst_set_caps(MMHandleType pHandle, media_packet_h packet, int track_index)
        case MEDIA_FORMAT_VIDEO:
                /* Following check is safe but not mandatory. */
                if ((current->track_index)%NO_OF_TRACK_TYPES != 0) {
-                       MX_E("\n\nThis is not an video track_index. Video track_index is not in 3*n format\n\n");
+                       MX_E("This is not an video track_index. Video track_index is not in 3*n format\n");
                        goto ERROR;
                }
 
@@ -1123,7 +1118,7 @@ static int gst_muxer_write_sample(MMHandleType pHandle, int track_index,
                else if (gst_handle->track_info.track_head) {
                        MX_E("\n\ngst_handle->track_info.track_head->track_index=%d\n", gst_handle->track_info.track_head->track_index);
                        if (gst_handle->track_info.track_head->next)
-                               MX_E("\n\next=%p\tnext->track_index=%d\n", gst_handle->track_info.track_head->next, gst_handle->track_info.track_head->next->track_index);
+                               MX_E("ext=%p\tnext->track_index=%d\n", gst_handle->track_info.track_head->next, gst_handle->track_info.track_head->next->track_index);
                } else
                        MX_E("\n\n****Head is NULL****\n");
                ret = MX_ERROR_INVALID_ARGUMENT;
@@ -1215,7 +1210,7 @@ static int gst_muxer_close_track(MMHandleType pHandle, int track_index)
                        MX_I("\n-----EOS for audioappsrc-----\n");
                        gst_app_src_end_of_stream((GstAppSrc *)(current->appsrc));
                } else {
-                       MX_E("\nInvalid track Index[%d].\n", track_index);
+                       MX_E("Invalid track Index[%d].\n", track_index);
                        goto ERROR;
                }
        }