/** @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; }