ubuf_av: fix ubuf_sound_resize

Don't modify audio planes content in ubuf_sound_av_resize because the
ubuf may not be writable.

Author: nto

lib/upipe-av/ubuf_av.c

@@ -741,10 +741,20 @@ static int ubuf_sound_av_resize(struct ubuf *ubuf, int offset, int new_size)
     else if (offset + new_size > size)
         return UBASE_ERR_INVALID;
 
-    av_samples_copy(frame->extended_data, frame->extended_data,
-                    0, offset, new_size, frame->ch_layout.nb_channels,
-                    frame->format);
+    int planar = av_sample_fmt_is_planar(frame->format);
+    int channels = frame->ch_layout.nb_channels;
+    int planes = planar ? channels : 1;
+
+    for (int i = 0; i < FFMIN(planes, AV_NUM_DATA_POINTERS); i++)
+        frame->extended_data[i] = frame->data[i] =
+            frame->data[i] + offset * sample_size;
+
+    for (int i = 0; i < frame->nb_extended_buf; i++)
+        frame->extended_data[i + AV_NUM_DATA_POINTERS] += offset * sample_size;
+
     frame->nb_samples = new_size;
+    av_samples_get_buffer_size(&frame->linesize[0], channels,
+                               frame->nb_samples, frame->format, 0);
 
     return UBASE_ERR_NONE;
 }

tests/Build.mk

@@ -19,6 +19,10 @@ distfiles = valgrind_wrapper.sh valgrind.supp \
 tests += ubits_test
 ubits_test-src = ubits_test.c
 
+tests += ubuf_av_sound_test
+ubuf_av_sound_test-src = ubuf_av_sound_test.c
+ubuf_av_sound_test-libs = libupipe libupipe_av libavutil
+
 tests += ubuf_block_mem_test
 ubuf_block_mem_test-src = ubuf_block_mem_test.c
 ubuf_block_mem_test-libs = libupipe

tests/ubuf_av_sound_test.c

