upipe_audio_merge_test: test interleaved data

Author: JDarnley

tests/upipe_audio_merge_test.c

@@ -71,6 +71,13 @@ const int16_t test_values_int[3][2] = {
     { INT16_MAX/4,   0 },
 };
 
+const int32_t test_values_interleaved[4][2] = {
+    { INT32_MIN/2,   INT32_MIN/2+1   },
+    { INT32_MAX/4*3, INT32_MAX/4*3-1 },
+    { 0xdeafbeef, 0xcafebabe },
+    { 0xabcdcba,  0x12345678 },
+};
+
 int count = 0;
 
 // Fill ubuf with the provided value.
@@ -112,6 +119,26 @@ static void fill_in_int(struct ubuf *ubuf, int16_t value)
     }
 }
 
+static void fill_in_interleaved(struct ubuf *ubuf, const int32_t *value)
+{
+    size_t size;
+    uint8_t sample_size;
+    ubase_assert(ubuf_sound_size(ubuf, &size, &sample_size));
+
+    const char *channel = NULL;
+    while (ubase_check(ubuf_sound_iterate_plane(ubuf, &channel)) &&
+           channel != NULL) {
+        int32_t *buffer;
+        ubase_assert(ubuf_sound_plane_write_int32_t(ubuf, channel, 0, -1,
+                                                    &buffer));
+
+        for (int x = 0; x < size; x++) {
+            buffer[2*x+0] = value[0];
+            buffer[2*x+1] = value[1];
+        }
+        ubase_assert(ubuf_sound_plane_unmap(ubuf, channel, 0, -1));
+    }
+}
 
 /** definition of our uprobe */
 static int catch(struct uprobe *uprobe, struct upipe *upipe,
@@ -219,6 +246,40 @@ static void test_input_idx(struct upipe *upipe, struct uref *uref,
     uref_free(uref);
 }
 
+static void test_input_interleaved(struct upipe *upipe, struct uref *uref,
+                       struct upump **upump_p)
+{
+    assert(uref != NULL);
+    const uint8_t *r;
+
+    const int32_t data[3][16] = { {
+        [2] = test_values_interleaved[0][0],
+        [3] = test_values_interleaved[0][1],
+        [4] = test_values_interleaved[1][0],
+        [5] = test_values_interleaved[1][1],
+    }, {
+        [4] = test_values_interleaved[2][0],
+        [5] = test_values_interleaved[2][1],
+    }, {
+        [2] = test_values_interleaved[3][0],
+        [3] = test_values_interleaved[3][1],
+    } };
+
+    size_t size;
+    uint8_t sample_size;
+    ubase_assert(ubuf_sound_size(uref->ubuf, &size, &sample_size));
+
+    ubase_assert(uref_sound_plane_read_uint8_t(uref, "lrcLRS0123456789", 0, -1, &r));
+    for (int x = 0; x < size; x++)
+        assert(memcmp(r + sample_size * x, data[count], sample_size) == 0);
+    ubase_assert(uref_sound_plane_unmap(uref, "lrcLRS0123456789", 0, -1));
+
+    upipe_notice(upipe, "interleaved data good");
+
+    count++;
+    uref_free(uref);
+}
+
 /** helper phony pipe */
 static int test_control(struct upipe *upipe, int command, va_list args)
 {
@@ -565,6 +626,121 @@ int main(int argc, char *argv[])
     uref_free(output_flow);
     upipe_release(upipe_audio_merge);
 
+    /* Test interleaved */
+
+    uprobe_notice(logger, NULL, "testing interleaved");
+
+    count = 0;
+    merge_test_mgr.upipe_input = test_input_interleaved;
+
+    /* merge superpipe */
+    output_flow = uref_sound_flow_alloc_def(uref_mgr, "s32.", 16, 64);
+    assert(output_flow);
+    ubase_assert(uref_sound_flow_set_rate(output_flow, 48000));
+    ubase_assert(uref_sound_flow_set_samples(output_flow, SAMPLES));
+
+    ubase_assert(uref_sound_flow_set_channels(output_flow, 16));
+    uref_sound_flow_add_plane(output_flow, "lrcLRS0123456789");
+    upipe_audio_merge = upipe_flow_alloc(upipe_audio_merge_mgr,
+            uprobe_pfx_alloc(uprobe_use(logger), UPROBE_LOG_LEVEL, "merge"), output_flow);
+    assert(upipe_audio_merge != NULL);
+
+    /* connect output of merge pipe to sink */
+    ubase_assert(upipe_set_output(upipe_audio_merge, upipe_sink));
+
+    /* merge subpipe 0 */
+    flow0 = uref_sound_flow_alloc_def(uref_mgr, "s32.", 2, 8);
+    assert(flow0);
+    ubase_assert(uref_sound_flow_add_plane(flow0, "lr"));
+    ubase_assert(uref_sound_flow_set_channels(flow0, 2));
+    ubase_assert(uref_sound_flow_set_channel_idx(flow0, 2));
+    uref_dump(flow0, logger);
+    upipe_audio_merge_input0 = upipe_void_alloc_sub(upipe_audio_merge,
+            uprobe_pfx_alloc(uprobe_use(logger), UPROBE_LOG_LEVEL,
+                             "merge input 0"));
+    assert(upipe_audio_merge_input0 != NULL);
+    ubase_assert(upipe_set_flow_def(upipe_audio_merge_input0, flow0));
+
+    /* merge subpipe 1 */
+    flow1 = uref_sound_flow_alloc_def(uref_mgr, "s32.", 2, 8);
+    assert(flow1);
+    ubase_assert(uref_sound_flow_add_plane(flow1, "lr"));
+    ubase_assert(uref_sound_flow_set_channels(flow1, 2));
+    ubase_assert(uref_sound_flow_set_channel_idx(flow1, 4));
+    uref_dump(flow1, logger);
+    upipe_audio_merge_input1 = upipe_void_alloc_sub(upipe_audio_merge,
+            uprobe_pfx_alloc(uprobe_use(logger), UPROBE_LOG_LEVEL,
+                             "merge input 1"));
+    assert(upipe_audio_merge_input1 != NULL);
+    ubase_assert(upipe_set_flow_def(upipe_audio_merge_input1, flow1));
+
+    /* input 0 sound ubuf manager */
+    sound_mgr_0 = ubuf_mem_mgr_alloc_from_flow_def(
+                 UBUF_POOL_DEPTH, UBUF_POOL_DEPTH, umem_mgr, flow0);
+    assert(sound_mgr_0);
+
+    /* First, feed a "real" sample to input 0 to test the pipe's function...*/
+    uref = uref_sound_alloc(uref_mgr, sound_mgr_0, SAMPLES);
+    assert(uref != NULL);
+    fill_in_interleaved(uref->ubuf, test_values_interleaved[0]);
+    ubase_assert(uref_sound_flow_set_samples(uref, SAMPLES));
+    upipe_input(upipe_audio_merge_input0, uref, NULL);
+
+    /* input 1 sound ubuf manager */
+    sound_mgr_1 = ubuf_mem_mgr_alloc_from_flow_def(
+                 UBUF_POOL_DEPTH, UBUF_POOL_DEPTH, umem_mgr, flow1);
+    assert(sound_mgr_1);
+
+    /* .. and then to input 1. */
+    uref = uref_sound_alloc(uref_mgr, sound_mgr_1, SAMPLES);
+    assert(uref != NULL);
+    fill_in_interleaved(uref->ubuf, test_values_interleaved[1]);
+    ubase_assert(uref_sound_flow_set_samples(uref, SAMPLES));
+    upipe_input(upipe_audio_merge_input1, uref, NULL);
+
+    /* Then feed a dummy sample with no attached ubuf to test error handling to input 0... */
+    uref = uref_sound_alloc(uref_mgr, sound_mgr_0, SAMPLES);
+    assert(uref != NULL);
+    ubuf_free(uref->ubuf);
+    uref->ubuf = NULL;
+    ubase_assert(uref_sound_flow_set_samples(uref, SAMPLES));
+    upipe_input(upipe_audio_merge_input0, uref, NULL);
+
+    /* .. and a real one to input 1. */
+    uref = uref_sound_alloc(uref_mgr, sound_mgr_1, SAMPLES);
+    assert(uref != NULL);
+    fill_in_interleaved(uref->ubuf, test_values_interleaved[2]);
+    ubase_assert(uref_sound_flow_set_samples(uref, SAMPLES));
+    upipe_input(upipe_audio_merge_input1, uref, NULL);
+
+    /* Then a real one to input 0. */
+    uref = uref_sound_alloc(uref_mgr, sound_mgr_0, SAMPLES);
+    assert(uref != NULL);
+    fill_in_interleaved(uref->ubuf, test_values_interleaved[3]);
+    ubase_assert(uref_sound_flow_set_samples(uref, SAMPLES));
+    upipe_input(upipe_audio_merge_input0, uref, NULL);
+
+    /* ... and a fake one to input 1 */
+    uref = uref_sound_alloc(uref_mgr, sound_mgr_1, SAMPLES);
+    assert(uref != NULL);
+    ubuf_free(uref->ubuf);
+    uref->ubuf = NULL;
+    ubase_assert(uref_sound_flow_set_samples(uref, SAMPLES));
+    upipe_input(upipe_audio_merge_input1, uref, NULL);
+
+    upipe_release(upipe_audio_merge_input0);
+    upipe_release(upipe_audio_merge_input1);
+
+    assert(count == 3);
+
+    /* clean */
+    uref_free(flow0);
+    uref_free(flow1);
+    ubuf_mgr_release(sound_mgr_0);
+    ubuf_mgr_release(sound_mgr_1);
+    uref_free(output_flow);
+    upipe_release(upipe_audio_merge);
+
     upipe_mgr_release(upipe_audio_merge_mgr); // nop
 
     test_free(upipe_sink);