gstreamer/subprojects/gst-plugins-base/tests/check/libs/dsd.c

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

386 lines
14 KiB
C
Raw Normal View History

/* GStreamer
* Copyright (C) 2023 Carlos Rafael Giani <crg7475@mailbox.org>
*
* 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.
*/
#include <gst/check/gstcheck.h>
#include <gst/audio/gstdsd.h>
#define NUM_CHANNELS (2)
#define NUM_BYTES_PER_CHANNEL (16)
#define NUM_PATTERN_BYTES (NUM_CHANNELS * NUM_BYTES_PER_CHANNEL)
typedef struct
{
GstDsdFormat format;
guint8 bytes[NUM_CHANNELS * NUM_BYTES_PER_CHANNEL];
} DsdTestPattern;
/* The following test patterns contain bytes 0x00 to 0x0F for the left channel
* and 0x80 to 0x8F for the right channel. These bytes are grouped in the test
* patterns according to their (non-)interleaved layout and grouping format. */
/* *INDENT-OFF* */
static const DsdTestPattern interleaved_dsd_test_patterns[] = {
{
GST_DSD_FORMAT_U8,
{
0x00, 0x80, 0x01, 0x81, 0x02, 0x82, 0x03, 0x83, 0x04, 0x84, 0x05, 0x85, 0x06, 0x86, 0x07, 0x87,
0x08, 0x88, 0x09, 0x89, 0x0A, 0x8A, 0x0B, 0x8B, 0x0C, 0x8C, 0x0D, 0x8D, 0x0E, 0x8E, 0x0F, 0x8F
}
},
{
GST_DSD_FORMAT_U16LE,
{
0x01, 0x00, 0x81, 0x80, 0x03, 0x02, 0x83, 0x82, 0x05, 0x04, 0x85, 0x84, 0x07, 0x06, 0x87, 0x86,
0x09, 0x08, 0x89, 0x88, 0x0B, 0x0A, 0x8B, 0x8A, 0x0D, 0x0C, 0x8D, 0x8C, 0x0F, 0x0E, 0x8F, 0x8E
}
},
{
GST_DSD_FORMAT_U16BE,
{
0x00, 0x01, 0x80, 0x81, 0x02, 0x03, 0x82, 0x83, 0x04, 0x05, 0x84, 0x85, 0x06, 0x07, 0x86, 0x87,
0x08, 0x09, 0x88, 0x89, 0x0A, 0x0B, 0x8A, 0x8B, 0x0C, 0x0D, 0x8C, 0x8D, 0x0E, 0x0F, 0x8E, 0x8F
}
},
{
GST_DSD_FORMAT_U32LE,
{
0x03, 0x02, 0x01, 0x00, 0x83, 0x82, 0x81, 0x80, 0x07, 0x06, 0x05, 0x04, 0x87, 0x86, 0x85, 0x84,
0x0B, 0x0A, 0x09, 0x08, 0x8B, 0x8A, 0x89, 0x88, 0x0F, 0x0E, 0x0D, 0x0C, 0x8F, 0x8E, 0x8D, 0x8C
}
},
{
GST_DSD_FORMAT_U32BE,
{
0x00, 0x01, 0x02, 0x03, 0x80, 0x81, 0x82, 0x83, 0x04, 0x05, 0x06, 0x07, 0x84, 0x85, 0x86, 0x87,
0x08, 0x09, 0x0A, 0x0B, 0x88, 0x89, 0x8A, 0x8B, 0x0C, 0x0D, 0x0E, 0x0F, 0x8C, 0x8D, 0x8E, 0x8F
}
}
};
/* *INDENT-ON* */
static const int num_interleaved_dsd_test_patterns =
sizeof (interleaved_dsd_test_patterns) / sizeof (DsdTestPattern);
/* *INDENT-OFF* */
static const DsdTestPattern non_interleaved_dsd_test_patterns[] = {
{
GST_DSD_FORMAT_U8,
{
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F
}
},
{
GST_DSD_FORMAT_U16LE,
{
0x01, 0x00, 0x03, 0x02, 0x05, 0x04, 0x07, 0x06, 0x09, 0x08, 0x0B, 0x0A, 0x0D, 0x0C, 0x0F, 0x0E,
0x81, 0x80, 0x83, 0x82, 0x85, 0x84, 0x87, 0x86, 0x89, 0x88, 0x8B, 0x8A, 0x8D, 0x8C, 0x8F, 0x8E
}
},
{
GST_DSD_FORMAT_U16BE,
{
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F,
}
},
{
GST_DSD_FORMAT_U32LE,
{
0x03, 0x02, 0x01, 0x00, 0x07, 0x06, 0x05, 0x04, 0x0B, 0x0A, 0x09, 0x08, 0x0F, 0x0E, 0x0D, 0x0C,
0x83, 0x82, 0x81, 0x80, 0x87, 0x86, 0x85, 0x84, 0x8B, 0x8A, 0x89, 0x88, 0x8F, 0x8E, 0x8D, 0x8C,
}
},
{
GST_DSD_FORMAT_U32BE,
{
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F,
}
},
};
/* *INDENT-ON* */
static const int num_non_interleaved_dsd_test_patterns =
sizeof (non_interleaved_dsd_test_patterns) / sizeof (DsdTestPattern);
static const gsize dsd_plane_offsets[NUM_CHANNELS] = { 0, 16 };
GST_START_TEST (test_dsd_conversion_interleaved_to_interleaved)
{
int in_idx, out_idx;
guint8 actual_output_pattern[NUM_PATTERN_BYTES];
for (in_idx = 0; in_idx < num_interleaved_dsd_test_patterns; ++in_idx) {
for (out_idx = 0; out_idx < num_interleaved_dsd_test_patterns; ++out_idx) {
guint8 const *input_pattern = interleaved_dsd_test_patterns[in_idx].bytes;
guint8 const *expected_output_pattern =
interleaved_dsd_test_patterns[out_idx].bytes;
GstDsdFormat input_format = interleaved_dsd_test_patterns[in_idx].format;
GstDsdFormat output_format =
interleaved_dsd_test_patterns[out_idx].format;
gboolean conversion_ok;
gst_dsd_convert (input_pattern, actual_output_pattern, input_format,
output_format, GST_AUDIO_LAYOUT_INTERLEAVED,
GST_AUDIO_LAYOUT_INTERLEAVED, NULL, NULL, NUM_PATTERN_BYTES,
NUM_CHANNELS, FALSE);
conversion_ok = memcmp (actual_output_pattern, expected_output_pattern,
NUM_PATTERN_BYTES) == 0;
if (!conversion_ok) {
GST_MEMDUMP ("expected:", expected_output_pattern, NUM_PATTERN_BYTES);
GST_MEMDUMP ("actual :", actual_output_pattern, NUM_PATTERN_BYTES);
}
fail_unless (conversion_ok, "DSD conversion output incorrect");
}
}
}
GST_END_TEST;
GST_START_TEST (test_dsd_conversion_interleaved_to_non_interleaved)
{
int in_idx, out_idx;
guint8 actual_output_pattern[NUM_PATTERN_BYTES];
for (in_idx = 0; in_idx < num_interleaved_dsd_test_patterns; ++in_idx) {
for (out_idx = 0; out_idx < num_non_interleaved_dsd_test_patterns;
++out_idx) {
guint8 const *input_pattern = interleaved_dsd_test_patterns[in_idx].bytes;
guint8 const *expected_output_pattern =
non_interleaved_dsd_test_patterns[out_idx].bytes;
GstDsdFormat input_format = interleaved_dsd_test_patterns[in_idx].format;
GstDsdFormat output_format =
non_interleaved_dsd_test_patterns[out_idx].format;
gboolean conversion_ok;
gst_dsd_convert (input_pattern, actual_output_pattern, input_format,
output_format, GST_AUDIO_LAYOUT_INTERLEAVED,
GST_AUDIO_LAYOUT_NON_INTERLEAVED, NULL, dsd_plane_offsets,
NUM_PATTERN_BYTES, NUM_CHANNELS, FALSE);
conversion_ok = memcmp (actual_output_pattern, expected_output_pattern,
NUM_PATTERN_BYTES) == 0;
if (!conversion_ok) {
GST_MEMDUMP ("expected:", expected_output_pattern, NUM_PATTERN_BYTES);
GST_MEMDUMP ("actual :", actual_output_pattern, NUM_PATTERN_BYTES);
}
fail_unless (conversion_ok, "DSD conversion output incorrect");
}
}
}
GST_END_TEST;
GST_START_TEST (test_dsd_conversion_non_interleaved_to_interleaved)
{
int in_idx, out_idx;
guint8 actual_output_pattern[NUM_PATTERN_BYTES];
for (in_idx = 0; in_idx < num_non_interleaved_dsd_test_patterns; ++in_idx) {
for (out_idx = 0; out_idx < num_interleaved_dsd_test_patterns; ++out_idx) {
guint8 const *input_pattern =
non_interleaved_dsd_test_patterns[in_idx].bytes;
guint8 const *expected_output_pattern =
interleaved_dsd_test_patterns[out_idx].bytes;
GstDsdFormat input_format =
non_interleaved_dsd_test_patterns[in_idx].format;
GstDsdFormat output_format =
interleaved_dsd_test_patterns[out_idx].format;
gboolean conversion_ok;
gst_dsd_convert (input_pattern,
actual_output_pattern,
input_format,
output_format,
GST_AUDIO_LAYOUT_NON_INTERLEAVED,
GST_AUDIO_LAYOUT_INTERLEAVED,
dsd_plane_offsets, NULL, NUM_PATTERN_BYTES, NUM_CHANNELS, FALSE);
conversion_ok = memcmp (actual_output_pattern, expected_output_pattern,
NUM_PATTERN_BYTES) == 0;
if (!conversion_ok) {
GST_MEMDUMP ("expected:", expected_output_pattern, NUM_PATTERN_BYTES);
GST_MEMDUMP ("actual :", actual_output_pattern, NUM_PATTERN_BYTES);
}
fail_unless (conversion_ok, "DSD conversion output incorrect");
}
}
}
GST_END_TEST;
GST_START_TEST (test_dsd_conversion_non_interleaved_to_non_interleaved)
{
int in_idx, out_idx;
guint8 actual_output_pattern[NUM_PATTERN_BYTES];
for (in_idx = 0; in_idx < num_non_interleaved_dsd_test_patterns; ++in_idx) {
for (out_idx = 0; out_idx < num_non_interleaved_dsd_test_patterns;
++out_idx) {
guint8 const *input_pattern =
non_interleaved_dsd_test_patterns[in_idx].bytes;
guint8 const *expected_output_pattern =
non_interleaved_dsd_test_patterns[out_idx].bytes;
GstDsdFormat input_format =
non_interleaved_dsd_test_patterns[in_idx].format;
GstDsdFormat output_format =
non_interleaved_dsd_test_patterns[out_idx].format;
gboolean conversion_ok;
gst_dsd_convert (input_pattern,
actual_output_pattern,
input_format,
output_format,
GST_AUDIO_LAYOUT_NON_INTERLEAVED,
GST_AUDIO_LAYOUT_NON_INTERLEAVED,
dsd_plane_offsets,
dsd_plane_offsets, NUM_PATTERN_BYTES, NUM_CHANNELS, FALSE);
conversion_ok = memcmp (actual_output_pattern, expected_output_pattern,
NUM_PATTERN_BYTES) == 0;
if (!conversion_ok) {
GST_MEMDUMP ("expected:", expected_output_pattern, NUM_PATTERN_BYTES);
GST_MEMDUMP ("actual :", actual_output_pattern, NUM_PATTERN_BYTES);
}
fail_unless (conversion_ok, "DSD conversion output incorrect");
}
}
}
GST_END_TEST;
GST_START_TEST (test_dsd_info_from_caps)
{
GstDsdInfo info;
GstCaps *full_caps, *minimal_caps;
full_caps = gst_caps_new_simple (GST_DSD_MEDIA_TYPE,
"format", G_TYPE_STRING, "DSDU16LE",
"rate", G_TYPE_INT, GST_DSD_MAKE_DSD_RATE_44x (128),
"channels", G_TYPE_INT, 2,
"layout", G_TYPE_STRING, "non-interleaved",
"channel-mask", GST_TYPE_BITMASK, 0x3, NULL);
fail_unless (gst_dsd_info_from_caps (&info, full_caps));
fail_unless_equals_int (info.format, GST_DSD_FORMAT_U16LE);
fail_unless_equals_int (info.rate, GST_DSD_MAKE_DSD_RATE_44x (128));
fail_unless_equals_int (info.channels, 2);
fail_unless_equals_int (info.layout, GST_AUDIO_LAYOUT_NON_INTERLEAVED);
fail_unless_equals_int (info.positions[0],
GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT);
fail_unless_equals_int (info.positions[1],
GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT);
gst_caps_unref (full_caps);
minimal_caps = gst_caps_new_simple (GST_DSD_MEDIA_TYPE,
"format", G_TYPE_STRING, "DSDU16LE",
"rate", G_TYPE_INT, GST_DSD_MAKE_DSD_RATE_44x (128),
"channels", G_TYPE_INT, 2, NULL);
fail_unless (gst_dsd_info_from_caps (&info, minimal_caps));
fail_unless_equals_int (info.format, GST_DSD_FORMAT_U16LE);
fail_unless_equals_int (info.rate, GST_DSD_MAKE_DSD_RATE_44x (128));
fail_unless_equals_int (info.channels, 2);
fail_unless_equals_int (info.layout, GST_AUDIO_LAYOUT_INTERLEAVED);
fail_unless_equals_int (info.positions[0],
GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT);
fail_unless_equals_int (info.positions[1],
GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT);
gst_caps_unref (minimal_caps);
}
GST_END_TEST;
GST_START_TEST (test_dsd_info_to_caps)
{
GstStructure *str;
GstCaps *caps;
gint rate;
gint channels;
guint64 channel_mask;
GstDsdInfo info = {
.format = GST_DSD_FORMAT_U16LE,
.rate = GST_DSD_MAKE_DSD_RATE_44x (64),
.channels = 2,
.layout = GST_AUDIO_LAYOUT_INTERLEAVED,
.positions = {GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT,
GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT}
,
.flags = GST_AUDIO_FLAG_NONE
};
caps = gst_dsd_info_to_caps (&info);
fail_if (caps == NULL, "caps were not created");
fail_unless_equals_int (gst_caps_get_size (caps), 1);
str = gst_caps_get_structure (caps, 0);
fail_if (str == NULL, "could not get structure");
fail_unless (gst_structure_has_name (str, GST_DSD_MEDIA_TYPE));
fail_unless (gst_structure_has_field_typed (str, "format", G_TYPE_STRING));
fail_unless_equals_string (gst_structure_get_string (str, "format"),
"DSDU16LE");
fail_unless (gst_structure_get_int (str, "rate", &rate));
fail_unless_equals_int (rate, GST_DSD_MAKE_DSD_RATE_44x (64));
fail_unless (gst_structure_get_int (str, "channels", &channels));
fail_unless_equals_int (channels, 2);
fail_unless_equals_string (gst_structure_get_string (str, "layout"),
"interleaved");
fail_unless (gst_structure_get (str, "channel-mask", GST_TYPE_BITMASK,
&channel_mask, NULL));
fail_unless_equals_uint64 (channel_mask, 0x3);
gst_caps_unref (caps);
}
GST_END_TEST;
static Suite *
dsd_suite (void)
{
Suite *s = suite_create ("dsd");
TCase *tc_chain = tcase_create ("general");
suite_add_tcase (s, tc_chain);
tcase_add_test (tc_chain, test_dsd_conversion_interleaved_to_interleaved);
tcase_add_test (tc_chain, test_dsd_conversion_interleaved_to_non_interleaved);
tcase_add_test (tc_chain, test_dsd_conversion_non_interleaved_to_interleaved);
tcase_add_test (tc_chain,
test_dsd_conversion_non_interleaved_to_non_interleaved);
tcase_add_test (tc_chain, test_dsd_info_from_caps);
tcase_add_test (tc_chain, test_dsd_info_to_caps);
return s;
}
GST_CHECK_MAIN (dsd);