StreamReceiver::~StreamReceiver() { avcodec_close(avctx); avcodec_free_context(&avctx); avformat_network_deinit(); av_frame_free(&avframe); }
int main(int argc, char **argv) { int ret; parse_loglevel(argc, argv, options); av_register_all(); avformat_network_init(); init_opts(); #if CONFIG_AVDEVICE avdevice_register_all(); #endif show_banner(); parse_options(NULL, argc, argv, options, opt_input_file); if (!input_filename) { show_usage(); fprintf(stderr, "You have to specify one input file.\n"); fprintf(stderr, "Use -h to get full help or, even better, run 'man %s'.\n", program_name); exit(1); } ret = probe_file(input_filename); uninit_opts(); av_dict_free(&fmt_entries_to_show); avformat_network_deinit(); return ret; }
int main(int argc, char **argv) { int ret; uint8_t *buffer = av_malloc(AVP_BUFFSIZE); if (!buffer) exit(1); register_exit(avprobe_cleanup); options = real_options; parse_loglevel(argc, argv, options); av_register_all(); avformat_network_init(); init_opts(); #if CONFIG_AVDEVICE avdevice_register_all(); #endif show_banner(); octx.print_header = ini_print_header; octx.print_footer = ini_print_footer; octx.print_array_header = ini_print_array_header; octx.print_array_footer = ini_print_array_footer; octx.print_object_header = ini_print_object_header; octx.print_integer = ini_print_integer; octx.print_string = ini_print_string; parse_options(NULL, argc, argv, options, opt_input_file); if (!input_filename) { show_usage(); fprintf(stderr, "You have to specify one input file.\n"); fprintf(stderr, "Use -h to get full help or, even better, run 'man %s'.\n", program_name); exit_program(1); } probe_out = avio_alloc_context(buffer, AVP_BUFFSIZE, 1, NULL, NULL, probe_buf_write, NULL); if (!probe_out) exit_program(1); probe_header(); ret = probe_file(input_filename); probe_footer(); avio_flush(probe_out); av_freep(&probe_out); av_freep(&buffer); uninit_opts(); avformat_network_deinit(); return ret; }
AVDemuxer::~AVDemuxer() { close(); if (pkt) { delete pkt; pkt = 0; } avformat_network_deinit(); }
void player_exit(void) { if (state != STOPPED) player_stop(); avformat_network_deinit(); SDL_Quit(); }
static int module_close(void) { mod_avf = mem_deref(mod_avf); #if LIBAVFORMAT_VERSION_INT >= ((53<<16) + (13<<8) + 0) avformat_network_deinit(); #endif return 0; }
int main(int argc, char *argv[]) { const char *op = NULL; int ret; av_log_set_level(AV_LOG_DEBUG); if (argc < 2) { usage(argv[0]); return 1; } /* register codecs and formats and other lavf/lavc components*/ av_register_all(); avformat_network_init(); op = argv[1]; if (strcmp(op, "list") == 0) { if (argc < 3) { av_log(NULL, AV_LOG_INFO, "Missing argument for list operation.\n"); ret = AVERROR(EINVAL); } else { ret = list_op(argv[2]); } } else if (strcmp(op, "del") == 0) { if (argc < 3) { av_log(NULL, AV_LOG_INFO, "Missing argument for del operation.\n"); ret = AVERROR(EINVAL); } else { ret = del_op(argv[2]); } } else if (strcmp(op, "move") == 0) { if (argc < 4) { av_log(NULL, AV_LOG_INFO, "Missing argument for move operation.\n"); ret = AVERROR(EINVAL); } else { ret = move_op(argv[2], argv[3]); } } else { av_log(NULL, AV_LOG_INFO, "Invalid operation %s\n", op); ret = AVERROR(EINVAL); } avformat_network_deinit(); return ret < 0 ? 1 : 0; }
void deInitFFmpeg() { pthread_mutex_lock(&init_mutex); // update counter ref_count--; if(ref_count == 0) { av_lockmgr_register(NULL); uninit_opts(); avformat_network_deinit(); } pthread_mutex_unlock(&init_mutex); }
int main(int argc, char **argv) { av_register_all(); avformat_network_init(); AVFormatContext *fmt_ctx; const char* input_filename = argv[1]; int ret = open_input_file(&fmt_ctx, input_filename); if (0 == ret) { printf("format name: %s\n",fmt_ctx->iformat->name); close_input_file(&fmt_ctx); } avformat_network_deinit(); return 0; }
int main(int argc, char *argv[]) { #ifdef __WINDOWS__ // disable buffering, we want logs immediately // even line buffering (setvbuf() with mode _IOLBF) is not sufficient setbuf(stdout, NULL); setbuf(stderr, NULL); #endif struct args args = { .serial = NULL, .help = SDL_FALSE, .version = SDL_FALSE, .port = DEFAULT_LOCAL_PORT, .max_size = DEFAULT_MAX_SIZE, .bit_rate = DEFAULT_BIT_RATE, }; if (!parse_args(&args, argc, argv)) { return 1; } if (args.help) { usage(argv[0]); return 0; } if (args.version) { print_version(); return 0; } av_register_all(); if (avformat_network_init()) { return 1; } #ifdef BUILD_DEBUG SDL_LogSetAllPriority(SDL_LOG_PRIORITY_DEBUG); #endif int res = scrcpy(args.serial, args.port, args.max_size, args.bit_rate) ? 0 : 1; avformat_network_deinit(); // ignore failure return res; }
void MovieDecoder::destroy() { if (m_pVideoCodecContext) { auto lock = ThreadPool::lock("ffmpeg_avcodec_open"); avcodec_close(m_pVideoCodecContext); m_pVideoCodecContext = nullptr; } if ((!m_FormatContextWasGiven) && m_pFormatContext) { avformat_close_input(&m_pFormatContext); } if (m_pPacket) { av_free_packet(m_pPacket); delete m_pPacket; m_pPacket = nullptr; } if (m_pFrame) { av_frame_free(&m_pFrame); } if (m_pFrameBuffer) { av_free(m_pFrameBuffer); m_pFrameBuffer = nullptr; } m_VideoStream = -1; avformat_network_deinit(); }
int main(int argc, char** argv) { //if(argc < 2) { // fprintf(stderr, "specify config file\n"); // exit(EXIT_FAILURE); //} signal(SIGINT, terminate); signal(SIGPIPE, SIG_IGN); //av_log_set_level(AV_LOG_DEBUG); av_register_all(); avcodec_register_all(); avformat_network_init(); fprintf(stderr, "FFmpeg initialized\n"); db_init_pg_conn("config.txt"); cameras = db_select_cameras(&n_cameras); pthread_t *threads = (pthread_t *)malloc(n_cameras * sizeof(pthread_t)); for(int i=0; i < n_cameras; i++) { if(pthread_create(&threads[i], NULL, recorder_thread, (void *)(&cameras[i])) < 0) error("pthread_create"); } fprintf(stderr, "All cameras started\n"); if(pthread_mutex_init(&screens_lock, NULL) < 0) { fprintf(stderr, "pthread_mutex_init failed\n"); exit(EXIT_FAILURE); } if(pthread_mutex_init(&clients_lock, NULL) < 0) { fprintf(stderr, "pthread_mutex_init failed\n"); exit(EXIT_FAILURE); } info_server_start(); rtsp_server_start(); pthread_t h264_to_mp4_thread; if(pthread_create(&h264_to_mp4_thread, NULL, start_h264_to_mp4_service, NULL) < 0) error("pthread_create"); event_loop(); for(int i=0; i < n_cameras; i++) { pthread_join(threads[i], NULL); free(cameras[i].url); free(cameras[i].name); pthread_mutex_destroy(&cameras[i].consumers_lock); } terminate_h264_to_mp4_service = 1; pthread_join(h264_to_mp4_thread, NULL); fprintf(stderr, "h264_to_mp4_thread shutted down\n"); free(cameras); free(threads); avformat_network_deinit(); db_close_pg_conn(); event_loop_stop(); pthread_mutex_destroy(&clients_lock); pthread_mutex_destroy(&screens_lock); fprintf(stderr, "Terminated.\n"); return (EXIT_SUCCESS); }
void PacketReceiver::exitAVLibs() { avformat_network_deinit(); }
void BarPlayerDestroy () { avformat_network_deinit (); ao_shutdown (); }
void HLSReader::play() { AVFormatContext *pFormatCtx = NULL; int videoStream; AVCodecContext *pCodecCtx = NULL; AVCodec *pCodec = NULL; AVPacket avPacket; // Register all formats and codecs av_register_all(); avformat_network_init(); // Open video file if(avformat_open_input(&pFormatCtx, url.toStdString().c_str(), NULL, NULL)!=0) return; // Couldn't open file // Dump information about file onto standard error // av_dump_format(pFormatCtx, 0, argv[1], 0); // Find the first video stream videoStream = av_find_best_stream(pFormatCtx, AVMEDIA_TYPE_VIDEO, -1, -1, &pCodec, 0 ); if(videoStream==-1) return; // Didn't find a video stream // Get a pointer to the codec context for the video stream pCodecCtx=pFormatCtx->streams[videoStream]->codec; // Find the decoder for the video stream pCodec=avcodec_find_decoder(pCodecCtx->codec_id); if(pCodec==NULL) { fprintf(stderr, "Unsupported codec!\n"); return ; // Codec not found } AVCodecContext* codec_ctx = avcodec_alloc_context3(pCodec); if(avcodec_copy_context(codec_ctx, pCodecCtx) != 0) { fprintf(stderr, "Couldn't copy codec context"); return; // Error copying codec context } QtAV::VideoDecoder* videoDecoder = QtAV::VideoDecoder::create(); videoDecoder->setCodecContext(codec_ctx); videoDecoder->open(); // if (avcodec_open2(codec_ctx,pCodec,NULL) < 0) { // return; // } // Read frames and decode to send video frames while(av_read_frame(pFormatCtx, &avPacket)>=0) { if (avPacket.stream_index == videoStream) { QtAV::Packet packet = QtAV::Packet::fromAVPacket(&avPacket, av_q2d(codec_ctx->time_base)); if (videoDecoder->decode(packet)) { QtAV::VideoFrame frame = videoDecoder->frame(); if (frame.isValid()) { emit decodedVideoFrame(frame); } } } } videoDecoder->close(); delete videoDecoder; av_free(&avPacket); // Close the codec avcodec_close(pCodecCtx); // Close the video file avformat_close_input(&pFormatCtx); avformat_network_deinit(); emit finished(); }
MediaManager::~MediaManager() { avformat_network_deinit(); }
int main(int argc, char **argv) { int bps = 0, ret, i; const char *input_url = NULL, *output_url = NULL; int64_t stream_pos = 0; int64_t start_time; char errbuf[50]; AVIOContext *input, *output; av_register_all(); avformat_network_init(); for (i = 1; i < argc; i++) { if (!strcmp(argv[i], "-b")) { bps = atoi(argv[i + 1]); i++; } else if (!input_url) { input_url = argv[i]; } else if (!output_url) { output_url = argv[i]; } else { return usage(argv[0], 1); } } if (!output_url) return usage(argv[0], 1); ret = avio_open2(&input, input_url, AVIO_FLAG_READ, NULL, NULL); if (ret) { av_strerror(ret, errbuf, sizeof(errbuf)); fprintf(stderr, "Unable to open %s: %s\n", input_url, errbuf); return 1; } ret = avio_open2(&output, output_url, AVIO_FLAG_WRITE, NULL, NULL); if (ret) { av_strerror(ret, errbuf, sizeof(errbuf)); fprintf(stderr, "Unable to open %s: %s\n", output_url, errbuf); goto fail; } start_time = av_gettime(); while (1) { uint8_t buf[1024]; int n; n = avio_read(input, buf, sizeof(buf)); if (n <= 0) break; avio_write(output, buf, n); stream_pos += n; if (bps) { avio_flush(output); while ((av_gettime() - start_time) * bps / AV_TIME_BASE < stream_pos) usleep(50 * 1000); } } avio_flush(output); avio_close(output); fail: avio_close(input); avformat_network_deinit(); return ret ? 1 : 0; }
void groove_finish(void) { if (should_deinit_network) { avformat_network_deinit(); should_deinit_network = 0; } }
// 内部函数实现 static int split_media_file(char *dst, char *src, __int64 start, __int64 end, PFN_SPC spc) { AVFormatContext *ifmt_ctx = NULL; AVFormatContext *ofmt_ctx = NULL; AVStream *istream = NULL; AVStream *ostream = NULL; AVRational tbms = { 1, 1000 }; AVRational tbvs = { 1, 1 }; int64_t startpts = -1; int64_t duration = -1; int64_t total = -1; int64_t current = -1; int streamidx= 0; int ret = -1; av_register_all(); avformat_network_init(); if ((ret = avformat_open_input(&ifmt_ctx, src, 0, 0)) < 0) { printf("could not open input file '%s' !", src); goto done; } if ((ret = avformat_find_stream_info(ifmt_ctx, 0)) < 0) { printf("failed to retrieve input stream information ! \n"); goto done; } avformat_alloc_output_context2(&ofmt_ctx, NULL, NULL, dst); if (!ofmt_ctx) { printf("could not create output context !\n"); goto done; } for (unsigned i=0; i<ifmt_ctx->nb_streams; i++) { istream = ifmt_ctx->streams[i]; if (istream->codec->codec_type == AVMEDIA_TYPE_VIDEO) { streamidx = i; tbvs = ifmt_ctx->streams[i]->time_base; } ostream = avformat_new_stream(ofmt_ctx, istream->codec->codec); if (!ostream) { printf("failed allocating output stream !\n"); goto done; } ret = avcodec_copy_context(ostream->codec, istream->codec); if (ret < 0) { printf("failed to copy context from input to output stream codec context !\n"); goto done; } ostream->codec->codec_tag = 0; if (ofmt_ctx->oformat->flags & AVFMT_GLOBALHEADER) { ostream->codec->flags |= AV_CODEC_FLAG_GLOBAL_HEADER; } } if (!(ofmt_ctx->oformat->flags & AVFMT_NOFILE)) { ret = avio_open(&ofmt_ctx->pb, dst, AVIO_FLAG_WRITE); if (ret < 0) { printf("could not open output file '%s' !", dst); goto done; } } // calulate pts if (start >= 0) { startpts = ifmt_ctx->start_time * 1000 / AV_TIME_BASE; duration = ifmt_ctx->duration * 1000 / AV_TIME_BASE; total = duration - start; if (total < 0) total = 1; current = 0; start += startpts; end += startpts; start = av_rescale_q_rnd(start, tbms, tbvs, (AVRounding)(AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX)); end = av_rescale_q_rnd(end , tbms, tbvs, (AVRounding)(AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX)); // seek to start position av_seek_frame(ifmt_ctx, streamidx, start, AVSEEK_FLAG_BACKWARD); } else { startpts = ifmt_ctx->start_time * 1000 / AV_TIME_BASE; duration = end; total = end; current = 0; start = startpts; end += startpts; start = av_rescale_q_rnd(start, tbms, tbvs, (AVRounding)(AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX)); end = av_rescale_q_rnd(end , tbms, tbvs, (AVRounding)(AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX)); } // write header ret = avformat_write_header(ofmt_ctx, NULL); if (ret < 0) { printf("error occurred when writing output file header !\n"); goto done; } while (!g_exit_remux) { AVPacket pkt; ret = av_read_frame(ifmt_ctx, &pkt); if (ret < 0) { // fprintf(stderr, "failed to read frame !\n"); break; } // get start pts if (pkt.stream_index == streamidx) { if (pkt.pts > end) { g_exit_remux = 1; goto next; } if (spc) { current = av_rescale_q_rnd(pkt.pts - start, tbvs, tbms, (AVRounding)(AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX)); if (current < 0 ) current = 0; if (current > total) current = total; spc(current, total); } } istream = ifmt_ctx->streams[pkt.stream_index]; ostream = ofmt_ctx->streams[pkt.stream_index]; pkt.pts = av_rescale_q_rnd(pkt.pts, istream->time_base, ostream->time_base, (AVRounding)(AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX)); pkt.dts = av_rescale_q_rnd(pkt.dts, istream->time_base, ostream->time_base, (AVRounding)(AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX)); pkt.duration = av_rescale_q(pkt.duration, istream->time_base, ostream->time_base); pkt.pos = -1; ret = av_interleaved_write_frame(ofmt_ctx, &pkt); if (ret < 0) { printf("error muxing packet !\n"); g_exit_remux = 1; goto next; } next: av_packet_unref(&pkt); } // write trailer av_write_trailer(ofmt_ctx); done: // close input avformat_close_input(&ifmt_ctx); // close output if (ofmt_ctx && !(ofmt_ctx->oformat->flags & AVFMT_NOFILE)) { avio_closep(&ofmt_ctx->pb); } avformat_free_context(ofmt_ctx); avformat_network_deinit(); // done printf("\n"); spc(total, total); printf("\ndone.\n"); return ret; }
static void uninit() { avformat_network_deinit(); }
int main (int argc, char *argv[]) { // setvbuf(stdout, NULL, _IONBF, 0); setlinebuf(stdout); assert(setenv("TZ", "UTC", 1) == 0); tzset(); // see http://www.purposeful.co.uk/software/gopt/ void *options = gopt_sort(&argc, (const char **)argv, gopt_start( gopt_option('h', 0, gopt_shorts('h', '?'), gopt_longs("help", "HELP"))//, // gopt_option('t', GOPT_ARG, gopt_shorts('t'), gopt_longs("thread-num")), // gopt_option('s', 0, gopt_shorts('s'), gopt_longs("silent", "quiet")), )); //TODO make customizable assert(setenv("LUA_PATH", "src/?.lua", 0) == 0); //http://rtmpdump.mplayerhq.hu/librtmp.3.html // const char usage[] = "usage: rtmp_load [--thread-num/-t N(default 1)] \"rtmp://example.com:1935/ app=app_name_or_empty playpath=path timeout=30\"\n"; const char usage[] = "usage: rtmp_load test.lua\n"; if (gopt(options, 'h')) { fprintf(stdout, usage); exit(EXIT_SUCCESS); } gopt_free(options); if (argc != 2) { // fprintf(stderr, "provide target rtmp string\n"); fprintf(stderr, "provide test file\n"); fprintf(stderr, usage); exit(EXIT_FAILURE); } char *script_path = argv[1]; lua_State *lua_state = luaL_newstate(); assert(lua_state != NULL); lua_gc(lua_state, LUA_GCSTOP, 0); luaL_openlibs(lua_state); lua_gc(lua_state, LUA_GCRESTART, -1); int r = luaL_loadfile(lua_state, script_path); if (r != 0) { if (r == LUA_ERRSYNTAX) { fprintf(stderr, "error loading %s, syntax error: %s\n", script_path, lua_tostring(lua_state, -1)); } else if (r == LUA_ERRFILE) { fprintf(stderr, "failed to open %s: %s\n", script_path, lua_tostring(lua_state, -1)); } else { fprintf(stderr, "error loading %s, ret = %i\n", script_path, r); } exit(EXIT_FAILURE); } lua_call(lua_state, 0, 1); // av_log_set_level(AV_LOG_ERROR); // av_log_set_level(AV_LOG_INFO); //http://libav.org/doxygen/master/log_8h.html av_log_set_level(AV_LOG_VERBOSE); // for parsing lib log // av_log_set_level(AV_LOG_DEBUG); // shows binary packet data //TODO http://libav.org/doxygen/master/librtmp_8c_source.html#l00080 av_log_set_callback(av_log_my_callback); av_register_all(); avcodec_register_all(); avformat_network_init(); if (av_lockmgr_register(handle_av_lock) != 0) { fprintf(stderr, "av_lockmgr_register failed\n"); exit(EXIT_FAILURE); } lua_call(lua_state, 0, 0); lua_close(lua_state); av_lockmgr_register(NULL); avformat_network_deinit(); exit(EXIT_SUCCESS); return 0; }
int main(int argc, char **argv) { int option; char *configfile; int background; int mdns_no_rsp; int mdns_no_daap; int loglevel; char *logdomains; char *logfile; char *ffid; char *pidfile; const char *gcry_version; sigset_t sigs; int sigfd; #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) struct kevent ke_sigs[4]; #endif int ret; struct option option_map[] = { { "ffid", 1, NULL, 'b' }, { "debug", 1, NULL, 'd' }, { "logdomains", 1, NULL, 'D' }, { "foreground", 0, NULL, 'f' }, { "config", 1, NULL, 'c' }, { "pidfile", 1, NULL, 'P' }, { "version", 0, NULL, 'v' }, { "mdns-no-rsp", 0, NULL, 512 }, { "mdns-no-daap", 0, NULL, 513 }, { NULL, 0, NULL, 0 } }; configfile = CONFFILE; pidfile = PIDFILE; loglevel = -1; logdomains = NULL; logfile = NULL; background = 1; ffid = NULL; mdns_no_rsp = 0; mdns_no_daap = 0; while ((option = getopt_long(argc, argv, "D:d:c:P:fb:v", option_map, NULL)) != -1) { switch (option) { case 512: mdns_no_rsp = 1; break; case 513: mdns_no_daap = 1; break; case 'b': ffid = optarg; break; case 'd': ret = safe_atoi32(optarg, &option); if (ret < 0) fprintf(stderr, "Error: loglevel must be an integer in '-d %s'\n", optarg); else loglevel = option; break; case 'D': logdomains = optarg; break; case 'f': background = 0; break; case 'c': configfile = optarg; break; case 'P': pidfile = optarg; break; case 'v': version(); return EXIT_SUCCESS; break; default: usage(argv[0]); return EXIT_FAILURE; break; } } ret = logger_init(NULL, NULL, (loglevel < 0) ? E_LOG : loglevel); if (ret != 0) { fprintf(stderr, "Could not initialize log facility\n"); return EXIT_FAILURE; } ret = conffile_load(configfile); if (ret != 0) { DPRINTF(E_FATAL, L_MAIN, "Config file errors; please fix your config\n"); logger_deinit(); return EXIT_FAILURE; } logger_deinit(); /* Reinit log facility with configfile values */ if (loglevel < 0) loglevel = cfg_getint(cfg_getsec(cfg, "general"), "loglevel"); logfile = cfg_getstr(cfg_getsec(cfg, "general"), "logfile"); ret = logger_init(logfile, logdomains, loglevel); if (ret != 0) { fprintf(stderr, "Could not reinitialize log facility with config file settings\n"); conffile_unload(); return EXIT_FAILURE; } /* Set up libevent logging callback */ event_set_log_callback(logger_libevent); DPRINTF(E_LOG, L_MAIN, "Forked Media Server Version %s taking off\n", VERSION); ret = av_lockmgr_register(ffmpeg_lockmgr); if (ret < 0) { DPRINTF(E_FATAL, L_MAIN, "Could not register ffmpeg lock manager callback\n"); ret = EXIT_FAILURE; goto ffmpeg_init_fail; } av_register_all(); #if LIBAVFORMAT_VERSION_MAJOR >= 54 || (LIBAVFORMAT_VERSION_MAJOR == 53 && LIBAVFORMAT_VERSION_MINOR >= 13) avformat_network_init(); #endif av_log_set_callback(logger_ffmpeg); #ifdef LASTFM /* Initialize libcurl */ curl_global_init(CURL_GLOBAL_DEFAULT); #endif /* Initialize libgcrypt */ gcry_control(GCRYCTL_SET_THREAD_CBS, &gcry_threads_pthread); gcry_version = gcry_check_version(GCRYPT_VERSION); if (!gcry_version) { DPRINTF(E_FATAL, L_MAIN, "libgcrypt version mismatch\n"); ret = EXIT_FAILURE; goto gcrypt_init_fail; } /* We aren't handling anything sensitive, so give up on secure * memory, which is a scarce system resource. */ gcry_control(GCRYCTL_DISABLE_SECMEM, 0); gcry_control(GCRYCTL_INITIALIZATION_FINISHED, 0); DPRINTF(E_DBG, L_MAIN, "Initialized with gcrypt %s\n", gcry_version); /* Block signals for all threads except the main one */ sigemptyset(&sigs); sigaddset(&sigs, SIGINT); sigaddset(&sigs, SIGHUP); sigaddset(&sigs, SIGCHLD); sigaddset(&sigs, SIGTERM); sigaddset(&sigs, SIGPIPE); ret = pthread_sigmask(SIG_BLOCK, &sigs, NULL); if (ret != 0) { DPRINTF(E_LOG, L_MAIN, "Error setting signal set\n"); ret = EXIT_FAILURE; goto signal_block_fail; } /* Daemonize and drop privileges */ ret = daemonize(background, pidfile); if (ret < 0) { DPRINTF(E_LOG, L_MAIN, "Could not initialize server\n"); ret = EXIT_FAILURE; goto daemon_fail; } /* Initialize libevent (after forking) */ evbase_main = event_init(); DPRINTF(E_LOG, L_MAIN, "mDNS init\n"); ret = mdns_init(); if (ret != 0) { DPRINTF(E_FATAL, L_MAIN, "mDNS init failed\n"); ret = EXIT_FAILURE; goto mdns_fail; } /* Initialize the database before starting */ DPRINTF(E_INFO, L_MAIN, "Initializing database\n"); ret = db_init(); if (ret < 0) { DPRINTF(E_FATAL, L_MAIN, "Database init failed\n"); ret = EXIT_FAILURE; goto db_fail; } /* Open a DB connection for the main thread */ ret = db_perthread_init(); if (ret < 0) { DPRINTF(E_FATAL, L_MAIN, "Could not perform perthread DB init for main\n"); ret = EXIT_FAILURE; goto db_fail; } /* Spawn worker thread */ ret = worker_init(); if (ret != 0) { DPRINTF(E_FATAL, L_MAIN, "Worker thread failed to start\n"); ret = EXIT_FAILURE; goto worker_fail; } /* Spawn cache thread */ ret = cache_init(); if (ret != 0) { DPRINTF(E_FATAL, L_MAIN, "Cache thread failed to start\n"); ret = EXIT_FAILURE; goto cache_fail; } /* Spawn file scanner thread */ ret = filescanner_init(); if (ret != 0) { DPRINTF(E_FATAL, L_MAIN, "File scanner thread failed to start\n"); ret = EXIT_FAILURE; goto filescanner_fail; } #ifdef HAVE_SPOTIFY_H /* Spawn Spotify thread */ ret = spotify_init(); if (ret < 0) { DPRINTF(E_INFO, L_MAIN, "Spotify thread not started\n");; } #endif /* Spawn player thread */ ret = player_init(); if (ret != 0) { DPRINTF(E_FATAL, L_MAIN, "Player thread failed to start\n"); ret = EXIT_FAILURE; goto player_fail; } /* Spawn HTTPd thread */ ret = httpd_init(); if (ret != 0) { DPRINTF(E_FATAL, L_MAIN, "HTTPd thread failed to start\n"); ret = EXIT_FAILURE; goto httpd_fail; } #ifdef MPD /* Spawn MPD thread */ ret = mpd_init(); if (ret != 0) { DPRINTF(E_FATAL, L_MAIN, "MPD thread failed to start\n"); ret = EXIT_FAILURE; goto mpd_fail; } #endif /* Start Remote pairing service */ ret = remote_pairing_init(); if (ret != 0) { DPRINTF(E_FATAL, L_MAIN, "Remote pairing service failed to start\n"); ret = EXIT_FAILURE; goto remote_fail; } /* Register mDNS services */ ret = register_services(ffid, mdns_no_rsp, mdns_no_daap); if (ret < 0) { ret = EXIT_FAILURE; goto mdns_reg_fail; } #if defined(__linux__) /* Set up signal fd */ sigfd = signalfd(-1, &sigs, SFD_NONBLOCK | SFD_CLOEXEC); if (sigfd < 0) { DPRINTF(E_FATAL, L_MAIN, "Could not setup signalfd: %s\n", strerror(errno)); ret = EXIT_FAILURE; goto signalfd_fail; } event_set(&sig_event, sigfd, EV_READ, signal_signalfd_cb, NULL); #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) sigfd = kqueue(); if (sigfd < 0) { DPRINTF(E_FATAL, L_MAIN, "Could not setup kqueue: %s\n", strerror(errno)); ret = EXIT_FAILURE; goto signalfd_fail; } EV_SET(&ke_sigs[0], SIGINT, EVFILT_SIGNAL, EV_ADD, 0, 0, NULL); EV_SET(&ke_sigs[1], SIGTERM, EVFILT_SIGNAL, EV_ADD, 0, 0, NULL); EV_SET(&ke_sigs[2], SIGHUP, EVFILT_SIGNAL, EV_ADD, 0, 0, NULL); EV_SET(&ke_sigs[3], SIGCHLD, EVFILT_SIGNAL, EV_ADD, 0, 0, NULL); ret = kevent(sigfd, ke_sigs, 4, NULL, 0, NULL); if (ret < 0) { DPRINTF(E_FATAL, L_MAIN, "Could not register signal events: %s\n", strerror(errno)); ret = EXIT_FAILURE; goto signalfd_fail; } event_set(&sig_event, sigfd, EV_READ, signal_kqueue_cb, NULL); #endif event_base_set(evbase_main, &sig_event); event_add(&sig_event, NULL); /* Run the loop */ event_base_dispatch(evbase_main); DPRINTF(E_LOG, L_MAIN, "Stopping gracefully\n"); ret = EXIT_SUCCESS; /* * On a clean shutdown, bring mDNS down first to give a chance * to the clients to perform a clean shutdown on their end */ DPRINTF(E_LOG, L_MAIN, "mDNS deinit\n"); mdns_deinit(); signalfd_fail: mdns_reg_fail: DPRINTF(E_LOG, L_MAIN, "Remote pairing deinit\n"); remote_pairing_deinit(); remote_fail: DPRINTF(E_LOG, L_MAIN, "HTTPd deinit\n"); httpd_deinit(); httpd_fail: DPRINTF(E_LOG, L_MAIN, "TCPd deinit\n"); #ifdef MPD DPRINTF(E_LOG, L_MAIN, "MPD deinit\n"); mpd_deinit(); mpd_fail: #endif DPRINTF(E_LOG, L_MAIN, "Player deinit\n"); player_deinit(); player_fail: #ifdef HAVE_SPOTIFY_H DPRINTF(E_LOG, L_MAIN, "Spotify deinit\n"); spotify_deinit(); #endif DPRINTF(E_LOG, L_MAIN, "File scanner deinit\n"); filescanner_deinit(); filescanner_fail: DPRINTF(E_LOG, L_MAIN, "Cache deinit\n"); cache_deinit(); cache_fail: DPRINTF(E_LOG, L_MAIN, "Worker deinit\n"); worker_deinit(); worker_fail: DPRINTF(E_LOG, L_MAIN, "Database deinit\n"); db_perthread_deinit(); db_deinit(); db_fail: if (ret == EXIT_FAILURE) { DPRINTF(E_LOG, L_MAIN, "mDNS deinit\n"); mdns_deinit(); } mdns_fail: daemon_fail: if (background) { ret = seteuid(0); if (ret < 0) DPRINTF(E_LOG, L_MAIN, "seteuid() failed: %s\n", strerror(errno)); else { ret = unlink(pidfile); if (ret < 0) DPRINTF(E_LOG, L_MAIN, "Could not unlink PID file %s: %s\n", pidfile, strerror(errno)); } } signal_block_fail: gcrypt_init_fail: #ifdef LASTFM curl_global_cleanup(); #endif #if LIBAVFORMAT_VERSION_MAJOR >= 54 || (LIBAVFORMAT_VERSION_MAJOR == 53 && LIBAVFORMAT_VERSION_MINOR >= 13) avformat_network_deinit(); #endif av_lockmgr_register(NULL); ffmpeg_init_fail: DPRINTF(E_LOG, L_MAIN, "Exiting.\n"); conffile_unload(); logger_deinit(); return ret; }
void SoftFFmpegVideo::deInitFFmpeg() { av_lockmgr_register(NULL); uninit_opts(); avformat_network_deinit(); }