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