void finish() { av_lockmgr_register(nullptr); CRYPTO_cleanup_all_ex_data(); FIPS_mode_set(0); ENGINE_cleanup(); CONF_modules_unload(1); ERR_remove_state(0); ERR_free_strings(); ERR_remove_thread_state(nullptr); EVP_cleanup(); delete[] _sslLocks; _sslLocks = nullptr; Platform::ThirdParty::finish(); }
LibAvDecoder::LibAvDecoder(){ if(!concurrencyRegistered){ if(av_lockmgr_register(libAv_mutexManager)){ qCritical("Failed to register LibAV concurrency manager"); throw Exception(); } concurrencyRegistered = true; } }
void dc_register_libav() { av_register_all(); avcodec_register_all(); avdevice_register_all(); avformat_network_init(); av_lockmgr_register(&lock_call_back); }
int CFfmpegDecode::initFFMPEG() { //m_state = RC_STATE_INIT; avcodec_register_all(); av_register_all(); //avformat_network_init(); if (av_lockmgr_register(lockmgr)) { // m_state = RC_STATE_INIT_ERROR; // return -1; } return 0; }
void LiveStream::init() { av_lockmgr_register(bc_av_lockmgr); av_register_all(); avformat_network_init(); m_renderTimer = new AutoTimer; m_renderTimer->setInterval(1000 / renderTimerFps); m_renderTimer->setSingleShot(false); m_stateTimer = new AutoTimer; m_stateTimer->setInterval(15000); m_stateTimer->setSingleShot(false); }
static void init_once() { av_register_all(); avdevice_register_all(); #if LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(53, 13, 0) avformat_network_init(); #endif av_lockmgr_register(avcodecManageMutex); if (getDebugMode()) setAvLogLevel(); }
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); }
/** * To debug ffmpeg", type this command on the console before starting playback: * setprop debug.nam.ffmpeg 1 * To disable the debug, type: * setprop debug.nam.ffmpge 0 */ status_t initFFmpeg() { status_t ret = OK; bool debug_enabled = false; char value[PROPERTY_VALUE_MAX]; pthread_mutex_lock(&init_mutex); if (property_get("debug.nam.ffmpeg", value, NULL) && (!strcmp(value, "1") || !av_strcasecmp(value, "true"))) { LOGI("set ffmpeg debug level to AV_LOG_DEBUG"); debug_enabled = true; } if (debug_enabled) av_log_set_level(AV_LOG_DEBUG); else av_log_set_level(AV_LOG_INFO); if(ref_count == 0) { nam_av_log_set_flags(AV_LOG_SKIP_REPEATED); av_log_set_callback(nam_av_log_callback); /* register all codecs, demux and protocols */ avcodec_register_all(); #if CONFIG_AVDEVICE avdevice_register_all(); #endif av_register_all(); avformat_network_init(); /* register android source */ ffmpeg_register_android_source(); init_opts(); if (av_lockmgr_register(lockmgr)) { LOGE("could not initialize lock manager!"); ret = NO_INIT; } } // update counter ref_count++; pthread_mutex_unlock(&init_mutex); return ret; }
int groove_init(void) { av_lockmgr_register(&my_lockmgr_cb); srand(time(NULL)); // register all codecs, demux and protocols avcodec_register_all(); av_register_all(); avformat_network_init(); avfilter_register_all(); should_deinit_network = 1; av_log_set_level(AV_LOG_QUIET); return 0; }
void initialize() { Mutex::ScopedLock lock(_mutex); if (++_refCount == 1) { // Before doing anything disable logging as it interferes with layout tests. //av_log_set_level(AV_LOG_QUIET); // Register our protocol glue code with FFmpeg. av_lockmgr_register(&LockManagerOperation); // Now register the rest of FFmpeg. av_register_all(); } }
int ffmpeg_init(void) { if (basic_init > 0) { return 0; } basic_init++; av_register_all(); av_lockmgr_register(ffmpeg_lock); url_set_interrupt_cb(ffmpeg_interrupt_callback); kill_item_list.max_items = MAX_PLAYER_THREADS; kill_item_list.item_ext_buf_size = 0; kill_item_list.muti_threads_access = 1; kill_item_list.reject_same_item_data = 1; itemlist_init(&kill_item_list); return 0; }
static void avformat_init( ) { // Initialise avformat if necessary if ( avformat_initialised == 0 ) { avformat_initialised = 1; av_lockmgr_register( &avformat_lockmgr ); av_register_all( ); #ifdef AVDEVICE avdevice_register_all(); #endif #if LIBAVFORMAT_VERSION_INT >= ((53<<16)+(13<<8)) avformat_network_init(); #endif av_log_set_level( mlt_log_get_level() ); } }
bool FFmpegCommon::initFFmpeg() { if ( !initDone ) { av_lockmgr_register( lockManager ); avcodec_register_all(); av_register_all(); avfilter_register_all(); initDone = true; /*const AVCodecDescriptor *desc = NULL; desc = avcodec_descriptor_next( desc ); while ( desc ) { qDebug() << desc->name; //qDebug() << " " << desc->long_name; desc = avcodec_descriptor_next( desc ); }*/ /*const AVOutputFormat *format = NULL; format = av_oformat_next( format ); while ( format ) { qDebug() << format->name << avcodec_get_name( format->video_codec ) << avcodec_get_name( format->audio_codec ); format = av_oformat_next( format ); }*/ h264CodecNames << "default"; hevcCodecNames << "default"; AVCodec * codec = av_codec_next(NULL); while (codec != NULL) { if (av_codec_is_encoder(codec) && codec->type == AVMEDIA_TYPE_VIDEO) { QString cn = codec->name; if (cn.contains("264")) { qDebug() << codec->name; h264CodecNames << codec->name; } else if (cn.contains("hevc") || cn.contains("265")) { qDebug() << codec->name; hevcCodecNames << codec->name; } } codec = av_codec_next(codec); } } return initDone; }
void start() { Platform::ThirdParty::start(); if (!RAND_status()) { // should be always inited in all modern OS char buf[16]; memcpy(buf, &_msStart, 8); memcpy(buf + 8, &_msFreq, 8); uchar sha256Buffer[32]; RAND_seed(hashSha256(buf, 16, sha256Buffer), 32); if (!RAND_status()) { LOG(("MTP Error: Could not init OpenSSL rand, RAND_status() is 0...")); } } // Force OpenSSL loading if it is linked in Qt, // so that we won't mess with our OpenSSL locking with Qt OpenSSL locking. auto sslSupported = QSslSocket::supportsSsl(); if (!sslSupported) { LOG(("Error: current Qt build doesn't support SSL requests.")); } if (!CRYPTO_get_locking_callback()) { // Qt didn't initialize OpenSSL, so we will. auto numLocks = CRYPTO_num_locks(); if (numLocks) { _sslLocks = new QMutex[numLocks]; CRYPTO_set_locking_callback(_sslLockingCallback); } else { LOG(("MTP Error: Could not init OpenSSL threads, CRYPTO_num_locks() returned zero!")); } CRYPTO_THREADID_set_callback(_sslThreadId); } if (!CRYPTO_get_dynlock_create_callback()) { CRYPTO_set_dynlock_create_callback(_sslCreateFunction); CRYPTO_set_dynlock_lock_callback(_sslLockFunction); CRYPTO_set_dynlock_destroy_callback(_sslDestroyFunction); } else if (!CRYPTO_get_dynlock_lock_callback()) { LOG(("MTP Error: dynlock_create callback is set without dynlock_lock callback!")); } av_register_all(); avcodec_register_all(); av_lockmgr_register(_ffmpegLockManager); _sslInited = true; }
LibavStreamer::LibavStreamer(const async_web_server_cpp::HttpRequest &request, async_web_server_cpp::HttpConnectionPtr connection, image_transport::ImageTransport it, const std::string &format_name, const std::string &codec_name, const std::string &content_type) : ImageStreamer(request, connection, it), output_format_(0), format_context_(0), codec_(0), codec_context_(0), video_stream_( 0), frame_(0), picture_(0), tmp_picture_(0), sws_context_(0), first_image_timestamp_(0), format_name_( format_name), codec_name_(codec_name), content_type_(content_type) { bitrate_ = request.get_query_param_value_or_default<int>("bitrate", 100000); qmin_ = request.get_query_param_value_or_default<int>("qmin", 10); qmax_ = request.get_query_param_value_or_default<int>("qmax", 42); gop_ = request.get_query_param_value_or_default<int>("gop", 250); av_lockmgr_register(&ffmpeg_boost_mutex_lock_manager); av_register_all(); }
int main(int argc, char* argv[]){ QCoreApplication::setOrganizationName("Ibrahim Sha'ath"); QCoreApplication::setOrganizationDomain("ibrahimshaath.co.uk"); QCoreApplication::setApplicationName(GuiStrings::getInstance()->appName()); // libav setup av_register_all(); av_log_set_level(AV_LOG_ERROR); av_lockmgr_register(NULL); // primitive command line use if(argc > 2){ int cliResult = commandLineInterface(argc,argv); if(cliResult >= 0) return cliResult; } qInstallMsgHandler(LoggingHandler); QApplication a(argc, argv); QTranslator qtTranslator; qtTranslator.load("qt_" + QLocale::system().name(), QLibraryInfo::location(QLibraryInfo::TranslationsPath)); a.installTranslator(&qtTranslator); QString localeParam = "%1/Translations/is_keyfinder_%2.qm"; #if defined Q_OS_MAC QDir dir(QApplication::applicationDirPath()); dir.cdUp(); QString localePath = localeParam.arg(dir.absolutePath()).arg(QLocale::system().name()); #elif defined Q_OS_LINUX QString localePath = localeParam.arg(WORK_CACHEDIR).arg(QLocale::system().name()); #else QString localePath = localeParam.arg(QCoreApplication::applicationDirPath()).arg(QLocale::system().name()); #endif QTranslator myappTranslator; myappTranslator.load(localePath); a.installTranslator(&myappTranslator); MainMenuHandler* menuHandler = new MainMenuHandler(0); menuHandler->new_Batch_Window(true); return a.exec(); }
void finish() { av_lockmgr_register(nullptr); CRYPTO_cleanup_all_ex_data(); #ifndef LIBRESSL_VERSION_NUMBER FIPS_mode_set(0); #endif ENGINE_cleanup(); CONF_modules_unload(1); ERR_remove_state(0); ERR_free_strings(); ERR_remove_thread_state(nullptr); EVP_cleanup(); delete[] base::take(_sslLocks); Platform::ThirdParty::finish(); }
JNIEXPORT jint JNICALL Java_com_jazzros_ffmpegtest_AVThread_nativeOpenFromFile(JNIEnv* env, jobject thiz, jstring mediafile) { __android_log_print(ANDROID_LOG_INFO, "com.jazzros.ffmpegtest", "nativeOpenFromFile()"); #ifdef USE_AV_LOCK_MANAGER // enable thread locking initializePfLockMgr(); av_lockmgr_register(pfLockMgr); __android_log_print(ANDROID_LOG_INFO, "com.jazzros.ffmpegtest", "av_lockmgr_register()"); #else __android_log_print(ANDROID_LOG_INFO, "com.jazzros.ffmpegtest", "av_lockmgr_register() not supported"); #endif // avcodec_init(); av_register_all(); avcodec_register_all(); av_log_set_callback (log_default_callback); const char* mfileName = (*env)->GetStringUTFChars(env, mediafile, 0); if (mfileName == 0) { __android_log_print(ANDROID_LOG_ERROR, "com.jazzros.ffmpegtest", "failed to retrieve media file name"); return -1; } __android_log_print(ANDROID_LOG_INFO, "com.jazzros.ffmpegtest", "opening %s", mfileName); int result = avformat_open_input(&gFormatCtx, mfileName, NULL, NULL); (*env)->ReleaseStringUTFChars(env, mediafile, mfileName); //always release the java string reference if (result != 0) { __android_log_print(ANDROID_LOG_ERROR, "com.jazzros.ffmpegtest", "avformat_open_input() failed"); return -2; } if (avformat_find_stream_info(gFormatCtx, NULL) < 0) { __android_log_print(ANDROID_LOG_ERROR, "com.jazzros.ffmpegtest", "avformat_find_stream_info() failed"); return -3; } return 0; }
HRESULT FFmpegDecodeFilter::GetService(REFIID riid, void** ppv) { std::lock_guard<decltype(_mutex)> lock(_mutex); if (_services == NULL) { avcodec_register_all(); av_lockmgr_register(&AVCodecMTLockCallback); //or to use InitOnceExecuteOnce. auto p = new(std::nothrow) FFmpegDecodeServices(); if (p == NULL) return E_OUTOFMEMORY; p->QueryInterface(IID_PPV_ARGS(&_services)); p->Release(); } if (ppv == NULL) return E_POINTER; if (_services == NULL) return E_ABORT; return _services->QueryInterface(riid, ppv); }
j_result_t CH264Decoder::InidDecoder() { J_OS::LOGINFO("CH264Decoder::InidDecoder"); #if LIBAVCODEC_VERSION_MAJOR < 54 avcodec_init(); #endif avcodec_register_all(); #ifdef _DEBUG av_log_set_callback(LogCallBack); #endif av_lockmgr_register(lockmgr); av_init_packet(&m_Packet); #ifdef WIN32 m_pCodec = avcodec_find_decoder(CODEC_ID_H264); m_pContext = avcodec_alloc_context(); #else m_pCodec = avcodec_find_decoder(AV_CODEC_ID_H264); m_pContext = avcodec_alloc_context3(m_pCodec); #endif if(!m_pCodec || !m_pContext) return J_DECODER_INIT_ERROR; if(m_pCodec->capabilities & CODEC_CAP_TRUNCATED) m_pContext->flags|= CODEC_FLAG_TRUNCATED; /*we do not send complete frames */ #ifdef WIN32 if(avcodec_open(m_pContext,m_pCodec) < 0) #else if(avcodec_open2(m_pContext,m_pCodec, NULL) < 0) #endif return J_DECODER_INIT_ERROR; m_pPicture = avcodec_alloc_frame(); if (!m_pPicture) return J_DECODER_INIT_ERROR; m_bInit = true; return J_OK; }
void FormatBaseStream::initialize() { if (!isInitialized) { LOGDEBUG("Init ffmpeg Libraries"); /* register all codecs, demux and protocols */ avcodec_register_all(); av_register_all(); avfilter_register_all(); avformat_network_init(); /*setup own logging callback*/ av_log_set_callback(FormatBaseStream::mhive_log_default_callback); av_log_set_level(AV_LOG_INFO); /* install my own lock manager * this is needed for multithreaded environment */ av_lockmgr_register(lockmgr); isInitialized = true; } }
status_t SoftFFmpegVideo::initFFmpeg() { //nam_av_log_set_flags(AV_LOG_SKIP_REPEATED); av_log_set_level(AV_LOG_DEBUG); av_log_set_callback(nam_av_log_callback); /* register all codecs, demux and protocols */ avcodec_register_all(); #if CONFIG_AVDEVICE avdevice_register_all(); #endif av_register_all(); avformat_network_init(); init_opts(); if (av_lockmgr_register(lockmgr)) { LOGE("could not initialize lock manager!"); return NO_INIT; } return OK; }
static void avformat_init( ) { // Initialise avformat if necessary if ( avformat_initialised == 0 ) { avformat_initialised = 1; av_lockmgr_register( &avformat_lockmgr ); mlt_factory_register_for_clean_up( &avformat_lockmgr, unregister_lockmgr ); av_register_all( ); #ifdef AVDEVICE avdevice_register_all(); #endif #if LIBAVFORMAT_VERSION_INT >= ((53<<16)+(13<<8)) avformat_network_init(); #endif av_log_set_level( mlt_log_get_level() ); if ( getenv("MLT_AVFORMAT_PRODUCER_CACHE") ) { int n = atoi( getenv("MLT_AVFORMAT_PRODUCER_CACHE" ) ); mlt_service_cache_set_size( NULL, "producer_avformat", n ); } } }
int nativePlayerOpen(const char* mfileName) { __android_log_print(ANDROID_LOG_INFO, "com.jazzros.ffmpegtest", "nativeOpenFromFile()"); #ifdef USE_AV_LOCK_MANAGER // enable thread locking initializePfLockMgr(); av_lockmgr_register(pfLockMgr); __android_log_print(ANDROID_LOG_INFO, "com.jazzros.ffmpegtest", "av_lockmgr_register()"); #else __android_log_print(ANDROID_LOG_INFO, "com.jazzros.ffmpegtest", "av_lockmgr_register() not supported"); #endif // avcodec_init(); av_register_all(); avcodec_register_all(); avdevice_register_all(); av_log_set_callback (log_default_callback); __android_log_print(ANDROID_LOG_INFO, "com.jazzros.ffmpegtest", "test file %s", mfileName); return gPlayerOpen(mfileName); }
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; }
/** * Showtime main */ int main(int argc, char **argv) { struct timeval tv; const char *settingspath = NULL; const char *uiargs[16]; const char *argv0 = argc > 0 ? argv[0] : "showtime"; const char *forceview = NULL; int nuiargs = 0; int can_standby = 0; int can_poweroff = 0; int r; trace_level = TRACE_INFO; gettimeofday(&tv, NULL); srand(tv.tv_usec); arch_set_default_paths(argc, argv); /* We read options ourselfs since getopt() is broken on some (nintento wii) targets */ argv++; argc--; while(argc > 0) { if(!strcmp(argv[0], "-h") || !strcmp(argv[0], "--help")) { printf("HTS Showtime %s\n" "Copyright (C) 2007-2010 Andreas Öman\n" "\n" "Usage: %s [options] [<url>]\n" "\n" " Options:\n" " -h, --help - This help text.\n" " -d - Enable debug output.\n" " --ffmpeglog - Print ffmpeg log messages.\n" " --with-standby - Enable system standby.\n" " --with-poweroff - Enable system power-off.\n" " -s <path> - Non-default Showtime settings path.\n" " --ui <ui> - Use specified user interface.\n" " -L <ip:host> - Send log messages to remote <ip:host>.\n" " --syslog - Send log messages to syslog.\n" #if ENABLE_STDIN " --stdin - Listen on stdin for events.\n" #endif " -v <view> - Use specific view for <url>.\n" " --cache <path> - Set path for cache [%s].\n" #if ENABLE_SERDEV " --serdev - Probe service ports for devices.\n" #endif "\n" " URL is any URL-type supported by Showtime, " "e.g., \"file:///...\"\n" "\n", htsversion_full, argv0, showtime_cache_path); exit(0); argc--; argv++; } else if(!strcmp(argv[0], "-d")) { trace_level++; argc -= 1; argv += 1; continue; } else if(!strcmp(argv[0], "--ffmpeglog")) { ffmpeglog = 1; argc -= 1; argv += 1; continue; } else if(!strcmp(argv[0], "--syslog")) { trace_to_syslog = 1; argc -= 1; argv += 1; continue; } else if(!strcmp(argv[0], "--stdin")) { listen_on_stdin = 1; argc -= 1; argv += 1; continue; #if ENABLE_SERDEV } else if(!strcmp(argv[0], "--serdev")) { enable_serdev = 1; argc -= 1; argv += 1; continue; #endif } else if(!strcmp(argv[0], "--with-standby")) { can_standby = 1; argc -= 1; argv += 1; continue; } else if(!strcmp(argv[0], "--with-poweroff")) { can_poweroff = 1; argc -= 1; argv += 1; continue; } else if(!strcmp(argv[0], "-s") && argc > 1) { settingspath = argv[1]; argc -= 2; argv += 2; continue; } else if(!strcmp(argv[0], "--ui") && argc > 1) { if(nuiargs < 16) uiargs[nuiargs++] = argv[1]; argc -= 2; argv += 2; continue; } else if(!strcmp(argv[0], "-L") && argc > 1) { showtime_logtarget = argv[1]; argc -= 2; argv += 2; continue; } else if (!strcmp(argv[0], "-v") && argc > 1) { forceview = argv[1]; argc -= 2; argv += 2; } else if (!strcmp(argv[0], "--cache") && argc > 1) { mystrset(&showtime_cache_path, argv[1]); argc -= 2; argv += 2; #ifdef __APPLE__ /* ignore -psn argument, process serial number */ } else if(!strncmp(argv[0], "-psn", 4)) { argc -= 1; argv += 1; continue; #endif } else break; } unicode_init(); /* Initialize property tree */ prop_init(); init_global_info(); /* Initiailize logging */ trace_init(); /* Callout framework */ callout_init(); /* Notification framework */ notifications_init(); /* Architecture specific init */ arch_init(); htsmsg_store_init(); /* Try to create cache path */ if(showtime_cache_path != NULL && (r = makedirs(showtime_cache_path)) != 0) { TRACE(TRACE_ERROR, "cache", "Unable to create cache path %s -- %s", showtime_cache_path, strerror(r)); showtime_cache_path = NULL; } /* Initializte blob cache */ blobcache_init(); /* Try to create settings path */ if(showtime_settings_path != NULL && (r = makedirs(showtime_settings_path)) != 0) { TRACE(TRACE_ERROR, "settings", "Unable to create settings path %s -- %s", showtime_settings_path, strerror(r)); showtime_settings_path = NULL; } /* Initialize keyring */ keyring_init(); /* Initialize settings */ settings_init(); /* Initialize libavcodec & libavformat */ av_lockmgr_register(fflockmgr); av_log_set_callback(fflog); av_register_all(); /* Freetype keymapper */ #if ENABLE_LIBFREETYPE freetype_init(); #endif /* Global keymapper */ keymapper_init(); /* Initialize media subsystem */ media_init(); /* Service handling */ service_init(); /* Initialize backend content handlers */ backend_init(); /* Initialize navigator */ nav_init(); /* Initialize audio subsystem */ audio_init(); /* Initialize bookmarks */ bookmarks_init(); /* Initialize plugin manager and load plugins */ plugins_init(); /* Internationalization */ i18n_init(); nav_open(NAV_HOME, NULL); /* Open initial page */ if(argc > 0) nav_open(argv[0], forceview); /* Various interprocess communication stuff (D-Bus on Linux, etc) */ ipc_init(); /* Service discovery. Must be after ipc_init() (d-bus and threads, etc) */ sd_init(); /* Initialize various external APIs */ api_init(); /* HTTP server and UPNP */ #if ENABLE_HTTPSERVER http_server_init(); upnp_init(); #endif /* */ runcontrol_init(can_standby, can_poweroff); TRACE(TRACE_DEBUG, "core", "Starting UI"); /* Initialize user interfaces */ ui_start(nuiargs, uiargs, argv0); finalize(); }
static void unregister_lockmgr( void *p ) { av_lockmgr_register( NULL ); }
void CCDataManager::Run() { //this is register for all ffmpeg action av_register_all(); //this is for mutli-thread ffmpeg working if(av_lockmgr_register(ffmpegLockManager)) { // TODO Failure av_lockmgr_register } CCSystemAlarm::GetInstance()->RegisterSystemAlarm(this); std::string mediaUrl; AVFormatContext *pAVFormatContext = NULL; int asIndex = -1; int vsIndex = -1; DataManagerStatus status = DATA_MANAGER_STATUS_ENUM_INIT; unsigned int decodersStatus = DECODERS_STATUS_ENUM_NONE_READY; int audioPacketQueueSize = 0; int videoPacketQueueSize = 0; while(m_bRunning) { SmartPtr<Event> event; if(PopFrontMessage(event)) { //std::cout << "event.GetPtr()->type=" << event.GetPtr()->type << std::endl; switch(event.GetPtr()->type) { case MESSAGE_TYPE_ENUM_OPEN_FILE: { mediaUrl = any_cast<std::string>(event.GetPtr()->anyParams); //AVCodecContext* pAudioCtx = NULL; //AVCodecContext* pVideoCtx = NULL; int ret = OpenFile(mediaUrl, &pAVFormatContext, &asIndex, &vsIndex); if(ret == 0) if(ret == 0) { //GetCodecContext(pAVFormatContext, asIndex, &pAudioCtx); //GetCodecContext(pAVFormatContext, vsIndex, &pVideoCtx); //status = DATA_MANAGER_STATUS_ENUM_WORKING; } std::vector<Any> openedParams; openedParams.push_back(Any(ret)); openedParams.push_back(Any(pAVFormatContext)); openedParams.push_back(Any(asIndex)); openedParams.push_back(Any(vsIndex)); PostMessage(MESSAGE_OBJECT_ENUM_DATA_MANAGER, MESSAGE_OBJECT_ENUM_PLAYER, MESSAGE_TYPE_ENUM_OPENED_FILE, openedParams); } break; case MESSAGE_TYPE_ENUM_AUDIO_DECODER_READY: { decodersStatus += DECODERS_STATUS_ENUM_AUDIO_READY; if(decodersStatus == DECODERS_STATUS_ENUM_ALL_READY) { status = DATA_MANAGER_STATUS_ENUM_WORKING; } } break; case MESSAGE_TYPE_ENUM_VIDEO_DECODER_READY: { decodersStatus += DECODERS_STATUS_ENUM_VIDEO_READY; if(decodersStatus == DECODERS_STATUS_ENUM_ALL_READY) { status = DATA_MANAGER_STATUS_ENUM_WORKING; } } break; case MESSAGE_TYPE_ENUM_AUDIO_DEOCDER_A_PACKET: { //status = DATA_MANAGER_STATUS_ENUM_SLEEPING; //we decoded a audio packet audioPacketQueueSize --; } break; case MESSAGE_TYPE_ENUM_VIDEO_DECODER_A_PACKET: { //status = DATA_MANAGER_STATUS_ENUM_SLEEPING; //we decoded a video packet videoPacketQueueSize --; } break; case MESSAGE_TYPE_ENUM_CLIENT_STOP: { status = DATA_MANAGER_STATUS_ENUM_DEADED; } break; default: std::cout << "Unknow Data Manager Message" << std::endl; break; } } switch(status) { case DATA_MANAGER_STATUS_ENUM_INIT: { } break; case DATA_MANAGER_STATUS_ENUM_WORKING: { if(audioPacketQueueSize < MAX_AUDIO_PACKET_QUEUE_SIZE || videoPacketQueueSize < MAX_VIDEO_PACKET_QUEUE_SIZE) { SmartPtr<CCPacket> packet(new CCPacket()); if(av_read_frame(pAVFormatContext, packet.GetPtr()->GetPacketPointer()) < 0) { PostMessage(MESSAGE_OBJECT_ENUM_DATA_MANAGER, MESSAGE_OBJECT_ENUM_AUDIO_DECODER, MESSAGE_TYPE_ENUM_DATA_MANAGER_EOF, Any()); PostMessage(MESSAGE_OBJECT_ENUM_DATA_MANAGER, MESSAGE_OBJECT_ENUM_VIDEO_DECODER, MESSAGE_TYPE_ENUM_DATA_MANAGER_EOF, Any()); //std::cout << "endend==========================================endend" << std::endl; m_bRunning = false; continue; } //CCFrequencyWorker::Wait(); //Sleep(2); if(packet.GetPtr()->GetPacketPointer()->stream_index == asIndex) { PostMessage(MESSAGE_OBJECT_ENUM_DATA_MANAGER, MESSAGE_OBJECT_ENUM_AUDIO_DECODER, MESSAGE_TYPE_ENUM_GET_AUDIO_PACKET, Any(packet)); //we got a audio packet audioPacketQueueSize ++; }else if(packet.GetPtr()->GetPacketPointer()->stream_index == vsIndex) { PostMessage(MESSAGE_OBJECT_ENUM_DATA_MANAGER, MESSAGE_OBJECT_ENUM_VIDEO_DECODER, MESSAGE_TYPE_ENUM_GET_VIDEO_PACKET, Any(packet)); //we got a video packet videoPacketQueueSize ++; } }// if audio packet enough or video packet enough else { Sleep(10); } } break; case DATA_MANAGER_STATUS_ENUM_SLEEPING: { Sleep(50); //after we have a reset , we should working //status = DATA_MANAGER_STATUS_ENUM_WORKING; } break; case DATA_MANAGER_STATUS_ENUM_DEADING: { } break; case DATA_MANAGER_STATUS_ENUM_DEADED: { m_bRunning = false; continue; } break; } // end switch } CCSystemAlarm::GetInstance()->UnRegisterSystemAlarm(this); }
int main(int argc,char **argv) { //Set default values bool forking = false; int port = 8080; int rtmpPort = 1935; const char *logfile = "mcu.log"; const char *pidfile = "mcu.pid"; //Get all for(int i=1;i<argc;i++) { //Check options if (strcmp(argv[i],"-h")==0 || strcmp(argv[i],"--help")==0) { //Show usage printf("Usage: mcu [-h] [--help] [--mcu-log logfile] [--mcu-pid pidfile] [--http-port port] [--rtmp-port port]\r\n\r\n" "Options:\r\n" " -h,--help Print help\r\n" " -f Run as daemon in safe mode\r\n" " --mcu-log Set mcu log file path (default: mcu.log)\r\n" " --mcu-pid Set mcu pid file path (default: mcu.pid)\r\n" " --http-port Set HTTP xmlrpc api port\r\n" " --rtmp-port Set RTMP xmlrpc api port\r\n"); //Exit return 0; } else if (strcmp(argv[i],"-f")==0) //Fork forking = true; else if (strcmp(argv[i],"--http-port")==0 && (i+1<argc)) //Get port port = atoi(argv[++i]); else if (strcmp(argv[i],"--rtmp-port")==0 && (i+1<argc)) //Get rtmp port rtmpPort = atoi(argv[++i]); else if (strcmp(argv[i],"--mcu-log")==0 && (i+1<argc)) //Get rtmp port logfile = argv[++i]; else if (strcmp(argv[i],"--mcu-pid")==0 && (i+1<argc)) //Get rtmp port pidfile = argv[++i]; } //Loop while(forking) { //Create the chld pid_t pid = fork(); // fork error if (pid<0) exit(1); // parent exits if (pid>0) exit(0); //Log printf("MCU started\r\n"); //Create the safe child pid = fork(); //Check pid if (pid==0) { //It is the child obtain a new process group setsid(); //for each descriptor for (int i=getdtablesize();i>=0;--i) //Close it close(i); //Redirect stdout and stderr int fd = open(logfile, O_WRONLY | O_CREAT | O_APPEND, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH); dup(fd); dup2(1,2); close(fd); //And continule break; } else if (pid<0) //Error return 0; //Pid string char spid[16]; //Print it sprintf(spid,"%d",pid); //Write pid to file int pfd = open(pidfile, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH); //Write it write(pfd,spid,strlen(spid)); //Close it close(pfd); int status; do { //Wait for child if (waitpid(pid, &status, WUNTRACED | WCONTINUED)<0) return -1; //If it has exited or stopped if (WIFEXITED(status) || WIFSTOPPED(status)) //Exit return 0; //If we have been killed if (WIFSIGNALED(status) && WTERMSIG(status)==9) //Exit return 0; } while (!WIFEXITED(status) && !WIFSIGNALED(status)); } //Dump core on fault rlimit l = {RLIM_INFINITY,RLIM_INFINITY}; //Set new limit setrlimit(RLIMIT_CORE, &l); //Register mutext for ffmpeg av_lockmgr_register(lock_ffmpeg); //Set log level av_log_set_callback(log_ffmpeg); //Ignore SIGPIPE signal( SIGPIPE, SIG_IGN ); //Create servers XmlRpcServer server(port); RTMPServer rtmpServer; // Live555MediaServer* rtspServer = Live555MediaServer::Instance(); //Create services MCU mcu; Broadcaster broadcaster; MediaGateway mediaGateway; JSR309Manager jsr309Manager; //Create xml cmd handlers for the mcu and broadcaster XmlHandler xmlrpcmcu(mcuCmdList,(void*)&mcu); XmlHandler xmlrpcbroadcaster(broadcasterCmdList,(void*)&broadcaster); XmlHandler xmlrpcmediagateway(mediagatewayCmdList,(void*)&mediaGateway); XmlHandler xmlrpcjsr309(jsr309CmdList,(void*)&jsr309Manager); //Create http streaming for service events XmlStreamingHandler xmleventjsr309; XmlStreamingHandler xmleventmcu; //And default status hanlder StatusHandler status; //Init de mcu mcu.Init(&xmleventmcu); //Init the broadcaster broadcaster.Init(); //Init the media gateway mediaGateway.Init(); //INit the jsr309 jsr309Manager.Init(&xmleventjsr309); //Add the rtmp application from the mcu to the rtmp server rtmpServer.AddApplication(L"mcu/",&mcu); //Add the rtmp applications from the broadcaster to the rmtp server rtmpServer.AddApplication(L"broadcaster/publish",&broadcaster); rtmpServer.AddApplication(L"broadcaster",&broadcaster); rtmpServer.AddApplication(L"streamer/mp4",&broadcaster); rtmpServer.AddApplication(L"streamer/flv",&broadcaster); //Add the rtmp applications from the media gateway rtmpServer.AddApplication(L"bridge/input",&mediaGateway); rtmpServer.AddApplication(L"bridge/output",&mediaGateway); //Append mcu cmd handler to the http server server.AddHandler(string("/mcu"),&xmlrpcmcu); server.AddHandler(string("/broadcaster"),&xmlrpcbroadcaster); server.AddHandler(string("/mediagateway"),&xmlrpcmediagateway); server.AddHandler(string("/jsr309"),&xmlrpcjsr309); server.AddHandler(string("/events/jsr309"),&xmleventjsr309); server.AddHandler(string("/events/mcu"),&xmleventmcu); #ifdef FLASHSTREAMER Flash flash; flash.Init(); XmlHandler xmlrpcFlash(flashCmdList,(void*)&flash); //Append flash cmldhandler server.AddHandler(string("/flash"),&xmlrpcFlash); #endif //Add the html status handler server.AddHandler(string("/status"),&status); //Init the rtmp server rtmpServer.Init(rtmpPort); // rtsp addon by liuhong // Init and start rtsp server //rtspServer->Init(); //Run it server.Start(); //End the rtmp server rtmpServer.End(); //End the mcu mcu.End(); //End the broadcaster broadcaster.End(); //End the media gateway mediaGateway.End(); //End the jsr309 jsr309Manager.End(); #ifdef FLASHSTREAMER //End flash player flash.End(); #endif }
int main(int argc, char* argv[]) { musicd_start_time = time(NULL); config_init(); config_set_hook("log-level", log_level_changed); config_set_hook("log-time-format", log_time_format_changed); config_set("log-level", "debug"); config_set_hook("directory", directory_changed); config_set("config", "~/.musicd.conf"); config_set("directory", "~/.musicd"); config_set("bind", "any"); config_set("port", "6800"); config_set_hook("image-prefix", scan_image_prefix_changed); config_set("image-prefix", "front,cover,jacket"); config_set("server-name", "musicd server"); if (config_load_args(argc, argv)) { musicd_log(LOG_FATAL, "main", "invalid command line arguments"); print_usage(argv[0]); return -1; } if (config_get_value("help")) { print_usage(argv[0]); return 0; } if (config_get_value("version")) { print_version(); return 0; } if (!config_to_bool("no-config") && config_load_file(config_to_path("config"))) { musicd_log(LOG_FATAL, "main", "could not read config file"); return -1; } /* Reload command line arguments - this is because the config file might have * overwritten them, and the command line has the highest priority. */ config_load_args(argc, argv); confirm_directory(); musicd_log(LOG_INFO, "main", "musicd version %s", MUSICD_VERSION_STRING); srand(time(NULL)); av_register_all(); avcodec_register_all(); av_lockmgr_register(&musicd_av_lockmgr); av_log_set_level(AV_LOG_QUIET); if (db_open()) { musicd_log(LOG_FATAL, "library", "can't open database"); return -1; } if (library_open()) { musicd_log(LOG_FATAL, "main", "could not open library"); return -1; } if (cache_open()) { musicd_log(LOG_FATAL, "main", "could not open cache"); return -1; } if (server_start()) { musicd_log(LOG_FATAL, "main", "could not start server"); return -1; } signal(SIGUSR1, start_scan_signal); scan_start(); while (1) { sleep(1); } return 0; }