From 629967c74081a90925d2543f9e869b5c3913772d Mon Sep 17 00:00:00 2001 From: Kieran Kunhya Date: Fri, 15 May 2026 18:38:54 +0100 Subject: [PATCH] sound: Move "sample_size" from uint8_t to uint16_t to allow for larger sample sizes Patch written by Claude --- examples/frame.c | 5 +- include/upipe/ubuf_sound.h | 8 +-- include/upipe/ubuf_sound_common.h | 6 +-- include/upipe/ubuf_sound_mem.h | 2 +- include/upipe/uref_sound.h | 4 +- include/upipe/uref_sound_flow.h | 51 +++++++++++++++++-- include/upipe/uref_sound_flow_formats.h | 2 +- lib/upipe-av/ubuf_av.c | 12 ++--- lib/upipe-av/upipe_avfilter.c | 2 +- .../ubuf_sound_blackmagic.cpp | 2 +- lib/upipe-ebur128/upipe_ebur128.c | 2 +- lib/upipe-filters/upipe_audio_max.c | 3 +- lib/upipe-modules/upipe_audio_blank.c | 5 +- lib/upipe-modules/upipe_audio_copy.c | 8 +-- lib/upipe-modules/upipe_audio_merge.c | 10 ++-- lib/upipe-modules/upipe_audio_split.c | 6 +-- lib/upipe-modules/upipe_audiocont.c | 4 +- lib/upipe-modules/upipe_block_to_sound.c | 5 +- lib/upipe-modules/upipe_convert_to_block.c | 2 +- lib/upipe-osx/upipe_osx_audioqueue_sink.c | 6 +-- lib/upipe-speexdsp/upipe_speexdsp.c | 2 +- lib/upipe-swresample/upipe_swr.c | 2 +- lib/upipe/ubuf_mem.c | 2 +- lib/upipe/ubuf_sound_common.c | 4 +- lib/upipe/ubuf_sound_mem.c | 8 +-- tests/ubuf_av_sound_test.c | 4 +- tests/ubuf_sound_mem_test.c | 4 +- tests/upipe_audio_max_test.c | 2 +- tests/upipe_audio_merge_test.c | 14 ++--- tests/upipe_audio_split_test.c | 2 +- tests/upipe_block_to_sound_test.c | 2 +- tests/upipe_convert_to_block_test.c | 2 +- tests/upipe_s337_encaps_test.c | 2 +- tests/upipe_speexdsp_test.c | 2 +- 34 files changed, 123 insertions(+), 74 deletions(-) diff --git a/examples/frame.c b/examples/frame.c index 0c7b89f44..819ad8e72 100644 --- a/examples/frame.c +++ b/examples/frame.c @@ -192,10 +192,11 @@ static int catch_uref(struct uprobe *uprobe, struct upipe *upipe, if (dump_size) { size_t size = 0, vsize = 0; uint8_t sample_size = 0; + uint16_t sound_sample_size = 0; if (ubase_check(uref_block_size(uref, &size))) upipe_dbg_va(upipe, "block size %zu", size); - else if (ubase_check(uref_sound_size(uref, &size, &sample_size))) - upipe_dbg_va(upipe, "sound size %zu (sample %u)", size, sample_size); + else if (ubase_check(uref_sound_size(uref, &size, &sound_sample_size))) + upipe_dbg_va(upipe, "sound size %zu (sample %u)", size, sound_sample_size); else if (ubase_check(uref_pic_size(uref, &size, &vsize, &sample_size))) upipe_dbg_va(upipe, "pic size %zux%zu (sample %u)", size, vsize, sample_size); diff --git a/include/upipe/ubuf_sound.h b/include/upipe/ubuf_sound.h index 3ba061f87..0845540a7 100644 --- a/include/upipe/ubuf_sound.h +++ b/include/upipe/ubuf_sound.h @@ -48,7 +48,7 @@ static inline struct ubuf *ubuf_sound_alloc(struct ubuf_mgr *mgr, int size) * @return an error code */ static inline int ubuf_sound_size(struct ubuf *ubuf, size_t *size_p, - uint8_t *sample_size_p) + uint16_t *sample_size_p) { return ubuf_control(ubuf, UBUF_SIZE_SOUND, size_p, sample_size_p); } @@ -266,7 +266,7 @@ static inline struct ubuf *ubuf_sound_copy(struct ubuf_mgr *mgr, int skip, int new_size) { size_t ubuf_size; - uint8_t sample_size; + uint16_t sample_size; if (unlikely(!ubase_check(ubuf_sound_size(ubuf, &ubuf_size, &sample_size)) || skip >= (int)ubuf_size)) return NULL; @@ -281,7 +281,7 @@ static inline struct ubuf *ubuf_sound_copy(struct ubuf_mgr *mgr, if (unlikely(new_ubuf == NULL)) return NULL; - uint8_t new_sample_size; + uint16_t new_sample_size; int extract_offset, extract_skip; int extract_size; if (unlikely(!ubase_check(ubuf_sound_size(new_ubuf, NULL, @@ -345,7 +345,7 @@ static inline struct ubuf *ubuf_sound_copy(struct ubuf_mgr *mgr, */ static inline int ubuf_sound_interleave(struct ubuf *ubuf, uint8_t *buf, int offset, int samples, - uint8_t sample_size, uint8_t planes) + uint16_t sample_size, uint8_t planes) { int i, j, k; const uint8_t *buffers_p[planes]; diff --git a/include/upipe/ubuf_sound_common.h b/include/upipe/ubuf_sound_common.h index 048c4aa7c..6acc22d25 100644 --- a/include/upipe/ubuf_sound_common.h +++ b/include/upipe/ubuf_sound_common.h @@ -59,7 +59,7 @@ struct ubuf_sound_common_mgr_plane { * members, common to sound managers. */ struct ubuf_sound_common_mgr { /** number of octets per plane in a sample */ - uint8_t sample_size; + uint16_t sample_size; /** number of planes to allocate */ uint8_t nb_planes; /** planes description */ @@ -178,7 +178,7 @@ int ubuf_sound_common_plane_dup(struct ubuf *ubuf, struct ubuf *new_ubuf, * @return an error code */ int ubuf_sound_common_size(struct ubuf *ubuf, size_t *size_p, - uint8_t *sample_size_p); + uint16_t *sample_size_p); /** @This iterates on sound planes channel types. Start by initializing * *channel_p to NULL. If *channel_p is NULL after running this function, there @@ -232,7 +232,7 @@ void ubuf_sound_common_mgr_clean(struct ubuf_mgr *mgr); * ubuf_sound_common_mgr * @param sample_size size in octets of a sample */ -void ubuf_sound_common_mgr_init(struct ubuf_mgr *mgr, uint8_t sample_size); +void ubuf_sound_common_mgr_init(struct ubuf_mgr *mgr, uint16_t sample_size); /** @This adds a new plane to a ubuf manager for sound formats. * diff --git a/include/upipe/ubuf_sound_mem.h b/include/upipe/ubuf_sound_mem.h index f84c66583..32dc00039 100644 --- a/include/upipe/ubuf_sound_mem.h +++ b/include/upipe/ubuf_sound_mem.h @@ -73,7 +73,7 @@ static inline int ubuf_sound_mem_get_shared(struct ubuf *ubuf, struct ubuf_mgr *ubuf_sound_mem_mgr_alloc(uint16_t ubuf_pool_depth, uint16_t shared_pool_depth, struct umem_mgr *umem_mgr, - uint8_t sample_size, + uint16_t sample_size, uint64_t align); /** @This adds a new plane to a ubuf manager for sound formats using umem. diff --git a/include/upipe/uref_sound.h b/include/upipe/uref_sound.h index 5a9c418a2..316da2f4d 100644 --- a/include/upipe/uref_sound.h +++ b/include/upipe/uref_sound.h @@ -54,7 +54,7 @@ static inline struct uref *uref_sound_alloc(struct uref_mgr *uref_mgr, /** @see ubuf_sound_size */ static inline int uref_sound_size(struct uref *uref, size_t *size_p, - uint8_t *sample_size_p) + uint16_t *sample_size_p) { if (uref->ubuf == NULL) return UBASE_ERR_INVALID; @@ -159,7 +159,7 @@ static inline int uref_sound_resize(struct uref *uref, int skip, int new_size) /** @see ubuf_sound_interleave */ static inline int uref_sound_interleave(struct uref *uref, uint8_t *buf, int offset, int samples, - uint8_t sample_size, uint8_t planes) + uint16_t sample_size, uint8_t planes) { if (uref->ubuf == NULL) return UBASE_ERR_INVALID; diff --git a/include/upipe/uref_sound_flow.h b/include/upipe/uref_sound_flow.h index 34a547c1f..0d4fd68ae 100644 --- a/include/upipe/uref_sound_flow.h +++ b/include/upipe/uref_sound_flow.h @@ -31,8 +31,52 @@ UREF_ATTR_SMALL_UNSIGNED(sound_flow, planes, "s.planes", number of planes) UREF_ATTR_STRING_VA(sound_flow, channel, "s.channel[%" PRIu8"]", channel type, uint8_t plane, plane) UREF_ATTR_SMALL_UNSIGNED(sound_flow, channels, "s.channels", number of channels) -UREF_ATTR_SMALL_UNSIGNED(sound_flow, sample_size, "s.sample_size", +UREF_ATTR_UNSIGNED(sound_flow, sample_size_storage, "s.sample_size", size in octets of a sample of an audio plane) +static inline int uref_sound_flow_get_sample_size(struct uref *uref, + uint16_t *p) +{ + uint64_t v; + UBASE_RETURN(uref_sound_flow_get_sample_size_storage(uref, &v)); + *p = (uint16_t)v; + return UBASE_ERR_NONE; +} +static inline int uref_sound_flow_set_sample_size(struct uref *uref, + uint16_t v) +{ + return uref_sound_flow_set_sample_size_storage(uref, v); +} +static UBASE_UNUSED inline int +uref_sound_flow_delete_sample_size(struct uref *uref) +{ + return uref_sound_flow_delete_sample_size_storage(uref); +} +static UBASE_UNUSED inline int +uref_sound_flow_copy_sample_size(struct uref *uref, struct uref *uref_src) +{ + return uref_sound_flow_copy_sample_size_storage(uref, uref_src); +} +static UBASE_UNUSED inline int +uref_sound_flow_match_sample_size(struct uref *uref, + uint16_t min, uint16_t max) +{ + uint64_t v; + UBASE_RETURN(uref_sound_flow_get_sample_size_storage(uref, &v)); + return (v >= min) && (v <= max) ? UBASE_ERR_NONE : UBASE_ERR_INVALID; +} +static UBASE_UNUSED inline int +uref_sound_flow_cmp_sample_size(struct uref *uref1, struct uref *uref2) +{ + uint64_t v1 = 0, v2 = 0; + int err1 = uref_sound_flow_get_sample_size_storage(uref1, &v1); + int err2 = uref_sound_flow_get_sample_size_storage(uref2, &v2); + if (!ubase_check(err1) && !ubase_check(err2)) + return 0; + if (!ubase_check(err1) || !ubase_check(err2)) + return -1; + return (int64_t)v1 - (int64_t)v2 < 0 ? -1 : + (int64_t)v1 - (int64_t)v2 > 0 ? 1 : 0; +} UREF_ATTR_SMALL_UNSIGNED(sound_flow, raw_sample_size, "s.sample_bits", size in bits of an audio sample) UREF_ATTR_UNSIGNED(sound_flow, rate, "s.rate", samples per second) @@ -51,7 +95,7 @@ UREF_ATTR_SMALL_UNSIGNED(sound_flow, channel_idx, "s.channel_index", index of fi static inline struct uref *uref_sound_flow_alloc_def(struct uref_mgr *mgr, const char *format, uint8_t channels, - uint8_t sample_size) + uint16_t sample_size) { struct uref *uref = uref_alloc_control(mgr); if (unlikely(uref == NULL)) return NULL; @@ -135,7 +179,8 @@ static inline int uref_sound_flow_copy_format(struct uref *uref_dst, struct uref *uref_src) { const char *def; - uint8_t planes, sample_size; + uint8_t planes; + uint16_t sample_size; UBASE_RETURN(uref_flow_get_def(uref_src, &def)) UBASE_RETURN(uref_flow_set_def(uref_dst, def)) UBASE_RETURN(uref_sound_flow_get_sample_size(uref_src, &sample_size)) diff --git a/include/upipe/uref_sound_flow_formats.h b/include/upipe/uref_sound_flow_formats.h index e6e641a00..a48bb3289 100644 --- a/include/upipe/uref_sound_flow_formats.h +++ b/include/upipe/uref_sound_flow_formats.h @@ -25,7 +25,7 @@ struct uref_sound_flow_format { /** name */ const char *name; /** sample size */ - uint8_t sample_size; + uint16_t sample_size; /** format is planar? */ bool planar; }; diff --git a/lib/upipe-av/ubuf_av.c b/lib/upipe-av/ubuf_av.c index 003600cec..b3e9d5cdc 100644 --- a/lib/upipe-av/ubuf_av.c +++ b/lib/upipe-av/ubuf_av.c @@ -628,11 +628,11 @@ static int ubuf_pic_av_plane_unmap(struct ubuf *ubuf, * @return an error code */ static int ubuf_sound_av_sample_size(struct ubuf *ubuf, - uint8_t *sample_size_p) + uint16_t *sample_size_p) { struct ubuf_av *ubuf_av = ubuf_av_from_ubuf(ubuf); struct ubuf_sound_av *ubuf_sound_av = ubuf_av_to_ubuf_sound_av(ubuf_av); - uint8_t sample_size = ubuf_sound_av->flow_format->sample_size; + uint16_t sample_size = ubuf_sound_av->flow_format->sample_size; if (!ubuf_sound_av->flow_format->planar) sample_size *= ubuf_av->frame->ch_layout.nb_channels; @@ -650,7 +650,7 @@ static int ubuf_sound_av_sample_size(struct ubuf *ubuf, */ static int ubuf_sound_av_size(struct ubuf *ubuf, size_t *size_p, - uint8_t *sample_size_p) + uint16_t *sample_size_p) { struct ubuf_av *ubuf_av = ubuf_av_from_ubuf(ubuf); struct ubuf_sound_av *ubuf_sound_av = ubuf_av_to_ubuf_sound_av(ubuf_av); @@ -709,7 +709,7 @@ static int ubuf_sound_av_resize(struct ubuf *ubuf, int offset, int new_size) AVFrame *frame = ubuf_av->frame; size_t size; - uint8_t sample_size; + uint16_t sample_size; UBASE_RETURN(ubuf_sound_av_size(ubuf, &size, &sample_size)); if (offset < 0) { @@ -796,7 +796,7 @@ static int ubuf_sound_av_plane_map(struct ubuf *ubuf, const char *channel, UBASE_RETURN(ubuf_sound_av_get_channel_id(ubuf, channel, &channel_id)); size_t samples; - uint8_t sample_size; + uint16_t sample_size; UBASE_RETURN(ubuf_sound_av_size(ubuf, &samples, &sample_size)); if (offset < 0) @@ -923,7 +923,7 @@ static int ubuf_av_control(struct ubuf *ubuf, int command, va_list args) case UBUF_SIZE_SOUND: { size_t *size_p = va_arg(args, size_t *); - uint8_t *sample_size_p = va_arg(args, uint8_t *); + uint16_t *sample_size_p = va_arg(args, uint16_t *); return ubuf_sound_av_size(ubuf, size_p, sample_size_p); } case UBUF_ITERATE_SOUND_PLANE: { diff --git a/lib/upipe-av/upipe_avfilter.c b/lib/upipe-av/upipe_avfilter.c index aaf5ff2d6..2d222713c 100644 --- a/lib/upipe-av/upipe_avfilter.c +++ b/lib/upipe-av/upipe_avfilter.c @@ -1041,7 +1041,7 @@ static int upipe_avfilt_avframe_from_uref_sound(struct upipe *upipe, goto inval; size_t size; - uint8_t sample_size; + uint16_t sample_size; UBASE_RETURN(uref_sound_size(uref, &size, &sample_size)); unsigned i = 0; diff --git a/lib/upipe-blackmagic/ubuf_sound_blackmagic.cpp b/lib/upipe-blackmagic/ubuf_sound_blackmagic.cpp index 6a0c8969e..7015fba82 100644 --- a/lib/upipe-blackmagic/ubuf_sound_blackmagic.cpp +++ b/lib/upipe-blackmagic/ubuf_sound_blackmagic.cpp @@ -148,7 +148,7 @@ static int ubuf_sound_bmd_control(struct ubuf *ubuf, int command, va_list args) } case UBUF_SIZE_SOUND: { size_t *size_p = va_arg(args, size_t *); - uint8_t *sample_size_p = va_arg(args, uint8_t *); + uint16_t *sample_size_p = va_arg(args, uint16_t *); return ubuf_sound_common_size(ubuf, size_p, sample_size_p); } case UBUF_ITERATE_SOUND_PLANE: { diff --git a/lib/upipe-ebur128/upipe_ebur128.c b/lib/upipe-ebur128/upipe_ebur128.c index 209bf744d..406070f25 100644 --- a/lib/upipe-ebur128/upipe_ebur128.c +++ b/lib/upipe-ebur128/upipe_ebur128.c @@ -113,7 +113,7 @@ static void upipe_ebur128_input(struct upipe *upipe, struct uref *uref, } size_t samples; - uint8_t sample_size; + uint16_t sample_size; if (unlikely(!ubase_check(uref_sound_size(uref, &samples, &sample_size)))) { upipe_warn(upipe, "invalid sound buffer"); uref_free(uref); diff --git a/lib/upipe-filters/upipe_audio_max.c b/lib/upipe-filters/upipe_audio_max.c index e4f187a2d..a89038905 100644 --- a/lib/upipe-filters/upipe_audio_max.c +++ b/lib/upipe-filters/upipe_audio_max.c @@ -203,7 +203,8 @@ static int upipe_amax_provide_flow_format(struct upipe *upipe, struct uref *flow = uref_dup(request->uref); UBASE_ALLOC_RETURN(flow); - uint8_t planes, channels, sample_size; + uint8_t planes, channels; + uint16_t sample_size; const char *channels_names; if (ubase_check(uref_sound_flow_get_planes(request->uref, &planes)) && ubase_check(uref_sound_flow_get_channels(request->uref, &channels)) && diff --git a/lib/upipe-modules/upipe_audio_blank.c b/lib/upipe-modules/upipe_audio_blank.c index 822d638aa..97edf41f2 100644 --- a/lib/upipe-modules/upipe_audio_blank.c +++ b/lib/upipe-modules/upipe_audio_blank.c @@ -93,7 +93,8 @@ static void upipe_ablk_free(struct upipe *upipe) static int upipe_ablk_check_flow_def(struct upipe *upipe, struct uref *flow_def) { - uint8_t planes, sample_size, channels; + uint8_t planes, channels; + uint16_t sample_size; uint64_t rate, samples; UBASE_RETURN(uref_flow_match_def(flow_def, UREF_SOUND_FLOW_DEF)); @@ -186,7 +187,7 @@ static void upipe_ablk_input(struct upipe *upipe, upipe_verbose(upipe, "allocate blank sound"); uint64_t samples = 0; - uint8_t sample_size = 0; + uint16_t sample_size = 0; uref_sound_flow_get_samples(flow_def, &samples); uref_sound_flow_get_sample_size(flow_def, &sample_size); diff --git a/lib/upipe-modules/upipe_audio_copy.c b/lib/upipe-modules/upipe_audio_copy.c index f0467d330..d6c33777c 100644 --- a/lib/upipe-modules/upipe_audio_copy.c +++ b/lib/upipe-modules/upipe_audio_copy.c @@ -73,7 +73,7 @@ struct upipe_audio_copy { /** input sample rate */ uint64_t samplerate; /** sample size */ - uint8_t sample_size; + uint16_t sample_size; /** input planes */ uint8_t planes; /** remain from previous output */ @@ -228,7 +228,7 @@ static int upipe_audio_copy_set_flow_def_real(struct upipe *upipe, uint64_t rate = 0; uint8_t planes = 0; - uint8_t sample_size = 0; + uint16_t sample_size = 0; uint64_t input_latency = 0; uref_sound_flow_get_rate(flow_def, &rate); uref_sound_flow_get_planes(flow_def, &planes); @@ -447,7 +447,7 @@ static bool upipe_audio_copy_handle(struct upipe *upipe, struct upipe_audio_copy *upipe_audio_copy = upipe_audio_copy_from_upipe(upipe); size_t size; - uint8_t sample_size; + uint16_t sample_size; if (unlikely(ubase_check(uref_flow_get_def(uref, NULL)))) { upipe_audio_copy_set_flow_def_real(upipe, uref); @@ -510,7 +510,7 @@ static int upipe_audio_copy_set_flow_def(struct upipe *upipe, { uint64_t rate = 0; uint8_t planes = 0; - uint8_t sample_size = 0; + uint16_t sample_size = 0; UBASE_RETURN(uref_flow_match_def(flow_def, EXPECTED_FLOW_DEF)); UBASE_RETURN(uref_sound_flow_get_rate(flow_def, &rate)); diff --git a/lib/upipe-modules/upipe_audio_merge.c b/lib/upipe-modules/upipe_audio_merge.c index 4334c578c..a8797f0e9 100644 --- a/lib/upipe-modules/upipe_audio_merge.c +++ b/lib/upipe-modules/upipe_audio_merge.c @@ -281,7 +281,7 @@ static void upipe_audio_merge_copy_to_output(struct upipe *upipe, uint8_t **out_ upipe_err(upipe, "error reading subpipe audio, skipping"); else { size_t samples = 0; - uint8_t sample_size = 0; + uint16_t sample_size = 0; UBASE_ERROR(upipe, uref_sound_size(upipe_audio_merge_sub->uref, &samples, &sample_size)); int index; @@ -315,9 +315,9 @@ static void upipe_audio_merge_copy_to_output_interleaved(struct upipe *upipe, uint8_t output_channels = 0; UBASE_ERROR(upipe, uref_sound_flow_get_channels(upipe_audio_merge->flow_def, &output_channels)); - uint8_t output_sample_size = 0; + uint16_t output_sample_size = 0; UBASE_ERROR(upipe, uref_sound_flow_get_sample_size(upipe_audio_merge->flow_def, &output_sample_size)); - uint8_t real_sample_size = output_sample_size / output_channels; + uint16_t real_sample_size = output_sample_size / output_channels; uint8_t cur_channel = 0; ulist_foreach (&upipe_audio_merge->inputs, uchain) { @@ -331,7 +331,7 @@ static void upipe_audio_merge_copy_to_output_interleaved(struct upipe *upipe, upipe_err(upipe, "error reading subpipe audio, skipping"); } else { size_t samples = 0; - uint8_t sample_size = 0; + uint16_t sample_size = 0; UBASE_ERROR(upipe, uref_sound_size(upipe_audio_merge_sub->uref, &samples, &sample_size)); int index; @@ -403,7 +403,7 @@ static void upipe_audio_merge_produce_output(struct upipe *upipe, struct upump * return; } - uint8_t output_sample_size = 0; + uint16_t output_sample_size = 0; UBASE_ERROR(upipe, uref_sound_flow_get_sample_size(upipe_audio_merge->flow_def, &output_sample_size)); uint8_t output_planes = 0; diff --git a/lib/upipe-modules/upipe_audio_split.c b/lib/upipe-modules/upipe_audio_split.c index a04d53821..ebd43d26c 100644 --- a/lib/upipe-modules/upipe_audio_split.c +++ b/lib/upipe-modules/upipe_audio_split.c @@ -42,9 +42,9 @@ struct upipe_audio_split { /** flow definition packet */ struct uref *flow_def; /** sample size in octets */ - uint8_t sample_size; + uint16_t sample_size; /** sample size in octets for 1 channel */ - uint8_t channel_sample_size; + uint16_t channel_sample_size; /** number of channels */ uint8_t channels; @@ -97,7 +97,7 @@ struct upipe_audio_split_sub { /** bit field of channels to copy */ uint64_t bitfield; /** sample size in octets */ - uint8_t sample_size; + uint16_t sample_size; /** public upipe structure */ struct upipe upipe; diff --git a/lib/upipe-modules/upipe_audiocont.c b/lib/upipe-modules/upipe_audiocont.c index 1152f88be..6aebd890b 100644 --- a/lib/upipe-modules/upipe_audiocont.c +++ b/lib/upipe-modules/upipe_audiocont.c @@ -417,7 +417,7 @@ static int upipe_audiocont_sub_extract(struct upipe *upipe, struct ubuf *ubuf, upipe_audiocont_from_sub_mgr(upipe->mgr); size_t ref_size; - uint8_t sample_size; + uint16_t sample_size; UBASE_RETURN(ubuf_sound_size(ubuf, &ref_size, &sample_size)) /* We assume the ubuf is allocated by us and therefore can be writtent and @@ -671,7 +671,7 @@ static void upipe_audiocont_input(struct upipe *upipe, struct uref *uref, } size_t ref_size = 0; - uint8_t sample_size = 0; + uint16_t sample_size = 0; if (unlikely(!ubase_check(uref_sound_size(uref, &ref_size, NULL)))) { upipe_warn_va(upipe, "invalid ref packet"); uref_free(uref); diff --git a/lib/upipe-modules/upipe_block_to_sound.c b/lib/upipe-modules/upipe_block_to_sound.c index fdee8b93a..b1ff724d1 100644 --- a/lib/upipe-modules/upipe_block_to_sound.c +++ b/lib/upipe-modules/upipe_block_to_sound.c @@ -59,7 +59,7 @@ struct upipe_block_to_sound { struct upipe upipe; /** data to set flow_def and ubuf */ - uint8_t sample_size; + uint16_t sample_size; uint8_t planes; }; @@ -219,7 +219,8 @@ static int upipe_block_to_sound_set_flow_def(struct upipe *upipe, uref_free(flow_def); return UBASE_ERR_INVALID; } - uint8_t channels, planes, sample_size; + uint8_t channels, planes; + uint16_t sample_size; if(unlikely(!ubase_check(uref_sound_flow_get_channels(flow_def, &channels))) || unlikely(!ubase_check(uref_sound_flow_get_planes(flow_def, &planes))) || unlikely(!ubase_check(uref_sound_flow_get_sample_size(flow_def, &sample_size)))) { diff --git a/lib/upipe-modules/upipe_convert_to_block.c b/lib/upipe-modules/upipe_convert_to_block.c index 0b4b23797..f91c09b93 100644 --- a/lib/upipe-modules/upipe_convert_to_block.c +++ b/lib/upipe-modules/upipe_convert_to_block.c @@ -217,7 +217,7 @@ static void upipe_tblk_handle_sound(struct upipe *upipe, struct uref *uref, if (unlikely(ubuf == NULL)) { /* We have to memcpy the thing. */ size_t samples; - uint8_t sample_size; + uint16_t sample_size; if (unlikely(!ubase_check(uref_sound_size(uref, &samples, &sample_size)))) { uref_free(uref); diff --git a/lib/upipe-osx/upipe_osx_audioqueue_sink.c b/lib/upipe-osx/upipe_osx_audioqueue_sink.c index 16fecabf2..4928346c9 100644 --- a/lib/upipe-osx/upipe_osx_audioqueue_sink.c +++ b/lib/upipe-osx/upipe_osx_audioqueue_sink.c @@ -236,7 +236,7 @@ static void upipe_osx_audioqueue_sink_worker(struct upump *upump) } size_t size; - uint8_t sample_size; + uint16_t sample_size; ubase_assert(uref_sound_size(uref, &size, &sample_size)); const void *audios[1]; @@ -271,7 +271,7 @@ static int upipe_osx_audioqueue_sink_set_flow_def_real(struct upipe *upipe, uint8_t planes = 0; uint64_t sample_rate = 0; /* hush gcc */ uint8_t channels = 0; - uint8_t sample_size = 0; + uint16_t sample_size = 0; OSStatus status; upipe_osx_audioqueue_sink_destroy(upipe); @@ -421,7 +421,7 @@ static int upipe_osx_audioqueue_sink_set_flow_def(struct upipe *upipe, uint8_t planes = 0; uint64_t sample_rate = 0; /* hush gcc */ uint8_t channels = 0; - uint8_t sample_size = 0; + uint16_t sample_size = 0; /* check flow format */ UBASE_RETURN(uref_flow_match_def(flow, EXPECTED_FLOW_DEF)); diff --git a/lib/upipe-speexdsp/upipe_speexdsp.c b/lib/upipe-speexdsp/upipe_speexdsp.c index 835c5e54b..82eb9a212 100644 --- a/lib/upipe-speexdsp/upipe_speexdsp.c +++ b/lib/upipe-speexdsp/upipe_speexdsp.c @@ -323,7 +323,7 @@ static int upipe_speexdsp_provide_flow_format(struct upipe *upipe, UBASE_RETURN(uref_sound_flow_get_channels(request->uref, &channels)) uint8_t planes; UBASE_RETURN(uref_sound_flow_get_planes(request->uref, &planes)) - uint8_t sample_size; + uint16_t sample_size; UBASE_RETURN(uref_sound_flow_get_sample_size(request->uref, &sample_size)) struct uref *flow = uref_dup(request->uref); diff --git a/lib/upipe-swresample/upipe_swr.c b/lib/upipe-swresample/upipe_swr.c index 404db5c55..bb9d97b2a 100644 --- a/lib/upipe-swresample/upipe_swr.c +++ b/lib/upipe-swresample/upipe_swr.c @@ -430,7 +430,7 @@ static struct upipe *upipe_swr_alloc(struct upipe_mgr *mgr, if (!upipe_swr->out_chan) { uref_sound_flow_delete_channels(flow_def); } - uint8_t sample_size = 0; + uint16_t sample_size = 0; uref_sound_flow_get_sample_size(flow_def, &sample_size); if (!sample_size) { uref_sound_flow_delete_sample_size(flow_def); diff --git a/lib/upipe/ubuf_mem.c b/lib/upipe/ubuf_mem.c index f60b84aff..eb1dcea12 100644 --- a/lib/upipe/ubuf_mem.c +++ b/lib/upipe/ubuf_mem.c @@ -107,7 +107,7 @@ struct ubuf_mgr *ubuf_mem_mgr_alloc_from_flow_def(uint16_t ubuf_pool_depth, } if (!ubase_ncmp(def, "sound.")) { - uint8_t sample_size; + uint16_t sample_size; uint8_t planes; if (unlikely(!ubase_check(uref_sound_flow_get_sample_size(flow_def, &sample_size) || diff --git a/lib/upipe/ubuf_sound_common.c b/lib/upipe/ubuf_sound_common.c index 7df83b5cf..ca660c35f 100644 --- a/lib/upipe/ubuf_sound_common.c +++ b/lib/upipe/ubuf_sound_common.c @@ -59,7 +59,7 @@ int ubuf_sound_common_plane_dup(struct ubuf *ubuf, struct ubuf *new_ubuf, * @return an error code */ int ubuf_sound_common_size(struct ubuf *ubuf, size_t *size_p, - uint8_t *sample_size_p) + uint16_t *sample_size_p) { struct ubuf_sound_common_mgr *common_mgr = ubuf_sound_common_mgr_from_ubuf_mgr(ubuf->mgr); @@ -197,7 +197,7 @@ void ubuf_sound_common_mgr_clean(struct ubuf_mgr *mgr) * ubuf_sound_common_mgr * @param sample_size size in octets of a sample */ -void ubuf_sound_common_mgr_init(struct ubuf_mgr *mgr, uint8_t sample_size) +void ubuf_sound_common_mgr_init(struct ubuf_mgr *mgr, uint16_t sample_size) { assert(sample_size); diff --git a/lib/upipe/ubuf_sound_mem.c b/lib/upipe/ubuf_sound_mem.c index 145bfd4b2..6ba602511 100644 --- a/lib/upipe/ubuf_sound_mem.c +++ b/lib/upipe/ubuf_sound_mem.c @@ -195,7 +195,7 @@ static int _ubuf_sound_mem_get_shared(struct ubuf *ubuf, struct ubuf_sound_mem *sound_mem = ubuf_sound_mem_from_ubuf(ubuf); *shared_p = sound_mem->shared; size_t size; - uint8_t sample_size; + uint16_t sample_size; UBASE_RETURN(ubuf_sound_common_size(ubuf, &size, &sample_size)) uint8_t *buffer; UBASE_RETURN(ubuf_sound_common_plane_map(ubuf, channel, 0, -1, &buffer)) @@ -221,7 +221,7 @@ static int ubuf_sound_mem_control(struct ubuf *ubuf, int command, va_list args) } case UBUF_SIZE_SOUND: { size_t *size_p = va_arg(args, size_t *); - uint8_t *sample_size_p = va_arg(args, uint8_t *); + uint16_t *sample_size_p = va_arg(args, uint16_t *); return ubuf_sound_common_size(ubuf, size_p, sample_size_p); } case UBUF_ITERATE_SOUND_PLANE: { @@ -366,7 +366,7 @@ static int ubuf_sound_mem_mgr_check(struct ubuf_mgr *mgr, if (ubase_ncmp(def, "sound.")) return UBASE_ERR_INVALID; - uint8_t sample_size; + uint16_t sample_size; uint8_t planes; uint64_t align = 0; @@ -450,7 +450,7 @@ static void ubuf_sound_mem_mgr_free(struct urefcount *urefcount) struct ubuf_mgr *ubuf_sound_mem_mgr_alloc(uint16_t ubuf_pool_depth, uint16_t shared_pool_depth, struct umem_mgr *umem_mgr, - uint8_t sample_size, + uint16_t sample_size, uint64_t align) { assert(umem_mgr != NULL); diff --git a/tests/ubuf_av_sound_test.c b/tests/ubuf_av_sound_test.c index 7e510ddff..112b73d41 100644 --- a/tests/ubuf_av_sound_test.c +++ b/tests/ubuf_av_sound_test.c @@ -21,7 +21,7 @@ static void fill_in(struct ubuf *ubuf) { size_t size; - uint8_t sample_size; + uint16_t sample_size; ubase_assert(ubuf_sound_size(ubuf, &size, &sample_size)); int octets = size * sample_size; @@ -43,7 +43,7 @@ int main(int argc, char **argv) struct ubuf *ubuf1, *ubuf2; const char *channel; size_t size; - uint8_t sample_size; + uint16_t sample_size; uint8_t *w; const uint8_t *r; AVFrame *frame; diff --git a/tests/ubuf_sound_mem_test.c b/tests/ubuf_sound_mem_test.c index 0c25a38c5..517a664c1 100644 --- a/tests/ubuf_sound_mem_test.c +++ b/tests/ubuf_sound_mem_test.c @@ -29,7 +29,7 @@ static void fill_in(struct ubuf *ubuf) { size_t size; - uint8_t sample_size; + uint16_t sample_size; ubase_assert(ubuf_sound_size(ubuf, &size, &sample_size)); int octets = size * sample_size; @@ -54,7 +54,7 @@ int main(int argc, char **argv) struct ubuf *ubuf1, *ubuf2; const char *channel; size_t size; - uint8_t sample_size; + uint16_t sample_size; uint8_t *w; const uint8_t *r; diff --git a/tests/upipe_audio_max_test.c b/tests/upipe_audio_max_test.c index cc04deb5a..a1f2fea07 100644 --- a/tests/upipe_audio_max_test.c +++ b/tests/upipe_audio_max_test.c @@ -133,7 +133,7 @@ static int provide_urequest(struct urequest *urequest, va_list args) static void fill_in(struct ubuf *ubuf) { size_t size; - uint8_t sample_size; + uint16_t sample_size; ubase_assert(ubuf_sound_size(ubuf, &size, &sample_size)); const char *channel; diff --git a/tests/upipe_audio_merge_test.c b/tests/upipe_audio_merge_test.c index c1b6fb3a7..17962fff9 100644 --- a/tests/upipe_audio_merge_test.c +++ b/tests/upipe_audio_merge_test.c @@ -67,7 +67,7 @@ int count = 0; static void fill_in(struct ubuf *ubuf, float value) { size_t size; - uint8_t sample_size; + uint16_t sample_size; ubase_assert(ubuf_sound_size(ubuf, &size, &sample_size)); const char *channel = NULL; @@ -86,7 +86,7 @@ static void fill_in(struct ubuf *ubuf, float value) static void fill_in_int(struct ubuf *ubuf, int16_t value) { size_t size; - uint8_t sample_size; + uint16_t sample_size; ubase_assert(ubuf_sound_size(ubuf, &size, &sample_size)); const char *channel = NULL; @@ -105,7 +105,7 @@ 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; + uint16_t sample_size; ubase_assert(ubuf_sound_size(ubuf, &size, &sample_size)); const char *channel = NULL; @@ -158,7 +158,7 @@ static void test_input(struct upipe *upipe, struct uref *uref, const float *r; size_t size; - uint8_t sample_size; + uint16_t sample_size; ubase_assert(ubuf_sound_size(uref->ubuf, &size, &sample_size)); ubase_assert(uref_sound_plane_read_float(uref, "l", 0, -1, &r)); @@ -184,7 +184,7 @@ static void test_input_int(struct upipe *upipe, struct uref *uref, const int16_t *r; size_t size; - uint8_t sample_size; + uint16_t sample_size; ubase_assert(ubuf_sound_size(uref->ubuf, &size, &sample_size)); ubase_assert(uref_sound_plane_read_int16_t(uref, "l", 0, -1, &r)); @@ -210,7 +210,7 @@ static void test_input_idx(struct upipe *upipe, struct uref *uref, const int16_t *r; size_t size; - uint8_t sample_size; + uint16_t sample_size; ubase_assert(ubuf_sound_size(uref->ubuf, &size, &sample_size)); ubase_assert(uref_sound_plane_read_int16_t(uref, "l", 0, -1, &r)); @@ -249,7 +249,7 @@ static void test_input_interleaved(struct upipe *upipe, struct uref *uref, } }; size_t size; - uint8_t sample_size; + uint16_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)); diff --git a/tests/upipe_audio_split_test.c b/tests/upipe_audio_split_test.c index ec727a9de..4f42db596 100644 --- a/tests/upipe_audio_split_test.c +++ b/tests/upipe_audio_split_test.c @@ -43,7 +43,7 @@ static int counter = 0; static void fill_in(struct ubuf *ubuf) { size_t size; - uint8_t sample_size; + uint16_t sample_size; ubase_assert(ubuf_sound_size(ubuf, &size, &sample_size)); int octets = size * sample_size; diff --git a/tests/upipe_block_to_sound_test.c b/tests/upipe_block_to_sound_test.c index 31fc1ea05..5d0b891fd 100644 --- a/tests/upipe_block_to_sound_test.c +++ b/tests/upipe_block_to_sound_test.c @@ -132,7 +132,7 @@ int main(int argc, char **argv) struct uref *uref; int block_size = 256; - uint8_t sample_size = 8; + uint16_t sample_size = 8; uint8_t channels = 2; diff --git a/tests/upipe_convert_to_block_test.c b/tests/upipe_convert_to_block_test.c index a207c8577..ab5f23cd8 100644 --- a/tests/upipe_convert_to_block_test.c +++ b/tests/upipe_convert_to_block_test.c @@ -70,7 +70,7 @@ static void pic_fill_in(struct ubuf *ubuf) static void sound_fill_in(struct ubuf *ubuf) { size_t size; - uint8_t sample_size; + uint16_t sample_size; ubase_assert(ubuf_sound_size(ubuf, &size, &sample_size)); int octets = size * sample_size; diff --git a/tests/upipe_s337_encaps_test.c b/tests/upipe_s337_encaps_test.c index 93e00ff6b..f7880a681 100644 --- a/tests/upipe_s337_encaps_test.c +++ b/tests/upipe_s337_encaps_test.c @@ -96,7 +96,7 @@ static void test_input(struct upipe *upipe, struct uref *uref, uref_dump(uref, upipe->uprobe); size_t samples; - uint8_t sample_size; + uint16_t sample_size; ubase_assert(uref_sound_size(uref, &samples, &sample_size)); assert(samples == A52_FRAME_SAMPLES); assert(sample_size == 2 * 4); diff --git a/tests/upipe_speexdsp_test.c b/tests/upipe_speexdsp_test.c index b5fceb251..cc55b0448 100644 --- a/tests/upipe_speexdsp_test.c +++ b/tests/upipe_speexdsp_test.c @@ -142,7 +142,7 @@ static int provide_urequest(struct urequest *urequest, va_list args) static void fill_in(struct ubuf *ubuf) { size_t size; - uint8_t sample_size; + uint16_t sample_size; ubase_assert(ubuf_sound_size(ubuf, &size, &sample_size)); const char *channel;