/* GStreamer * * unit test for qtmux * * Copyright (C) <2008> Mark Nauwelaerts * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Library General Public License for more details. * * You should have received a copy of the GNU Library General Public * License along with this library; if not, write to the * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, * Boston, MA 02110-1301, USA. */ #ifdef HAVE_CONFIG_H #include #endif #ifdef HAVE_UNISTD_H #include #endif #include #include #include /* For ease of programming we use globals to keep refs for our floating * src and sink pads we create; otherwise we always have to do get_pad, * get_peer, and then remove references in every test function */ static GstPad *mysrcpad, *mysinkpad; #define VIDEO_RAW_CAPS_STRING "video/x-raw" #define AUDIO_CAPS_STRING "audio/mpeg, " \ "mpegversion = (int) 1, " \ "layer = (int) 3, " \ "channels = (int) 2, " \ "rate = (int) 48000" #define AUDIO_AAC_CAPS_STRING "audio/mpeg, " \ "mpegversion=(int)4, " \ "channels=(int)1, " \ "rate=(int)44100, " \ "stream-format=(string)raw, " \ "level=(string)2, " \ "base-profile=(string)lc, " \ "profile=(string)lc, " \ "codec_data=(buffer)1208" #define VIDEO_CAPS_STRING "video/mpeg, " \ "mpegversion = (int) 4, " \ "systemstream = (boolean) false, " \ "width = (int) 384, " \ "height = (int) 288, " \ "framerate = (fraction) 25/1" #define VIDEO_CAPS_H264_STRING "video/x-h264, " \ "width=(int)320, " \ "height=(int)240, " \ "framerate=(fraction)30/1, " \ "pixel-aspect-ratio=(fraction)1/1, " \ "codec_data=(buffer)01640014ffe1001867640014a" \ "cd94141fb0110000003001773594000f14299600" \ "1000568ebecb22c, " \ "stream-format=(string)avc, " \ "alignment=(string)au, " \ "level=(string)2, " \ "profile=(string)high" static GstStaticPadTemplate sinktemplate = GST_STATIC_PAD_TEMPLATE ("sink", GST_PAD_SINK, GST_PAD_ALWAYS, GST_STATIC_CAPS ("video/quicktime")); static GstStaticPadTemplate srcvideotemplate = GST_STATIC_PAD_TEMPLATE ("src", GST_PAD_SRC, GST_PAD_ALWAYS, GST_STATIC_CAPS (VIDEO_CAPS_STRING)); static GstStaticPadTemplate srcvideoh264template = GST_STATIC_PAD_TEMPLATE ("src", GST_PAD_SRC, GST_PAD_ALWAYS, GST_STATIC_CAPS (VIDEO_CAPS_H264_STRING)); static GstStaticPadTemplate srcvideorawtemplate = GST_STATIC_PAD_TEMPLATE ("src", GST_PAD_SRC, GST_PAD_ALWAYS, GST_STATIC_CAPS (VIDEO_RAW_CAPS_STRING)); static GstStaticPadTemplate srcaudiotemplate = GST_STATIC_PAD_TEMPLATE ("src", GST_PAD_SRC, GST_PAD_ALWAYS, GST_STATIC_CAPS (AUDIO_CAPS_STRING)); static GstStaticPadTemplate srcaudioaactemplate = GST_STATIC_PAD_TEMPLATE ("src", GST_PAD_SRC, GST_PAD_ALWAYS, GST_STATIC_CAPS (AUDIO_AAC_CAPS_STRING)); /* setup and teardown needs some special handling for muxer */ static GstPad * setup_src_pad (GstElement * element, GstStaticPadTemplate * template, const gchar * sinkname) { GstPad *srcpad, *sinkpad; GST_DEBUG_OBJECT (element, "setting up sending pad"); /* sending pad */ srcpad = gst_pad_new_from_static_template (template, "src"); fail_if (srcpad == NULL, "Could not create a srcpad"); ASSERT_OBJECT_REFCOUNT (srcpad, "srcpad", 1); if (!(sinkpad = gst_element_get_static_pad (element, sinkname))) sinkpad = gst_element_get_request_pad (element, sinkname); fail_if (sinkpad == NULL, "Could not get sink pad from %s", GST_ELEMENT_NAME (element)); /* references are owned by: 1) us, 2) qtmux, 3) collect pads */ ASSERT_OBJECT_REFCOUNT (sinkpad, "sinkpad", 3); fail_unless (gst_pad_link (srcpad, sinkpad) == GST_PAD_LINK_OK, "Could not link source and %s sink pads", GST_ELEMENT_NAME (element)); gst_object_unref (sinkpad); /* because we got it higher up */ /* references are owned by: 1) qtmux, 2) collect pads */ ASSERT_OBJECT_REFCOUNT (sinkpad, "sinkpad", 2); return srcpad; } static void teardown_src_pad (GstPad * srcpad) { GstPad *sinkpad; /* clean up floating src pad */ sinkpad = gst_pad_get_peer (srcpad); fail_if (sinkpad == NULL); /* pad refs held by 1) qtmux 2) collectpads and 3) us (through _get_peer) */ ASSERT_OBJECT_REFCOUNT (sinkpad, "sinkpad", 3); gst_pad_unlink (srcpad, sinkpad); /* after unlinking, pad refs still held by * 1) qtmux and 2) collectpads and 3) us (through _get_peer) */ ASSERT_OBJECT_REFCOUNT (sinkpad, "sinkpad", 3); gst_object_unref (sinkpad); /* one more ref is held by element itself */ /* pad refs held by creator */ ASSERT_OBJECT_REFCOUNT (srcpad, "srcpad", 1); gst_object_unref (srcpad); } gboolean downstream_is_seekable; static gboolean qtmux_sinkpad_query (GstPad * pad, GstObject * parent, GstQuery * query) { gboolean ret = FALSE; if (GST_QUERY_TYPE (query) == GST_QUERY_SEEKING) { gst_query_set_seeking (query, GST_FORMAT_BYTES, downstream_is_seekable, 0, -1); ret = TRUE; } return ret; } static GstElement * setup_qtmux (GstStaticPadTemplate * srctemplate, const gchar * sinkname, gboolean seekable) { GstElement *qtmux; GST_DEBUG ("setup_qtmux"); qtmux = gst_check_setup_element ("qtmux"); mysrcpad = setup_src_pad (qtmux, srctemplate, sinkname); mysinkpad = gst_check_setup_sink_pad (qtmux, &sinktemplate); downstream_is_seekable = seekable; gst_pad_set_query_function (mysinkpad, qtmux_sinkpad_query); gst_pad_set_active (mysrcpad, TRUE); gst_pad_set_active (mysinkpad, TRUE); return qtmux; } static void cleanup_qtmux (GstElement * qtmux, const gchar * sinkname) { GST_DEBUG ("cleanup_qtmux"); gst_element_set_state (qtmux, GST_STATE_NULL); gst_pad_set_active (mysrcpad, FALSE); gst_pad_set_active (mysinkpad, FALSE); teardown_src_pad (mysrcpad); gst_check_teardown_sink_pad (qtmux); gst_check_teardown_element (qtmux); } static void check_qtmux_pad (GstStaticPadTemplate * srctemplate, const gchar * sinkname, guint32 dts_method) { GstElement *qtmux; GstBuffer *inbuffer, *outbuffer; GstCaps *caps; int num_buffers; int i; guint8 data0[12] = "\000\000\000\024ftypqt "; guint8 data1[16] = "\000\000\000\010free\000\000\000\000mdat"; guint8 data2[4] = "moov"; GstSegment segment; qtmux = setup_qtmux (srctemplate, sinkname, TRUE); g_object_set (qtmux, "dts-method", dts_method, NULL); fail_unless (gst_element_set_state (qtmux, GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS, "could not set to playing"); gst_pad_push_event (mysrcpad, gst_event_new_stream_start ("test")); caps = gst_pad_get_pad_template_caps (mysrcpad); gst_pad_set_caps (mysrcpad, caps); gst_caps_unref (caps); /* ensure segment (format) properly setup */ gst_segment_init (&segment, GST_FORMAT_TIME); fail_unless (gst_pad_push_event (mysrcpad, gst_event_new_segment (&segment))); inbuffer = gst_buffer_new_and_alloc (1); gst_buffer_memset (inbuffer, 0, 0, 1); GST_BUFFER_TIMESTAMP (inbuffer) = 0; GST_BUFFER_DURATION (inbuffer) = 40 * GST_MSECOND; ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1); fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK); /* send eos to have moov written */ fail_unless (gst_pad_push_event (mysrcpad, gst_event_new_eos ()) == TRUE); num_buffers = g_list_length (buffers); /* at least expect ftyp, mdat header, buffer chunk and moov */ fail_unless (num_buffers >= 4); /* clean up first to clear any pending refs in sticky caps */ cleanup_qtmux (qtmux, sinkname); for (i = 0; i < num_buffers; ++i) { outbuffer = GST_BUFFER (buffers->data); fail_if (outbuffer == NULL); buffers = g_list_remove (buffers, outbuffer); switch (i) { case 0: { /* ftyp header */ fail_unless (gst_buffer_get_size (outbuffer) >= 20); fail_unless (gst_buffer_memcmp (outbuffer, 0, data0, sizeof (data0)) == 0); fail_unless (gst_buffer_memcmp (outbuffer, 16, data0 + 8, 4) == 0); break; } case 1: /* mdat header */ fail_unless (gst_buffer_get_size (outbuffer) == 16); fail_unless (gst_buffer_memcmp (outbuffer, 0, data1, sizeof (data1)) == 0); break; case 2: /* buffer we put in */ fail_unless (gst_buffer_get_size (outbuffer) == 1); break; case 3: /* moov */ fail_unless (gst_buffer_get_size (outbuffer) > 8); fail_unless (gst_buffer_memcmp (outbuffer, 4, data2, sizeof (data2)) == 0); break; default: break; } ASSERT_BUFFER_REFCOUNT (outbuffer, "outbuffer", 1); gst_buffer_unref (outbuffer); outbuffer = NULL; } g_list_free (buffers); buffers = NULL; } static void check_qtmux_pad_fragmented (GstStaticPadTemplate * srctemplate, const gchar * sinkname, guint32 dts_method, gboolean streamable) { GstElement *qtmux; GstBuffer *inbuffer, *outbuffer; GstCaps *caps; int num_buffers; int i; guint8 data0[12] = "\000\000\000\024ftypqt "; guint8 data1[4] = "mdat"; guint8 data2[4] = "moov"; guint8 data3[4] = "moof"; guint8 data4[4] = "mfra"; GstSegment segment; qtmux = setup_qtmux (srctemplate, sinkname, !streamable); g_object_set (qtmux, "dts-method", dts_method, NULL); g_object_set (qtmux, "fragment-duration", 2000, NULL); g_object_set (qtmux, "streamable", streamable, NULL); fail_unless (gst_element_set_state (qtmux, GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS, "could not set to playing"); gst_pad_push_event (mysrcpad, gst_event_new_stream_start ("test")); caps = gst_pad_get_pad_template_caps (mysrcpad); gst_pad_set_caps (mysrcpad, caps); gst_caps_unref (caps); /* ensure segment (format) properly setup */ gst_segment_init (&segment, GST_FORMAT_TIME); fail_unless (gst_pad_push_event (mysrcpad, gst_event_new_segment (&segment))); inbuffer = gst_buffer_new_and_alloc (1); gst_buffer_memset (inbuffer, 0, 0, 1); GST_BUFFER_TIMESTAMP (inbuffer) = 0; GST_BUFFER_DURATION (inbuffer) = 40 * GST_MSECOND; ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1); fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK); /* send eos to have all written */ fail_unless (gst_pad_push_event (mysrcpad, gst_event_new_eos ()) == TRUE); num_buffers = g_list_length (buffers); /* at least expect ftyp, moov, moof, mdat header, buffer chunk * and optionally mfra */ fail_unless (num_buffers >= 5); /* clean up first to clear any pending refs in sticky caps */ cleanup_qtmux (qtmux, sinkname); for (i = 0; i < num_buffers; ++i) { outbuffer = GST_BUFFER (buffers->data); fail_if (outbuffer == NULL); buffers = g_list_remove (buffers, outbuffer); switch (i) { case 0: { /* ftyp header */ fail_unless (gst_buffer_get_size (outbuffer) >= 20); fail_unless (gst_buffer_memcmp (outbuffer, 0, data0, sizeof (data0)) == 0); fail_unless (gst_buffer_memcmp (outbuffer, 16, data0 + 8, 4) == 0); break; } case 1: /* moov */ fail_unless (gst_buffer_get_size (outbuffer) > 8); fail_unless (gst_buffer_memcmp (outbuffer, 4, data2, sizeof (data2)) == 0); break; case 2: /* moof */ fail_unless (gst_buffer_get_size (outbuffer) > 8); fail_unless (gst_buffer_memcmp (outbuffer, 4, data3, sizeof (data3)) == 0); break; case 3: /* mdat header */ fail_unless (gst_buffer_get_size (outbuffer) == 8); fail_unless (gst_buffer_memcmp (outbuffer, 4, data1, sizeof (data1)) == 0); break; case 4: /* buffer we put in */ fail_unless (gst_buffer_get_size (outbuffer) == 1); break; case 5: /* mfra */ fail_unless (gst_buffer_get_size (outbuffer) > 8); fail_unless (gst_buffer_memcmp (outbuffer, 4, data4, sizeof (data4)) == 0); break; default: break; } ASSERT_BUFFER_REFCOUNT (outbuffer, "outbuffer", 1); gst_buffer_unref (outbuffer); outbuffer = NULL; } g_list_free (buffers); buffers = NULL; } /* dts-method dd */ GST_START_TEST (test_video_pad_dd) { check_qtmux_pad (&srcvideotemplate, "video_%u", 0); } GST_END_TEST; GST_START_TEST (test_audio_pad_dd) { check_qtmux_pad (&srcaudiotemplate, "audio_%u", 0); } GST_END_TEST; GST_START_TEST (test_video_pad_frag_dd) { check_qtmux_pad_fragmented (&srcvideotemplate, "video_%u", 0, FALSE); } GST_END_TEST; GST_START_TEST (test_audio_pad_frag_dd) { check_qtmux_pad_fragmented (&srcaudiotemplate, "audio_%u", 0, FALSE); } GST_END_TEST; GST_START_TEST (test_video_pad_frag_dd_streamable) { check_qtmux_pad_fragmented (&srcvideotemplate, "video_%u", 0, TRUE); } GST_END_TEST; GST_START_TEST (test_audio_pad_frag_dd_streamable) { check_qtmux_pad_fragmented (&srcaudiotemplate, "audio_%u", 0, TRUE); } GST_END_TEST; /* dts-method reorder */ GST_START_TEST (test_video_pad_reorder) { check_qtmux_pad (&srcvideotemplate, "video_%u", 1); } GST_END_TEST; GST_START_TEST (test_audio_pad_reorder) { check_qtmux_pad (&srcaudiotemplate, "audio_%u", 1); } GST_END_TEST; GST_START_TEST (test_video_pad_frag_reorder) { check_qtmux_pad_fragmented (&srcvideotemplate, "video_%u", 1, FALSE); } GST_END_TEST; GST_START_TEST (test_audio_pad_frag_reorder) { check_qtmux_pad_fragmented (&srcaudiotemplate, "audio_%u", 1, FALSE); } GST_END_TEST; GST_START_TEST (test_video_pad_frag_reorder_streamable) { check_qtmux_pad_fragmented (&srcvideotemplate, "video_%u", 1, TRUE); } GST_END_TEST; GST_START_TEST (test_audio_pad_frag_reorder_streamable) { check_qtmux_pad_fragmented (&srcaudiotemplate, "audio_%u", 1, TRUE); } GST_END_TEST; /* dts-method asc */ GST_START_TEST (test_video_pad_asc) { check_qtmux_pad (&srcvideotemplate, "video_%u", 2); } GST_END_TEST; GST_START_TEST (test_audio_pad_asc) { check_qtmux_pad (&srcaudiotemplate, "audio_%u", 2); } GST_END_TEST; GST_START_TEST (test_video_pad_frag_asc) { check_qtmux_pad_fragmented (&srcvideotemplate, "video_%u", 2, FALSE); } GST_END_TEST; GST_START_TEST (test_audio_pad_frag_asc) { check_qtmux_pad_fragmented (&srcaudiotemplate, "audio_%u", 2, FALSE); } GST_END_TEST; GST_START_TEST (test_video_pad_frag_asc_streamable) { check_qtmux_pad_fragmented (&srcvideotemplate, "video_%u", 2, TRUE); } GST_END_TEST; GST_START_TEST (test_audio_pad_frag_asc_streamable) { check_qtmux_pad_fragmented (&srcaudiotemplate, "audio_%u", 2, TRUE); } GST_END_TEST; GST_START_TEST (test_reuse) { GstElement *qtmux = setup_qtmux (&srcvideotemplate, "video_%u", TRUE); GstBuffer *inbuffer; GstCaps *caps; GstSegment segment; gst_element_set_state (qtmux, GST_STATE_PLAYING); gst_element_set_state (qtmux, GST_STATE_NULL); gst_element_set_state (qtmux, GST_STATE_PLAYING); gst_pad_set_active (mysrcpad, TRUE); gst_pad_set_active (mysinkpad, TRUE); gst_pad_push_event (mysrcpad, gst_event_new_stream_start ("test")); caps = gst_pad_get_pad_template_caps (mysrcpad); gst_pad_set_caps (mysrcpad, caps); gst_caps_unref (caps); /* ensure segment (format) properly setup */ gst_segment_init (&segment, GST_FORMAT_TIME); fail_unless (gst_pad_push_event (mysrcpad, gst_event_new_segment (&segment))); inbuffer = gst_buffer_new_and_alloc (1); fail_unless (inbuffer != NULL); gst_buffer_memset (inbuffer, 0, 0, 1); GST_BUFFER_TIMESTAMP (inbuffer) = 0; GST_BUFFER_DURATION (inbuffer) = 40 * GST_MSECOND; ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1); fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK); /* send eos to have all written */ fail_unless (gst_pad_push_event (mysrcpad, gst_event_new_eos ()) == TRUE); cleanup_qtmux (qtmux, "video_%u"); } GST_END_TEST; static GstEncodingContainerProfile * create_qtmux_profile (const gchar * variant) { GstEncodingContainerProfile *cprof; GstCaps *caps; if (variant == NULL) { caps = gst_caps_new_empty_simple ("video/quicktime"); } else { caps = gst_caps_new_simple ("video/quicktime", "variant", G_TYPE_STRING, variant, NULL); } cprof = gst_encoding_container_profile_new ("Name", "blah", caps, NULL); gst_caps_unref (caps); caps = gst_caps_new_simple ("audio/x-raw", "format", G_TYPE_STRING, "S16BE", "channels", G_TYPE_INT, 2, "rate", G_TYPE_INT, 44100, NULL); gst_encoding_container_profile_add_profile (cprof, GST_ENCODING_PROFILE (gst_encoding_audio_profile_new (caps, NULL, NULL, 1))); gst_caps_unref (caps); return cprof; } GST_START_TEST (test_encodebin_qtmux) { GstEncodingContainerProfile *cprof; GstElement *enc; GstPad *pad; enc = gst_element_factory_make ("encodebin", NULL); if (enc == NULL) return; /* Make sure encodebin finds a muxer for a profile with a variant field .. */ cprof = create_qtmux_profile ("apple"); g_object_set (enc, "profile", cprof, NULL); gst_encoding_profile_unref (cprof); /* should have created a pad after setting the profile */ pad = gst_element_get_static_pad (enc, "audio_0"); fail_unless (pad != NULL); gst_object_unref (pad); gst_object_unref (enc); /* ... and for a profile without a variant field */ enc = gst_element_factory_make ("encodebin", NULL); cprof = create_qtmux_profile (NULL); g_object_set (enc, "profile", cprof, NULL); gst_encoding_profile_unref (cprof); /* should have created a pad after setting the profile */ pad = gst_element_get_static_pad (enc, "audio_0"); fail_unless (pad != NULL); gst_object_unref (pad); gst_object_unref (enc); } GST_END_TEST; /* Fake mp3 encoder for test */ typedef GstElement TestMp3Enc; typedef GstElementClass TestMp3EncClass; static GstStaticPadTemplate src_template = GST_STATIC_PAD_TEMPLATE ("src", GST_PAD_SRC, GST_PAD_ALWAYS, GST_STATIC_CAPS ("audio/mpeg, mpegversion=1, layer=[1,3]") ); static GstStaticPadTemplate sink_template = GST_STATIC_PAD_TEMPLATE ("sink", GST_PAD_SINK, GST_PAD_ALWAYS, GST_STATIC_CAPS ("audio/x-raw") ); static GType test_mp3_enc_get_type (void); static void test_input_push_segment_start (gpointer user_data, GstClockTime start); G_DEFINE_TYPE (TestMp3Enc, test_mp3_enc, GST_TYPE_ELEMENT); static void test_mp3_enc_class_init (TestMp3EncClass * klass) { GstElementClass *element_class = GST_ELEMENT_CLASS (klass); gst_element_class_add_pad_template (element_class, gst_static_pad_template_get (&sink_template)); gst_element_class_add_pad_template (element_class, gst_static_pad_template_get (&src_template)); gst_element_class_set_metadata (element_class, "MPEG1 Audio Encoder", "Codec/Encoder/Audio", "Pretends to encode mp3", "Foo Bar "); } static void test_mp3_enc_init (TestMp3Enc * mp3enc) { GstPad *pad; pad = gst_pad_new_from_static_template (&sink_template, "sink"); gst_element_add_pad (mp3enc, pad); pad = gst_pad_new_from_static_template (&src_template, "src"); gst_element_add_pad (mp3enc, pad); } static gboolean plugin_init (GstPlugin * plugin) { return gst_element_register (plugin, "testmp3enc", GST_RANK_NONE, test_mp3_enc_get_type ()); } static GstEncodingContainerProfile * create_mp4mux_profile (void) { GstEncodingContainerProfile *cprof; GstCaps *caps; caps = gst_caps_new_simple ("video/quicktime", "variant", G_TYPE_STRING, "iso", NULL); cprof = gst_encoding_container_profile_new ("Name", "blah", caps, NULL); gst_caps_unref (caps); caps = gst_caps_new_simple ("audio/mpeg", "mpegversion", G_TYPE_INT, 1, "layer", G_TYPE_INT, 3, "channels", G_TYPE_INT, 2, "rate", G_TYPE_INT, 44100, NULL); gst_encoding_container_profile_add_profile (cprof, GST_ENCODING_PROFILE (gst_encoding_audio_profile_new (caps, NULL, NULL, 1))); gst_caps_unref (caps); return cprof; } GST_START_TEST (test_encodebin_mp4mux) { GstEncodingContainerProfile *cprof; GstPluginFeature *feature; GstElement *enc, *mux; GstPad *pad; /* need a fake mp3 encoder because mp4 only accepts encoded formats */ gst_plugin_register_static (GST_VERSION_MAJOR, GST_VERSION_MINOR, "fakemp3enc", "fakemp3enc", plugin_init, VERSION, "LGPL", "gst-plugins-good", GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN); feature = gst_registry_find_feature (gst_registry_get (), "testmp3enc", GST_TYPE_ELEMENT_FACTORY); gst_plugin_feature_set_rank (feature, GST_RANK_PRIMARY + 100); enc = gst_element_factory_make ("encodebin", NULL); if (enc == NULL) return; /* Make sure encodebin finds mp4mux even though qtmux outputs a superset */ cprof = create_mp4mux_profile (); g_object_set (enc, "profile", cprof, NULL); gst_encoding_profile_unref (cprof); /* should have created a pad after setting the profile */ pad = gst_element_get_static_pad (enc, "audio_0"); fail_unless (pad != NULL); gst_object_unref (pad); mux = gst_bin_get_by_interface (GST_BIN (enc), GST_TYPE_TAG_SETTER); fail_unless (mux != NULL); { GstElementFactory *f = gst_element_get_factory (mux); /* make sure we got mp4mux for variant=iso */ GST_INFO ("muxer: %s", G_OBJECT_TYPE_NAME (mux)); fail_unless_equals_string (GST_OBJECT_NAME (f), "mp4mux"); } gst_object_unref (mux); gst_object_unref (enc); gst_plugin_feature_set_rank (feature, GST_RANK_NONE); gst_object_unref (feature); } GST_END_TEST; static gboolean extract_tags (const gchar * location, GstTagList ** taglist) { gboolean ret = TRUE; GstElement *src; GstBus *bus; GstElement *pipeline = gst_parse_launch ("filesrc name=src ! qtdemux ! fakesink", NULL); src = gst_bin_get_by_name (GST_BIN (pipeline), "src"); g_object_set (src, "location", location, NULL); bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline)); fail_unless (gst_element_set_state (pipeline, GST_STATE_PLAYING) != GST_STATE_CHANGE_FAILURE); if (*taglist == NULL) { *taglist = gst_tag_list_new_empty (); } while (1) { GstMessage *msg = gst_bus_timed_pop_filtered (bus, GST_CLOCK_TIME_NONE, GST_MESSAGE_TAG | GST_MESSAGE_ERROR | GST_MESSAGE_EOS); if (GST_MESSAGE_TYPE (msg) == GST_MESSAGE_EOS) { gst_message_unref (msg); break; } else if (GST_MESSAGE_TYPE (msg) == GST_MESSAGE_ERROR) { ret = FALSE; gst_message_unref (msg); break; } else if (GST_MESSAGE_TYPE (msg) == GST_MESSAGE_TAG) { GstTagList *tags; gst_message_parse_tag (msg, &tags); gst_tag_list_insert (*taglist, tags, GST_TAG_MERGE_REPLACE); gst_tag_list_unref (tags); } gst_message_unref (msg); } gst_object_unref (bus); gst_element_set_state (pipeline, GST_STATE_NULL); gst_object_unref (src); gst_object_unref (pipeline); return ret; } static void test_average_bitrate_custom (const gchar * elementname, GstStaticPadTemplate * tmpl, const gchar * sinkpadname) { gchar *location; GstElement *qtmux; GstElement *filesink; GstBuffer *inbuffer; GstCaps *caps; int i; gint bytes[] = { 16, 22, 12 }; gint64 durations[] = { GST_SECOND * 3, GST_SECOND * 5, GST_SECOND * 2 }; gint64 total_bytes = 0; GstClockTime total_duration = 0; GstSegment segment; location = g_strdup_printf ("%s/%s-%d", g_get_tmp_dir (), "qtmuxtest", g_random_int ()); GST_INFO ("Using location %s for bitrate test", location); qtmux = gst_check_setup_element (elementname); filesink = gst_element_factory_make ("filesink", NULL); g_object_set (filesink, "location", location, NULL); gst_element_link (qtmux, filesink); mysrcpad = setup_src_pad (qtmux, tmpl, sinkpadname); fail_unless (mysrcpad != NULL); gst_pad_set_active (mysrcpad, TRUE); fail_unless (gst_element_set_state (filesink, GST_STATE_PLAYING) != GST_STATE_CHANGE_FAILURE, "could not set filesink to playing"); fail_unless (gst_element_set_state (qtmux, GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS, "could not set to playing"); gst_pad_push_event (mysrcpad, gst_event_new_stream_start ("test")); caps = gst_pad_get_pad_template_caps (mysrcpad); gst_pad_set_caps (mysrcpad, caps); gst_caps_unref (caps); /* ensure segment (format) properly setup */ gst_segment_init (&segment, GST_FORMAT_TIME); fail_unless (gst_pad_push_event (mysrcpad, gst_event_new_segment (&segment))); for (i = 0; i < 3; i++) { inbuffer = gst_buffer_new_and_alloc (bytes[i]); gst_buffer_memset (inbuffer, 0, 0, bytes[i]); GST_BUFFER_TIMESTAMP (inbuffer) = total_duration; GST_BUFFER_DURATION (inbuffer) = (GstClockTime) durations[i]; ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1); total_bytes += gst_buffer_get_size (inbuffer); total_duration += GST_BUFFER_DURATION (inbuffer); fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK); } /* send eos to have moov written */ fail_unless (gst_pad_push_event (mysrcpad, gst_event_new_eos ()) == TRUE); gst_element_set_state (qtmux, GST_STATE_NULL); gst_element_set_state (filesink, GST_STATE_NULL); gst_pad_set_active (mysrcpad, FALSE); teardown_src_pad (mysrcpad); gst_object_unref (filesink); gst_check_teardown_element (qtmux); /* check the bitrate tag */ { GstTagList *taglist = NULL; guint bitrate = 0; guint expected; fail_unless (extract_tags (location, &taglist)); fail_unless (gst_tag_list_get_uint (taglist, GST_TAG_BITRATE, &bitrate)); expected = (guint) gst_util_uint64_scale_round ((guint64) total_bytes, (guint64) 8 * GST_SECOND, (guint64) total_duration); fail_unless (bitrate == expected); gst_tag_list_unref (taglist); } /* delete file */ g_unlink (location); g_free (location); } GST_START_TEST (test_average_bitrate) { test_average_bitrate_custom ("mp4mux", &srcaudioaactemplate, "audio_%u"); test_average_bitrate_custom ("mp4mux", &srcvideoh264template, "video_%u"); test_average_bitrate_custom ("qtmux", &srcaudioaactemplate, "audio_%u"); test_average_bitrate_custom ("qtmux", &srcvideoh264template, "video_%u"); } GST_END_TEST; struct TestInputData { GstPad *srcpad; GstSegment segment; GList *input; GThread *thread; /* When comparing ts, the input will be subtracted from this */ gint64 ts_offset; /* Due to DTS, the segment start might be shifted so this list * is used to vefity each received segments */ GList *expected_segment_start; GstClockTime expected_gap_ts; GstClockTime expected_gap_duration; gboolean gap_received; GstPad *sinkpad; GList *output_iter; }; static void test_input_data_init (struct TestInputData *data) { data->ts_offset = 0; data->expected_segment_start = NULL; data->expected_gap_ts = 0; data->expected_gap_duration = 0; data->gap_received = FALSE; data->srcpad = NULL; data->sinkpad = NULL; data->input = NULL; data->thread = NULL; test_input_push_segment_start (data, 0); } static void test_input_data_clean (struct TestInputData *data) { g_list_free_full (data->input, (GDestroyNotify) gst_mini_object_unref); if (data->sinkpad) { gst_pad_set_active (data->sinkpad, FALSE); gst_object_unref (data->sinkpad); } gst_pad_set_active (data->srcpad, FALSE); teardown_src_pad (data->srcpad); } static gpointer test_input_push_data (gpointer user_data) { struct TestInputData *data = user_data; GList *iter; GstFlowReturn flow; for (iter = data->input; iter; iter = g_list_next (iter)) { if (GST_IS_BUFFER (iter->data)) { GST_INFO ("Pushing buffer %" GST_PTR_FORMAT " on pad: %s:%s", iter->data, GST_DEBUG_PAD_NAME (data->srcpad)); flow = gst_pad_push (data->srcpad, gst_buffer_ref ((GstBuffer *) iter->data)); fail_unless (flow == GST_FLOW_OK); } else { GST_INFO_OBJECT (data->srcpad, "Pushing event: %" GST_PTR_FORMAT, iter->data); fail_unless (gst_pad_push_event (data->srcpad, gst_event_ref ((GstEvent *) iter->data)) == TRUE); } } return NULL; } static void test_input_push_segment_start (gpointer user_data, GstClockTime start) { struct TestInputData *data = user_data; GstClockTime *start_data = g_malloc (sizeof (GstClockTime)); *start_data = start; data->expected_segment_start = g_list_append (data->expected_segment_start, start_data); } static GstClockTime test_input_pop_segment_start (gpointer user_data) { struct TestInputData *data = user_data; GstClockTime start = GST_CLOCK_TIME_NONE; GstClockTime *start_data; if (data->expected_segment_start) { start_data = data->expected_segment_start->data; data->expected_segment_start = g_list_delete_link (data->expected_segment_start, data->expected_segment_start); start = *start_data; g_free (start_data); } return start; } static GstBuffer * create_buffer (GstClockTime pts, GstClockTime dts, GstClockTime duration, guint bytes) { GstBuffer *buf; guint8 *data; data = g_malloc0 (bytes); buf = gst_buffer_new_wrapped (data, bytes); GST_BUFFER_PTS (buf) = pts; GST_BUFFER_DTS (buf) = dts; GST_BUFFER_DURATION (buf) = duration; return buf; } static GstFlowReturn _test_sink_pad_chain (GstPad * pad, GstObject * parent, GstBuffer * buffer) { struct TestInputData *test_data = g_object_get_qdata (G_OBJECT (pad), g_quark_from_static_string ("test-mux-pad")); GstBuffer *expected_buffer; fail_unless (test_data->output_iter); fail_unless (GST_IS_BUFFER (test_data->output_iter->data)); expected_buffer = test_data->output_iter->data; fail_unless (GST_BUFFER_PTS (buffer) == (GST_BUFFER_PTS_IS_VALID (expected_buffer) ? GST_BUFFER_PTS (expected_buffer) - test_data->ts_offset : GST_BUFFER_PTS (expected_buffer))); fail_unless (GST_BUFFER_DTS (buffer) == (GST_BUFFER_DTS_IS_VALID (expected_buffer) ? GST_BUFFER_DTS (expected_buffer) - test_data->ts_offset : GST_BUFFER_DTS (buffer))); fail_unless (GST_BUFFER_DURATION (buffer) == GST_BUFFER_DURATION (expected_buffer)); test_data->output_iter = g_list_next (test_data->output_iter); gst_buffer_unref (buffer); return GST_FLOW_OK; } static void compare_event (GstEvent * event, GstEvent * expected) { fail_unless (GST_EVENT_TYPE (event) == GST_EVENT_TYPE (expected)); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_CAPS:{ GstCaps *caps, *expected_caps; gst_event_parse_caps (event, &caps); gst_event_parse_caps (expected, &expected_caps); fail_unless (gst_caps_can_intersect (caps, expected_caps)); } break; default: break; } } static gboolean _test_sink_pad_event (GstPad * pad, GstObject * parent, GstEvent * event) { struct TestInputData *test_data = g_object_get_qdata (G_OBJECT (pad), g_quark_from_static_string ("test-mux-pad")); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_STREAM_START: case GST_EVENT_CAPS: case GST_EVENT_EOS: fail_unless (test_data->output_iter); fail_unless (GST_IS_EVENT (test_data->output_iter->data)); compare_event (event, test_data->output_iter->data); test_data->output_iter = g_list_next (test_data->output_iter); break; case GST_EVENT_SEGMENT:{ const GstSegment *segment; fail_unless (test_data->output_iter); fail_unless (GST_IS_EVENT (test_data->output_iter->data)); gst_event_parse_segment (event, &segment); fail_unless (segment->start == test_input_pop_segment_start (test_data)); test_data->output_iter = g_list_next (test_data->output_iter); break; } case GST_EVENT_GAP:{ GstClockTime timestamp; GstClockTime duration; gst_event_parse_gap (event, ×tamp, &duration); fail_unless (timestamp == test_data->expected_gap_ts); fail_unless (duration == test_data->expected_gap_duration); test_data->gap_received = TRUE; break; } case GST_EVENT_TAG: /* ignore this event */ break; default: GST_ERROR_OBJECT (pad, "Unexpected event: %" GST_PTR_FORMAT, event); fail ("Unexpected event received %s", GST_EVENT_TYPE_NAME (event)); break; } gst_event_unref (event); return TRUE; } static void _test_pad_added_cb (GstElement * element, GstPad * pad, gpointer udata) { GstCaps *caps; struct TestInputData **inputs = udata; gint i = -1; const gchar *name; const gchar *strname; caps = gst_pad_get_current_caps (pad); strname = gst_structure_get_name (gst_caps_get_structure (caps, 0)); if (g_str_has_prefix (strname, "video/")) { i = 0; /* video is 0, audio is 1 */ name = "videosink"; } else { i = 1; name = "audiosink"; } gst_caps_unref (caps); fail_unless (i != -1); fail_unless (inputs[i]->sinkpad == NULL); inputs[i]->sinkpad = gst_pad_new (name, GST_PAD_SINK); inputs[i]->output_iter = inputs[i]->input; g_object_set_qdata (G_OBJECT (inputs[i]->sinkpad), g_quark_from_static_string ("test-mux-pad"), inputs[i]); gst_pad_set_chain_function (inputs[i]->sinkpad, _test_sink_pad_chain); gst_pad_set_event_function (inputs[i]->sinkpad, _test_sink_pad_event); gst_pad_set_active (inputs[i]->sinkpad, TRUE); fail_unless (gst_pad_link (pad, inputs[i]->sinkpad) == GST_PAD_LINK_OK); } static void check_output (const gchar * location, struct TestInputData *input1, struct TestInputData *input2) { GstElement *filesrc; GstElement *demux; struct TestInputData *inputs[2] = { input1, input2 }; filesrc = gst_element_factory_make ("filesrc", NULL); demux = gst_element_factory_make ("qtdemux", NULL); fail_unless (gst_element_link (filesrc, demux)); g_object_set (filesrc, "location", location, NULL); g_signal_connect (demux, "pad-added", (GCallback) _test_pad_added_cb, inputs); fail_unless (gst_element_set_state (demux, GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS); fail_unless (gst_element_set_state (filesrc, GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS); /* FIXME use a main loop */ g_usleep (2 * G_USEC_PER_SEC); fail_unless (gst_element_set_state (demux, GST_STATE_NULL) == GST_STATE_CHANGE_SUCCESS); fail_unless (gst_element_set_state (filesrc, GST_STATE_NULL) == GST_STATE_CHANGE_SUCCESS); gst_object_unref (filesrc); gst_object_unref (demux); } /* Muxes a file with qtmux using the inputs provided and * then verifies that the generated file corresponds to the * data in the inputs */ static void run_muxing_test (struct TestInputData *input1, struct TestInputData *input2) { gchar *location; GstElement *qtmux; GstElement *filesink; location = g_strdup_printf ("%s/%s-%d", g_get_tmp_dir (), "qtmuxtest", g_random_int ()); qtmux = gst_check_setup_element ("qtmux"); filesink = gst_element_factory_make ("filesink", NULL); g_object_set (filesink, "location", location, NULL); gst_element_link (qtmux, filesink); input1->srcpad = setup_src_pad (qtmux, &srcvideorawtemplate, "video_%u"); fail_unless (input1->srcpad != NULL); gst_pad_set_active (input1->srcpad, TRUE); input2->srcpad = setup_src_pad (qtmux, &srcaudioaactemplate, "audio_%u"); fail_unless (input2->srcpad != NULL); gst_pad_set_active (input2->srcpad, TRUE); fail_unless (gst_element_set_state (filesink, GST_STATE_PLAYING) != GST_STATE_CHANGE_FAILURE, "could not set filesink to playing"); fail_unless (gst_element_set_state (qtmux, GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS, "could not set to playing"); input1->thread = g_thread_new ("test-push-data-1", test_input_push_data, input1); input2->thread = g_thread_new ("test-push-data-2", test_input_push_data, input2); /* FIXME set a mainloop and wait for EOS */ g_thread_join (input1->thread); g_thread_join (input2->thread); input1->thread = NULL; input2->thread = NULL; gst_element_set_state (qtmux, GST_STATE_NULL); gst_element_set_state (filesink, GST_STATE_NULL); check_output (location, input1, input2); gst_object_unref (filesink); test_input_data_clean (input1); test_input_data_clean (input2); gst_check_teardown_element (qtmux); /* delete file */ g_unlink (location); g_free (location); } GST_START_TEST (test_muxing) { struct TestInputData input1, input2; GstCaps *caps; test_input_data_init (&input1); test_input_data_init (&input2); /* Create the inputs, after calling the run below, all this data is * transfered to it and we have no need to clean up */ input1.input = NULL; input1.input = g_list_append (input1.input, gst_event_new_stream_start ("test-1")); caps = gst_caps_from_string ("video/x-raw, width=(int)800, height=(int)600, " "framerate=(fraction)1/1, format=(string)RGB"); input1.input = g_list_append (input1.input, gst_event_new_caps (caps)); gst_caps_unref (caps); gst_segment_init (&input1.segment, GST_FORMAT_TIME); input1.input = g_list_append (input1.input, gst_event_new_segment (&input1.segment)); input1.input = g_list_append (input1.input, create_buffer (0, GST_CLOCK_TIME_NONE, GST_SECOND, 800 * 600 * 3)); input1.input = g_list_append (input1.input, create_buffer (1 * GST_SECOND, GST_CLOCK_TIME_NONE, GST_SECOND, 800 * 600 * 3)); input1.input = g_list_append (input1.input, create_buffer (2 * GST_SECOND, GST_CLOCK_TIME_NONE, GST_SECOND, 800 * 600 * 3)); input1.input = g_list_append (input1.input, gst_event_new_eos ()); input2.input = NULL; input2.input = g_list_append (input2.input, gst_event_new_stream_start ("test-2")); caps = gst_caps_from_string ("audio/mpeg, rate=(int)44100, channels=(int)1, mpegversion=(int)4, " "stream-format=(string)raw, framed=(boolean)true"); input2.input = g_list_append (input2.input, gst_event_new_caps (caps)); gst_caps_unref (caps); gst_segment_init (&input2.segment, GST_FORMAT_TIME); input2.input = g_list_append (input2.input, gst_event_new_segment (&input2.segment)); input2.input = g_list_append (input2.input, create_buffer (0, 0, GST_SECOND, 4096)); input2.input = g_list_append (input2.input, create_buffer (1 * GST_SECOND, 1 * GST_SECOND, GST_SECOND, 4096)); input2.input = g_list_append (input2.input, create_buffer (2 * GST_SECOND, 2 * GST_SECOND, GST_SECOND, 4096)); input2.input = g_list_append (input2.input, gst_event_new_eos ()); run_muxing_test (&input1, &input2); } GST_END_TEST; GST_START_TEST (test_muxing_non_zero_segment) { struct TestInputData input1, input2; GstCaps *caps; test_input_data_init (&input1); test_input_data_init (&input2); /* Create the inputs, after calling the run below, all this data is * transfered to it and we have no need to clean up */ input1.input = NULL; input1.input = g_list_append (input1.input, gst_event_new_stream_start ("test-1")); caps = gst_caps_from_string ("video/x-raw, width=(int)800, height=(int)600, " "framerate=(fraction)1/1, format=(string)RGB"); input1.input = g_list_append (input1.input, gst_event_new_caps (caps)); gst_caps_unref (caps); gst_segment_init (&input1.segment, GST_FORMAT_TIME); input1.segment.start = 10 * GST_SECOND; input1.input = g_list_append (input1.input, gst_event_new_segment (&input1.segment)); input1.input = g_list_append (input1.input, create_buffer (10 * GST_SECOND, GST_CLOCK_TIME_NONE, GST_SECOND, 800 * 600 * 3)); input1.input = g_list_append (input1.input, create_buffer (11 * GST_SECOND, GST_CLOCK_TIME_NONE, GST_SECOND, 800 * 600 * 3)); input1.input = g_list_append (input1.input, create_buffer (12 * GST_SECOND, GST_CLOCK_TIME_NONE, GST_SECOND, 800 * 600 * 3)); input1.input = g_list_append (input1.input, gst_event_new_eos ()); input1.ts_offset = GST_SECOND * 10; input2.input = NULL; input2.input = g_list_append (input2.input, gst_event_new_stream_start ("test-2")); caps = gst_caps_from_string ("audio/mpeg, rate=(int)44100, channels=(int)1, mpegversion=(int)4, " "stream-format=(string)raw, framed=(boolean)true"); input2.input = g_list_append (input2.input, gst_event_new_caps (caps)); gst_caps_unref (caps); gst_segment_init (&input2.segment, GST_FORMAT_TIME); input2.segment.start = 10 * GST_SECOND; input2.input = g_list_append (input2.input, gst_event_new_segment (&input2.segment)); input2.input = g_list_append (input2.input, create_buffer (10 * GST_SECOND, 10 * GST_SECOND, GST_SECOND, 4096)); input2.input = g_list_append (input2.input, create_buffer (11 * GST_SECOND, 11 * GST_SECOND, GST_SECOND, 4096)); input2.input = g_list_append (input2.input, create_buffer (12 * GST_SECOND, 12 * GST_SECOND, GST_SECOND, 4096)); input2.input = g_list_append (input2.input, gst_event_new_eos ()); input2.ts_offset = GST_SECOND * 10; run_muxing_test (&input1, &input2); } GST_END_TEST; GST_START_TEST (test_muxing_non_zero_segment_different) { struct TestInputData input1, input2; GstCaps *caps; test_input_data_init (&input1); test_input_data_init (&input2); /* Create the inputs, after calling the run below, all this data is * transfered to it and we have no need to clean up */ input1.input = NULL; input1.input = g_list_append (input1.input, gst_event_new_stream_start ("test-1")); caps = gst_caps_from_string ("video/x-raw, width=(int)800, height=(int)600, " "framerate=(fraction)1/1, format=(string)RGB"); input1.input = g_list_append (input1.input, gst_event_new_caps (caps)); gst_caps_unref (caps); gst_segment_init (&input1.segment, GST_FORMAT_TIME); input1.segment.start = 5 * GST_SECOND; input1.input = g_list_append (input1.input, gst_event_new_segment (&input1.segment)); input1.input = g_list_append (input1.input, create_buffer (5 * GST_SECOND, GST_CLOCK_TIME_NONE, GST_SECOND, 800 * 600 * 3)); input1.input = g_list_append (input1.input, create_buffer (6 * GST_SECOND, GST_CLOCK_TIME_NONE, GST_SECOND, 800 * 600 * 3)); input1.input = g_list_append (input1.input, create_buffer (7 * GST_SECOND, GST_CLOCK_TIME_NONE, GST_SECOND, 800 * 600 * 3)); input1.input = g_list_append (input1.input, gst_event_new_eos ()); input1.ts_offset = GST_SECOND * 5; input2.input = NULL; input2.input = g_list_append (input2.input, gst_event_new_stream_start ("test-2")); caps = gst_caps_from_string ("audio/mpeg, rate=(int)44100, channels=(int)1, mpegversion=(int)4, " "stream-format=(string)raw, framed=(boolean)true"); input2.input = g_list_append (input2.input, gst_event_new_caps (caps)); gst_caps_unref (caps); gst_segment_init (&input2.segment, GST_FORMAT_TIME); input2.segment.start = 10 * GST_SECOND; input2.input = g_list_append (input2.input, gst_event_new_segment (&input2.segment)); input2.input = g_list_append (input2.input, create_buffer (10 * GST_SECOND, 10 * GST_SECOND, GST_SECOND, 4096)); input2.input = g_list_append (input2.input, create_buffer (11 * GST_SECOND, 11 * GST_SECOND, GST_SECOND, 4096)); input2.input = g_list_append (input2.input, create_buffer (12 * GST_SECOND, 12 * GST_SECOND, GST_SECOND, 4096)); input2.input = g_list_append (input2.input, gst_event_new_eos ()); input2.ts_offset = GST_SECOND * 10; run_muxing_test (&input1, &input2); } GST_END_TEST; GST_START_TEST (test_muxing_dts_outside_segment) { struct TestInputData input1, input2; GstCaps *caps; test_input_data_init (&input1); test_input_data_init (&input2); /* Create the inputs, after calling the run below, all this data is * transfered to it and we have no need to clean up */ input1.input = NULL; input1.input = g_list_append (input1.input, gst_event_new_stream_start ("test-1")); caps = gst_caps_from_string ("video/x-h264, width=(int)800, height=(int)600, " "framerate=(fraction)1/1, stream-format=(string)avc, codec_data=(buffer)0000," " alignment=(string)au, level=(int)2, profile=(string)high"); input1.input = g_list_append (input1.input, gst_event_new_caps (caps)); gst_caps_unref (caps); gst_segment_init (&input1.segment, GST_FORMAT_TIME); input1.segment.start = 1 * GST_SECOND; input1.input = g_list_append (input1.input, gst_event_new_segment (&input1.segment)); input1.input = g_list_append (input1.input, create_buffer (1 * GST_SECOND, 0, GST_SECOND, 4096)); input1.input = g_list_append (input1.input, create_buffer (2 * GST_SECOND, 1 * GST_SECOND, GST_SECOND, 4096)); input1.input = g_list_append (input1.input, create_buffer (3 * GST_SECOND, 2 * GST_SECOND, GST_SECOND, 4096)); input1.input = g_list_append (input1.input, gst_event_new_eos ()); /* First DTS is 0, first PTS is 1s. The segment start being 1, this means * running time -1s and 0. So the output segment should start from 1s to keep * the same running time */ test_input_pop_segment_start (&input1); test_input_push_segment_start (&input1, GST_SECOND); input2.input = NULL; input2.input = g_list_append (input2.input, gst_event_new_stream_start ("test-2")); caps = gst_caps_from_string ("audio/mpeg, rate=(int)44100, channels=(int)1, mpegversion=(int)4, " "stream-format=(string)raw, framed=(boolean)true"); input2.input = g_list_append (input2.input, gst_event_new_caps (caps)); gst_caps_unref (caps); gst_segment_init (&input2.segment, GST_FORMAT_TIME); input2.input = g_list_append (input2.input, gst_event_new_segment (&input2.segment)); input2.input = g_list_append (input2.input, create_buffer (0, 0, GST_SECOND, 44100 * 4 * 2)); input2.input = g_list_append (input2.input, create_buffer (GST_SECOND, GST_SECOND, GST_SECOND, 44100 * 4 * 2)); input2.input = g_list_append (input2.input, create_buffer (2 * GST_SECOND, 2 * GST_SECOND, GST_SECOND, 44100 * 4 * 2)); input2.input = g_list_append (input2.input, gst_event_new_eos ()); run_muxing_test (&input1, &input2); } GST_END_TEST; GST_START_TEST (test_muxing_initial_gap) { struct TestInputData input1, input2; GstCaps *caps; test_input_data_init (&input1); test_input_data_init (&input2); /* Create the inputs, after calling the run below, all this data is * transfered to it and we have no need to clean up */ input1.input = NULL; input1.input = g_list_append (input1.input, gst_event_new_stream_start ("test-1")); caps = gst_caps_from_string ("video/x-h264, width=(int)800, height=(int)600, " "framerate=(fraction)1/1, stream-format=(string)avc, codec_data=(buffer)0000," " alignment=(string)au, level=(int)2, profile=(string)high"); input1.input = g_list_append (input1.input, gst_event_new_caps (caps)); gst_caps_unref (caps); gst_segment_init (&input1.segment, GST_FORMAT_TIME); input1.input = g_list_append (input1.input, gst_event_new_segment (&input1.segment)); /* Duplicate the segment to please the harness */ input1.input = g_list_append (input1.input, gst_event_new_segment (&input1.segment)); input1.input = g_list_append (input1.input, create_buffer (1 * GST_SECOND, 0, GST_SECOND, 4096)); input1.input = g_list_append (input1.input, create_buffer (2 * GST_SECOND, 1 * GST_SECOND, GST_SECOND, 4096)); input1.input = g_list_append (input1.input, create_buffer (3 * GST_SECOND, 2 * GST_SECOND, GST_SECOND, 4096)); input1.input = g_list_append (input1.input, gst_event_new_eos ()); /* We expect a 1s gap at the start */ input1.expected_gap_duration = GST_SECOND; /* There will be two segments, first is 0, so leave it there, second should * match the first CTTS (PTS - DTS) */ test_input_push_segment_start (&input1, GST_SECOND); input2.input = NULL; input2.input = g_list_append (input2.input, gst_event_new_stream_start ("test-2")); caps = gst_caps_from_string ("audio/mpeg, rate=(int)44100, channels=(int)1, mpegversion=(int)4, " "stream-format=(string)raw, framed=(boolean)true"); input2.input = g_list_append (input2.input, gst_event_new_caps (caps)); gst_caps_unref (caps); gst_segment_init (&input2.segment, GST_FORMAT_TIME); input2.input = g_list_append (input2.input, gst_event_new_segment (&input2.segment)); input2.input = g_list_append (input2.input, create_buffer (0, 0, GST_SECOND, 44100 * 4 * 2)); input2.input = g_list_append (input2.input, create_buffer (GST_SECOND, GST_SECOND, GST_SECOND, 44100 * 4 * 2)); input2.input = g_list_append (input2.input, create_buffer (2 * GST_SECOND, 2 * GST_SECOND, GST_SECOND, 44100 * 4 * 2)); input2.input = g_list_append (input2.input, gst_event_new_eos ()); run_muxing_test (&input1, &input2); fail_unless (input1.gap_received); } GST_END_TEST; static Suite * qtmux_suite (void) { Suite *s = suite_create ("qtmux"); TCase *tc_chain = tcase_create ("general"); /* avoid glib warnings when setting deprecated dts-method property */ g_setenv ("G_ENABLE_DIAGNOSTIC", "0", TRUE); suite_add_tcase (s, tc_chain); tcase_add_test (tc_chain, test_video_pad_dd); tcase_add_test (tc_chain, test_audio_pad_dd); tcase_add_test (tc_chain, test_video_pad_frag_dd); tcase_add_test (tc_chain, test_audio_pad_frag_dd); tcase_add_test (tc_chain, test_video_pad_frag_dd_streamable); tcase_add_test (tc_chain, test_audio_pad_frag_dd_streamable); tcase_add_test (tc_chain, test_video_pad_reorder); tcase_add_test (tc_chain, test_audio_pad_reorder); tcase_add_test (tc_chain, test_video_pad_frag_reorder); tcase_add_test (tc_chain, test_audio_pad_frag_reorder); tcase_add_test (tc_chain, test_video_pad_frag_reorder_streamable); tcase_add_test (tc_chain, test_audio_pad_frag_reorder_streamable); tcase_add_test (tc_chain, test_video_pad_asc); tcase_add_test (tc_chain, test_audio_pad_asc); tcase_add_test (tc_chain, test_video_pad_frag_asc); tcase_add_test (tc_chain, test_audio_pad_frag_asc); tcase_add_test (tc_chain, test_video_pad_frag_asc_streamable); tcase_add_test (tc_chain, test_audio_pad_frag_asc_streamable); tcase_add_test (tc_chain, test_average_bitrate); tcase_add_test (tc_chain, test_reuse); tcase_add_test (tc_chain, test_encodebin_qtmux); tcase_add_test (tc_chain, test_encodebin_mp4mux); tcase_add_test (tc_chain, test_muxing); tcase_add_test (tc_chain, test_muxing_non_zero_segment); tcase_add_test (tc_chain, test_muxing_non_zero_segment_different); tcase_add_test (tc_chain, test_muxing_dts_outside_segment); tcase_add_test (tc_chain, test_muxing_initial_gap); return s; } GST_CHECK_MAIN (qtmux)