/** @This changes the upump_mgr set by this probe.
*
* @param uprobe pointer to probe
* @param upump_mgr new upump manager to provide to pipes
*/
void uprobe_upump_mgr_set(struct uprobe *uprobe, struct upump_mgr *upump_mgr)
{
struct uprobe_upump_mgr *uprobe_upump_mgr =
uprobe_upump_mgr_from_uprobe(uprobe);
upump_mgr_release(uprobe_upump_mgr->upump_mgr);
uprobe_upump_mgr->upump_mgr = upump_mgr_use(upump_mgr);
}
/** @This cleans a uprobe_upump_mgr structure.
*
* @param uprobe_upump_mgr structure to clean
*/
void uprobe_upump_mgr_clean(struct uprobe_upump_mgr *uprobe_upump_mgr)
{
assert(uprobe_upump_mgr != NULL);
struct uprobe *uprobe = uprobe_upump_mgr_to_uprobe(uprobe_upump_mgr);
upump_mgr_release(uprobe_upump_mgr->upump_mgr);
uprobe_clean(uprobe);
}
/** @This frees a upipe.
*
* @param upipe description structure of the pipe
*/
static void upipe_avcdec_free(struct upipe *upipe)
{
struct upipe_avcdec *upipe_avcdec = upipe_avcdec_from_upipe(upipe);
if (upipe_avcdec->context) {
_upipe_avcdec_set_codec(upipe, NULL, NULL, 0);
return; /* _set_codec() calls _use()/_release() */
}
upipe_throw_dead(upipe);
if (upipe_avcdec->frame) {
av_free(upipe_avcdec->frame);
}
if (upipe_avcdec->saved_uref) {
uref_free(upipe_avcdec->saved_uref);
}
if (upipe_avcdec->saved_upump_mgr) {
upump_mgr_sink_unblock(upipe_avcdec->saved_upump_mgr);
upump_mgr_release(upipe_avcdec->saved_upump_mgr);
}
upipe_avcdec_abort_av_deal(upipe);
upipe_avcdec_clean_output(upipe);
upipe_avcdec_clean_ubuf_mgr(upipe);
upipe_avcdec_clean_uref_mgr(upipe);
upipe_avcdec_clean_upump_mgr(upipe);
upipe_clean(upipe);
free(upipe_avcdec);
}
static void *thread(void *unused)
{
struct ev_loop *loop = ev_loop_new(0);
struct upump_mgr *upump_mgr =
upump_ev_mgr_alloc(loop, UPUMP_POOL, UPUMP_BLOCKER_POOL);
assert(upump_mgr != NULL);
struct upipe *upipe;
upipe = upipe_void_alloc(&uprobe_test_mgr, uprobe_use(uprobe));
assert(upump_mgr_get_opaque(upump_mgr, struct upipe *) == NULL);
uprobe_test_free(upipe);
uprobe_pthread_upump_mgr_set(uprobe, upump_mgr);
upipe = upipe_void_alloc(&uprobe_test_mgr, uprobe_use(uprobe));
assert(upump_mgr_get_opaque(upump_mgr, struct upipe *) == upipe);
uprobe_test_free(upipe);
upump_mgr_set_opaque(upump_mgr, NULL);
uprobe_throw(uprobe, NULL, UPROBE_FREEZE_UPUMP_MGR);
upipe = upipe_void_alloc(&uprobe_test_mgr, uprobe_use(uprobe));
assert(upump_mgr_get_opaque(upump_mgr, struct upipe *) == NULL);
uprobe_test_free(upipe);
uprobe_throw(uprobe, NULL, UPROBE_THAW_UPUMP_MGR);
upipe = upipe_void_alloc(&uprobe_test_mgr, uprobe_use(uprobe));
assert(upump_mgr_get_opaque(upump_mgr, struct upipe *) == upipe);
uprobe_test_free(upipe);
upump_mgr_release(upump_mgr);
ev_loop_destroy(loop);
return NULL;
}
/** @internal @This is called by AudioQueue after reading a buffer
* @param _upipe description structure of the pipe (void)
* @param queue AudioQueue
* @param qbuf AudioQueue buffer
*/
static void upipe_osx_audioqueue_sink_cb(void *_upipe, AudioQueueRef queue,
struct AudioQueueBuffer *qbuf)
{
/* TODO uncblock ? */
#if 0
struct upump_mgr *upump_mgr = qbuf->mUserData;
upump_mgr_sink_unblock(upump_mgr);
upump_mgr_release(upump_mgr);
#endif
AudioQueueFreeBuffer(queue, qbuf);
}
/** @internal @This is the open_codec upump callback
* It calls _open_codec_cb.
*
* @param upump description structure of the pump
*/
static void upipe_avcdec_open_codec_cb(struct upump *upump)
{
assert(upump);
struct upipe *upipe = upump_get_opaque(upump, struct upipe*);
struct upipe_avcdec *upipe_avcdec = upipe_avcdec_from_upipe(upipe);
struct upipe_avcodec_open_params *params = &upipe_avcdec->open_params;
struct upump *upump_av_deal = upipe_avcdec->upump_av_deal;
/* check udeal */
if (upump_av_deal) {
if (unlikely(!upipe_av_deal_grab())) {
upipe_dbg(upipe, "could not grab resource, return");
return;
}
upipe_avcdec->upump_av_deal = NULL;
}
/* real open_codec function */
bool ret = upipe_avcdec_open_codec(upipe, params->codec,
params->extradata, params->extradata_size);
/* clean dealer */
if (unlikely(!upipe_av_deal_yield(upump_av_deal))) {
upump_free(upump_av_deal);
upump_av_deal = NULL;
upipe_err(upipe, "can't stop dealer");
upipe_throw_upump_error(upipe);
if (upipe_avcdec->context) {
avcodec_close(upipe_avcdec->context);
av_free(upipe_avcdec->context);
upipe_avcdec->context = NULL;
}
return;
}
upump_free(upump_av_deal);
upump_av_deal = NULL;
if (!ret) {
return;
}
/* unblock input pump*/
if (upipe_avcdec->saved_upump_mgr) {
upipe_dbg(upipe, "unblocking saved upump_mgr");
upump_mgr_sink_unblock(upipe_avcdec->saved_upump_mgr);
upump_mgr_release(upipe_avcdec->saved_upump_mgr);
upipe_avcdec->saved_upump_mgr = NULL;
}
}
/** helper phony pipe to test uprobe_pthread_upump_mgr */
static struct upipe *uprobe_test_alloc(struct upipe_mgr *mgr,
struct uprobe *uprobe,
uint32_t signature, va_list args)
{
struct upipe *upipe = malloc(sizeof(struct upipe));
assert(upipe != NULL);
upipe_init(upipe, mgr, uprobe);
struct upump_mgr *m = NULL;
upipe_throw_need_upump_mgr(upipe, &m);
if (m != NULL) {
upump_mgr_set_opaque(m, upipe);
upump_mgr_release(m);
}
return upipe;
}
int main(int argc, char **argv)
{
struct ev_loop *loop = ev_default_loop(0);
upump_mgr = upump_ev_mgr_alloc(loop);
assert(upump_mgr != NULL);
struct uprobe *uprobe = uprobe_upump_mgr_alloc(NULL, upump_mgr);
assert(uprobe != NULL);
struct upipe *upipe = uprobe_test_alloc(&uprobe_test_mgr, uprobe);
uprobe_test_free(upipe);
uprobe_upump_mgr_free(uprobe);
upump_mgr_release(upump_mgr);
return 0;
}
int main(int argc, char **argv)
{
long flags;
assert(ecore_init());
mgr = upump_ecore_mgr_alloc(UPUMP_POOL, UPUMP_BLOCKER_POOL);
assert(mgr != NULL);
/* Create a pipe with non-blocking write */
assert(pipe(pipefd) != -1);
flags = fcntl(pipefd[1], F_GETFL);
assert(flags != -1);
flags |= O_NONBLOCK;
assert(fcntl(pipefd[1], F_SETFL, flags) != -1);
/* Create watchers */
write_idler = upump_alloc_idler(mgr, write_idler_cb, NULL, NULL);
assert(write_idler != NULL);
write_watcher = upump_alloc_fd_write(mgr, write_watcher_cb, NULL, NULL,
pipefd[1]);
assert(write_watcher != NULL);
read_timer = upump_alloc_timer(mgr, read_timer_cb, NULL, NULL, timeout, 0);
assert(read_timer != NULL);
read_watcher = upump_alloc_fd_read(mgr, read_watcher_cb, NULL, NULL,
pipefd[0]);
assert(read_watcher != NULL);
/* Start tests */
upump_start(write_idler);
ecore_main_loop_begin();
printf("\nread: \t%zd\nwrite: \t%zd\n", bytes_read, bytes_written);
assert(bytes_read);
assert(bytes_read == bytes_written);
/* Clean up */
upump_free(write_idler);
upump_free(write_watcher);
upump_free(read_timer);
upump_free(read_watcher);
upump_mgr_release(mgr);
ecore_shutdown();
return 0;
}
/** @This starts the avcodec thread.
*
* @param _glxplayer pointer to glxplayer structure
* @return always NULL
*/
static void *upipe_glxplayer_dec_thread(void *_glxplayer)
{
struct upipe_glxplayer *glxplayer = (struct upipe_glxplayer *)_glxplayer;
struct ev_loop *loop = ev_loop_new(0);
struct upump_mgr *upump_mgr =
upump_ev_mgr_alloc(loop, UPUMP_POOL, UPUMP_BLOCKER_POOL);
upipe_xfer_mgr_attach(glxplayer->dec_xfer, upump_mgr);
uprobe_pthread_upump_mgr_set(glxplayer->uprobe_logger, upump_mgr);
upump_mgr_release(upump_mgr);
ev_loop(loop, 0);
ev_loop_destroy(loop);
printf("end of avc thread\n");
return NULL;
}
int main(int argc, char** argv)
{
enum uprobe_log_level loglevel = UPROBE_LOG_LEVEL;
bool upipe_ts = false;
int opt;
// parse options
while ((opt = getopt(argc, argv, "dt")) != -1) {
switch (opt) {
case 'd':
loglevel--;
break;
case 't':
upipe_ts = true;
break;
default:
break;
}
}
if (optind >= argc) {
printf("Usage: %s [-d] [-t] filename\n", argv[0]);
exit(-1);
}
const char *uri = argv[optind++];
// upipe env
struct ev_loop *loop = ev_default_loop(0);
struct upump_mgr *upump_mgr =
upump_ev_mgr_alloc(loop, UPUMP_POOL, UPUMP_BLOCKER_POOL);
assert(upump_mgr != NULL);
struct upipe_glxplayer *glxplayer = upipe_glxplayer_alloc(loglevel);
assert(glxplayer != NULL);
upipe_glxplayer_play(glxplayer, upump_mgr, uri, upipe_ts);
upump_mgr_release(upump_mgr);
ev_loop(loop, 0);
upipe_glxplayer_free(glxplayer);
ev_default_destroy();
return 0;
}
int main(int argc, char **argv)
{
long flags;
loop = ev_default_loop(0);
mgr = upump_ev_mgr_alloc(loop, UPUMP_POOL, UPUMP_BLOCKER_POOL);
assert(mgr != NULL);
/* Create a pipe with non-blocking write */
assert(pipe(pipefd) != -1);
flags = fcntl(pipefd[1], F_GETFL);
assert(flags != -1);
flags |= O_NONBLOCK;
assert(fcntl(pipefd[1], F_SETFL, flags) != -1);
/* Create watchers */
write_idler = upump_alloc_idler(mgr, write_idler_cb, NULL);
assert(write_idler != NULL);
write_watcher = upump_alloc_fd_write(mgr, write_watcher_cb, NULL,
pipefd[1]);
assert(write_watcher != NULL);
read_timer = upump_alloc_timer(mgr, read_timer_cb, NULL, timeout, 0);
assert(read_timer != NULL);
read_watcher = upump_alloc_fd_read(mgr, read_watcher_cb, NULL, pipefd[0]);
assert(read_watcher != NULL);
/* Start tests */
upump_start(write_idler);
ev_loop(loop, 0);
assert(bytes_read);
assert(bytes_read == bytes_written);
/* Clean up */
upump_free(write_idler);
upump_free(write_watcher);
upump_free(read_timer);
upump_free(read_watcher);
upump_mgr_release(mgr);
ev_default_destroy();
return 0;
}
void run(struct upump_mgr *mgr)
{
long flags;
assert(mgr != NULL);
/* Create a pipe with non-blocking write */
assert(pipe(pipefd) != -1);
flags = fcntl(pipefd[1], F_GETFL);
assert(flags != -1);
flags |= O_NONBLOCK;
assert(fcntl(pipefd[1], F_SETFL, flags) != -1);
/* Create watchers */
write_idler = upump_alloc_idler(mgr, write_idler_cb, NULL, NULL);
assert(write_idler != NULL);
write_watcher = upump_alloc_fd_write(mgr, write_watcher_cb, NULL, NULL,
pipefd[1]);
assert(write_watcher != NULL);
read_timer = upump_alloc_timer(mgr, read_timer_cb, NULL, NULL, timeout, 0);
assert(read_timer != NULL);
read_watcher = upump_alloc_fd_read(mgr, read_watcher_cb, NULL, NULL,
pipefd[0]);
assert(read_watcher != NULL);
/* Start tests */
upump_start(write_idler);
upump_mgr_run(mgr, NULL);
assert(bytes_read);
assert(bytes_read == bytes_written);
/* Clean up */
upump_free(write_idler);
upump_free(write_watcher);
upump_free(read_timer);
upump_free(read_watcher);
upump_mgr_release(mgr);
}
int main(int argc, char **argv)
{
int opt;
/* parse options */
while ((opt = getopt(argc, argv, "dqD:")) != -1) {
switch (opt) {
case 'd':
if (loglevel > 0) loglevel--;
break;
case 'q':
if (loglevel < UPROBE_LOG_ERROR) loglevel++;
break;
case 'D':
dump = optarg;
break;
default:
usage(argv[0]);
}
}
if (optind >= argc - 1) {
usage(argv[0]);
}
srcpath = argv[optind++];
dstpath = argv[optind++];
/* choose log fd */
logstream = stderr;
/* setup environnement */
struct umem_mgr *umem_mgr = umem_alloc_mgr_alloc();
struct udict_mgr *udict_mgr = udict_inline_mgr_alloc(UDICT_POOL_DEPTH,
umem_mgr, -1, -1);
uref_mgr = uref_std_mgr_alloc(UREF_POOL_DEPTH, udict_mgr,
0);
struct upump_mgr *upump_mgr = upump_ev_mgr_alloc_default(UPUMP_POOL,
UPUMP_BLOCKER_POOL);
/* default probe */
logger = uprobe_stdio_alloc(NULL, logstream, loglevel);
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);
uref_mgr_release(uref_mgr);
upump_mgr_release(upump_mgr);
/* split probe */
struct uprobe uprobe_catch;
uprobe_init(&uprobe_catch, split_catch, uprobe_use(logger));
/* other probes */
uprobe_init(&uprobe_avcdec, avcdec_catch, uprobe_use(logger));
uprobe_init(&uprobe_uref, uref_catch, uprobe_use(logger));
/* upipe-av */
upipe_av_init(true, uprobe_use(logger));
/* global pipe managers */
upipe_avcdec_mgr = upipe_avcdec_mgr_alloc();
upipe_avcenc_mgr = upipe_avcenc_mgr_alloc();
upipe_sws_mgr = upipe_sws_mgr_alloc();
upipe_filter_blend_mgr = upipe_filter_blend_mgr_alloc();
upipe_fsink_mgr = upipe_fsink_mgr_alloc();
upipe_probe_uref_mgr = upipe_probe_uref_mgr_alloc();
/* null */
struct upipe_mgr *upipe_null_mgr = upipe_null_mgr_alloc();
upipe_null = upipe_void_alloc(upipe_null_mgr,
uprobe_pfx_alloc(uprobe_use(logger), loglevel, "null"));
assert(upipe_null != NULL);
upipe_mgr_release(upipe_null_mgr);
/* file source */
struct upipe_mgr *upipe_fsrc_mgr = upipe_fsrc_mgr_alloc();
upipe_source = upipe_void_alloc(upipe_fsrc_mgr,
uprobe_pfx_alloc(uprobe_use(logger), loglevel, "fsrc"));
assert(upipe_source != NULL);
upipe_mgr_release(upipe_fsrc_mgr);
if (!ubase_check(upipe_set_uri(upipe_source, srcpath)))
exit(EXIT_FAILURE);
/* upipe-ts */
struct upipe_mgr *upipe_ts_demux_mgr = upipe_ts_demux_mgr_alloc();
struct upipe_mgr *upipe_autof_mgr = upipe_autof_mgr_alloc();
upipe_ts_demux_mgr_set_autof_mgr(upipe_ts_demux_mgr, upipe_autof_mgr);
upipe_mgr_release(upipe_autof_mgr);
struct upipe *ts_demux = upipe_void_alloc_output(upipe_source,
upipe_ts_demux_mgr,
uprobe_pfx_alloc(
uprobe_selflow_alloc(uprobe_use(logger),
uprobe_selflow_alloc(uprobe_use(logger), &uprobe_catch,
UPROBE_SELFLOW_PIC, "auto"),
UPROBE_SELFLOW_VOID, "auto"),
loglevel, "tsdemux"));
assert(ts_demux != NULL);
upipe_mgr_release(upipe_ts_demux_mgr);
upipe_release(ts_demux);
/* fire loop ! */
upump_mgr_run(upump_mgr, NULL);
/* release everyhing */
upipe_release(upipe_source);
upipe_release(upipe_split_output);
upipe_release(upipe_null);
uprobe_release(logger);
uprobe_clean(&uprobe_catch);
uprobe_clean(&uprobe_avcdec);
uprobe_clean(&uprobe_uref);
upipe_mgr_release(upipe_avcdec_mgr);
upipe_mgr_release(upipe_avcenc_mgr);
upipe_mgr_release(upipe_sws_mgr);
upipe_mgr_release(upipe_filter_blend_mgr);
upipe_mgr_release(upipe_fsink_mgr);
upipe_mgr_release(upipe_probe_uref_mgr);
udict_mgr_release(udict_mgr);
umem_mgr_release(umem_mgr);
upipe_av_clean();
return 0;
}
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;
}