@@ -0,0 +1,201 @@
+/*
+ * Copyright (C) 2025 EasyTools S.A.S.
+ *
+ * Authors: Clément Vasseur
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject
+ * to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/** @file
+ * @short unit tests for ubuf_av manager for sound formats
+ */
+
+#undef NDEBUG
+
+#include "upipe/ubuf_sound.h"
+#include "upipe-av/ubuf_av.h"
+
+#include <assert.h>
+#include <libavutil/frame.h>
+
+static void fill_in(struct ubuf *ubuf)
+{
+    size_t size;
+    uint8_t sample_size;
+    ubase_assert(ubuf_sound_size(ubuf, &size, &sample_size));
+    int octets = size * sample_size;
+
+    const char *channel;
+    ubuf_sound_foreach_plane(ubuf, channel) {
+        uint8_t *buffer;
+        ubase_assert(ubuf_sound_plane_write_uint8_t(ubuf, channel, 0, -1,
+                                                    &buffer));
+
+        for (int x = 0; x < octets; x++)
+            buffer[x] = (uint8_t)channel[0] + x;
+        ubase_assert(ubuf_sound_plane_unmap(ubuf, channel, 0, -1));
+    }
+}
+
+int main(int argc, char **argv)
+{
+    struct ubuf_mgr *mgr;
+    struct ubuf *ubuf1, *ubuf2;
+    const char *channel;
+    size_t size;
+    uint8_t sample_size;
+    uint8_t *w;
+    const uint8_t *r;
+    AVFrame *frame;
+
+    /* packed s16 stereo */
+    mgr = ubuf_av_mgr_alloc();
+    assert(mgr != NULL);
+
+    frame = av_frame_alloc();
+    assert(frame != NULL);
+    frame->format = AV_SAMPLE_FMT_S16;
+    frame->nb_samples = 32;
+    frame->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_STEREO;
+    assert(av_frame_get_buffer(frame, 0) == 0);
+
+    ubuf1 = ubuf_sound_av_alloc(mgr, frame);
+    assert(ubuf1 != NULL);
+    av_frame_unref(frame);
+
+    ubase_assert(ubuf_sound_size(ubuf1, &size, &sample_size));
+    assert(size == 32);
+    assert(sample_size == 4);
+
+    unsigned int nb_planes = 0;
+    ubuf_sound_foreach_plane(ubuf1, channel) {
+        nb_planes++;
+        assert(!strcmp(channel, "lr"));
+    }
+    assert(nb_planes == 1);
+
+    ubase_assert(ubuf_sound_plane_read_uint8_t(ubuf1, "lr", 0, -1, &r));
+    ubase_assert(ubuf_sound_plane_unmap(ubuf1, "lr", 0, -1));
+
+    fill_in(ubuf1);
+
+    ubase_assert(ubuf_sound_plane_read_uint8_t(ubuf1, "lr", 2, 1, &r));
+    assert(*r == 'l' + 8);
+    ubase_assert(ubuf_sound_plane_unmap(ubuf1, "lr", 2, 1));
+
+    ubuf2 = ubuf_dup(ubuf1);
+    assert(ubuf2 != NULL);
+    ubase_nassert(ubuf_sound_plane_write_uint8_t(ubuf1, "lr", 0, -1, &w));
+    ubuf_free(ubuf2);
+
+    ubase_nassert(ubuf_sound_resize(ubuf1, 0, 33));
+
+    ubase_assert(ubuf_sound_resize(ubuf1, 2, -1));
+    ubase_assert(ubuf_sound_plane_read_uint8_t(ubuf1, "lr", 0, -1, &r));
+    assert(r[0] == 'l' + 8);
+    ubase_assert(ubuf_sound_plane_unmap(ubuf1, "lr", 0, -1));
+
+    ubase_assert(ubuf_sound_resize(ubuf1, 0, 29));
+
+    ubuf_free(ubuf1);
+
+    ubuf_mgr_release(mgr);
+
+    /* planar float 5.1 */
+    mgr = ubuf_av_mgr_alloc();
+    assert(mgr != NULL);
+
+    frame->format = AV_SAMPLE_FMT_FLTP;
+    frame->nb_samples = 32;
+    frame->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_5POINT1;
+    assert(av_frame_get_buffer(frame, 0) == 0);
+
+    ubuf1 = ubuf_sound_av_alloc(mgr, frame);
+    assert(ubuf1 != NULL);
+    av_frame_unref(frame);
+
+    ubase_assert(ubuf_sound_size(ubuf1, &size, &sample_size));
+    assert(size == 32);
+    assert(sample_size == sizeof(float));
+
+    nb_planes = 0;
+    ubuf_sound_foreach_plane(ubuf1, channel)
+        nb_planes++;
+    assert(nb_planes == 6);
+
+    ubase_assert(ubuf_sound_plane_read_uint8_t(ubuf1, "l", 0, -1, &r));
+    ubase_assert(ubuf_sound_plane_unmap(ubuf1, "l", 0, -1));
+
+    fill_in(ubuf1);
+
+    ubase_assert(ubuf_sound_plane_read_uint8_t(ubuf1, "l", 2, 1, &r));
+    assert(*r == 'l' + 8);
+    ubase_assert(ubuf_sound_plane_unmap(ubuf1, "l", 2, 1));
+    ubase_assert(ubuf_sound_plane_read_uint8_t(ubuf1, "r", 2, 1, &r));
+    assert(*r == 'r' + 8);
+    ubase_assert(ubuf_sound_plane_unmap(ubuf1, "r", 2, 1));
+    ubase_assert(ubuf_sound_plane_read_uint8_t(ubuf1, "c", 2, 1, &r));
+    assert(*r == 'c' + 8);
+    ubase_assert(ubuf_sound_plane_unmap(ubuf1, "c", 2, 1));
+    ubase_assert(ubuf_sound_plane_read_uint8_t(ubuf1, "L", 2, 1, &r));
+    assert(*r == 'L' + 8);
+    ubase_assert(ubuf_sound_plane_unmap(ubuf1, "L", 2, 1));
+    ubase_assert(ubuf_sound_plane_read_uint8_t(ubuf1, "R", 2, 1, &r));
+    assert(*r == 'R' + 8);
+    ubase_assert(ubuf_sound_plane_unmap(ubuf1, "R", 2, 1));
+    ubase_assert(ubuf_sound_plane_read_uint8_t(ubuf1, "S", 2, 1, &r));
+    assert(*r == 'S' + 8);
+    ubase_assert(ubuf_sound_plane_unmap(ubuf1, "S", 2, 1));
+
+    ubuf2 = ubuf_dup(ubuf1);
+    assert(ubuf2 != NULL);
+    ubase_nassert(ubuf_sound_plane_write_uint8_t(ubuf1, "l", 0, -1, &w));
+    ubuf_free(ubuf2);
+
+    ubase_nassert(ubuf_sound_resize(ubuf1, 0, 33));
+
+    ubase_assert(ubuf_sound_resize(ubuf1, 2, -1));
+    ubase_assert(ubuf_sound_plane_read_uint8_t(ubuf1, "l", 0, -1, &r));
+    assert(r[0] == 'l' + 8);
+    ubase_assert(ubuf_sound_plane_unmap(ubuf1, "l", 0, -1));
+    ubase_assert(ubuf_sound_plane_read_uint8_t(ubuf1, "r", 0, -1, &r));
+    assert(r[0] == 'r' + 8);
+    ubase_assert(ubuf_sound_plane_unmap(ubuf1, "r", 0, -1));
+    ubase_assert(ubuf_sound_plane_read_uint8_t(ubuf1, "c", 0, -1, &r));
+    assert(r[0] == 'c' + 8);
+    ubase_assert(ubuf_sound_plane_unmap(ubuf1, "c", 0, -1));
+    ubase_assert(ubuf_sound_plane_read_uint8_t(ubuf1, "L", 0, -1, &r));
+    assert(r[0] == 'L' + 8);
+    ubase_assert(ubuf_sound_plane_unmap(ubuf1, "L", 0, -1));
+    ubase_assert(ubuf_sound_plane_read_uint8_t(ubuf1, "R", 0, -1, &r));
+    assert(r[0] == 'R' + 8);
+    ubase_assert(ubuf_sound_plane_unmap(ubuf1, "R", 0, -1));
+    ubase_assert(ubuf_sound_plane_read_uint8_t(ubuf1, "S", 0, -1, &r));
+    assert(r[0] == 'S' + 8);
+    ubase_assert(ubuf_sound_plane_unmap(ubuf1, "S", 0, -1));
+
+    ubase_assert(ubuf_sound_resize(ubuf1, 0, 29));
+
+    ubuf_free(ubuf1);
+    ubuf_mgr_release(mgr);
+    av_frame_free(&frame);
+
+    return 0;
+}