/** @internal @This sets the input flow definition.
*
* @param upipe description structure of the pipe
* @param flow_def flow definition packet
* @return an error code
*/
static int upipe_a52f_set_flow_def(struct upipe *upipe, struct uref *flow_def)
{
if (flow_def == NULL)
return UBASE_ERR_INVALID;
const char *def;
if (unlikely(!ubase_check(uref_flow_get_def(flow_def, &def)) ||
(ubase_ncmp(def, "block.ac3.") &&
ubase_ncmp(def, "block.eac3.") &&
strcmp(def, "block."))))
return UBASE_ERR_INVALID;
struct uref *flow_def_dup;
if (unlikely((flow_def_dup = uref_dup(flow_def)) == NULL)) {
upipe_throw_fatal(upipe, UBASE_ERR_ALLOC);
return UBASE_ERR_ALLOC;
}
struct upipe_a52f *upipe_a52f = upipe_a52f_from_upipe(upipe);
upipe_a52f->input_latency = 0;
uref_clock_get_latency(flow_def, &upipe_a52f->input_latency);
if (unlikely(upipe_a52f->samplerate &&
!ubase_check(uref_clock_set_latency(flow_def_dup,
upipe_a52f->input_latency +
UCLOCK_FREQ * A52_FRAME_SAMPLES /
upipe_a52f->samplerate))))
upipe_throw_fatal(upipe, UBASE_ERR_ALLOC);
flow_def = upipe_a52f_store_flow_def_input(upipe, flow_def_dup);
if (flow_def != NULL)
upipe_a52f_store_flow_def(upipe, flow_def);
return UBASE_ERR_NONE;
}
/** @internal @This sets the input flow definition.
*
* @param upipe description structure of the pipe
* @param flow_def flow definition packet
* @return an error code
*/
static int upipe_s337_encaps_set_flow_def(struct upipe *upipe,
struct uref *flow_def)
{
if (flow_def == NULL)
return UBASE_ERR_INVALID;
const char *def;
UBASE_RETURN(uref_flow_get_def(flow_def, &def))
uint64_t rate;
UBASE_RETURN(uref_sound_flow_get_rate(flow_def, &rate))
if (ubase_ncmp(def, EXPECTED_FLOW_DEF))
return UBASE_ERR_INVALID;
struct uref *flow_def_dup = uref_dup(flow_def);
if (flow_def_dup == NULL)
return UBASE_ERR_ALLOC;
uref_flow_set_def(flow_def_dup, "sound.s32.s337.a52.");
uref_sound_flow_set_channels(flow_def_dup, 2);
uref_sound_flow_set_sample_size(flow_def_dup, 2*4);
if (!ubase_check(uref_sound_flow_add_plane(flow_def_dup, "lr")) ||
!ubase_check(uref_sound_flow_set_rate(flow_def_dup, rate))) {
uref_free(flow_def_dup);
return UBASE_ERR_ALLOC;
}
upipe_s337_encaps_require_ubuf_mgr(upipe, flow_def_dup);
return UBASE_ERR_NONE;
}
/** @internal @This sets the input flow definition.
*
* @param upipe description structure of the pipe
* @param flow flow definition packet
* @return an error code
*/
static int upipe_filter_ebur128_set_flow_def(struct upipe *upipe,
struct uref *flow)
{
struct upipe_filter_ebur128 *upipe_filter_ebur128 =
upipe_filter_ebur128_from_upipe(upipe);
if (flow == NULL)
return UBASE_ERR_INVALID;
UBASE_RETURN(uref_flow_match_def(flow, "sound.s16."))
uint8_t channels, planes;
uint64_t rate;
if (unlikely(!ubase_check(uref_sound_flow_get_rate(flow, &rate))
|| !ubase_check(uref_sound_flow_get_channels(flow, &channels))
|| !ubase_check(uref_sound_flow_get_planes(flow, &planes))
|| planes != 1)) {
return UBASE_ERR_INVALID;
}
struct uref *flow_dup;
if (unlikely((flow_dup = uref_dup(flow)) == NULL)) {
upipe_throw_fatal(upipe, UBASE_ERR_ALLOC);
return UBASE_ERR_ALLOC;
}
if (unlikely(upipe_filter_ebur128->st)) {
//ebur128_destroy(&upipe_filter_ebur128->st);
ebur128_change_parameters(upipe_filter_ebur128->st, channels, rate);
} else {
upipe_filter_ebur128->st = ebur128_init(channels, rate,
EBUR128_MODE_LRA | EBUR128_MODE_I | EBUR128_MODE_HISTOGRAM);
}
upipe_filter_ebur128_store_flow_def(upipe, flow_dup);
return UBASE_ERR_NONE;
}
/** @internal @This sets the input flow definition.
*
* @param upipe description structure of the pipe
* @param flow_def flow definition packet
* @return an error code
*/
static int upipe_s337d_set_flow_def(struct upipe *upipe, struct uref *flow_def)
{
if (flow_def == NULL)
return UBASE_ERR_INVALID;
const char *def;
uint64_t rate;
if (unlikely(!ubase_check(uref_flow_get_def(flow_def, &def)) ||
(ubase_ncmp(def, "block.s337.") &&
strcmp(def, "block.")) ||
!ubase_check(uref_sound_flow_get_rate(flow_def, &rate))))
return UBASE_ERR_INVALID;
struct uref *flow_def_dup;
if (unlikely((flow_def_dup = uref_dup(flow_def)) == NULL)) {
upipe_throw_fatal(upipe, UBASE_ERR_ALLOC);
return UBASE_ERR_ALLOC;
}
struct upipe_s337d *upipe_s337d = upipe_s337d_from_upipe(upipe);
upipe_s337d->sample_rate = rate;
flow_def = upipe_s337d_store_flow_def_input(upipe, flow_def_dup);
if (flow_def != NULL)
upipe_s337d_store_flow_def(upipe, flow_def);
return UBASE_ERR_NONE;
}
/** @internal @This sets the input flow definition.
*
* @param upipe description structure of the pipe
* @param flow_def flow definition packet
* @return an error code
*/
static int upipe_agg_set_flow_def(struct upipe *upipe, struct uref *flow_def)
{
if (flow_def == NULL)
return UBASE_ERR_INVALID;
UBASE_RETURN(uref_flow_match_def(flow_def, EXPECTED_FLOW_DEF))
struct upipe_agg *upipe_agg = upipe_agg_from_upipe(upipe);
uint64_t size = 0;
uref_block_flow_get_size(flow_def, &size);
upipe_agg->input_size = size;
uint64_t octetrate = 0;
uref_block_flow_get_octetrate(flow_def, &octetrate);
uint64_t latency = 0;
uref_clock_get_latency(flow_def, &latency);
struct uref *flow_def_dup;
if ((flow_def_dup = uref_dup(flow_def)) == NULL)
return UBASE_ERR_ALLOC;
UBASE_RETURN(uref_block_flow_set_size(flow_def_dup, upipe_agg->output_size))
if (octetrate) {
UBASE_RETURN(uref_clock_set_latency(flow_def_dup, latency +
(uint64_t)upipe_agg->output_size * UCLOCK_FREQ / octetrate))
}
upipe_agg_store_flow_def(upipe, flow_def_dup);
return UBASE_ERR_NONE;
}
/** @internal @This parses and outputs a m3u file.
*
* @param upipe description structure of the pipe
* @return an error code
*/
static void upipe_m3u_reader_process(struct upipe *upipe)
{
struct upipe_m3u_reader *upipe_m3u_reader =
upipe_m3u_reader_from_upipe(upipe);
if (unlikely(upipe_m3u_reader->current_flow_def == NULL)) {
upipe_m3u_reader->current_flow_def =
uref_dup(upipe_m3u_reader->flow_def);
if (unlikely(upipe_m3u_reader->current_flow_def == NULL)) {
upipe_throw_fatal(upipe, UBASE_ERR_ALLOC);
return;
}
}
/* parse m3u */
int ret = UBASE_ERR_NONE;
struct uref *uref = upipe_m3u_reader->next_uref;
for (size_t offset = 0;
uref &&
ubase_check(ret) &&
ubase_check(uref_block_scan(uref, &offset, '\n'));
offset = 0, uref = upipe_m3u_reader->next_uref) {
struct uref *line =
upipe_m3u_reader_extract_uref_stream(upipe, offset + 1);
ret = upipe_m3u_reader_process_line(
upipe, upipe_m3u_reader->current_flow_def, line);
uref_free(line);
}
if (!ubase_check(ret))
upipe_err(upipe, "invalid m3u");
}
/** @internal @This sets the input flow definition.
*
* @param upipe description structure of the pipe
* @param flow_def flow definition packet
* @return an error code
*/
static int upipe_idem_set_flow_def(struct upipe *upipe, struct uref *flow_def)
{
if (flow_def == NULL)
return UBASE_ERR_INVALID;
struct uref *flow_def_dup;
if (unlikely((flow_def_dup = uref_dup(flow_def)) == NULL))
return UBASE_ERR_ALLOC;
upipe_idem_store_flow_def(upipe, flow_def_dup);
return UBASE_ERR_NONE;
}
/** @internal @This sets the input flow definition.
*
* @param upipe description structure of the pipe
* @param flow_def flow definition packet
* @return an error code
*/
static int upipe_fsink_set_flow_def(struct upipe *upipe, struct uref *flow_def)
{
if (flow_def == NULL)
return UBASE_ERR_INVALID;
UBASE_RETURN(uref_flow_match_def(flow_def, UPIPE_FSINK_EXPECTED_FLOW_DEF))
flow_def = uref_dup(flow_def);
UBASE_ALLOC_RETURN(flow_def)
upipe_input(upipe, flow_def, NULL);
return UBASE_ERR_NONE;
}
/** @internal @This sets the input flow definition.
*
* @param upipe description structure of the pipe
* @param flow_def flow definition packet
* @return an error code
*/
static int upipe_dveo_asi_sink_set_flow_def(struct upipe *upipe, struct uref *flow_def)
{
if (flow_def == NULL)
return UBASE_ERR_INVALID;
UBASE_RETURN(uref_flow_match_def(flow_def, "block.mpegts."))
flow_def = uref_dup(flow_def);
UBASE_ALLOC_RETURN(flow_def)
upipe_input(upipe, flow_def, NULL);
return UBASE_ERR_NONE;
}
/** @internal @This sets the input flow definition.
*
* @param upipe description structure of the pipe
* @param flow_def flow definition packet
* @return an error code
*/
static int upipe_block_to_sound_set_flow_def(struct upipe *upipe,
struct uref *flow_def)
{
struct upipe_block_to_sound *upipe_block_to_sound = upipe_block_to_sound_from_upipe(upipe);
if (flow_def == NULL)
return UBASE_ERR_INVALID;
if (unlikely(!ubase_check(uref_flow_match_def(flow_def, "block.")))) {
uref_free(flow_def);
return UBASE_ERR_INVALID;
}
flow_def = uref_dup(upipe_block_to_sound->flow_def_config);
if (unlikely(flow_def == NULL)) {
upipe_throw_fatal(upipe, UBASE_ERR_ALLOC);
return UBASE_ERR_ALLOC;
}
if(unlikely(!ubase_check(uref_flow_match_def(flow_def, "sound.s32.")))) {
uref_free(flow_def);
return UBASE_ERR_INVALID;
}
uint8_t channels, planes, 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)))) {
uref_free(flow_def);
return UBASE_ERR_INVALID;
}
struct uref *flow_def_dup;
if (unlikely((flow_def_dup = uref_dup(flow_def)) == NULL)) {
upipe_throw_fatal(upipe, UBASE_ERR_ALLOC);
return UBASE_ERR_ALLOC;
}
upipe_block_to_sound_store_flow_def(upipe, flow_def_dup);
upipe_block_to_sound_require_ubuf_mgr(upipe, flow_def);
return UBASE_ERR_NONE;
}
/** @internal @This sets the output flow format.
*
* @param upipe description structure of the pipe
* @param flow_def new flow format to set
* @return an error code
*/
static int upipe_dvbcsa_enc_set_flow_def(struct upipe *upipe,
struct uref *flow_def)
{
struct upipe_dvbcsa_enc *upipe_dvbcsa_enc =
upipe_dvbcsa_enc_from_upipe(upipe);
UBASE_RETURN(uref_flow_match_def(flow_def, EXPECTED_FLOW_DEF));
struct uref *flow_def_dup = uref_dup(flow_def);
UBASE_ALLOC_RETURN(flow_def_dup);
upipe_dvbcsa_enc_store_flow_def(upipe, flow_def_dup);
return UBASE_ERR_NONE;
}
/** @internal @This sets the input flow definition.
*
* @param upipe description structure of the pipe
* @param flow_def flow definition packet
* @return an error code
*/
static int upipe_htons_set_flow_def(struct upipe *upipe, struct uref *flow_def)
{
if (flow_def == NULL)
return UBASE_ERR_INVALID;
UBASE_RETURN(uref_flow_match_def(flow_def, EXPECTED_FLOW_DEF))
struct uref *flow_def_dup;
if ((flow_def_dup = uref_dup(flow_def)) == NULL)
return UBASE_ERR_ALLOC;
upipe_htons_store_flow_def(upipe, flow_def_dup);
return UBASE_ERR_NONE;
}
/** @internal @This handles inner reader pipe events.
*
* @param uprobe structure used to raise events
* @param inner pointer to inner pipe
* @param event event thrown
* @param args optional arguments
* @return an error code
*/
static int probe_reader(struct uprobe *uprobe, struct upipe *inner,
int event, va_list args)
{
struct upipe_hls *upipe_hls = upipe_hls_from_probe_reader(uprobe);
struct upipe *upipe = upipe_hls_to_upipe(upipe_hls);
if (event >= UPROBE_LOCAL)
return UBASE_ERR_NONE;
if (event == UPROBE_NEED_OUTPUT) {
struct uref *flow_format = va_arg(args, struct uref *);
const char *def;
UBASE_RETURN(uref_flow_get_def(flow_format, &def));
struct uref *flow_format_dup = uref_dup(flow_format);
if (unlikely(!flow_format_dup)) {
upipe_throw_fatal(upipe, UBASE_ERR_ALLOC);
return UBASE_ERR_ALLOC;
}
upipe_hls_store_flow_def(upipe, flow_format_dup);
if (!strcmp(def, "block.m3u.playlist.")) {
struct upipe_mgr *upipe_null_mgr = upipe_null_mgr_alloc();
struct upipe *output = upipe_void_alloc_output(
inner, upipe_null_mgr,
uprobe_pfx_alloc(uprobe_use(&upipe_hls->probe_null),
UPROBE_LOG_VERBOSE, "null"));
upipe_mgr_release(upipe_null_mgr);
upipe_release(output);
upipe_split_throw_update(upipe);
return UBASE_ERR_NONE;
}
else if (!strcmp(def, "block.m3u.master.")) {
struct upipe_mgr *upipe_hls_master_mgr =
upipe_hls_master_mgr_alloc();
UBASE_ALLOC_RETURN(upipe_hls_master_mgr);
struct upipe *output = upipe_void_alloc_output(
inner, upipe_hls_master_mgr,
uprobe_pfx_alloc(uprobe_use(&upipe_hls->probe_master),
UPROBE_LOG_VERBOSE, "master"));
upipe_mgr_release(upipe_hls_master_mgr);
UBASE_ALLOC_RETURN(output);
upipe_hls_store_bin_output(upipe, output);
return UBASE_ERR_NONE;
}
else
upipe_warn_va(upipe, "unsupported flow format %s", def);
return UBASE_ERR_INVALID;
}
return upipe_throw_proxy(upipe, inner, event, args);
}
/** @internal @This catches events of the avcdec.
*
* @param uprobe pointer to probe
* @param upipe pointer to pipe throwing the event
* @param event event thrown
* @param args optional event-specific parameters
* @return an error code
*/
static int upipe_glxplayer_catch_avcdec(struct uprobe *uprobe,
struct upipe *upipe,
int event, va_list args)
{
switch (event) {
case UPROBE_NEED_OUTPUT: {
struct upipe_glxplayer *glxplayer =
container_of(uprobe, struct upipe_glxplayer, uprobe_avcdec_s);
struct uref *flow_def = va_arg(args, struct uref *);
struct upipe *deint =
upipe_void_alloc_output(upipe,
glxplayer->upipe_filter_blend_mgr,
uprobe_pfx_alloc(uprobe_use(glxplayer->uprobe_logger),
glxplayer->loglevel, "deint"));
if (unlikely(deint == NULL))
return UBASE_ERR_ALLOC;
struct uref *output_flow = uref_dup(flow_def);
if (unlikely(output_flow == NULL))
return UBASE_ERR_ALLOC;
uref_pic_flow_clear_format(output_flow);
if (unlikely(!ubase_check(uref_pic_flow_set_macropixel(output_flow, 1)) ||
!ubase_check(uref_pic_flow_set_planes(output_flow, 0)) ||
!ubase_check(uref_pic_flow_add_plane(output_flow, 1, 1, 3,
"r8g8b8")))) {
uref_free(output_flow);
return UBASE_ERR_ALLOC;
}
struct upipe *yuvrgb = upipe_flow_alloc_output(deint,
glxplayer->upipe_sws_mgr,
uprobe_pfx_alloc_va(uprobe_use(glxplayer->uprobe_logger),
glxplayer->loglevel, "rgb"),
output_flow);
assert(yuvrgb != NULL);
uref_free(output_flow);
upipe_release(deint);
glxplayer->upipe_glx_qsink =
upipe_qsink_alloc(glxplayer->upipe_qsink_mgr,
uprobe_pfx_alloc(uprobe_use(glxplayer->uprobe_logger),
glxplayer->loglevel, "glx qsink"),
glxplayer->upipe_glx_qsrc);
if (unlikely(glxplayer->upipe_glx_qsink == NULL))
return UBASE_ERR_ALLOC;
upipe_set_output(yuvrgb, glxplayer->upipe_glx_qsink);
upipe_release(yuvrgb);
return UBASE_ERR_NONE;
}
default:
return uprobe_throw_next(uprobe, upipe, event, args);
}
}
static int upipe_dump_set_flow_def(struct upipe *upipe, struct uref *flow_def)
{
int ret = uref_flow_match_def(flow_def, "block.");
if (!ubase_check(ret))
return ret;
struct uref *flow_def_dup = uref_dup(flow_def);
if (unlikely(flow_def_dup == NULL))
return UBASE_ERR_ALLOC;
upipe_dump_store_flow_def(upipe, flow_def_dup);
return UBASE_ERR_NONE;
}
/** @internal @This provides a flow format suggestion.
*
* @param upipe description structure of the pipe
* @param request description structure of the request
* @return an error code
*/
static int upipe_filter_ebur128_provide_flow_format(struct upipe *upipe,
struct urequest *request)
{
const char *def;
UBASE_RETURN(uref_flow_get_def(request->uref, &def))
struct uref *flow = uref_dup(request->uref);
UBASE_ALLOC_RETURN(flow);
if (!ubase_ncmp(def, "sound.u8."))
UBASE_FATAL(upipe, uref_flow_set_def(flow, "sound.s16."));
return urequest_provide_flow_format(request, flow);
}
/** @internal @This sets the input flow definition.
*
* @param upipe description structure of the pipe
* @param flow_def flow definition packet
* @return an error code
*/
static int upipe_rtpd_set_flow_def(struct upipe *upipe, struct uref *flow_def)
{
if (flow_def == NULL)
return UBASE_ERR_INVALID;
UBASE_RETURN(uref_flow_match_def(flow_def, EXPECTED_FLOW_DEF))
struct uref *flow_def_dup;
if (unlikely((flow_def_dup = uref_dup(flow_def)) == NULL))
return UBASE_ERR_ALLOC;
struct upipe_rtpd *upipe_rtpd = upipe_rtpd_from_upipe(upipe);
uref_free(upipe_rtpd->flow_def_input);
upipe_rtpd->flow_def_input = flow_def_dup;
return UBASE_ERR_NONE;
}
/** @internal @This sets the input flow definition.
*
* @param upipe description structure of the pipe
* @param flow_def flow definition packet
* @return an error code
*/
static int upipe_ts_psim_set_flow_def(struct upipe *upipe,
struct uref *flow_def)
{
if (flow_def == NULL)
return UBASE_ERR_INVALID;
UBASE_RETURN(uref_flow_match_def(flow_def, EXPECTED_FLOW_DEF))
struct uref *flow_def_dup;
if (unlikely((flow_def_dup = uref_dup(flow_def)) == NULL)) {
upipe_throw_fatal(upipe, UBASE_ERR_ALLOC);
return UBASE_ERR_ALLOC;
}
upipe_ts_psim_store_flow_def(upipe, flow_def_dup);
return UBASE_ERR_NONE;
}
/** @internal @This sets the input flow definition.
*
* @param upipe description structure of the pipe
* @param flow_def flow definition packet
* @return an error code
*/
static int upipe_burst_set_flow_def(struct upipe *upipe, struct uref *flow_def)
{
if (unlikely(!ubase_check(uref_flow_match_def(flow_def, "block."))))
return UBASE_ERR_INVALID;
struct uref *flow_def_dup = uref_dup(flow_def);
if (unlikely(flow_def_dup == NULL)) {
upipe_throw_fatal(upipe, UBASE_ERR_ALLOC);
return UBASE_ERR_ALLOC;
}
upipe_burst_store_flow_def(upipe, flow_def_dup);
return UBASE_ERR_NONE;
}
/** @internal @This provides a flow format suggestion.
*
* @param upipe description structure of the pipe
* @param request description structure of the request
* @return an error code
*/
static int upipe_nacl_audio_provide_flow_format(struct upipe *upipe,
struct urequest *request)
{
struct uref *flow_format = uref_dup(request->uref);
UBASE_ALLOC_RETURN(flow_format);
uref_sound_flow_clear_format(flow_format);
uref_flow_set_def(flow_format, EXPECTED_FLOW_DEF);
uref_sound_flow_set_channels(flow_format, 2);
uref_sound_flow_set_sample_size(flow_format, 4);
uref_sound_flow_set_planes(flow_format, 0);
uref_sound_flow_add_plane(flow_format, "lr");
uref_sound_flow_set_rate(flow_format, SAMPLE_RATE);
return urequest_provide_flow_format(request, flow_format);
}
/** @internal @This sets the input flow definition.
*
* @param upipe description structure of the pipe
* @param flow flow definition packet
* @return an error code
*/
static int upipe_filter_ebur128_set_flow_def(struct upipe *upipe,
struct uref *flow)
{
struct upipe_filter_ebur128 *upipe_filter_ebur128 =
upipe_filter_ebur128_from_upipe(upipe);
if (flow == NULL)
return UBASE_ERR_INVALID;
enum upipe_filter_ebur128_fmt fmt;
const char *def;
UBASE_RETURN(uref_flow_get_def(flow, &def))
if (!ubase_ncmp(def, "sound.s16."))
fmt = UPIPE_FILTER_EBUR128_SHORT;
else if (!ubase_ncmp(def, "sound.s32."))
fmt = UPIPE_FILTER_EBUR128_INT;
else if (!ubase_ncmp(def, "sound.f32."))
fmt = UPIPE_FILTER_EBUR128_FLOAT;
else if (!ubase_ncmp(def, "sound.f64."))
fmt = UPIPE_FILTER_EBUR128_DOUBLE;
else
return UBASE_ERR_INVALID;
uint64_t rate;
if (unlikely(!ubase_check(uref_sound_flow_get_rate(flow, &rate))
|| !ubase_check(uref_sound_flow_get_channels(flow,
&upipe_filter_ebur128->channels))
|| !ubase_check(uref_sound_flow_get_planes(flow,
&upipe_filter_ebur128->planes))))
return UBASE_ERR_INVALID;
struct uref *flow_dup;
if (unlikely((flow_dup = uref_dup(flow)) == NULL)) {
upipe_throw_fatal(upipe, UBASE_ERR_ALLOC);
return UBASE_ERR_ALLOC;
}
upipe_filter_ebur128->fmt = fmt;
if (unlikely(upipe_filter_ebur128->st)) {
//ebur128_destroy(&upipe_filter_ebur128->st);
ebur128_change_parameters(upipe_filter_ebur128->st,
upipe_filter_ebur128->channels, rate);
} else {
upipe_filter_ebur128->st =
ebur128_init(upipe_filter_ebur128->channels, rate,
EBUR128_MODE_LRA | EBUR128_MODE_I | EBUR128_MODE_HISTOGRAM);
}
upipe_filter_ebur128_store_flow_def(upipe, flow_dup);
return UBASE_ERR_NONE;
}
/** @internal @This sets the input flow definition.
*
* @param upipe description structure of the pipe
* @param flow_def flow definition packet
* @return an error code
*/
static int upipe_filter_blend_set_flow_def(struct upipe *upipe,
struct uref *flow_def)
{
if (flow_def == NULL)
return UBASE_ERR_INVALID;
UBASE_RETURN(uref_flow_match_def(flow_def, "pic."))
struct uref *flow_def_dup;
if (unlikely((flow_def_dup = uref_dup(flow_def)) == NULL)) {
upipe_throw_fatal(upipe, UBASE_ERR_ALLOC);
return UBASE_ERR_ALLOC;
}
UBASE_RETURN(uref_pic_set_progressive(flow_def_dup))
upipe_input(upipe, flow_def_dup, NULL);
return UBASE_ERR_NONE;
}
static int upipe_rtcp_set_flow_def(struct upipe *upipe,
struct uref *flow_def)
{
if (flow_def == NULL)
return UBASE_ERR_INVALID;
struct uref *flow_def_dup = uref_dup(flow_def);
if (unlikely(flow_def_dup == NULL)) {
upipe_throw_fatal(upipe, UBASE_ERR_ALLOC);
return UBASE_ERR_ALLOC;
}
upipe_rtcp_store_flow_def(upipe, flow_def_dup);
return UBASE_ERR_NONE;
}
static int upipe_rtp_h264_set_flow_def(struct upipe *upipe,
struct uref *flow_def)
{
if (flow_def == NULL)
return UBASE_ERR_INVALID;
UBASE_RETURN(uref_flow_match_def(flow_def, "block.h264."))
struct uref *flow_def_dup = uref_dup(flow_def);
if (unlikely(flow_def_dup == NULL)) {
upipe_throw_fatal(upipe, UBASE_ERR_ALLOC);
return UBASE_ERR_ALLOC;
}
upipe_rtp_h264_store_flow_def(upipe, flow_def_dup);
return UBASE_ERR_NONE;
}
/** @internal @This sets the input flow definition.
*
* @param upipe description structure of the pipe
* @param flow_def flow definition packet
* @return an error code
*/
static int upipe_audiobar_set_flow_def(struct upipe *upipe,
struct uref *flow_def)
{
if (flow_def == NULL)
return UBASE_ERR_INVALID;
uref_dump(flow_def, upipe->uprobe);
UBASE_RETURN(uref_flow_match_def(flow_def, INPUT_FLOW_DEF))
uint8_t channels;
UBASE_RETURN(uref_sound_flow_get_channels(flow_def, &channels))
struct uref *flow_def_dup;
if (unlikely((flow_def_dup = uref_dup(flow_def)) == NULL))
return UBASE_ERR_ALLOC;
upipe_input(upipe, flow_def_dup, NULL);
return UBASE_ERR_NONE;
}
/** @internal @This sets the input flow definition.
*
* @param upipe description structure of the pipe
* @param flow_def flow definition packet
* @return an error code
*/
static int upipe_tblk_set_flow_def(struct upipe *upipe, struct uref *flow_def)
{
if (flow_def == NULL)
return UBASE_ERR_INVALID;
const char *def;
if (unlikely(!ubase_check(uref_flow_get_def(flow_def, &def)) ||
(ubase_ncmp(def, "block.") && ubase_ncmp(def, "pic.") &&
ubase_ncmp(def, "sound."))))
return UBASE_ERR_INVALID;
struct uref *flow_def_dup;
if ((flow_def_dup = uref_dup(flow_def)) == NULL)
return UBASE_ERR_ALLOC;
upipe_input(upipe, flow_def_dup, NULL);
return UBASE_ERR_NONE;
}
/** @internal @This sets the input flow definition.
*
* @param upipe description structure of the pipe
* @param flow_def flow definition packet
* @return an error code
*/
static int upipe_setflowdef_set_flow_def(struct upipe *upipe,
struct uref *flow_def)
{
if (flow_def == NULL)
return UBASE_ERR_INVALID;
struct uref *flow_def_dup;
if ((flow_def_dup = uref_dup(flow_def)) == NULL)
return UBASE_ERR_ALLOC;
struct upipe_setflowdef *upipe_setflowdef =
upipe_setflowdef_from_upipe(upipe);
uref_free(upipe_setflowdef->flow_def_input);
upipe_setflowdef->flow_def_input = flow_def_dup;
upipe_setflowdef_build_flow_def(upipe);
return UBASE_ERR_NONE;
}
/** @This sets the dictionary to set into urefs.
*
* @param upipe description structure of the pipe
* @param dict dictionary to set
* @return an error code
*/
static int _upipe_setflowdef_set_dict(struct upipe *upipe, struct uref *dict)
{
struct upipe_setflowdef *upipe_setflowdef = upipe_setflowdef_from_upipe(upipe);
if (upipe_setflowdef->dict != NULL)
uref_free(upipe_setflowdef->dict);
if (dict != NULL) {
upipe_setflowdef->dict = uref_dup(dict);
if (upipe_setflowdef->dict == NULL) {
upipe_throw_fatal(upipe, UBASE_ERR_ALLOC);
return UBASE_ERR_ALLOC;
}
} else
upipe_setflowdef->dict = NULL;
upipe_setflowdef_build_flow_def(upipe);
return UBASE_ERR_NONE;
}
/** @internal @This checks the ubuf manager.
*
* @param upipe description structure of the pipe
* @param flow_format amended flow format
* @return an error code
*/
static int upipe_vblk_check(struct upipe *upipe, struct uref *flow_format)
{
struct upipe_vblk *upipe_vblk = upipe_vblk_from_upipe(upipe);
if (flow_format)
upipe_vblk_store_flow_def(upipe, flow_format);
if (!upipe_vblk->flow_def)
return UBASE_ERR_NONE;
if (!upipe_vblk->ubuf_mgr) {
upipe_vblk_require_ubuf_mgr(upipe, uref_dup(upipe_vblk->flow_def));
return UBASE_ERR_NONE;
}
return UBASE_ERR_NONE;
}
/** @internal @This sets the input flow definition.
*
* @param upipe description structure of the pipe
* @param flow_def flow definition packet
* @return an error code
*/
static int upipe_ts_pcr_interpolator_set_flow_def(struct upipe *upipe,
struct uref *flow_def)
{
if (flow_def == NULL)
return UBASE_ERR_INVALID;
const char *def;
UBASE_RETURN(uref_flow_get_def(flow_def, &def))
if (ubase_ncmp(def, EXPECTED_FLOW_DEF))
return UBASE_ERR_INVALID;
struct uref *flow_def_dup = uref_dup(flow_def);
if (unlikely(flow_def_dup == NULL)) {
upipe_throw_fatal(upipe, UBASE_ERR_ALLOC);
return UBASE_ERR_ALLOC;
}
upipe_ts_pcr_interpolator_store_flow_def(upipe, flow_def_dup);
return UBASE_ERR_NONE;
}
