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();
}
