| #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); |