gstreamer/subprojects/gst-plugins-bad/tests/check/libs/mse.c

1119 lines
34 KiB
C

/* GStreamer
*
* SPDX-License-Identifier: LGPL-2.1
*
* Copyright (C) 2022, 2023 Collabora Ltd.
*
* 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 "config.h"
#endif
#ifdef HAVE_VALGRIND
# include <valgrind/valgrind.h>
#endif
#include <gst/check/gstcheck.h>
#include <gst/mse/mse.h>
#include <gst/mse/gstappendpipeline-private.h>
#include <gst/mse/gstmediasource-private.h>
#include <gst/mse/gstmediasourcetrack-private.h>
#include <gst/mse/gstmediasourcetrackbuffer-private.h>
#include <gst/mse/gstmediasourcesamplemap-private.h>
static GstCheckLogFilter *
add_log_filter (GLogLevelFlags level, const gchar * regex)
{
GRegex *gregex = g_regex_new (regex, 0, 0, NULL);
return gst_check_add_log_filter ("GStreamer-MSE", level, gregex, NULL, NULL,
NULL);
}
static gchar *
test_mp4_path (void)
{
return g_build_filename (GST_TEST_FILES_PATH, "mse.mp4", NULL);
}
static gchar *
test_webm_path (void)
{
return g_build_filename (GST_TEST_FILES_PATH, "mse.webm", NULL);
}
static GstMediaSource *
opened_media_source (void)
{
GstMediaSource *media_source = gst_media_source_new ();
media_source->ready_state = GST_MEDIA_SOURCE_READY_STATE_OPEN;
return media_source;
}
static GstSample *
new_empty_sample_full (GstClockTime dts, GstClockTime pts,
GstClockTime duration, GstBufferFlags flags, GstCaps * caps,
GstSegment * segment, GstStructure * info)
{
GstBuffer *buffer = gst_buffer_new ();
GST_BUFFER_DTS (buffer) = dts;
GST_BUFFER_PTS (buffer) = pts;
GST_BUFFER_DURATION (buffer) = duration;
GST_BUFFER_FLAGS (buffer) = flags;
GstSample *sample = gst_sample_new (buffer, caps, segment, info);
gst_buffer_unref (buffer);
return sample;
}
static GstSample *
new_empty_sample_with_timing (GstClockTime dts, GstClockTime pts,
GstClockTime duration)
{
return new_empty_sample_full (dts, pts, duration, 0, NULL, NULL, NULL);
}
static GstSample *
new_sample_with_bytes_and_timing (GBytes * bytes, GstClockTime dts,
GstClockTime pts, GstClockTime duration)
{
GstBuffer *buffer = gst_buffer_new_wrapped_bytes (bytes);
GST_BUFFER_DTS (buffer) = dts;
GST_BUFFER_PTS (buffer) = pts;
GST_BUFFER_DURATION (buffer) = duration;
GstSample *sample = gst_sample_new (buffer, NULL, NULL, NULL);
gst_buffer_unref (buffer);
g_bytes_unref (bytes);
return sample;
}
GST_START_TEST (test_create_and_free)
{
GstMediaSource *media_source = gst_media_source_new ();
fail_unless (GST_IS_MEDIA_SOURCE (media_source));
gst_check_object_destroyed_on_unref (media_source);
}
GST_END_TEST;
GST_START_TEST (test_create_initial_state)
{
GstMediaSource *media_source = gst_media_source_new ();
GstSourceBufferList *buffers =
gst_media_source_get_source_buffers (media_source);
GstSourceBufferList *active_buffers =
gst_media_source_get_active_source_buffers (media_source);
fail_unless (gst_media_source_get_ready_state (media_source) ==
GST_MEDIA_SOURCE_READY_STATE_CLOSED);
fail_unless (gst_source_buffer_list_get_length (buffers) == 0);
fail_unless (gst_source_buffer_list_get_length (active_buffers) == 0);
fail_unless (gst_media_source_get_position (media_source) ==
GST_CLOCK_TIME_NONE);
gst_object_unref (media_source);
gst_object_unref (buffers);
gst_object_unref (active_buffers);
}
GST_END_TEST;
GST_START_TEST (test_add_source_buffer_with_content_type_null)
{
add_log_filter (G_LOG_LEVEL_CRITICAL,
"^.*_add_source_buffer: assertion 'type != NULL' failed");
GstMediaSource *media_source = gst_media_source_new ();
g_assert_null (gst_media_source_add_source_buffer (media_source, NULL, NULL));
gst_object_unref (media_source);
}
GST_END_TEST;
GST_START_TEST (test_add_source_buffer_with_content_type_empty)
{
GError *error = NULL;
GstMediaSource *media_source = gst_media_source_new ();
GstSourceBuffer *source_buffer =
gst_media_source_add_source_buffer (media_source, "", &error);
g_assert_null (source_buffer);
g_assert_error (error, GST_MEDIA_SOURCE_ERROR, GST_MEDIA_SOURCE_ERROR_TYPE);
gst_object_unref (media_source);
g_clear_error (&error);
}
GST_END_TEST;
GST_START_TEST (test_add_source_buffer_with_content_type_fake)
{
GError *error = NULL;
GstMediaSource *media_source = gst_media_source_new ();
GstSourceBuffer *source_buffer =
gst_media_source_add_source_buffer (media_source, "fake/type", &error);
g_assert_null (source_buffer);
g_assert_error (error, GST_MEDIA_SOURCE_ERROR,
GST_MEDIA_SOURCE_ERROR_NOT_SUPPORTED);
gst_object_unref (media_source);
g_clear_error (&error);
}
GST_END_TEST;
GST_START_TEST (test_add_source_buffer_to_unopened_media_source)
{
GError *error = NULL;
GstMediaSource *media_source = gst_media_source_new ();
GstSourceBuffer *source_buffer =
gst_media_source_add_source_buffer (media_source, "video/webm", &error);
g_assert_null (source_buffer);
g_assert_error (error, GST_MEDIA_SOURCE_ERROR,
GST_MEDIA_SOURCE_ERROR_INVALID_STATE);
gst_object_unref (media_source);
g_clear_error (&error);
}
GST_END_TEST;
GST_START_TEST (test_add_source_buffer_to_opened_media_source)
{
GError *error = NULL;
GstMediaSource *media_source = opened_media_source ();
GstSourceBufferList *buffers =
gst_media_source_get_source_buffers (media_source);
guint n_buffers_before = gst_source_buffer_list_get_length (buffers);
GstSourceBuffer *source_buffer =
gst_media_source_add_source_buffer (media_source, "video/webm", &error);
guint n_buffers_after = gst_source_buffer_list_get_length (buffers);
fail_unless (GST_IS_SOURCE_BUFFER (source_buffer));
g_assert_no_error (error);
fail_unless (n_buffers_before < n_buffers_after);
g_object_unref (media_source);
g_object_unref (buffers);
g_object_unref (source_buffer);
g_clear_error (&error);
}
GST_END_TEST;
GST_START_TEST (test_remove_source_buffer_from_unrelated_media_source)
{
GError *error = NULL;
GstMediaSource *a = opened_media_source ();
GstMediaSource *b = opened_media_source ();
GstSourceBuffer *buffer_in_b =
gst_media_source_add_source_buffer (b, "video/webm", &error);
gst_media_source_remove_source_buffer (a, buffer_in_b, &error);
g_assert_error (error, GST_MEDIA_SOURCE_ERROR,
GST_MEDIA_SOURCE_ERROR_NOT_FOUND);
gst_object_unref (a);
gst_object_unref (b);
gst_object_unref (buffer_in_b);
g_clear_error (&error);
}
GST_END_TEST;
GST_START_TEST (test_remove_source_buffer_from_parent_media_source)
{
GError *error = NULL;
GstMediaSource *media_source = opened_media_source ();
GstSourceBufferList *buffers =
gst_media_source_get_source_buffers (media_source);
GstSourceBuffer *buffer =
gst_media_source_add_source_buffer (media_source, "video/webm", &error);
guint n_buffers_before = gst_source_buffer_list_get_length (buffers);
gst_media_source_remove_source_buffer (media_source, buffer, &error);
guint n_buffers_after = gst_source_buffer_list_get_length (buffers);
g_assert_no_error (error);
fail_unless (n_buffers_before > n_buffers_after);
gst_object_unref (media_source);
gst_object_unref (buffers);
gst_object_unref (buffer);
g_clear_error (&error);
}
GST_END_TEST;
GST_START_TEST (test_set_live_seekable_range_on_unopened_media_source)
{
GError *error = NULL;
GstMediaSource *media_source = gst_media_source_new ();
gst_media_source_set_live_seekable_range (media_source, 0, 1, &error);
g_assert_error (error, GST_MEDIA_SOURCE_ERROR,
GST_MEDIA_SOURCE_ERROR_INVALID_STATE);
gst_object_unref (media_source);
g_clear_error (&error);
}
GST_END_TEST;
GST_START_TEST (test_set_backwards_live_seekable_range_on_opened_media_source)
{
GError *error = NULL;
GstMediaSource *media_source = opened_media_source ();
gst_media_source_set_live_seekable_range (media_source, 2, 1, &error);
GstMediaSourceRange range = {
.start = GST_CLOCK_TIME_NONE,
.end = GST_CLOCK_TIME_NONE,
};
gst_media_source_get_live_seekable_range (media_source, &range);
g_assert_error (error, GST_MEDIA_SOURCE_ERROR, GST_MEDIA_SOURCE_ERROR_TYPE);
fail_unless (range.start == 0);
fail_unless (range.end == 0);
gst_object_unref (media_source);
g_clear_error (&error);
}
GST_END_TEST;
GST_START_TEST (test_set_live_seekable_range_on_opened_media_source)
{
GError *error = NULL;
GstClockTime start = 1, end = 2;
GstMediaSource *media_source = opened_media_source ();
gst_media_source_set_live_seekable_range (media_source, start, end, &error);
GstMediaSourceRange range = {
.start = GST_CLOCK_TIME_NONE,
.end = GST_CLOCK_TIME_NONE,
};
gst_media_source_get_live_seekable_range (media_source, &range);
g_assert_no_error (error);
fail_unless (range.start == start);
fail_unless (range.end == end);
gst_object_unref (media_source);
g_clear_error (&error);
}
GST_END_TEST;
GST_START_TEST (test_clear_live_seekable_range_on_unopened_media_source)
{
GError *error = NULL;
GstMediaSource *media_source = gst_media_source_new ();
gst_media_source_clear_live_seekable_range (media_source, &error);
g_assert_error (error, GST_MEDIA_SOURCE_ERROR,
GST_MEDIA_SOURCE_ERROR_INVALID_STATE);
gst_object_unref (media_source);
g_clear_error (&error);
}
GST_END_TEST;
GST_START_TEST (test_clear_live_seekable_range_on_opened_media_source)
{
GError *error = NULL;
GstMediaSource *media_source = opened_media_source ();
gst_media_source_set_live_seekable_range (media_source, 1, 2, NULL);
gst_media_source_clear_live_seekable_range (media_source, &error);
GstMediaSourceRange range = {
.start = GST_CLOCK_TIME_NONE,
.end = GST_CLOCK_TIME_NONE,
};
gst_media_source_get_live_seekable_range (media_source, &range);
g_assert_no_error (error);
fail_unless (range.start == 0);
fail_unless (range.end == 0);
gst_object_unref (media_source);
g_clear_error (&error);
}
GST_END_TEST;
GST_START_TEST (test_append_pipeline_create_and_free)
{
GError *error = NULL;
GstAppendPipeline *pipeline = gst_append_pipeline_new (NULL, NULL, &error);
g_assert_no_error (error);
fail_unless (GST_IS_APPEND_PIPELINE (pipeline));
gst_check_object_destroyed_on_unref (pipeline);
g_clear_error (&error);
}
GST_END_TEST;
typedef struct
{
GMutex mutex;
GCond eos_cond;
GCond error_cond;
} AppendPipelineTestContext;
static void
test_append_pipeline_eos (GstAppendPipeline * pipeline,
GstMediaSourceTrack * track, gpointer user_data)
{
AppendPipelineTestContext *context = user_data;
g_mutex_lock (&context->mutex);
g_cond_signal (&context->eos_cond);
g_mutex_unlock (&context->mutex);
GST_DEBUG_OBJECT (pipeline, "signalled eos");
}
static void
test_append_pipeline_error (GstAppendPipeline * pipeline, gpointer user_data)
{
AppendPipelineTestContext *context = user_data;
g_mutex_lock (&context->mutex);
g_cond_signal (&context->error_cond);
g_mutex_unlock (&context->mutex);
GST_DEBUG_OBJECT (pipeline, "signalled error");
}
static void
test_append_pipeline_await_eos (GstAppendPipeline * pipeline,
AppendPipelineTestContext * context)
{
GST_DEBUG_OBJECT (pipeline, "waiting for eos");
g_mutex_lock (&context->mutex);
while (!gst_append_pipeline_get_eos (pipeline)) {
g_cond_wait (&context->eos_cond, &context->mutex);
}
g_mutex_unlock (&context->mutex);
GST_DEBUG_OBJECT (pipeline, "received eos");
}
static void
test_append_pipeline_await_error (GstAppendPipeline * pipeline,
AppendPipelineTestContext * context)
{
GST_DEBUG_OBJECT (pipeline, "waiting for error");
g_mutex_lock (&context->mutex);
while (!gst_append_pipeline_get_failed (pipeline)) {
g_cond_wait (&context->error_cond, &context->mutex);
}
g_mutex_unlock (&context->mutex);
GST_DEBUG_OBJECT (pipeline, "received error");
}
static void
test_append_pipeline (const gchar * filename)
{
AppendPipelineTestContext context = { 0 };
GstAppendPipelineCallbacks callbacks = {
.eos = test_append_pipeline_eos,
};
GstAppendPipeline *pipeline =
gst_append_pipeline_new (&callbacks, &context, NULL);
GError *error = NULL;
gchar *data;
gsize length;
g_file_get_contents (filename, &data, &length, &error);
g_assert_no_error (error);
fail_unless (gst_append_pipeline_append (pipeline,
gst_buffer_new_wrapped (data, length)) == GST_FLOW_OK);
gst_append_pipeline_eos (pipeline);
test_append_pipeline_await_eos (pipeline, &context);
fail_if (gst_append_pipeline_get_failed (pipeline));
gst_object_unref (pipeline);
g_clear_error (&error);
}
GST_START_TEST (test_append_pipeline_mp4)
{
gchar *filename = test_mp4_path ();
test_append_pipeline (filename);
g_free (filename);
}
GST_END_TEST;
GST_START_TEST (test_append_pipeline_webm)
{
gchar *filename = test_webm_path ();
test_append_pipeline (filename);
g_free (filename);
}
GST_END_TEST;
static GstAppendPipeline *
failed_append_pipeline (GstAppendPipelineCallbacks * callbacks,
AppendPipelineTestContext * context)
{
GstAppendPipeline *pipeline =
gst_append_pipeline_new (callbacks, context, NULL);
gst_append_pipeline_fail (pipeline);
return pipeline;
}
GST_START_TEST (test_append_pipeline_invalid_data_triggers_error)
{
AppendPipelineTestContext context = { 0 };
GstAppendPipelineCallbacks callbacks = {
.eos = test_append_pipeline_eos,
.error = test_append_pipeline_error,
};
GstAppendPipeline *pipeline = failed_append_pipeline (&callbacks, &context);
test_append_pipeline_await_error (pipeline, &context);
gst_object_unref (pipeline);
}
GST_END_TEST;
GST_START_TEST (test_append_pipeline_invalid_data_triggers_eos)
{
AppendPipelineTestContext context = { 0 };
GstAppendPipelineCallbacks callbacks = {
.eos = test_append_pipeline_eos,
.error = test_append_pipeline_error,
};
GstAppendPipeline *pipeline = failed_append_pipeline (&callbacks, &context);
test_append_pipeline_await_eos (pipeline, &context);
gst_object_unref (pipeline);
}
GST_END_TEST;
GST_START_TEST (test_append_pipeline_reset_recovery)
{
AppendPipelineTestContext context = { 0 };
GstAppendPipelineCallbacks callbacks = {
.eos = test_append_pipeline_eos,
.error = test_append_pipeline_error,
};
GstAppendPipeline *pipeline = failed_append_pipeline (&callbacks, &context);
test_append_pipeline_await_error (pipeline, &context);
fail_unless (gst_append_pipeline_get_failed (pipeline));
fail_unless (gst_append_pipeline_reset (pipeline));
fail_if (gst_append_pipeline_get_failed (pipeline));
gchar *data;
gsize length;
{
GError *error = NULL;
gchar *filename = test_webm_path ();
g_file_get_contents (filename, &data, &length, &error);
g_assert_no_error (error);
g_clear_error (&error);
g_free (filename);
}
fail_unless (gst_append_pipeline_append (pipeline,
gst_buffer_new_wrapped (data, length)) == GST_FLOW_OK);
gst_append_pipeline_eos (pipeline);
test_append_pipeline_await_eos (pipeline, &context);
fail_if (gst_append_pipeline_get_failed (pipeline));
gst_object_unref (pipeline);
}
GST_END_TEST;
GST_START_TEST (test_track_create_and_free)
{
GstMediaSourceTrack *track =
gst_media_source_track_new (GST_MEDIA_SOURCE_TRACK_TYPE_OTHER, "");
fail_unless (GST_IS_MEDIA_SOURCE_TRACK (track));
gst_check_object_destroyed_on_unref (track);
}
GST_END_TEST;
GST_START_TEST (test_track_create_with_invalid_type)
{
add_log_filter (G_LOG_LEVEL_CRITICAL,
"^.*track_new_full: assertion .*type .* failed");
g_assert_null (gst_media_source_track_new (-1, ""));
g_assert_null (gst_media_source_track_new (GST_MEDIA_SOURCE_TRACK_TYPE_OTHER +
1, ""));
}
GST_END_TEST;
GST_START_TEST (test_track_push_with_adequate_space)
{
GstMediaSourceTrack *track =
gst_media_source_track_new_with_size (GST_MEDIA_SOURCE_TRACK_TYPE_OTHER,
"", 1);
GstBuffer *buffer = gst_buffer_new ();
GstSample *sample = gst_sample_new (buffer, NULL, NULL, NULL);
gboolean result = gst_media_source_track_push (track, sample);
fail_unless (result);
gst_buffer_unref (buffer);
gst_object_unref (track);
}
GST_END_TEST;
GST_START_TEST (test_track_push_with_inadequate_space)
{
GstMediaSourceTrack *track =
gst_media_source_track_new_with_size (GST_MEDIA_SOURCE_TRACK_TYPE_OTHER,
"", 0);
GstBuffer *buffer = gst_buffer_new ();
GstSample *sample = gst_sample_new (buffer, NULL, NULL, NULL);
gboolean result = gst_media_source_track_try_push (track, sample);
fail_if (result);
gst_sample_unref (sample);
gst_buffer_unref (buffer);
gst_object_unref (track);
}
GST_END_TEST;
GST_START_TEST (test_track_buffer_empty)
{
GstMediaSourceTrackBuffer *buffer = gst_media_source_track_buffer_new ();
GArray *ranges = gst_media_source_track_buffer_get_ranges (buffer);
fail_unless_equals_uint64 (ranges->len, 0);
gst_object_unref (buffer);
g_array_unref (ranges);
}
GST_END_TEST;
GST_START_TEST (test_track_buffer_single_span)
{
GstMediaSourceTrackBuffer *buffer = gst_media_source_track_buffer_new ();
GstSample *sample = new_empty_sample_with_timing (0, 0, 1);
gst_media_source_track_buffer_add (buffer, sample);
GArray *ranges = gst_media_source_track_buffer_get_ranges (buffer);
fail_unless_equals_uint64 (ranges->len, 1);
GstMediaSourceRange range = g_array_index (ranges, GstMediaSourceRange, 0);
fail_unless_equals_uint64 (range.start, 0);
fail_unless_equals_uint64 (range.end, 1);
gst_sample_unref (sample);
gst_object_unref (buffer);
g_array_unref (ranges);
}
GST_END_TEST;
GST_START_TEST (test_track_buffer_continuous_span)
{
GstMediaSourceTrackBuffer *buffer = gst_media_source_track_buffer_new ();
GstClockTime a_start = 0;
GstClockTime a_duration = GST_SECOND;
GstClockTime b_start = a_start + a_duration;
GstClockTime b_duration = a_duration;
GstSample *a = new_empty_sample_with_timing (a_start, a_start, a_duration);
GstSample *b = new_empty_sample_with_timing (b_start, b_start, b_duration);
gst_media_source_track_buffer_add (buffer, a);
gst_media_source_track_buffer_add (buffer, b);
GArray *ranges = gst_media_source_track_buffer_get_ranges (buffer);
fail_unless_equals_uint64 (ranges->len, 1);
GstMediaSourceRange range = g_array_index (ranges, GstMediaSourceRange, 0);
fail_unless_equals_uint64 (range.start, a_start);
fail_unless_equals_uint64 (range.end, a_start + a_duration + b_duration);
gst_sample_unref (a);
gst_sample_unref (b);
gst_object_unref (buffer);
g_array_unref (ranges);
}
GST_END_TEST;
GST_START_TEST (test_track_buffer_discontinuous_span)
{
GstMediaSourceTrackBuffer *buffer = gst_media_source_track_buffer_new ();
GstClockTime a_start = 0;
GstClockTime a_duration = GST_SECOND;
GstClockTime b_start = a_start + a_duration + GST_SECOND;
GstClockTime b_duration = a_duration;
GstSample *a = new_empty_sample_with_timing (a_start, a_start, a_duration);
GstSample *b = new_empty_sample_with_timing (b_start, b_start, b_duration);
gst_media_source_track_buffer_add (buffer, a);
gst_media_source_track_buffer_add (buffer, b);
GArray *ranges = gst_media_source_track_buffer_get_ranges (buffer);
fail_unless_equals_uint64 (ranges->len, 2);
GstMediaSourceRange range_a = g_array_index (ranges, GstMediaSourceRange, 0);
fail_unless_equals_uint64 (range_a.start, a_start);
fail_unless_equals_uint64 (range_a.end, a_start + a_duration);
GstMediaSourceRange range_b = g_array_index (ranges, GstMediaSourceRange, 1);
fail_unless_equals_uint64 (range_b.start, b_start);
fail_unless_equals_uint64 (range_b.end, b_start + b_duration);
gst_sample_unref (a);
gst_sample_unref (b);
gst_object_unref (buffer);
g_array_unref (ranges);
}
GST_END_TEST;
GST_START_TEST (test_source_buffer_generate_timestamps_mp4)
{
GstMediaSource *media_source = opened_media_source ();
GstSourceBuffer *source_buffer = gst_media_source_add_source_buffer
(media_source, "video/mp4", NULL);
fail_unless_equals_uint64 (gst_source_buffer_get_append_mode (source_buffer),
GST_SOURCE_BUFFER_APPEND_MODE_SEGMENTS);
gst_object_unref (source_buffer);
gst_object_unref (media_source);
}
GST_END_TEST;
GST_START_TEST (test_source_buffer_generate_timestamps_aac)
{
GstMediaSource *media_source = opened_media_source ();
GstSourceBuffer *source_buffer = gst_media_source_add_source_buffer
(media_source, "audio/aac", NULL);
fail_unless (GST_IS_SOURCE_BUFFER (source_buffer));
fail_unless_equals_uint64 (gst_source_buffer_get_append_mode (source_buffer),
GST_SOURCE_BUFFER_APPEND_MODE_SEQUENCE);
gst_object_unref (source_buffer);
gst_object_unref (media_source);
}
GST_END_TEST;
GST_START_TEST (test_source_buffer_change_content_type_null)
{
GstMediaSource *media_source = opened_media_source ();
GstSourceBuffer *source_buffer = gst_media_source_add_source_buffer
(media_source, "video/mp4", NULL);
fail_unless (GST_IS_SOURCE_BUFFER (source_buffer));
GError *error = NULL;
gst_source_buffer_change_content_type (source_buffer, NULL, &error);
g_assert_error (error, GST_MEDIA_SOURCE_ERROR, GST_MEDIA_SOURCE_ERROR_TYPE);
g_clear_error (&error);
gst_object_unref (source_buffer);
gst_object_unref (media_source);
}
GST_END_TEST;
GST_START_TEST (test_source_buffer_change_content_type_empty)
{
GstMediaSource *media_source = opened_media_source ();
GstSourceBuffer *source_buffer = gst_media_source_add_source_buffer
(media_source, "video/mp4", NULL);
fail_unless (GST_IS_SOURCE_BUFFER (source_buffer));
GError *error = NULL;
gst_source_buffer_change_content_type (source_buffer, "", &error);
g_assert_error (error, GST_MEDIA_SOURCE_ERROR, GST_MEDIA_SOURCE_ERROR_TYPE);
g_clear_error (&error);
gst_object_unref (source_buffer);
gst_object_unref (media_source);
}
GST_END_TEST;
GST_START_TEST (test_source_buffer_change_content_type)
{
GstMediaSource *media_source = opened_media_source ();
GstSourceBuffer *source_buffer = gst_media_source_add_source_buffer
(media_source, "video/mp4", NULL);
fail_unless (GST_IS_SOURCE_BUFFER (source_buffer));
GError *error = NULL;
gst_source_buffer_change_content_type (source_buffer, "video/webm", &error);
g_assert_error (error, GST_MEDIA_SOURCE_ERROR,
GST_MEDIA_SOURCE_ERROR_NOT_SUPPORTED);
gst_object_unref (source_buffer);
gst_object_unref (media_source);
g_clear_error (&error);
}
GST_END_TEST;
static const gchar *unsupported_content_types[] = {
"xxx",
"text/html",
"image/jpeg",
};
GST_START_TEST (test_media_source_unsupported_content_type)
{
const gchar *content_type = unsupported_content_types[__i__];
ck_assert_msg (!gst_media_source_is_type_supported (content_type),
"%s should be rejected as an unsupported MIME type", content_type);
}
GST_END_TEST;
static const gchar *valid_mp4_content_types[] = {
"video/mp4;codecs=\"avc1.4d001e\"", // H.264 Main Profile level 3.0
"video/mp4;codecs=\"avc1.42001e\"", // H.264 Baseline Profile level 3.0
"audio/mp4;codecs=\"mp4a.40.2\"", // MPEG4 AAC-LC
"audio/mp4;codecs=\"mp4a.40.5\"", // MPEG4 HE-AAC
"audio/mp4;codecs=\"mp4a.67\"", // MPEG2 AAC-LC
"video/mp4;codecs=\"mp4a.40.2\"",
"video/mp4;codecs=\"avc1.4d001e,mp4a.40.2\"",
"video/mp4;codecs=\"mp4a.40.2 , avc1.4d001e \"",
"video/mp4;codecs=\"avc1.4d001e,mp4a.40.5\"",
"audio/mp4;codecs=\"Opus\"",
"video/mp4;codecs=\"Opus\"",
"audio/mp4;codecs=\"fLaC\"",
"video/mp4;codecs=\"fLaC\"",
};
GST_START_TEST (test_media_source_supported_mp4_content_type)
{
const gchar *content_type = valid_mp4_content_types[__i__];
ck_assert_msg (gst_media_source_is_type_supported (content_type),
"%s must be a supported MP4 content type", content_type);
}
GST_END_TEST;
static const gchar *valid_webm_content_types[] = {
"video/webm;codecs=\"vp8\"",
"video/webm;codecs=\"vorbis\"",
"video/webm;codecs=\"vp8,vorbis\"",
"video/webm;codecs=\"vorbis, vp8\"",
"audio/webm;codecs=\"vorbis\"",
"AUDIO/WEBM;CODECS=\"vorbis\"",
"audio/webm;codecs=vorbis;test=\"6\"",
"audio/webm;codecs=\"opus\"",
"video/webm;codecs=\"opus\"",
};
GST_START_TEST (test_media_source_supported_webm_content_type)
{
const gchar *content_type = valid_webm_content_types[__i__];
ck_assert_msg (gst_media_source_is_type_supported (content_type),
"%s must be a supported WebM content type", content_type);
}
GST_END_TEST;
GST_START_TEST (test_sample_map_create_and_destroy)
{
GstMediaSourceSampleMap *map = gst_media_source_sample_map_new ();
gst_check_object_destroyed_on_unref (map);
}
GST_END_TEST;
GST_START_TEST (test_sample_map_add_valid_sample)
{
GstMediaSourceSampleMap *map = gst_media_source_sample_map_new ();
GstSample *sample = new_empty_sample_with_timing (0, 0, 0);
fail_if (gst_media_source_sample_map_contains (map, sample));
gst_media_source_sample_map_add (map, sample);
fail_unless (gst_media_source_sample_map_contains (map, sample));
gst_object_unref (map);
gst_sample_unref (sample);
}
GST_END_TEST;
GST_START_TEST (test_sample_map_add_invalid_sample)
{
add_log_filter (G_LOG_LEVEL_CRITICAL,
"^.*_sample_map_add: assertion .* failed");
GstMediaSourceSampleMap *map = gst_media_source_sample_map_new ();
GstSample *sample = new_empty_sample_with_timing (GST_CLOCK_TIME_NONE,
GST_CLOCK_STIME_NONE, GST_CLOCK_TIME_NONE);
gst_media_source_sample_map_add (map, sample);
fail_if (gst_media_source_sample_map_contains (map, sample));
gst_object_unref (map);
gst_sample_unref (sample);
}
GST_END_TEST;
GST_START_TEST (test_sample_map_remove_sample)
{
GstMediaSourceSampleMap *map = gst_media_source_sample_map_new ();
GstSample *sample = new_empty_sample_with_timing (0, 0, 0);
gst_media_source_sample_map_add (map, sample);
gst_media_source_sample_map_remove (map, sample);
fail_if (gst_media_source_sample_map_contains (map, sample));
gst_object_unref (map);
gst_sample_unref (sample);
}
GST_END_TEST;
GST_START_TEST (test_sample_map_remove_range_from_start)
{
GstMediaSourceSampleMap *map = gst_media_source_sample_map_new ();
GstSample *samples_to_remove[100] = { NULL };
for (guint i = 0; i < G_N_ELEMENTS (samples_to_remove); i++) {
GstClockTime time = i;
GstSample *sample = new_empty_sample_with_timing (time, time, 1);
gst_media_source_sample_map_add (map, sample);
samples_to_remove[i] = sample;
}
GstSample *samples_to_preserve[100] = { NULL };
for (guint i = 0; i < G_N_ELEMENTS (samples_to_preserve); i++) {
GstClockTime time = i + G_N_ELEMENTS (samples_to_remove);
GstSample *sample = new_empty_sample_with_timing (time, time, 0);
gst_media_source_sample_map_add (map, sample);
samples_to_preserve[i] = sample;
}
gst_media_source_sample_map_remove_range_from_start (map, 100);
for (guint i = 0; i < G_N_ELEMENTS (samples_to_remove); i++) {
GstSample *sample = samples_to_remove[i];
fail_if (gst_media_source_sample_map_contains (map, sample));
gst_sample_unref (sample);
}
for (guint i = 0; i < G_N_ELEMENTS (samples_to_preserve); i++) {
GstSample *sample = samples_to_preserve[i];
fail_unless (gst_media_source_sample_map_contains (map, sample));
gst_sample_unref (sample);
}
gst_object_unref (map);
}
GST_END_TEST;
GST_START_TEST (test_sample_map_remove_range_from_start_byte_count)
{
GstMediaSourceSampleMap *map = gst_media_source_sample_map_new ();
GstSample *samples_to_remove[100] = { NULL };
const guint8 chunk[1000] = { 0 };
gsize total_bytes_to_remove = 0;
for (guint i = 0; i < G_N_ELEMENTS (samples_to_remove); i++) {
GstClockTime time = i;
gsize buffer_size = g_random_int_range (0, G_N_ELEMENTS (chunk));
GBytes *bytes = g_bytes_new_static (chunk, buffer_size);
total_bytes_to_remove += buffer_size;
GstSample *sample = new_sample_with_bytes_and_timing (bytes, time, time, 1);
gst_media_source_sample_map_add (map, sample);
samples_to_remove[i] = sample;
}
GstSample *samples_to_preserve[100] = { NULL };
for (guint i = 0; i < G_N_ELEMENTS (samples_to_preserve); i++) {
GstClockTime time = i + G_N_ELEMENTS (samples_to_remove);
GBytes *bytes = g_bytes_new_static (chunk, 1);
GstSample *sample = new_sample_with_bytes_and_timing (bytes, time, time, 0);
gst_media_source_sample_map_add (map, sample);
samples_to_preserve[i] = sample;
}
gsize bytes_removed =
gst_media_source_sample_map_remove_range_from_start (map,
G_N_ELEMENTS (samples_to_remove));
fail_unless_equals_uint64 (bytes_removed, total_bytes_to_remove);
for (guint i = 0; i < G_N_ELEMENTS (samples_to_remove); i++) {
gst_sample_unref (samples_to_remove[i]);
}
for (guint i = 0; i < G_N_ELEMENTS (samples_to_preserve); i++) {
gst_sample_unref (samples_to_preserve[i]);
}
gst_object_unref (map);
}
GST_END_TEST;
#define DEFAULT_TCASE_TIMEOUT 15
#ifdef HAVE_VALGRIND
#define TCASE_TIMEOUT (RUNNING_ON_VALGRIND ? (5 * 60) : DEFAULT_TCASE_TIMEOUT)
#else
#define TCASE_TIMEOUT DEFAULT_TCASE_TIMEOUT
#endif
static inline TCase *
new_tcase (const gchar * name)
{
TCase *tcase = tcase_create (name);
tcase_set_timeout (tcase, TCASE_TIMEOUT);
return tcase;
}
static Suite *
mse_suite (void)
{
Suite *s = suite_create ("GstMse");
TCase *tc_media_source = new_tcase ("GstMediaSource");
TCase *tc_source_buffer = new_tcase ("GstSourceBuffer");
TCase *tc_source_buffer_list = new_tcase ("GstSourceBufferList");
TCase *tc_append_pipeline = new_tcase ("GstAppendPipeline");
TCase *tc_track = new_tcase ("GstMediaSourceTrack");
TCase *tc_track_buffer = new_tcase ("GstMediaSourceTrackBuffer");
TCase *tc_sample_map = new_tcase ("GstMediaSourceSampleMap");
tcase_add_test (tc_media_source, test_create_and_free);
tcase_add_test (tc_media_source, test_create_initial_state);
tcase_add_test (tc_media_source,
test_add_source_buffer_with_content_type_null);
tcase_add_test (tc_media_source,
test_add_source_buffer_with_content_type_empty);
tcase_add_test (tc_media_source,
test_add_source_buffer_with_content_type_fake);
tcase_add_test (tc_media_source,
test_add_source_buffer_to_unopened_media_source);
tcase_add_test (tc_media_source,
test_add_source_buffer_to_opened_media_source);
tcase_add_test (tc_media_source,
test_remove_source_buffer_from_unrelated_media_source);
tcase_add_test (tc_media_source,
test_remove_source_buffer_from_parent_media_source);
tcase_add_test (tc_media_source,
test_set_live_seekable_range_on_unopened_media_source);
tcase_add_test (tc_media_source,
test_set_backwards_live_seekable_range_on_opened_media_source);
tcase_add_test (tc_media_source,
test_set_live_seekable_range_on_opened_media_source);
tcase_add_test (tc_media_source,
test_clear_live_seekable_range_on_unopened_media_source);
tcase_add_test (tc_media_source,
test_clear_live_seekable_range_on_opened_media_source);
tcase_add_loop_test (tc_media_source,
test_media_source_unsupported_content_type,
0, G_N_ELEMENTS (unsupported_content_types));
tcase_add_loop_test (tc_media_source,
test_media_source_supported_mp4_content_type,
0, G_N_ELEMENTS (valid_mp4_content_types));
tcase_add_loop_test (tc_media_source,
test_media_source_supported_webm_content_type,
0, G_N_ELEMENTS (valid_webm_content_types));
tcase_add_test (tc_source_buffer, test_source_buffer_generate_timestamps_mp4);
tcase_add_test (tc_source_buffer, test_source_buffer_generate_timestamps_aac);
tcase_add_test (tc_source_buffer,
test_source_buffer_change_content_type_null);
tcase_add_test (tc_source_buffer,
test_source_buffer_change_content_type_empty);
tcase_add_test (tc_source_buffer, test_source_buffer_change_content_type);
tcase_add_test (tc_append_pipeline, test_append_pipeline_create_and_free);
tcase_add_test (tc_append_pipeline, test_append_pipeline_mp4);
tcase_add_test (tc_append_pipeline, test_append_pipeline_webm);
tcase_add_test (tc_append_pipeline,
test_append_pipeline_invalid_data_triggers_eos);
tcase_add_test (tc_append_pipeline,
test_append_pipeline_invalid_data_triggers_error);
tcase_add_test (tc_append_pipeline, test_append_pipeline_reset_recovery);
tcase_add_test (tc_track, test_track_create_and_free);
tcase_add_test (tc_track, test_track_create_with_invalid_type);
tcase_add_test (tc_track, test_track_push_with_adequate_space);
tcase_add_test (tc_track, test_track_push_with_inadequate_space);
tcase_add_test (tc_track_buffer, test_track_buffer_empty);
tcase_add_test (tc_track_buffer, test_track_buffer_single_span);
tcase_add_test (tc_track_buffer, test_track_buffer_continuous_span);
tcase_add_test (tc_track_buffer, test_track_buffer_discontinuous_span);
tcase_add_test (tc_sample_map, test_sample_map_create_and_destroy);
tcase_add_test (tc_sample_map, test_sample_map_add_valid_sample);
tcase_add_test (tc_sample_map, test_sample_map_add_invalid_sample);
tcase_add_test (tc_sample_map, test_sample_map_remove_sample);
tcase_add_test (tc_sample_map, test_sample_map_remove_range_from_start);
tcase_add_test (tc_sample_map,
test_sample_map_remove_range_from_start_byte_count);
suite_add_tcase (s, tc_media_source);
suite_add_tcase (s, tc_source_buffer);
suite_add_tcase (s, tc_source_buffer_list);
suite_add_tcase (s, tc_append_pipeline);
suite_add_tcase (s, tc_track);
suite_add_tcase (s, tc_track_buffer);
suite_add_tcase (s, tc_sample_map);
return s;
}
GST_CHECK_MAIN (mse)