/** @internal @This catches events of the dec queue source.
*
* @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_dec_qsrc(struct uprobe *uprobe,
struct upipe *upipe,
int event, va_list args)
{
switch (event) {
case UPROBE_SOURCE_END: {
struct upipe_glxplayer *glxplayer =
container_of(uprobe, struct upipe_glxplayer, uprobe_dec_qsrc_s);
upipe_flush(glxplayer->upipe_glx_qsink);
upipe_release(glxplayer->upipe_glx_qsink);
return UBASE_ERR_NONE;
}
case UPROBE_NEED_OUTPUT: {
struct upipe_glxplayer *glxplayer =
container_of(uprobe, struct upipe_glxplayer, uprobe_dec_qsrc_s);
struct upipe *avcdec = upipe_void_alloc_output(upipe,
glxplayer->upipe_avcdec_mgr,
uprobe_pfx_alloc_va(
uprobe_use(&glxplayer->uprobe_avcdec_s),
glxplayer->loglevel, "avcdec"));
if (unlikely(avcdec == NULL))
return UBASE_ERR_ALLOC;
upipe_set_option(avcdec, "threads", "2");
upipe_release(avcdec);
return UBASE_ERR_NONE;
}
default:
return uprobe_throw_next(uprobe, upipe, event, args);
}
}
/** @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_fdec_set_flow_def(struct upipe *upipe, struct uref *flow_def)
{
struct upipe_fdec_mgr *fdec_mgr = upipe_fdec_mgr_from_upipe_mgr(upipe->mgr);
struct upipe_fdec *upipe_fdec = upipe_fdec_from_upipe(upipe);
if (flow_def == NULL)
return UBASE_ERR_INVALID;
if (upipe_fdec->last_inner != NULL) {
if (ubase_check(upipe_set_flow_def(upipe_fdec->last_inner, flow_def)))
return UBASE_ERR_NONE;
}
upipe_fdec_store_bin_input(upipe, NULL);
upipe_fdec_store_bin_output(upipe, NULL);
struct upipe *avcdec = upipe_void_alloc(fdec_mgr->avcdec_mgr,
uprobe_pfx_alloc(
uprobe_use(&upipe_fdec->last_inner_probe),
UPROBE_LOG_VERBOSE, "avcdec"));
if (unlikely(avcdec == NULL)) {
upipe_err_va(upipe, "couldn't allocate avcdec");
return UBASE_ERR_UNHANDLED;
}
if (unlikely(!ubase_check(upipe_set_flow_def(avcdec, flow_def)))) {
upipe_err_va(upipe, "couldn't set avcdec flow def");
upipe_release(avcdec);
return UBASE_ERR_UNHANDLED;
}
if (upipe_fdec->options != NULL && upipe_fdec->options->udict != NULL) {
const char *key = NULL;
enum udict_type type = UDICT_TYPE_END;
while (ubase_check(udict_iterate(upipe_fdec->options->udict, &key,
&type)) && type != UDICT_TYPE_END) {
const char *value;
if (key == NULL ||
!ubase_check(udict_get_string(upipe_fdec->options->udict,
&value, type, key)))
continue;
if (!ubase_check(upipe_set_option(avcdec, key, value)))
upipe_warn_va(upipe, "option %s=%s invalid", key, value);
}
}
upipe_fdec_store_bin_input(upipe, upipe_use(avcdec));
upipe_fdec_store_bin_output(upipe, avcdec);
return UBASE_ERR_NONE;
}
/** @internal @This sets the value of an option.
*
* @param upipe description structure of the pipe
* @param key name of the option
* @param value of the option, or NULL to delete it
* @return an error code
*/
static int upipe_fdec_set_option(struct upipe *upipe,
const char *key, const char *value)
{
struct upipe_fdec *upipe_fdec = upipe_fdec_from_upipe(upipe);
assert(key != NULL);
if (upipe_fdec->options == NULL)
return UBASE_ERR_ALLOC;
if (upipe_fdec->last_inner != NULL) {
UBASE_RETURN(upipe_set_option(upipe_fdec->last_inner, key, value))
}
if (value != NULL)
return udict_set_string(upipe_fdec->options->udict, value,
UDICT_TYPE_STRING, key);
else
udict_delete(upipe_fdec->options->udict, UDICT_TYPE_STRING, key);
return UBASE_ERR_NONE;
}
/** avcdec callback */
static int avcdec_catch(struct uprobe *uprobe, struct upipe *upipe,
int event, va_list args)
{
if (event != UPROBE_NEED_OUTPUT)
return uprobe_throw_next(uprobe, upipe, event, args);
struct uref *flow_def = va_arg(args, struct uref *);
uint64_t hsize, vsize, wanted_hsize;
struct urational sar;
bool progressive;
if (unlikely(!ubase_check(uref_pic_flow_get_hsize(flow_def, &hsize)) ||
!ubase_check(uref_pic_flow_get_vsize(flow_def, &vsize)) ||
!ubase_check(uref_pic_flow_get_sar(flow_def, &sar)))) {
upipe_err_va(upipe, "incompatible flow def");
upipe_release(upipe_source);
return UBASE_ERR_UNHANDLED;
}
wanted_hsize = (hsize * sar.num / sar.den / 2) * 2;
progressive = ubase_check(uref_pic_get_progressive(flow_def));
struct uref *flow_def2 = uref_dup(flow_def);
upipe_use(upipe);
if (!progressive) {
uref_pic_set_progressive(flow_def2);
struct upipe *deint = upipe_void_alloc_output(upipe,
upipe_filter_blend_mgr,
uprobe_pfx_alloc(uprobe_use(logger),
loglevel, "deint"));
assert(deint != NULL);
upipe_release(upipe);
upipe = deint;
}
if (wanted_hsize != hsize) {
uref_pic_flow_set_hsize(flow_def2, wanted_hsize);
struct upipe *sws = upipe_flow_alloc_output(upipe, upipe_sws_mgr,
uprobe_pfx_alloc_va(uprobe_use(logger),
loglevel, "sws"), flow_def2);
assert(sws != NULL);
upipe_release(upipe);
upipe = sws;
}
uref_pic_flow_clear_format(flow_def2);
uref_flow_set_def(flow_def2, "block.mjpeg.pic.");
struct upipe *jpegenc = upipe_flow_alloc_output(upipe, upipe_avcenc_mgr,
uprobe_pfx_alloc_va(uprobe_use(logger),
loglevel, "jpeg"), flow_def2);
assert(jpegenc != NULL);
upipe_release(upipe);
upipe_set_option(jpegenc, "qmax", "2");
upipe = jpegenc;
struct upipe *urefprobe = upipe_void_alloc_output(upipe,
upipe_probe_uref_mgr,
uprobe_pfx_alloc_va(uprobe_use(&uprobe_uref),
loglevel, "urefprobe"));
assert(urefprobe != NULL);
upipe_release(upipe);
upipe = urefprobe;
struct upipe *fsink = upipe_void_alloc_output(upipe, upipe_fsink_mgr,
uprobe_pfx_alloc_va(uprobe_use(logger),
((loglevel > UPROBE_LOG_DEBUG) ? UPROBE_LOG_WARNING : loglevel),
"jpegsink"));
assert(fsink != NULL);
upipe_release(upipe);
upipe_fsink_set_path(fsink, dstpath, UPIPE_FSINK_OVERWRITE);
upipe = fsink;
uref_free(flow_def2);
upipe_release(upipe);
return UBASE_ERR_NONE;
}
