JNIEXPORT jint JNI_OnLoad(JavaVM *vm, void *reserved) {
av_register_all();
av_log_set_callback(av_log_callback);
return JNI_VERSION_1_4;
}
static void FFMpegPlayerAndroid_enableErrorCallback(JNIEnv *env, jobject obj) {
av_log_set_callback(FFMpegPlayerAndroid_handleErrors);
}
void
main_init(void)
{
char errbuf[512];
hts_mutex_init(&gconf.state_mutex);
hts_cond_init(&gconf.state_cond, &gconf.state_mutex);
gconf.exit_code = 1;
asyncio_init_early();
init_group(INIT_GROUP_NET);
unicode_init();
/* Initialize property tree */
prop_init();
init_global_info();
/* Initiailize logging */
trace_init();
/* Callout framework */
callout_init();
prop_init_late();
/* Initialize htsmsg_store() */
htsmsg_store_init();
/* Notification framework */
notifications_init();
/* Initialize settings */
settings_init();
TRACE(TRACE_DEBUG, "core", "Loading resources from %s", app_dataroot());
TRACE(TRACE_DEBUG, "core", "Cache path: %s", gconf.cache_path);
/* Try to create cache path */
if(gconf.cache_path != NULL &&
fa_makedirs(gconf.cache_path, errbuf, sizeof(errbuf))) {
TRACE(TRACE_ERROR, "core", "Unable to create cache path %s -- %s",
gconf.cache_path, errbuf);
gconf.cache_path = NULL;
}
/* Initialize sqlite3 */
#if ENABLE_SQLITE
db_init();
#endif
/* Initializte blob cache */
blobcache_init();
TRACE(TRACE_DEBUG, "core", "Persistent path: %s", gconf.persistent_path);
/* Try to create settings path */
if(gconf.persistent_path != NULL &&
fa_makedirs(gconf.persistent_path, errbuf, sizeof(errbuf))) {
TRACE(TRACE_ERROR, "core",
"Unable to create path for persistent storage %s -- %s",
gconf.persistent_path, errbuf);
gconf.persistent_path = NULL;
}
/* Per-item key/value store */
kvstore_init();
/* Metadata init */
#if ENABLE_METADATA
metadata_init();
metadb_init();
decoration_init();
#endif
subtitles_init();
/* Initialize keyring */
keyring_init();
#if ENABLE_LIBAV
/* Initialize libavcodec & libavformat */
av_lockmgr_register(fflockmgr);
av_log_set_callback(fflog);
av_register_all();
TRACE(TRACE_INFO, "libav", LIBAVFORMAT_IDENT", "LIBAVCODEC_IDENT", "LIBAVUTIL_IDENT" cpuflags:0x%x", av_get_cpu_flags());
#endif
init_group(INIT_GROUP_GRAPHICS);
#if ENABLE_GLW
glw_settings_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 plugin manager */
plugins_init(gconf.devplugins);
/* Start software installer thread (plugins, upgrade, etc) */
hts_thread_create_detached("swinst", swthread, NULL, THREAD_PRIO_BGTASK);
/* Internationalization */
i18n_init();
/* Video settings */
video_settings_init();
/* Various interprocess communication stuff (D-Bus on Linux, etc) */
init_group(INIT_GROUP_IPC);
/* Service discovery. Must be after ipc_init() (d-bus and threads, etc) */
if(!gconf.disable_sd)
sd_init();
/* Initialize various external APIs */
init_group(INIT_GROUP_API);
/* Asynchronous IO (Used by HTTP server, etc) */
asyncio_start();
runcontrol_init();
TRACE(TRACE_DEBUG, "SYSTEM", "Hashed device ID: %s", gconf.device_id);
if(gconf.device_type[0])
TRACE(TRACE_DEBUG, "SYSTEM", "Device type: %s", gconf.device_type);
}
void show_version(void) {
av_log_set_callback(log_callback_help);
printf(LIBAV_VERSION "\n");
print_all_libs_info(SHOW_VERSION, AV_LOG_INFO);
}
static void init_count_warnings(void)
{
av_log_set_callback(count_warnings);
num_warnings = 0;
}
static void reset_count_warnings(void)
{
av_log_set_callback(av_log_default_callback);
}
AVWRAP_DECL int AVWrapper_Init(
void (*pAddFileLogRaw)(const char*),
const char* pFilename,
const char* pDesc,
const char* pSoundFile,
const char* pFormatName,
const char* pVCodecName,
const char* pACodecName,
int Width, int Height,
int FramerateNum, int FramerateDen,
int VQuality)
{
int ret;
AddFileLogRaw = pAddFileLogRaw;
av_log_set_callback( &LogCallback );
g_Width = Width;
g_Height = Height;
g_Framerate.num = FramerateNum;
g_Framerate.den = FramerateDen;
g_VQuality = VQuality;
// initialize libav and register all codecs and formats
av_register_all();
// find format
g_pFormat = av_guess_format(pFormatName, NULL, NULL);
if (!g_pFormat)
return FatalError("Format \"%s\" was not found", pFormatName);
// allocate the output media context
g_pContainer = avformat_alloc_context();
if (!g_pContainer)
return FatalError("Could not allocate output context");
g_pContainer->oformat = g_pFormat;
// store description of file
av_dict_set(&g_pContainer->metadata, "comment", pDesc, 0);
// append extesnion to filename
char ext[16];
strncpy(ext, g_pFormat->extensions, 16);
ext[15] = 0;
ext[strcspn(ext,",")] = 0;
snprintf(g_pContainer->filename, sizeof(g_pContainer->filename), "%s.%s", pFilename, ext);
// find codecs
g_pVCodec = avcodec_find_encoder_by_name(pVCodecName);
g_pACodec = avcodec_find_encoder_by_name(pACodecName);
// add audio and video stream to container
g_pVStream = NULL;
g_pAStream = NULL;
if (g_pVCodec)
{
ret = AddVideoStream();
if (ret < 0)
return ret;
}
else
Log("Video codec \"%s\" was not found; video will be ignored.\n", pVCodecName);
if (g_pACodec)
{
g_pSoundFile = fopen(pSoundFile, "rb");
if (g_pSoundFile)
{
fread(&g_Frequency, 4, 1, g_pSoundFile);
fread(&g_Channels, 4, 1, g_pSoundFile);
AddAudioStream();
}
else
Log("Could not open %s\n", pSoundFile);
}
else
Log("Audio codec \"%s\" was not found; audio will be ignored.\n", pACodecName);
if (!g_pAStream && !g_pVStream)
return FatalError("No video, no audio, aborting...");
// write format info to log
av_dump_format(g_pContainer, 0, g_pContainer->filename, 1);
// open the output file, if needed
if (!(g_pFormat->flags & AVFMT_NOFILE))
{
if (avio_open(&g_pContainer->pb, g_pContainer->filename, AVIO_FLAG_WRITE) < 0)
return FatalError("Could not open output file (%s)", g_pContainer->filename);
}
// write the stream header, if any
avformat_write_header(g_pContainer, NULL);
g_pVFrame->pts = -1;
return 0;
}
int
main(int argc, char **argv)
{
int option;
char *configfile;
int background;
int mdns_no_rsp;
int mdns_no_daap;
int mdns_no_mpd;
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;
mdns_no_mpd = 1; // only announce if mpd protocol support is activated
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();
avfilter_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 event base (after forking) */
evbase_main = event_base_new();
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;
}
mdns_no_mpd = 0;
#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, mdns_no_mpd);
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;
}
sig_event = event_new(evbase_main, 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;
}
sig_event = event_new(evbase_main, sigfd, EV_READ, signal_kqueue_cb, NULL);
#endif
if (!sig_event)
{
DPRINTF(E_FATAL, L_MAIN, "Could not create signal event\n");
ret = EXIT_FAILURE;
goto sig_event_fail;
}
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();
sig_event_fail:
signalfd_fail:
mdns_reg_fail:
DPRINTF(E_LOG, L_MAIN, "Remote pairing deinit\n");
remote_pairing_deinit();
remote_fail:
#ifdef MPD
DPRINTF(E_LOG, L_MAIN, "MPD deinit\n");
mpd_deinit();
mpd_fail:
#endif
DPRINTF(E_LOG, L_MAIN, "HTTPd deinit\n");
httpd_deinit();
httpd_fail:
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;
}
int CTool::SetFFmpegLog()
{
//在程序初始化时设置ffmpeg日志的回调函数
av_log_set_callback(Log);
return 0;
}
// Init avcodec library and set the logger callback.
static void avelement_class_init(AVElementClass * klass)
{
av_log_set_callback(avcodec_logger);
av_log_set_level(AV_LOG_WARNING);
}
C_RESULT ffmpeg_stage_decoding_transform(ffmpeg_stage_decoding_config_t *cfg, vp_api_io_data_t *in, vp_api_io_data_t *out)
{
static const int sws_flags = SWS_FAST_BILINEAR;
AVCodecContext *pCodecCtxMP4 = cfg->pCodecCtxMP4;
AVCodecContext *pCodecCtxH264 = cfg->pCodecCtxH264;
AVFrame *pFrame = cfg->pFrame;
AVFrame *pFrameOutput = cfg->pFrameOutput;
static AVPacket packet;
int frameFinished = 0;
bool_t frameDimChanged = FALSE;
static parrot_video_encapsulation_t PaVE, prevPaVE;
#if WAIT_FOR_I_FRAME
static bool_t waitForIFrame = TRUE;
#endif
#ifdef NUM_SAMPLES
static struct timeval start_time, start_time2;
static int numsamples = 0;
#endif
if (0 == in->size) // No frame
{
FFMPEG_DEBUG ("in->size is zero, don't do anything");
return C_OK;
}
vp_os_mutex_lock( &out->lock );
if(out->status == VP_API_STATUS_INIT) // Init only code
{
out->numBuffers = 1;
out->buffers = cfg->bufferArray;
out->buffers[0] = NULL;
out->indexBuffer = 0;
out->lineSize = 0;
av_init_packet(&packet);
#if __FFMPEG_DEBUG_ENABLED
#else
av_log_set_callback (&empty_av_log_callback);
#endif
}
if (! check_and_copy_PaVE(&PaVE, in, &prevPaVE, &frameDimChanged))
{
FFMPEG_DEBUG("Received a frame without PaVE informations");
vp_os_mutex_unlock( &out->lock );
return C_FAIL;
}
if ((out->status == VP_API_STATUS_INIT) || frameDimChanged) // Init and "new frame dimensions" code
{
pCodecCtxMP4->width = PaVE.encoded_stream_width;
pCodecCtxMP4->height = PaVE.encoded_stream_height;
pCodecCtxH264->width = PaVE.encoded_stream_width;
pCodecCtxH264->height = PaVE.encoded_stream_height;
cfg->src_picture.width = PaVE.display_width;
cfg->src_picture.height = PaVE.display_height;
cfg->src_picture.format = pCodecCtxH264->pix_fmt;
cfg->dst_picture.width = PaVE.display_width;
cfg->dst_picture.height = PaVE.display_height;
out->size = avpicture_get_size(cfg->dst_picture.format, cfg->dst_picture.width, cfg->dst_picture.height);
cfg->buffer = (uint8_t *)av_realloc(cfg->buffer, out->size * sizeof(uint8_t));
out->buffers[0] = cfg->buffer;
avpicture_fill((AVPicture *)pFrameOutput, (uint8_t*)out->buffers[out->indexBuffer], cfg->dst_picture.format,
cfg->dst_picture.width, cfg->dst_picture.height);
cfg->img_convert_ctx = sws_getCachedContext(cfg->img_convert_ctx, PaVE.display_width, PaVE.display_height,
pCodecCtxH264->pix_fmt, PaVE.display_width, PaVE.display_height,
cfg->dst_picture.format, sws_flags, NULL, NULL, NULL);
if (out->status == VP_API_STATUS_INIT)
{
#ifdef NUM_SAMPLES
gettimeofday(&start_time, NULL);
#endif
out->status = VP_API_STATUS_PROCESSING;
FFMPEG_DEBUG("End of init");
}
}
#if WAIT_FOR_I_FRAME
if ( (PaVE.frame_number != (prevPaVE.frame_number +1))
&&
( PaVE.frame_number != prevPaVE.frame_number || PaVE.slice_index != (prevPaVE.slice_index+1) ) )
{
FFMPEG_DEBUG ("Missed a frame :\nPrevious was %d of type %d\nNew is %d of type %d", prevPaVE.frame_number, prevPaVE.frame_type,
PaVE.frame_number, PaVE.frame_type);
waitForIFrame = TRUE;
}
#if DISPLAY_DROPPED_FRAMES
if (waitForIFrame && PaVE.frame_type == FRAME_TYPE_P_FRAME)
{
FFMPEG_DEBUG ("Dropped a P frame\n");
dropped_frames++;
}
#endif
if(out->status == VP_API_STATUS_PROCESSING && (!waitForIFrame || (PaVE.frame_type == FRAME_TYPE_IDR_FRAME) || (PaVE.frame_type == FRAME_TYPE_I_FRAME))) // Processing code
{
waitForIFrame = FALSE;
#else
if(out->status == VP_API_STATUS_PROCESSING) // Processing code
{
#endif
/* The 'check_and_copy_PaVE' function already removed the PaVE from the 'in' buffer */
packet.data = ((unsigned char*)in->buffers[in->indexBuffer]);
packet.size = in->size;
FFMPEG_DEBUG("Size : %d", packet.size);
#ifdef NUM_SAMPLES
struct timeval end_time;
static float32_t frame_decoded_time = 0;
gettimeofday(&start_time2, NULL);
#endif
// Decode video frame
if (PaVE.video_codec == CODEC_MPEG4_VISUAL)
{
avcodec_decode_video2 (pCodecCtxMP4, pFrame, &frameFinished, &packet);
}
else if (PaVE.video_codec == CODEC_MPEG4_AVC)
{
avcodec_decode_video2 (pCodecCtxH264, pFrame, &frameFinished, &packet);
}
// Did we get a video frame?
if(frameFinished)
{
pFrameOutput->data[0] = (uint8_t*)out->buffers[out->indexBuffer];
sws_scale(cfg->img_convert_ctx, (const uint8_t *const*)pFrame->data,
pFrame->linesize, 0,
PaVE.display_height,
pFrameOutput->data, pFrameOutput->linesize);
cfg->num_picture_decoded++;
#ifdef NUM_SAMPLES
gettimeofday(&end_time, NULL);
frame_decoded_time += ((end_time.tv_sec * 1000.0 + end_time.tv_usec / 1000.0) - (start_time2.tv_sec * 1000.0 + start_time2.tv_usec / 1000.0));
if(numsamples++ > NUM_SAMPLES)
{
float32_t value = ((end_time.tv_sec * 1000.0 + end_time.tv_usec / 1000.0) - (start_time.tv_sec * 1000.0 + start_time.tv_usec / 1000.0));
printf("Frames decoded in average %f fps, received and decoded in average %f fps\n", (1000.0 / (frame_decoded_time / (float32_t)NUM_SAMPLES)), 1000.0 / (value / (float32_t)NUM_SAMPLES));
gettimeofday(&start_time, NULL);
frame_decoded_time = 0;
numsamples = 0;
}
#endif
}
else
{
printf ("Decoding failed for a %s\n", (PaVE.frame_type == FRAME_TYPE_P_FRAME) ? "P Frame" : "I Frame");
}
#if DISPLAY_DROPPED_FRAMES
if ((PaVE.frame_type == FRAME_TYPE_IDR_FRAME) || (PaVE.frame_type == FRAME_TYPE_I_FRAME))
{
if (previous_ok_frame != 0)
{
static int globalMiss = 0, globalDrop = 0, globalFrames = 0;
globalMiss += missed_frames;
globalDrop += dropped_frames;
int globalMissDrop = globalMiss + globalDrop;
int total_miss = missed_frames + dropped_frames;
int total_frames = PaVE.frame_number - previous_ok_frame;
globalFrames += total_frames;
float missPercent = (100.0 * missed_frames) / (1.0 * total_frames);
float dropPercent = (100.0 * dropped_frames) / (1.0 * total_frames);
float totalPercent = (100.0 * total_miss) / (1.0 * total_frames);
float missMean = (100.0 * globalMiss) / (1.0 * globalFrames);
float dropMean = (100.0 * globalDrop) / (1.0 * globalFrames);
float totalMean = (100.0 * globalMissDrop) / (1.0 * globalFrames);
printf ("LAST %4d F => M %4d (%4.1f%%) / D %4d (%4.1f%%) / T %4d (%4.1f%%) <=> ALL %4d F => M %4d (%4.1f%%) / D %4d (%4.1f%%) / T %4d (%4.1f%%)\n", total_frames, missed_frames, missPercent, dropped_frames, dropPercent, total_miss, totalPercent, globalFrames, globalMiss, missMean, globalDrop, dropMean, globalMissDrop, totalMean);
}
missed_frames = 0; dropped_frames = 0;
previous_ok_frame = PaVE.frame_number;
}
#endif
}
vp_os_mutex_unlock( &out->lock );
return C_OK;
}
#define FFMPEG_CHECK_AND_FREE(pointer, freeFunc) \
do \
{ \
if (NULL != pointer) \
{ \
freeFunc (pointer); \
pointer = NULL; \
} \
} while (0)
#define FFMPEG_CHECK_AND_FREE_WITH_CALL(pointer, func, freeFunc) \
do \
{ \
if (NULL != pointer) \
{ \
func (pointer); \
freeFunc (pointer); \
pointer = NULL; \
} \
} while (0)
C_RESULT ffmpeg_stage_decoding_close(ffmpeg_stage_decoding_config_t *cfg)
{
FFMPEG_CHECK_AND_FREE_WITH_CALL(cfg->pCodecCtxMP4, avcodec_close, av_free);
FFMPEG_CHECK_AND_FREE_WITH_CALL(cfg->pCodecCtxH264, avcodec_close, av_free);
FFMPEG_CHECK_AND_FREE(cfg->pFrame, av_free);
FFMPEG_CHECK_AND_FREE(cfg->pFrameOutput, av_free);
FFMPEG_CHECK_AND_FREE(cfg->bufferArray, vp_os_free);
FFMPEG_CHECK_AND_FREE(cfg->buffer, av_free);
FFMPEG_CHECK_AND_FREE(cfg->img_convert_ctx, sws_freeContext);
return C_OK;
}
