static void pic_fill_in(struct ubuf *ubuf)
{
size_t hsize, vsize;
uint8_t macropixel;
ubase_assert(ubuf_pic_size(ubuf, &hsize, &vsize, ¯opixel));
const char *chroma = NULL;
while (ubase_check(ubuf_pic_plane_iterate(ubuf, &chroma)) &&
chroma != NULL) {
size_t stride;
uint8_t hsub, vsub, macropixel_size;
ubase_assert(ubuf_pic_plane_size(ubuf, chroma, &stride, &hsub, &vsub,
¯opixel_size));
int hoctets = hsize * macropixel_size / hsub / macropixel;
uint8_t *buffer;
ubase_assert(ubuf_pic_plane_write(ubuf, chroma, 0, 0, -1, -1, &buffer));
for (int y = 0; y < vsize / vsub; y++) {
for (int x = 0; x < hoctets; x++)
buffer[x] = 1 + (y * hoctets) + x;
buffer += stride;
}
ubase_assert(ubuf_pic_plane_unmap(ubuf, chroma, 0, 0, -1, -1));
}
}
static void upipe_dump_input(struct upipe *upipe, struct uref *uref,
struct upump **upump_p)
{
struct upipe_dump *upipe_dump = upipe_dump_from_upipe(upipe);
uref_dump(uref, upipe->uprobe);
size_t total_size;
ubase_assert(uref_block_size(uref, &total_size));
upipe_notice_va(upipe, "dumping ubuf %p of size %zu",
uref->ubuf, total_size);
if (upipe_dump->max_len != (size_t)-1 &&
total_size > upipe_dump->max_len)
total_size = upipe_dump->max_len;
unsigned int count = 0;
uint8_t line[16];
int offset = 0;
while (total_size) {
const uint8_t *buf;
int size = total_size;
ubase_assert(uref_block_read(uref, offset, &size, &buf));
assert(size != 0);
total_size -= size;
for (unsigned i = 0; i < size; i++, count++) {
line[count % 16] = buf[i];
if (!((count + 1) % 16) || (!total_size && (i + 1 == size)))
upipe_dump_line(upipe, count - (count % 16),
line, (count % 16) + 1);
}
ubase_assert(uref_block_unmap(uref, offset));
offset += size;
}
#define UPIPE_DUMP_SEP \
"--------------------------------------------" \
"-------------------------------------------"
upipe_notice(upipe, UPIPE_DUMP_SEP);
upipe_dump_output(upipe, uref, upump_p);
}
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));
}
static void sound_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 = NULL;
while (ubase_check(ubuf_sound_plane_iterate(ubuf, &channel)) &&
channel != NULL) {
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));
}
}
static int catch_fsrc(struct uprobe *uprobe,
struct upipe *upipe,
int event, va_list args)
{
switch (event) {
case UPROBE_SOURCE_END:
if (++current < nb_files)
ubase_assert(upipe_set_uri(upipe, files[current]));
return UBASE_ERR_NONE;
}
return uprobe_throw_next(uprobe, upipe, event, args);
}
/** @internal @This handles the input uref.
*
* @param upipe description structure of the pipe
* @param uref input uref
* @param upump_p reference to pump that generated the buffer
*/
static void upipe_vblk_input(struct upipe *upipe,
struct uref *uref,
struct upump **upump_p)
{
struct upipe_vblk *upipe_vblk = upipe_vblk_from_upipe(upipe);
struct uref *flow_def = upipe_vblk->flow_def;
struct uref *input_flow_def = upipe_vblk->input_flow_def;
if (uref->ubuf) {
upipe_vblk_output(upipe, uref, upump_p);
return;
}
if (unlikely(!input_flow_def)) {
upipe_warn(upipe, "no input flow definition");
uref_free(uref);
return;
}
if (unlikely(!flow_def)) {
upipe_warn(upipe, "no output flow definition");
uref_free(uref);
return;
}
if (unlikely(!upipe_vblk->ubuf_mgr)) {
upipe_warn(upipe, "no ubuf manager set");
uref_free(uref);
return;
}
if (unlikely(!upipe_vblk->ubuf)) {
upipe_verbose(upipe, "allocate blank picture");
uint64_t hsize, vsize;
ubase_assert(uref_pic_flow_get_hsize(upipe_vblk->flow_def, &hsize));
ubase_assert(uref_pic_flow_get_vsize(upipe_vblk->flow_def, &vsize));
upipe_vblk->ubuf = ubuf_pic_alloc(upipe_vblk->ubuf_mgr, hsize, vsize);
if (unlikely(!upipe_vblk->ubuf)) {
upipe_err(upipe, "fail to allocate picture");
uref_free(uref);
upipe_throw_fatal(upipe, UBASE_ERR_ALLOC);
return;
}
ubuf_pic_clear(upipe_vblk->ubuf, 0, 0, -1, -1, 1);
}
struct ubuf *ubuf = ubuf_dup(upipe_vblk->ubuf);
if (unlikely(!ubuf)) {
upipe_err(upipe, "fail to duplicate blank picture");
uref_free(uref);
upipe_throw_fatal(upipe, UBASE_ERR_ALLOC);
return;
}
uref_attach_ubuf(uref, ubuf);
if (ubase_check(uref_pic_get_progressive(flow_def)))
uref_pic_set_progressive(uref);
upipe_vblk_output(upipe, uref, upump_p);
}
static int catch_uref(struct uprobe *uprobe,
struct upipe *upipe,
int event, va_list args)
{
switch (event) {
case UPROBE_NEW_FLOW_DEF: {
struct uref *uref = va_arg(args, struct uref *);
const char *flow_def;
ubase_assert(uref_flow_get_def(uref, &flow_def));
printf("flow definition: %s\n", flow_def);
uint8_t version;
if (ubase_check(uref_m3u_flow_get_version(uref, &version)))
printf("version: %u\n", version);
const char *playlist_type;
if (ubase_check(uref_m3u_playlist_flow_get_type(uref, &playlist_type)))
printf("playlist type: %s\n", playlist_type);
uint64_t target_duration;
if (ubase_check(uref_m3u_playlist_flow_get_target_duration(
uref, &target_duration)))
printf("playlist target duration: %"PRIu64"\n", target_duration);
uint64_t media_sequence;
if (ubase_check(uref_m3u_playlist_flow_get_media_sequence(
uref, &media_sequence)))
printf("playlist target duration: %"PRIu64"\n", media_sequence);
if (ubase_check(uref_m3u_playlist_flow_get_endlist(uref)))
printf("playlist end\n");
return UBASE_ERR_NONE;
}
case UPROBE_PROBE_UREF: {
UBASE_SIGNATURE_CHECK(args, UPIPE_PROBE_UREF_SIGNATURE)
struct uref *uref = va_arg(args, struct uref *);
const char *uri;
if (ubase_check(uref_m3u_get_uri(uref, &uri)))
printf("uri: %s\n", uri);
uint64_t playlist_seq_duration;
if (ubase_check(uref_m3u_playlist_get_seq_duration(
uref, &playlist_seq_duration)))
printf("playlist sequence duration: %"PRIu64"\n",
playlist_seq_duration);
uint64_t playlist_byte_range_len;
if (ubase_check(uref_m3u_playlist_get_byte_range_len(
uref, &playlist_byte_range_len)))
printf("playlist byte range length: %"PRIu64"\n",
playlist_byte_range_len);
uint64_t playlist_byte_range_off;
if (ubase_check(uref_m3u_playlist_get_byte_range_off(
uref, &playlist_byte_range_off)))
printf("playlist byte range offset: %"PRIu64"\n",
playlist_byte_range_off);
uint64_t master_bandwidth;
if (ubase_check(uref_m3u_master_get_bandwidth(
uref, &master_bandwidth)))
printf("master bandwidth: %"PRIu64"\n", master_bandwidth);
const char *master_codecs;
if (ubase_check(uref_m3u_master_get_codecs(
uref, &master_codecs)))
printf("master codecs: %s\n", master_codecs);
const char *resolution;
if (ubase_check(uref_m3u_master_get_resolution(
uref, &resolution)))
printf("master resolution: %s\n", resolution);
const char *audio;
if (ubase_check(uref_m3u_master_get_audio(
uref, &audio)))
printf("master audio: %s\n", audio);
const char *media_type;
if (ubase_check(uref_m3u_master_get_media_type(
uref, &media_type)))
printf("master media_type: %s\n", media_type);
const char *media_name;
if (ubase_check(uref_m3u_master_get_media_name(
uref, &media_name)))
printf("master media_name: %s\n", media_name);
const char *media_group;
if (ubase_check(uref_m3u_master_get_media_group(
uref, &media_group)))
printf("master media_group: %s\n", media_group);
if (ubase_check(uref_m3u_master_get_media_default(uref)))
printf("master media_default\n");
if (ubase_check(uref_m3u_master_get_media_autoselect(uref)))
printf("master media_autoselect\n");
return UBASE_ERR_NONE;
}
}
return uprobe_throw_next(uprobe, upipe, event, args);
}
int main(int argc, char *argv[])
{
assert(argc >= 2);
nb_files = argc - 1;
files = argv + 1;
struct upump_mgr *upump_mgr = upump_ev_mgr_alloc_default(UPUMP_POOL,
UPUMP_BLOCKER_POOL);
assert(upump_mgr != NULL);
struct umem_mgr *umem_mgr = umem_alloc_mgr_alloc();
assert(umem_mgr != NULL);
struct udict_mgr *udict_mgr = udict_inline_mgr_alloc(UDICT_POOL_DEPTH,
umem_mgr, -1, -1);
assert(udict_mgr != NULL);
struct uref_mgr *uref_mgr = uref_std_mgr_alloc(UREF_POOL_DEPTH, udict_mgr,
0);
/* main probe */
struct uprobe *logger =
uprobe_stdio_alloc(NULL, stderr, UPROBE_LOG_VERBOSE);
assert(logger != NULL);
logger = uprobe_uref_mgr_alloc(logger, uref_mgr);
assert(logger != NULL);
logger = uprobe_upump_mgr_alloc(logger, upump_mgr);
assert(logger != NULL);
logger = uprobe_ubuf_mem_alloc(logger, umem_mgr, UBUF_POOL_DEPTH,
UBUF_POOL_DEPTH);
assert(logger != NULL);
/* file source */
struct uprobe uprobe_fsrc;
uprobe_init(&uprobe_fsrc, catch_fsrc, uprobe_use(logger));
struct upipe_mgr *upipe_fsrc_mgr = upipe_fsrc_mgr_alloc();
assert(upipe_fsrc_mgr != NULL);
struct upipe *upipe_fsrc = upipe_void_alloc(upipe_fsrc_mgr,
uprobe_pfx_alloc(uprobe_use(&uprobe_fsrc),
UPROBE_LOG_DEBUG, "file source"));
assert(upipe_fsrc != NULL);
upipe_mgr_release(upipe_fsrc_mgr);
ubase_assert(upipe_set_uri(upipe_fsrc, files[current]));
/* m3u reader */
struct upipe_mgr *upipe_m3u_reader_mgr = upipe_m3u_reader_mgr_alloc();
assert(upipe_m3u_reader_mgr != NULL);
struct upipe *upipe_m3u_reader = upipe_void_alloc_output(
upipe_fsrc, upipe_m3u_reader_mgr,
uprobe_pfx_alloc(uprobe_use(logger),
UPROBE_LOG_VERBOSE, "m3u reader"));
upipe_mgr_release(upipe_m3u_reader_mgr);
assert(upipe_m3u_reader != NULL);
struct uprobe uprobe_uref;
uprobe_init(&uprobe_uref, catch_uref, uprobe_use(logger));
struct upipe_mgr *upipe_probe_uref_mgr = upipe_probe_uref_mgr_alloc();
assert(upipe_probe_uref_mgr != NULL);
struct upipe *upipe_probe_uref = upipe_void_chain_output(
upipe_m3u_reader, upipe_probe_uref_mgr,
uprobe_pfx_alloc(uprobe_use(&uprobe_uref),
UPROBE_LOG_DEBUG, "probe uref"));
upipe_mgr_release(upipe_probe_uref_mgr);
assert(upipe_probe_uref != NULL);
/* null output */
struct upipe_mgr *upipe_null_mgr = upipe_null_mgr_alloc();
assert(upipe_null_mgr != NULL);
struct upipe *upipe_null = upipe_void_chain_output(
upipe_probe_uref, upipe_null_mgr,
uprobe_pfx_alloc(uprobe_use(logger),
UPROBE_LOG_DEBUG, "null"));
upipe_mgr_release(upipe_null_mgr);
assert(upipe_null != NULL);
upipe_release(upipe_null);
/* run main loop */
upump_mgr_run(upump_mgr, NULL);
/* release */
upipe_release(upipe_fsrc);
upump_mgr_release(upump_mgr);
uref_mgr_release(uref_mgr);
udict_mgr_release(udict_mgr);
umem_mgr_release(umem_mgr);
uprobe_clean(&uprobe_fsrc);
uprobe_clean(&uprobe_uref);
uprobe_release(logger);
return 0;
}
int main(int argc, char **argv)
{
struct umem_mgr *umem_mgr = umem_alloc_mgr_alloc();
assert(umem_mgr != NULL);
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;
/* packed s16 stereo */
mgr = ubuf_sound_mem_mgr_alloc(UBUF_POOL_DEPTH, UBUF_POOL_DEPTH, umem_mgr,
4, 32);
assert(mgr != NULL);
ubase_assert(ubuf_sound_mem_mgr_add_plane(mgr, "lr"));
ubuf1 = ubuf_sound_alloc(mgr, 32);
assert(ubuf1 != NULL);
ubase_assert(ubuf_sound_size(ubuf1, &size, &sample_size));
assert(size == 32);
assert(sample_size == 4);
channel = NULL;
unsigned int nb_planes = 0;
while (ubase_check(ubuf_sound_plane_iterate(ubuf1, &channel)) &&
channel != NULL) {
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_sound_mem_mgr_alloc(UBUF_POOL_DEPTH, UBUF_POOL_DEPTH, umem_mgr,
sizeof(float), 32);
assert(mgr != NULL);
ubase_assert(ubuf_sound_mem_mgr_add_plane(mgr, "l"));
ubase_assert(ubuf_sound_mem_mgr_add_plane(mgr, "r"));
ubase_assert(ubuf_sound_mem_mgr_add_plane(mgr, "c"));
ubase_assert(ubuf_sound_mem_mgr_add_plane(mgr, "L"));
ubase_assert(ubuf_sound_mem_mgr_add_plane(mgr, "R"));
ubase_assert(ubuf_sound_mem_mgr_add_plane(mgr, "S"));
ubuf1 = ubuf_sound_alloc(mgr, 32);
assert(ubuf1 != NULL);
ubase_assert(ubuf_sound_size(ubuf1, &size, &sample_size));
assert(size == 32);
assert(sample_size == sizeof(float));
channel = NULL;
nb_planes = 0;
while (ubase_check(ubuf_sound_plane_iterate(ubuf1, &channel)) &&
channel != NULL)
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);
/* sound -> block transformation */
mgr = ubuf_sound_mem_mgr_alloc(UBUF_POOL_DEPTH, UBUF_POOL_DEPTH, umem_mgr,
4, 32);
assert(mgr != NULL);
ubase_assert(ubuf_sound_mem_mgr_add_plane(mgr, "lr"));
ubuf1 = ubuf_sound_alloc(mgr, 32);
assert(ubuf1 != NULL);
fill_in(ubuf1);
struct ubuf_mgr *block_mgr = ubuf_block_mem_mgr_alloc(UBUF_POOL_DEPTH,
UBUF_POOL_DEPTH, umem_mgr, 0, 0, 0, 0);
struct ubuf *ubuf_block = ubuf_block_mem_alloc_from_sound(block_mgr,
ubuf1, "lr");
assert(ubuf_block != NULL);
ubase_assert(ubuf_block_size(ubuf_block, &size));
assert(size == 32 * 4);
int size2 = -1;
ubase_assert(ubuf_block_read(ubuf_block, 0, &size2, &r));
assert(size2 == 32 * 4);
assert(r[0] == 'l');
ubuf_free(ubuf_block);
ubuf_mgr_release(block_mgr);
ubuf_free(ubuf1);
ubuf_mgr_release(mgr);
umem_mgr_release(umem_mgr);
return 0;
}
