mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-12-04 23:46:43 +00:00
367 lines
11 KiB
C
367 lines
11 KiB
C
#include <gst/check/gstcheck.h>
|
|
#include <gst/base/base.h>
|
|
#include <gst/isoff/gstisoff.h>
|
|
|
|
#include "isoff.h"
|
|
|
|
GST_START_TEST (isoff_box_header_minimal)
|
|
{
|
|
/* INDENT-OFF */
|
|
static const guint8 data[] = {
|
|
16, 32, 64, 128,
|
|
't', 'e', 's', 't'
|
|
};
|
|
/* INDENT-ON */
|
|
GstByteReader reader = GST_BYTE_READER_INIT (data, sizeof (data));
|
|
guint32 type;
|
|
guint8 extended_type[16];
|
|
guint header_size;
|
|
guint64 size;
|
|
|
|
fail_unless (gst_isoff_parse_box_header (&reader, &type, extended_type,
|
|
&header_size, &size));
|
|
fail_unless (type == GST_MAKE_FOURCC ('t', 'e', 's', 't'));
|
|
fail_unless_equals_int (header_size, 8);
|
|
fail_unless_equals_uint64 (size, 0x10204080);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (isoff_box_header_long_size)
|
|
{
|
|
/* INDENT-OFF */
|
|
static const guint8 data[] = {
|
|
0, 0, 0, 1,
|
|
't', 'e', 's', 't',
|
|
1, 2, 4, 8, 16, 32, 64, 128
|
|
};
|
|
/* INDENT-ON */
|
|
GstByteReader reader = GST_BYTE_READER_INIT (data, sizeof (data));
|
|
guint32 type;
|
|
guint8 extended_type[16];
|
|
guint header_size;
|
|
guint64 size;
|
|
|
|
fail_unless (gst_isoff_parse_box_header (&reader, &type, extended_type,
|
|
&header_size, &size));
|
|
fail_unless (type == GST_MAKE_FOURCC ('t', 'e', 's', 't'));
|
|
fail_unless_equals_int (header_size, 16);
|
|
fail_unless_equals_uint64 (size, G_GUINT64_CONSTANT (0x0102040810204080));
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (isoff_box_header_uuid_type)
|
|
{
|
|
/* INDENT-OFF */
|
|
static const guint8 data[] = {
|
|
16, 32, 64, 128,
|
|
'u', 'u', 'i', 'd',
|
|
'a', 'b', 'c', 'd',
|
|
'e', 'f', 'g', 'h',
|
|
'i', 'j', 'k', 'l',
|
|
'm', 'n', 'o', 'p'
|
|
};
|
|
/* INDENT-ON */
|
|
GstByteReader reader = GST_BYTE_READER_INIT (data, sizeof (data));
|
|
guint32 type;
|
|
guint8 extended_type[16];
|
|
guint header_size;
|
|
guint64 size;
|
|
|
|
fail_unless (gst_isoff_parse_box_header (&reader, &type, extended_type,
|
|
&header_size, &size));
|
|
fail_unless (type == GST_MAKE_FOURCC ('u', 'u', 'i', 'd'));
|
|
fail_unless_equals_int (header_size, 24);
|
|
fail_unless_equals_uint64 (size, 0x10204080);
|
|
fail_unless (memcmp (data + 8, extended_type, 16) == 0);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (isoff_box_header_uuid_type_long_size)
|
|
{
|
|
/* INDENT-OFF */
|
|
static const guint8 data[] = {
|
|
0, 0, 0, 1,
|
|
'u', 'u', 'i', 'd',
|
|
1, 2, 4, 8, 16, 32, 64, 128,
|
|
'a', 'b', 'c', 'd',
|
|
'e', 'f', 'g', 'h',
|
|
'i', 'j', 'k', 'l',
|
|
'm', 'n', 'o', 'p'
|
|
};
|
|
/* INDENT-ON */
|
|
GstByteReader reader = GST_BYTE_READER_INIT (data, sizeof (data));
|
|
guint32 type;
|
|
guint8 extended_type[16];
|
|
guint header_size;
|
|
guint64 size;
|
|
|
|
fail_unless (gst_isoff_parse_box_header (&reader, &type, extended_type,
|
|
&header_size, &size));
|
|
fail_unless (type == GST_MAKE_FOURCC ('u', 'u', 'i', 'd'));
|
|
fail_unless_equals_int (header_size, 32);
|
|
fail_unless_equals_uint64 (size, G_GUINT64_CONSTANT (0x0102040810204080));
|
|
fail_unless (memcmp (data + 16, extended_type, 16) == 0);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (isoff_moof_parse)
|
|
{
|
|
/* INDENT-ON */
|
|
GstByteReader reader = GST_BYTE_READER_INIT (moof1, sizeof (moof1));
|
|
guint32 type;
|
|
guint8 extended_type[16];
|
|
guint header_size;
|
|
guint64 size;
|
|
GstMoofBox *moof;
|
|
GstTrafBox *traf;
|
|
GstTrunBox *trun;
|
|
guint i;
|
|
|
|
fail_unless (gst_isoff_parse_box_header (&reader, &type, extended_type,
|
|
&header_size, &size));
|
|
fail_unless (type == GST_MAKE_FOURCC ('m', 'o', 'o', 'f'));
|
|
fail_unless_equals_int (header_size, 8);
|
|
fail_unless_equals_uint64 (size, sizeof (moof1));
|
|
|
|
moof = gst_isoff_moof_box_parse (&reader);
|
|
fail_unless (moof != NULL);
|
|
|
|
fail_unless_equals_int (moof->mfhd.sequence_number, 1);
|
|
fail_unless_equals_int (moof->traf->len, 1);
|
|
|
|
traf = &g_array_index (moof->traf, GstTrafBox, 0);
|
|
fail_unless_equals_int (traf->tfhd.version, 0);
|
|
fail_unless_equals_int (traf->tfhd.flags,
|
|
GST_TFHD_FLAGS_DEFAULT_SAMPLE_DURATION_PRESENT);
|
|
fail_unless_equals_int (traf->tfhd.track_id, 1);
|
|
fail_unless_equals_uint64 (traf->tfhd.base_data_offset, 0);
|
|
fail_unless_equals_int (traf->tfhd.sample_description_index, 0);
|
|
fail_unless_equals_int (traf->tfhd.default_sample_duration, 8);
|
|
fail_unless_equals_int (traf->tfhd.default_sample_size, 0);
|
|
fail_unless_equals_int (traf->tfhd.default_sample_flags, 0);
|
|
|
|
fail_unless_equals_int (traf->trun->len, 1);
|
|
trun = &g_array_index (traf->trun, GstTrunBox, 0);
|
|
|
|
fail_unless_equals_int (trun->version, 1);
|
|
fail_unless_equals_int (trun->flags,
|
|
GST_TRUN_FLAGS_SAMPLE_COMPOSITION_TIME_OFFSETS_PRESENT |
|
|
GST_TRUN_FLAGS_SAMPLE_FLAGS_PRESENT | GST_TRUN_FLAGS_SAMPLE_SIZE_PRESENT |
|
|
GST_TRUN_FLAGS_DATA_OFFSET_PRESENT);
|
|
fail_unless_equals_int (trun->sample_count, 96);
|
|
fail_unless_equals_int (trun->data_offset, size + header_size);
|
|
fail_unless_equals_int (trun->first_sample_flags, 0);
|
|
|
|
fail_unless_equals_int (trun->samples->len, 96);
|
|
|
|
for (i = 0; i < 96; i++) {
|
|
GstTrunSample *sample = &g_array_index (trun->samples, GstTrunSample, i);
|
|
|
|
fail_unless_equals_int (sample->sample_duration, 0);
|
|
if (i == 0) {
|
|
/* sample_depends_on = 2 => I-frame */
|
|
/* sample_is_non_sync_sample = 0 */
|
|
fail_unless_equals_int (sample->sample_flags, 0x02000000);
|
|
} else {
|
|
/* sample_depends_on = 1 => non-I-frame */
|
|
/* sample_is_non_sync_sample = 1 */
|
|
fail_unless_equals_int (sample->sample_flags, 0x01010000);
|
|
}
|
|
|
|
/* sample size and CTO is changing for each sample */
|
|
}
|
|
|
|
gst_isoff_moof_box_free (moof);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (isoff_moof_parse_with_tfdt)
|
|
{
|
|
/* INDENT-ON */
|
|
GstByteReader reader = GST_BYTE_READER_INIT (seg_2_m4f, sizeof (seg_2_m4f));
|
|
guint32 type;
|
|
guint8 extended_type[16];
|
|
guint header_size;
|
|
guint64 size;
|
|
GstMoofBox *moof;
|
|
GstTrafBox *traf;
|
|
GstTrunBox *trun;
|
|
guint i;
|
|
|
|
fail_unless (gst_isoff_parse_box_header (&reader, &type, extended_type,
|
|
&header_size, &size));
|
|
fail_unless (type == GST_ISOFF_FOURCC_MOOF);
|
|
fail_unless_equals_int (header_size, 8);
|
|
fail_unless_equals_uint64 (size, seg_2_m4f_len);
|
|
|
|
moof = gst_isoff_moof_box_parse (&reader);
|
|
fail_unless (moof != NULL);
|
|
|
|
fail_unless_equals_int (moof->mfhd.sequence_number, 4);
|
|
fail_unless_equals_int (moof->traf->len, 1);
|
|
|
|
traf = &g_array_index (moof->traf, GstTrafBox, 0);
|
|
fail_unless_equals_int (traf->tfhd.version, 0);
|
|
fail_unless_equals_int (traf->tfhd.flags,
|
|
GST_TFHD_FLAGS_DEFAULT_BASE_IS_MOOF);
|
|
fail_unless_equals_int (traf->tfhd.track_id, 2);
|
|
fail_unless_equals_uint64 (traf->tfhd.base_data_offset, 0);
|
|
fail_unless_equals_int (traf->tfhd.sample_description_index, 0);
|
|
fail_unless_equals_int (traf->tfhd.default_sample_duration, 0);
|
|
fail_unless_equals_int (traf->tfhd.default_sample_size, 0);
|
|
fail_unless_equals_int (traf->tfhd.default_sample_flags, 0);
|
|
|
|
fail_unless_equals_uint64 (traf->tfdt.decode_time, 132096);
|
|
|
|
fail_unless_equals_int (traf->trun->len, 1);
|
|
trun = &g_array_index (traf->trun, GstTrunBox, 0);
|
|
|
|
fail_unless_equals_int (trun->version, 0);
|
|
fail_unless_equals_int (trun->flags,
|
|
GST_TRUN_FLAGS_SAMPLE_SIZE_PRESENT |
|
|
GST_TRUN_FLAGS_SAMPLE_DURATION_PRESENT |
|
|
GST_TRUN_FLAGS_DATA_OFFSET_PRESENT);
|
|
fail_unless_equals_int (trun->sample_count, 129);
|
|
fail_unless_equals_int (trun->data_offset, size + header_size);
|
|
fail_unless_equals_int (trun->first_sample_flags, 0);
|
|
|
|
fail_unless_equals_int (trun->samples->len, 129);
|
|
|
|
for (i = 0; i < 129; i++) {
|
|
GstTrunSample *sample = &g_array_index (trun->samples, GstTrunSample, i);
|
|
|
|
fail_unless_equals_int (sample->sample_duration, seg_sample_duration);
|
|
fail_unless_equals_int (sample->sample_flags, 0x00000000);
|
|
fail_unless_equals_int (sample->sample_size, seg_2_sample_sizes[i]);
|
|
}
|
|
|
|
gst_isoff_moof_box_free (moof);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (isoff_moof_parse_with_tfxd_tfrf)
|
|
{
|
|
GstByteReader reader =
|
|
GST_BYTE_READER_INIT (Fragments_audio, sizeof (Fragments_audio));
|
|
guint32 type;
|
|
guint8 extended_type[16];
|
|
guint header_size;
|
|
guint64 size;
|
|
GstMoofBox *moof;
|
|
GstTrafBox *traf;
|
|
GstTfxdBox *tfxd;
|
|
GstTfrfBox *tfrf;
|
|
GstTfrfBoxEntry *tfrf_entry;
|
|
|
|
fail_unless (gst_isoff_parse_box_header (&reader, &type, extended_type,
|
|
&header_size, &size));
|
|
fail_unless (type == GST_ISOFF_FOURCC_MOOF);
|
|
fail_unless_equals_int (header_size, 8);
|
|
fail_unless_equals_uint64 (size, Fragments_audio_len);
|
|
|
|
moof = gst_isoff_moof_box_parse (&reader);
|
|
fail_unless (moof != NULL);
|
|
|
|
fail_unless_equals_int (moof->mfhd.sequence_number, 124);
|
|
fail_unless_equals_int (moof->traf->len, 1);
|
|
|
|
traf = &g_array_index (moof->traf, GstTrafBox, 0);
|
|
fail_unless_equals_int (traf->tfhd.version, 0);
|
|
fail_unless_equals_int (traf->tfhd.flags,
|
|
GST_TFHD_FLAGS_DEFAULT_SAMPLE_FLAGS_PRESENT);
|
|
fail_unless_equals_int (traf->tfhd.track_id, 1);
|
|
fail_unless_equals_uint64 (traf->tfhd.base_data_offset, 0);
|
|
fail_unless_equals_int (traf->tfhd.sample_description_index, 0);
|
|
fail_unless_equals_int (traf->tfhd.default_sample_duration, 0);
|
|
fail_unless_equals_int (traf->tfhd.default_sample_size, 0);
|
|
|
|
tfxd = traf->tfxd;
|
|
fail_unless (tfxd != NULL);
|
|
fail_unless_equals_uint64 (tfxd->time, 1188108174758706);
|
|
fail_unless_equals_uint64 (tfxd->duration, 19969161);
|
|
|
|
tfrf = traf->tfrf;
|
|
fail_unless (tfrf != NULL);
|
|
fail_unless_equals_int (tfrf->entries_count, 2);
|
|
fail_unless_equals_int (tfrf->entries->len, 2);
|
|
|
|
tfrf_entry = &g_array_index (tfrf->entries, GstTfrfBoxEntry, 0);
|
|
fail_unless (tfrf_entry != NULL);
|
|
fail_unless_equals_uint64 (tfrf_entry->time, 1188108194727867);
|
|
fail_unless_equals_uint64 (tfrf_entry->duration, 19969160);
|
|
|
|
tfrf_entry = &g_array_index (tfrf->entries, GstTfrfBoxEntry, 1);
|
|
fail_unless (tfrf_entry != NULL);
|
|
fail_unless_equals_uint64 (tfrf_entry->time, 1188108214697027);
|
|
fail_unless_equals_uint64 (tfrf_entry->duration, 19969162);
|
|
|
|
gst_isoff_moof_box_free (moof);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (isoff_moov_parse)
|
|
{
|
|
/* INDENT-ON */
|
|
GstByteReader reader = GST_BYTE_READER_INIT (init_mp4, sizeof (init_mp4));
|
|
guint32 type;
|
|
guint8 extended_type[16];
|
|
guint header_size;
|
|
guint64 size;
|
|
GstMoovBox *moov;
|
|
GstTrakBox *trak;
|
|
|
|
fail_unless (gst_isoff_parse_box_header (&reader, &type, extended_type,
|
|
&header_size, &size));
|
|
fail_unless (type == GST_ISOFF_FOURCC_MOOV);
|
|
fail_unless_equals_int (header_size, 8);
|
|
fail_unless_equals_uint64 (size, sizeof (init_mp4));
|
|
|
|
moov = gst_isoff_moov_box_parse (&reader);
|
|
fail_unless (moov != NULL);
|
|
|
|
fail_unless_equals_int (moov->trak->len, 1);
|
|
|
|
trak = &g_array_index (moov->trak, GstTrakBox, 0);
|
|
fail_unless_equals_int (trak->tkhd.track_id, 2);
|
|
fail_unless (trak->mdia.hdlr.handler_type, GST_ISOFF_FOURCC_SOUN);
|
|
fail_unless_equals_int (trak->mdia.mdhd.timescale, seg_timescale);
|
|
|
|
gst_isoff_moov_box_free (moov);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
static Suite *
|
|
dash_isoff_suite (void)
|
|
{
|
|
Suite *s = suite_create ("isoff");
|
|
TCase *tc_isoff_box = tcase_create ("isoff-box-parsing");
|
|
TCase *tc_moof = tcase_create ("moof");
|
|
TCase *tc_moov = tcase_create ("moov");
|
|
|
|
tcase_add_test (tc_isoff_box, isoff_box_header_minimal);
|
|
tcase_add_test (tc_isoff_box, isoff_box_header_long_size);
|
|
tcase_add_test (tc_isoff_box, isoff_box_header_uuid_type);
|
|
tcase_add_test (tc_isoff_box, isoff_box_header_uuid_type_long_size);
|
|
|
|
suite_add_tcase (s, tc_isoff_box);
|
|
|
|
tcase_add_test (tc_moof, isoff_moof_parse);
|
|
tcase_add_test (tc_moof, isoff_moof_parse_with_tfdt);
|
|
tcase_add_test (tc_moof, isoff_moof_parse_with_tfxd_tfrf);
|
|
suite_add_tcase (s, tc_moof);
|
|
|
|
tcase_add_test (tc_moov, isoff_moov_parse);
|
|
suite_add_tcase (s, tc_moov);
|
|
|
|
return s;
|
|
}
|
|
|
|
GST_CHECK_MAIN (dash_isoff);
|