/* global initialization
*
* XXX: in theory we can select the filters/formats we want to support, but
* this does not work in practise.
*/
void BarPlayerInit () {
ao_initialize ();
av_register_all ();
avfilter_register_all ();
avformat_network_init ();
}
FFmpegVideo::FFmpegVideo(void)
{
pCodecCtx = NULL;
av_register_all();
}
int main(int argc, char **argv)
{
const char *filename;
AVOutputFormat *fmt;
AVFormatContext *oc;
AVStream *audio_st, *video_st;
AVCodec *audio_codec, *video_codec;
double audio_pts, video_pts;
int i;
/* Initialize libavcodec, and register all codecs and formats. */
av_register_all();
if (argc != 2) {
printf("usage: %s output_file\n"
"API example program to output a media file with libavformat.\n"
"The output format is automatically guessed according to the file extension.\n"
"Raw images can also be output by using '%%d' in the filename\n"
"\n", argv[0]);
return 1;
}
filename = argv[1];
/* allocate the output media context */
avformat_alloc_output_context2(&oc, NULL, NULL, filename);
if (!oc) {
printf("Could not deduce output format from file extension: using MPEG.\n");
avformat_alloc_output_context2(&oc, NULL, "mpeg", filename);
}
if (!oc) {
return 1;
}
fmt = oc->oformat;
/* Add the audio and video streams using the default format codecs
* and initialize the codecs. */
video_st = NULL;
audio_st = NULL;
if (fmt->video_codec != AV_CODEC_ID_NONE) {
video_st = add_video_stream(oc, &video_codec, fmt->video_codec);
}
if (fmt->audio_codec != AV_CODEC_ID_NONE) {
audio_st = add_audio_stream(oc, &audio_codec, fmt->audio_codec);
}
/* Now that all the parameters are set, we can open the audio and
* video codecs and allocate the necessary encode buffers. */
if (video_st)
open_video(oc, video_codec, video_st);
if (audio_st)
open_audio(oc, audio_codec, audio_st);
av_dump_format(oc, 0, filename, 1);
/* open the output file, if needed */
if (!(fmt->flags & AVFMT_NOFILE)) {
if (avio_open(&oc->pb, filename, AVIO_FLAG_WRITE) < 0) {
fprintf(stderr, "Could not open '%s'\n", filename);
return 1;
}
}
/* Write the stream header, if any. */
if (avformat_write_header(oc, NULL) < 0) {
fprintf(stderr, "Error occurred when opening output file\n");
return 1;
}
frame->pts = 0;
for (;;) {
/* Compute current audio and video time. */
if (audio_st)
audio_pts = (double)audio_st->pts.val * audio_st->time_base.num / audio_st->time_base.den;
else
audio_pts = 0.0;
if (video_st)
video_pts = (double)video_st->pts.val * video_st->time_base.num /
video_st->time_base.den;
else
video_pts = 0.0;
if ((!audio_st || audio_pts >= STREAM_DURATION) &&
(!video_st || video_pts >= STREAM_DURATION))
break;
/* write interleaved audio and video frames */
if (!video_st || (video_st && audio_st && audio_pts < video_pts)) {
write_audio_frame(oc, audio_st);
} else {
write_video_frame(oc, video_st);
frame->pts++;
}
}
/* Write the trailer, if any. The trailer must be written before you
* close the CodecContexts open when you wrote the header; otherwise
* av_write_trailer() may try to use memory that was freed on
* av_codec_close(). */
av_write_trailer(oc);
/* Close each codec. */
if (video_st)
close_video(oc, video_st);
if (audio_st)
close_audio(oc, audio_st);
/* Free the streams. */
for (i = 0; i < oc->nb_streams; i++) {
av_freep(&oc->streams[i]->codec);
av_freep(&oc->streams[i]);
}
if (!(fmt->flags & AVFMT_NOFILE))
/* Close the output file. */
avio_close(oc->pb);
/* free the stream */
av_free(oc);
return 0;
}
int main(int argc, char* argv[]) {
// SetUnhandledExceptionFilter(callback);
SDL_Event event;
VideoState* is = NULL;
is = (VideoState*) av_mallocz(sizeof(VideoState));
if (argc < 2) {
fprintf(stderr, "Usage: test <file>\n");
exit(1);
}
av_register_all();
if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER)) {
fprintf(stderr, "Could't not initialize SDL - %s\n", SDL_GetError());
exit(1);
}
screen = SDL_CreateWindow("Hello World", SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED, WINDOW_WIDTH, WINDOW_HEIGHT, SDL_WINDOW_OPENGL);
if (!screen) {
printf("Could not initialize SDL -%s\n", SDL_GetError());
return -1;
}
render = SDL_CreateRenderer(screen, -1, 0);
screen_mutex = SDL_CreateMutex();
av_strlcpy(is->filename, argv[1], sizeof(is->filename));
is->pictq_mutex = SDL_CreateMutex();
is->pictq_cond = SDL_CreateCond();
schedule_refresh(is, 40);
is->av_sync_type = DEFAULT_AV_SYNC_TYPE;
is->parse_tid = SDL_CreateThread(decode_thread, "decode_thread", is);
if (!is->parse_tid) {
av_free(is);
return -1;
}
av_init_packet(&flush_pkt);
flush_pkt.data = (unsigned char*) "FLUSH";
for (;;) {
double incr, pos;
SDL_WaitEvent(&event);
switch (event.type) {
case SDL_KEYDOWN:
switch (event.key.keysym.sym) {
case SDLK_LEFT:
incr = -10.0;
goto do_seek;
case SDLK_RIGHT:
incr = 10.0;
goto do_seek;
case SDLK_UP:
incr = 60.0;
goto do_seek;
case SDLK_DOWN:
incr = -60.0;
goto do_seek;
do_seek: if (global_video_state) {
pos = get_master_clock(global_video_state);
pos += incr;
stream_seek(global_video_state,
(int64_t) (pos * AV_TIME_BASE), incr);
}
break;
default:
break;
}
break;
case FF_QUIT_EVENT:
case SDL_QUIT:
is->quit = 1;
SDL_Quit();
return 0;
break;
case FF_REFRESH_EVENT:
video_refresh_timer(event.user.data1);
break;
default:
break;
}
}
return 0;
}
LibAVC::LibAVC(void )
{
av_register_all();
}
///static
void QFFmpegPlayer::Init()
{
av_register_all();
avformat_network_init();
}
/** Convert an audio file to an AAC file in an MP4 container. */
int main(int argc, char **argv)
{
AVFormatContext *input_format_context = NULL, *output_format_context = NULL;
AVCodecContext *input_codec_context = NULL, *output_codec_context = NULL;
AVAudioResampleContext *resample_context = NULL;
AVAudioFifo *fifo = NULL;
int ret = AVERROR_EXIT;
if (argc < 3) {
fprintf(stderr, "Usage: %s <input file> <output file>\n", argv[0]);
exit(1);
}
/** Register all codecs and formats so that they can be used. */
av_register_all();
/** Open the input file for reading. */
if (open_input_file(argv[1], &input_format_context,
&input_codec_context))
goto cleanup;
/** Open the output file for writing. */
if (open_output_file(argv[2], input_codec_context,
&output_format_context, &output_codec_context))
goto cleanup;
/** Initialize the resampler to be able to convert audio sample formats. */
if (init_resampler(input_codec_context, output_codec_context,
&resample_context))
goto cleanup;
/** Initialize the FIFO buffer to store audio samples to be encoded. */
if (init_fifo(&fifo))
goto cleanup;
/** Write the header of the output file container. */
if (write_output_file_header(output_format_context))
goto cleanup;
/**
* Loop as long as we have input samples to read or output samples
* to write; abort as soon as we have neither.
*/
while (1) {
/** Use the encoder's desired frame size for processing. */
const int output_frame_size = output_codec_context->frame_size;
int finished = 0;
/**
* Make sure that there is one frame worth of samples in the FIFO
* buffer so that the encoder can do its work.
* Since the decoder's and the encoder's frame size may differ, we
* need to FIFO buffer to store as many frames worth of input samples
* that they make up at least one frame worth of output samples.
*/
while (av_audio_fifo_size(fifo) < output_frame_size) {
/**
* Decode one frame worth of audio samples, convert it to the
* output sample format and put it into the FIFO buffer.
*/
if (read_decode_convert_and_store(fifo, input_format_context,
input_codec_context,
output_codec_context,
resample_context, &finished))
goto cleanup;
/**
* If we are at the end of the input file, we continue
* encoding the remaining audio samples to the output file.
*/
if (finished)
break;
}
/**
* If we have enough samples for the encoder, we encode them.
* At the end of the file, we pass the remaining samples to
* the encoder.
*/
while (av_audio_fifo_size(fifo) >= output_frame_size ||
(finished && av_audio_fifo_size(fifo) > 0))
/**
* Take one frame worth of audio samples from the FIFO buffer,
* encode it and write it to the output file.
*/
if (load_encode_and_write(fifo, output_format_context,
output_codec_context))
goto cleanup;
/**
* If we are at the end of the input file and have encoded
* all remaining samples, we can exit this loop and finish.
*/
if (finished) {
int data_written;
/** Flush the encoder as it may have delayed frames. */
do {
if (encode_audio_frame(NULL, output_format_context,
output_codec_context, &data_written))
goto cleanup;
} while (data_written);
break;
}
}
/** Write the trailer of the output file container. */
if (write_output_file_trailer(output_format_context))
goto cleanup;
ret = 0;
cleanup:
if (fifo)
av_audio_fifo_free(fifo);
if (resample_context) {
avresample_close(resample_context);
avresample_free(&resample_context);
}
if (output_codec_context)
avcodec_close(output_codec_context);
if (output_format_context) {
avio_close(output_format_context->pb);
avformat_free_context(output_format_context);
}
if (input_codec_context)
avcodec_close(input_codec_context);
if (input_format_context)
avformat_close_input(&input_format_context);
return ret;
}
void SysinfoDlg::GetSysinfo(){
//取得系统支持的格式信息（协议，封装格式，编码器）
av_register_all();
//初始化
si.first_c=NULL;
si.first_if=NULL;
si.first_up=NULL;
URLProtocol **pup=&(si.first_up);
avio_enum_protocols((void **)pup,0);
int up_index=0;
while((*pup)!=NULL){
CString f_index,name,isread,iswrite,priv_data_size;
int nIndex=0;
#ifdef _UNICODE
name.Format(_T("%S"),(*pup)->name);
#else
//大%S在unicode工程下，后面的参数作为ansi看待
name.Format(_T("%s"),(*pup)->name);
#endif
priv_data_size.Format(_T("%d"),(*pup)->priv_data_size);
f_index.Format(_T("%d"),up_index);
//获取当前记录条数
nIndex=sysinfosubup.m_sysinfoup.GetItemCount();
//“行”数据结构
LV_ITEM lvitem;
lvitem.mask=LVIF_TEXT;
lvitem.iItem=nIndex;
lvitem.iSubItem=0;
//注：vframe_index不可以直接赋值！
//务必使用f_index执行Format!再赋值！
lvitem.pszText=f_index.GetBuffer();
//lvitem.pszText=(LPWSTR)(LPCTSTR)f_index;
//------------------------
sysinfosubup.m_sysinfoup.InsertItem(&lvitem);
sysinfosubup.m_sysinfoup.SetItemText(nIndex,1,name);
//下一个
avio_enum_protocols((void **)pup,0);
up_index++;
}
si.first_if= av_iformat_next(NULL);
si.first_c=av_codec_next(NULL);
AVInputFormat *if_temp=si.first_if;
AVCodec *c_temp=si.first_c;
//InputFormat
int if_index=0;
while(if_temp!=NULL){
CString f_index,name,long_name,extensions,priv_data_size;
int nIndex=0;
#ifdef _UNICODE
name.Format(_T("%S"),if_temp->name);
long_name.Format(_T("%S"),if_temp->long_name);
extensions.Format(_T("%S"),if_temp->extensions);
#else
name.Format(_T("%s"),if_temp->name);
long_name.Format(_T("%s"),if_temp->long_name);
extensions.Format(_T("%s"),if_temp->extensions);
#endif
priv_data_size.Format(_T("%d"),if_temp->priv_data_size);
f_index.Format(_T("%d"),if_index);
//获取当前记录条数
nIndex=sysinfosubif.m_sysinfoif.GetItemCount();
//“行”数据结构
LV_ITEM lvitem;
lvitem.mask=LVIF_TEXT;
lvitem.iItem=nIndex;
lvitem.iSubItem=0;
//注：vframe_index不可以直接赋值！
//务必使用f_index执行Format!再赋值！
lvitem.pszText=f_index.GetBuffer();
//------------------------
sysinfosubif.m_sysinfoif.InsertItem(&lvitem);
sysinfosubif.m_sysinfoif.SetItemText(nIndex,1,name);
sysinfosubif.m_sysinfoif.SetItemText(nIndex,2,long_name);
sysinfosubif.m_sysinfoif.SetItemText(nIndex,3,extensions);
sysinfosubif.m_sysinfoif.SetItemText(nIndex,4,priv_data_size);
if_temp=if_temp->next;
if_index++;
}
//Codec
int c_index=0;
while(c_temp!=NULL){
CString f_index,name,long_name,priv_data_size,capabilities,
supported_framerates,pix_fmts,supported_samplerates,sample_fmts,channel_layouts;
int nIndex=0;
#ifdef _UNICODE
name.Format(_T("%S"),c_temp->name);
long_name.Format(_T("%S"),c_temp->long_name);
#else
name.Format(_T("%s"),c_temp->name);
long_name.Format(_T("%s"),c_temp->long_name);
#endif
priv_data_size.Format(_T("%d"),c_temp->priv_data_size);
f_index.Format(_T("%d"),c_index);
//“行”数据结构
LV_ITEM lvitem;
lvitem.mask=LVIF_TEXT;
lvitem.iSubItem=0;
switch(c_temp->type){
case AVMEDIA_TYPE_VIDEO:
if(c_temp->supported_framerates==NULL){
supported_framerates.Format(_T("Any"));
}else{
float sf_cal=0.0;
sf_cal=(c_temp->supported_framerates->num)/(c_temp->supported_framerates->den);
supported_framerates.Format(_T("%f"),sf_cal);
}
if(c_temp->pix_fmts==NULL){
pix_fmts.Format(_T("Unknown"));
}else{
const enum AVPixelFormat *pf_temp=c_temp->pix_fmts;
while(*pf_temp!=-1){
pix_fmts.AppendFormat(_T("%d;"),*pf_temp);
pf_temp++;
}
}
//获取当前记录条数
nIndex=sysinfosubvc.m_sysinfovc.GetItemCount();
lvitem.iItem=nIndex;
lvitem.pszText=f_index.GetBuffer();
//------------------------
sysinfosubvc.m_sysinfovc.InsertItem(&lvitem);
sysinfosubvc.m_sysinfovc.SetItemText(nIndex,1,name);
sysinfosubvc.m_sysinfovc.SetItemText(nIndex,2,long_name);
sysinfosubvc.m_sysinfovc.SetItemText(nIndex,3,supported_framerates);
sysinfosubvc.m_sysinfovc.SetItemText(nIndex,4,pix_fmts);
sysinfosubvc.m_sysinfovc.SetItemText(nIndex,5,priv_data_size);
break;
case AVMEDIA_TYPE_AUDIO:
if(c_temp->supported_samplerates==NULL){
supported_samplerates.Format(_T("Unknown"));
}else{
const int *sr_temp=c_temp->supported_samplerates;
while(*sr_temp!=0){
supported_samplerates.AppendFormat(_T("%d;"),*sr_temp);
sr_temp++;
}
}
if(c_temp->sample_fmts==NULL){
pix_fmts.Format(_T("Any"));
}else{
const enum AVSampleFormat *sf_temp=c_temp->sample_fmts;
while(*sf_temp!=-1){
sample_fmts.AppendFormat(_T("%d;"),*sf_temp);
sf_temp++;
}
}
//获取当前记录条数
nIndex=sysinfosubac.m_sysinfoac.GetItemCount();
lvitem.iItem=nIndex;
lvitem.pszText=f_index.GetBuffer();
//------------------------
sysinfosubac.m_sysinfoac.InsertItem(&lvitem);
sysinfosubac.m_sysinfoac.SetItemText(nIndex,1,name);
sysinfosubac.m_sysinfoac.SetItemText(nIndex,2,long_name);
sysinfosubac.m_sysinfoac.SetItemText(nIndex,3,supported_samplerates);
sysinfosubac.m_sysinfoac.SetItemText(nIndex,4,sample_fmts);
sysinfosubac.m_sysinfoac.SetItemText(nIndex,5,priv_data_size);
break;
default:
//获取当前记录条数
nIndex=sysinfosuboc.m_sysinfooc.GetItemCount();
lvitem.iItem=nIndex;
lvitem.pszText=f_index.GetBuffer();
//------------------------
sysinfosuboc.m_sysinfooc.InsertItem(&lvitem);
sysinfosuboc.m_sysinfooc.SetItemText(nIndex,1,name);
sysinfosuboc.m_sysinfooc.SetItemText(nIndex,2,long_name);
sysinfosuboc.m_sysinfooc.SetItemText(nIndex,3,priv_data_size);
break;
}
c_temp=c_temp->next;
c_index++;
}
}
int main(int argc, char *argv[])
{
AVFormatContext *pFormatCtx = NULL;
int i, videoStream;
AVCodecContext *pCodecCtx;
AVCodec *pCodec;
AVFrame *pFrame;
AVPacket packet;
int frameFinished;
int *stream_size=NULL;
int *stream_max=NULL;
int *stream_min=NULL;
double *stream_ave=NULL;
int total_max=0, total_min=INT32_MAX;
double total_ave=0;
int numberStreams;
int frame_counter=0;
int total_size=0;
int tave=0;
struct settings programSettings;
struct stat fileStat;
off_t total_file_size;
double framerate;
// default settings
programSettings.ave_len=1;
programSettings.output_stderr=0;
programSettings.output_interval=1;
programSettings.output_interval_seconds=0;
programSettings.output_progress=0;
// parse commandline options
const static char *legal_flags = "s:i:I:ePh";
int c;
char *error=NULL;
while ((c = getopt (argc, argv, legal_flags)) != -1) {
switch (c) {
case 's':
// been programming in java too much recently
// I want to catch a number format exception here
// And tell the user of their error.
programSettings.ave_len=(int)strtol(optarg, &error, 10);
if (*error || programSettings.ave_len < 1) {
fprintf(stderr,"Smoothing value is invalid\n");
print_usage();
return -1;
}
break;
case 'e':
programSettings.output_stderr=1;
break;
case 'P':
programSettings.output_progress=1;
break;
case 'i':
programSettings.output_interval=(int)strtol(optarg, &error, 10);
if (*error || programSettings.output_interval<1) {
fprintf(stderr,"Interval is invalid\n");
print_usage();
return -1;
}
break;
case 'I':
programSettings.output_interval_seconds=strtod(optarg, &error);
if (*error || programSettings.output_interval_seconds <= 0) {
fprintf(stderr,"Interval Seconds is invalid\n");
print_usage();
return -1;
}
break;
case 'h':
case '*':
print_usage();
return 0;
break;
}
}
optind--;
// argc -= optind;
argv += optind;
//fprintf (stderr, "optind = %d. Trying file: %s\n",optind,argv[1]);
// Register all formats and codecs
av_register_all();
if (argv[1] == NULL)
{
fprintf(stderr,"Error: No filename.\n");
print_usage();
return -1; // Couldn't open file
}
if (programSettings.output_progress) {
stat(argv[1], &fileStat);
// check for return error
progress_init(0,fileStat.st_size);
}
// Open video file
#if LIBAVFORMAT_VERSION_MAJOR < 53
if(av_open_input_file(&pFormatCtx, argv[1], NULL, 0, NULL)!=0)
#else
if(avformat_open_input(&pFormatCtx, argv[1], NULL, NULL)!=0)
#endif
{
fprintf(stderr,"Error: could not open file.\n");
return -1; // Couldn't open file
}
// Retrieve stream information
#if LIBAVFORMAT_VERSION_MAJOR < 53
if(av_find_stream_info(pFormatCtx)<0)
#else
if(avformat_find_stream_info(pFormatCtx,NULL)<0)
#endif
{
fprintf(stderr,"Error: could not interpret file.\n");
return -1; // Couldn't find stream information
}
// Dump information about file onto standard error
#if LIBAVFORMAT_VERSION_MAJOR < 53
dump_format(pFormatCtx, 0, argv[1], 0);
#else
av_dump_format(pFormatCtx, 0, argv[1], 0);
#endif
// As this program outputs based on video frames.
// Find the first video stream
// To determine the bitrate.
videoStream=-1;
numberStreams = pFormatCtx->nb_streams;
stream_size = (int *)malloc(numberStreams * sizeof(int));
stream_min = (int *)malloc(numberStreams * sizeof(int));
stream_max = (int *)malloc(numberStreams * sizeof(int));
stream_ave = (double *)malloc(numberStreams * sizeof(double));
for(i=0; i<numberStreams; i++) {
// fprintf (stderr,"stream: %d = %d (%s)\n",i,pFormatCtx->streams[i]->codec->codec_type ,pFormatCtx->streams[i]->codec->codec_name);
// Initialise statistic counters
stream_size[i] = 0;
stream_min[i]=INT32_MAX;
stream_max[i]=0;
stream_ave[i] = 0;
#if LIBAVFORMAT_VERSION_MAJOR < 53
if(pFormatCtx->streams[i]->codec->codec_type==CODEC_TYPE_VIDEO)
#else
if(pFormatCtx->streams[i]->codec->codec_type==AVMEDIA_TYPE_VIDEO)
#endif
{
videoStream=i;
#if LIBAVFORMAT_VERSION_MAJOR < 55
framerate = pFormatCtx->streams[i]->r_frame_rate.num;
#else
framerate = pFormatCtx->streams[i]->avg_frame_rate.num;
#endif
#if LIBAVFORMAT_VERSION_MAJOR < 55
if (pFormatCtx->streams[i]->r_frame_rate.den != 0)
framerate /= pFormatCtx->streams[i]->r_frame_rate.den;
// fprintf (stderr,"Video Stream: %d Frame Rate: %d:%d\n",videoStream,pFormatCtx->streams[i]->r_frame_rate.num,pFormatCtx->streams[i]->r_frame_rate.den);
#else
if (pFormatCtx->streams[i]->avg_frame_rate.den != 0)
framerate /= pFormatCtx->streams[i]->avg_frame_rate.den;
// fprintf (stderr,"Video Stream: %d Frame Rate: %d:%d\n",videoStream,pFormatCtx->streams[i]->avg_frame_rate.num,pFormatCtx->streams[i]->avg_frame_rate.den);
#endif
}
}
if(videoStream==-1) {
free (stream_size); free (stream_min); free (stream_max); free (stream_ave);
return -1; // Didn't find a video stream
}
// Get a pointer to the codec context for the video stream
pCodecCtx=pFormatCtx->streams[videoStream]->codec;
// Find the decoder for the video stream
pCodec=avcodec_find_decoder(pCodecCtx->codec_id);
if(pCodec==NULL) {
free (stream_size); free (stream_min); free (stream_max); free (stream_ave);
return -1; // Codec not found
}
if (framerate == 0)
{
//fprintf(stderr,"frame rate %d:%d\n",pCodecCtx->time_base.num,pCodecCtx->time_base.den);
framerate = pCodecCtx->time_base.den;
if (pCodecCtx->time_base.den != 0)
framerate /= pCodecCtx->time_base.num;
}
if (programSettings.output_interval_seconds >0)
{
if (INT32_MAX / framerate > programSettings.output_interval_seconds)
{
programSettings.output_interval = programSettings.output_interval_seconds * framerate;
} else {
fprintf(stderr,"Interval seconds too large\n");
free (stream_size); free (stream_min); free (stream_max); free (stream_ave);
return -1;
}
}
// fprintf (stderr,"Video Stream: %d Frame Rate: %g\n",videoStream,framerate);
// Open codec
#if LIBAVCODEC_VERSION_MAJOR < 52
if(avcodec_open(pCodecCtx, *pCodec)<0)
#else
if(avcodec_open2(pCodecCtx, pCodec,NULL)<0)
#endif
{
free (stream_size); free (stream_min); free (stream_max); free (stream_ave);
return -1; // Could not open codec
}
// Allocate video frame
#if LIBAVCODEC_VERSION_MAJOR < 55
pFrame=avcodec_alloc_frame();
#else
pFrame=av_frame_alloc();
#endif
int counter_interval=0;
total_file_size=0;
// Loop until nothing read
while(av_read_frame(pFormatCtx, &packet)>=0)
{
stream_size[packet.stream_index] += packet.size;
if (programSettings.output_progress) {
total_file_size += packet.size;
progress_loadBar(total_file_size);
}
// Is this a packet from the video stream?
if(packet.stream_index==videoStream)
{
// Decode video frame
// I'm not entirely sure when avcodec_decode_video was deprecated. most likely earlier than 53
#if LIBAVCODEC_VERSION_MAJOR < 52
avcodec_decode_video(pCodecCtx, pFrame, &frameFinished, packet.data, packet.size);
#else
avcodec_decode_video2(pCodecCtx, pFrame, &frameFinished, &packet);
#endif
if (counter_interval++ >= programSettings.output_interval) {
//if (!(frame_counter % ave_len)) {
// print the statistics in gnuplot friendly format...
total_size=0;
for(i=0; i<numberStreams; i++) { total_size += stream_size[i]; }
// if (tave == -1) { tave = total_size; }
tave = ((tave * (programSettings.ave_len-1)) + total_size) / programSettings.ave_len / programSettings.output_interval;
if(total_min > total_size)
total_min = total_size;
if(total_max < total_size)
total_max = total_size;
total_ave += total_size;
printf ("%f ",frame_counter/framerate);
printf ("%f ",tave*8*framerate);
for(i=0; i<numberStreams; i++) {
// double rate = stream_size[i]*8*framerate/ programSettings.output_interval;
if(stream_min[i] > stream_size[i])
stream_min[i] = stream_size[i];
if(stream_max[i] < stream_size[i])
stream_max[i] = stream_size[i];
stream_ave[i] += stream_size[i];
printf ("%f ",stream_size[i]*8*framerate/ programSettings.output_interval);
stream_size[i]=0;
}
printf("\n");
//}
counter_interval = 1;
}
frame_counter++;
}
// Free the packet that was allocated by av_read_frame
#if LIBAVCODEC_VERSION_MAJOR < 52
av_freep(&packet);
#else
av_free_packet(&packet);
#endif
}
free(stream_size);
// Free the YUV frame
av_free(pFrame);
// Close the codec
avcodec_close(pCodecCtx);
// Close the video file
#if LIBAVCODEC_VERSION_MAJOR < 53
av_close_input_file(pFormatCtx);
#else
avformat_close_input(&pFormatCtx);
#endif
// Print statistics
if (programSettings.output_stderr)
{
fprintf(stderr,"%20s %20s %20s %20s\n","Stream","Min Bitrate","Average bitrate","Max bitrate");
fprintf(stderr,"%20s %20f %20f %20f\n","Total",total_min*8*framerate/ programSettings.output_interval,
total_ave * 8*framerate/ programSettings.output_interval/(frame_counter/programSettings.output_interval),
total_max*8*framerate/ programSettings.output_interval);
for(i=0; i<numberStreams; i++) {
fprintf(stderr,"%20d %20f %20f %20f\n",i,stream_min[i]*8*framerate/ programSettings.output_interval,
stream_ave[i] *8*framerate/ programSettings.output_interval/(frame_counter/programSettings.output_interval),
stream_max[i]*8*framerate/ programSettings.output_interval);
}
}
free (stream_min); free (stream_max); free (stream_ave);
return 0;
}
int phonica_init()
{
av_register_all();
return 0;
}
int main(int argc, char *argv[]) {
SDL_Event event;
VideoState *is;
is = (VideoState*)av_mallocz(sizeof(VideoState));
if (argc < 2) {
fprintf(stderr, "Usage: test <file>\n");
exit(1);
}
// Register all formats and codecs
av_register_all();
if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER)) {
fprintf(stderr, "Could not initialize SDL - %s\n", SDL_GetError());
exit(1);
}
// Make a screen to put our video
#ifndef __DARWIN__
screen = SDL_SetVideoMode(640, 480, 0, 0);
#else
screen = SDL_SetVideoMode(640, 480, 24, 0);
#endif
if (!screen) {
fprintf(stderr, "SDL: could not set video mode - exiting\n");
exit(1);
}
screen_mutex = SDL_CreateMutex();
av_strlcpy(is->filename, argv[1], sizeof(is->filename));
is->pictq_mutex = SDL_CreateMutex();
is->pictq_cond = SDL_CreateCond();
schedule_refresh(is, 40);
is->parse_tid = SDL_CreateThread(decode_thread, is);
if (!is->parse_tid) {
av_free(is);
return -1;
}
for (;;) {
SDL_WaitEvent(&event);
switch (event.type) {
case FF_QUIT_EVENT:
case SDL_QUIT:
is->quit = 1;
SDL_Quit();
return 0;
break;
case FF_REFRESH_EVENT:
video_refresh_timer(event.user.data1);
break;
default:
break;
}
}
return 0;
}
int main(int argc, char *argv[]) {
char *filename = NULL;
//char *filename_suffix = NULL;
char *inputsource = NULL;
char *outputDB = NULL;
//Find the last / in passed filename.
if (strrchr(argv[1],'/') == NULL) {
if (strcmp(argv[1],"-") == 0) {
inputsource = "/dev/stdin";
if (argv[2] == NULL) {
printf("Please input a name for the movie!\n");
return -1;
} else {
if (strrchr(argv[2],'/') == NULL) {
filename = argv[2];
} else {
filename = strrchr(argv[2],'/') + 1;
}
if (argv[3] != NULL && argc == 4) {
outputDB = argv[3];
} else {
outputDB = "/home/gsc/videoaudiofingerprint.db";
}
}
} else {
filename = argv[1];
inputsource = argv[1];
if (argv[2] != NULL && argc == 3) {
outputDB = argv[2];
} else {
outputDB = "/home/gsc/videoaudiofingerprint.db";
}
}
} else {
filename = strrchr(argv[1],'/') + 1;
inputsource = argv[1];
if (argv[3] != NULL && argc == 4) {
outputDB = argv[3];
} else {
outputDB = "/home/gsc/videoaudiofingerprint.db";
}
}
printf("Filename = %s Input source = %s DB output = %s argc = %d\n",filename,inputsource,outputDB, argc);
/*** DB initialization ***/
int retval = 0;
// Create a handle for database connection, create a pointer to sqlite3
sqlite3 *handle;
//Full array init of size 5h@60fps (a.k.a large enough)
//TO FIX: use dynamic array?
int *fullArray = (int*) calloc ( (1080000-1), sizeof (int));
// Create the database. If it doesnt exist, it would be created
// pass a pointer to the pointer to sqlite3, in short sqlite3**
retval = sqlite3_open(outputDB,&handle);
// If connection failed, handle returns NULL
if(retval) {
printf("Database connection failed\n");
return -1;
}
char query1[] = "create table allmovies (allmovieskey INTEGER PRIMARY KEY,name TEXT,fps INTEGER, date INTEGER);";
// Execute the query for creating the table
retval = sqlite3_exec(handle,query1,0,0,0);
char query2[] = "PRAGMA count_changes = OFF";
retval = sqlite3_exec(handle,query2,0,0,0);
char query3[] = "PRAGMA synchronous = OFF";
retval = sqlite3_exec(handle,query3,0,0,0);
//Hashluma table
char query_hash[] = "create table hashluma (avg_range int, movies TEXT)";
retval = sqlite3_exec(handle,query_hash,0,0,0);
if (!retval) {
//Populating the hash tables
printf("Populating hashluma table\n");
char hashquery[50];
memset(hashquery, 0, 50);
int i = 0;
for(i=0; i <= 254; i++) {
sprintf(hashquery, "insert into hashluma (avg_range) values (%d)", i);
retval = sqlite3_exec(handle,hashquery,0,0,0);
}
}
char table_query[150];
memset(table_query, 0, 150);
sprintf(table_query,"create table '%s' (s_end FLOAT, luma INTEGER);",filename);
int repeated = 0;
retval = sqlite3_exec(handle,table_query,0,0,0);
if (retval) {
char error [100];
memset(error, 0, 100);
sprintf(error,"Table for movie %s already exists! Skipping fingerprinting ... \n",filename);
printf("%s",error);
//Decide which is the best policy, not FP? overwrite? new file?
repeated = 1;
sqlite3_close(handle);
return 0;
}
/*** DB init finished ***/
printf("Analyzing video %s\n",filename);
av_register_all();
AVFormatContext *pFormatCtx;
// Open video file
if(av_open_input_file(&pFormatCtx, inputsource, NULL, 0, NULL)!=0) {
printf("Could't open file %s\n", argv[1]);
return -1; // Couldn't open file
}
// Retrieve stream information
if(av_find_stream_info(pFormatCtx)<0) {
printf("Could't find stream information\n");
return -1; // Couldn't find stream information
}
// Dump information about file onto standard error
dump_format(pFormatCtx, 0, filename, 0);
int i;
AVCodecContext *pVideoCodecCtx;
AVCodecContext *pAudioCodecCtx;
// Find the first video stream
int videoStream=-1;
int audioStream=-1;
for(i=0; i<pFormatCtx->nb_streams; i++) {
if(pFormatCtx->streams[i]->codec->codec_type==CODEC_TYPE_VIDEO && videoStream==-1)
videoStream=i;
if(pFormatCtx->streams[i]->codec->codec_type==CODEC_TYPE_AUDIO && audioStream==-1)
audioStream=i;
}
if(videoStream==-1 || audioStream==-1)
return -1; // Didn't find both streams
// Get a pointer to the codec context for the video stream
pVideoCodecCtx=pFormatCtx->streams[videoStream]->codec;
// Similar, for audio stream
pAudioCodecCtx=pFormatCtx->streams[audioStream]->codec;
AVCodec *pVideoCodec;
AVCodec *pAudioCodec;
// Find the decoder for the streams
pVideoCodec=avcodec_find_decoder(pVideoCodecCtx->codec_id);
pAudioCodec=avcodec_find_decoder(pAudioCodecCtx->codec_id);
if(pVideoCodec==NULL) {
fprintf(stderr, "Unsupported video codec!\n");
sqlite3_close(handle);
return -1; // Codec not found
}
if(pAudioCodec==NULL) {
fprintf(stderr, "Unsupported audio codec!\n");
sqlite3_close(handle);
return -1; // Codec not found
}
// Open codecs
if(avcodec_open(pVideoCodecCtx, pVideoCodec)<0) {
sqlite3_close(handle);
return -1; // Could not open codec
}
if(avcodec_open(pAudioCodecCtx, pAudioCodec)<0) {
sqlite3_close(handle);
return -1; // Could not open codec
}
AVFrame *pVideoFrame;
AVFrame *pVideoFrameYUV;
AVFrame *pAudioFrame;
int samples = 0;
// Allocate audio/video frame
pVideoFrame=avcodec_alloc_frame();
pVideoFrameYUV=avcodec_alloc_frame();
pAudioFrame=avcodec_alloc_frame();
if(pVideoFrameYUV==NULL || pVideoFrame==NULL || pAudioFrame==NULL) {
sqlite3_close(handle);
return -1;
}
uint8_t *videoBuffer;
int16_t *audioBuffer;
int numVideoBytes;
int numAudioBytes;
// Determine required buffer size and allocate buffer
numVideoBytes=avpicture_get_size(PIX_FMT_YUV420P, pVideoCodecCtx->width, pVideoCodecCtx->height);
videoBuffer=(uint8_t *)av_mallocz(numVideoBytes*sizeof(uint8_t));
numAudioBytes = AVCODEC_MAX_AUDIO_FRAME_SIZE + FF_INPUT_BUFFER_PADDING_SIZE;
audioBuffer=(int16_t *)av_mallocz(numAudioBytes);
// Assign appropriate parts of videoBuffer to image planes in pVideoFrameYUV
// Note that pVideoFrameYUV is an AVFrame, but AVFrame is a superset of AVPicture
avpicture_fill((AVPicture *)pVideoFrameYUV, videoBuffer, PIX_FMT_YUV420P, pVideoCodecCtx->width, pVideoCodecCtx->height);
int frameFinished = 0;
AVPacket packet;
av_init_packet(&packet);
struct SwsContext * sws_context;
double fps = 0.0;
struct timeval tv;
gettimeofday(&tv, NULL);
char allmovies_query[150];
memset(allmovies_query, 0, 150);
fps = (double)pFormatCtx->streams[videoStream]->r_frame_rate.num/(double)pFormatCtx->streams[videoStream]->r_frame_rate.den;
//if (repeated) {
// filename_suffix = (int)tv.tv_sec;
// sprintf(filename, "%s_%d", filename, filename_suffix);
// sprintf(allmovies_query, "insert into allmovies (name,fps,date) values ('%s',%d,%d);", filename, (int)(fps*100), filename_suffix);
//} else {
sprintf(allmovies_query, "insert into allmovies (name,fps,date) values ('%s',%d,%d);", filename, (int)(fps*100), (int)tv.tv_sec);
//}
retval = sqlite3_exec(handle,allmovies_query,0,0,0);
printf("%d %d\n",pAudioCodecCtx->sample_rate,pAudioCodecCtx->channels);
i = 0;
unsigned int offset = 0; // bytes
//fftw_complex *in;
int totalSamples = 0;
//in = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * N);
int counter = 0;
float audioTime = 0.0;
while(av_read_frame(pFormatCtx, &packet)>=0) {
// Decode video
if(packet.stream_index==videoStream) {
// Decode video frame
avcodec_decode_video2(pVideoCodecCtx, pVideoFrame, &frameFinished, &packet);
// Did we get a video frame?
if(frameFinished) {
if (pVideoCodecCtx->pix_fmt != PIX_FMT_YUV420P) {
// Convert the image from its native format to YUV (PIX_FMT_YUV420P)
//img_convert((AVPicture *)pVideoFrameYUV, PIX_FMT_YUV420P, (AVPicture*)pVideoFrame, pVideoCodecCtx->pix_fmt, pVideoCodecCtx->width, pVideoCodecCtx->height);
sws_context = sws_getContext(pVideoCodecCtx->width, pVideoCodecCtx->height, pVideoCodecCtx->pix_fmt, pVideoCodecCtx->width, pVideoCodecCtx->height, PIX_FMT_YUV420P, SWS_FAST_BILINEAR, NULL, NULL, NULL);
sws_scale(sws_context, pVideoFrame->data, pVideoFrame->linesize, 0, pVideoCodecCtx->height, pVideoFrameYUV->data, pVideoFrameYUV->linesize);
sws_freeContext(sws_context);
retval = AvgFrameImport(pVideoFrameYUV, pVideoCodecCtx->width, pVideoCodecCtx->height, i++, filename, handle, fps, fullArray);
} else {
retval = AvgFrameImport(pVideoFrame, pVideoCodecCtx->width, pVideoCodecCtx->height, i++, filename, handle, fps, fullArray);
}
}
}
// Decode audio
// http://qtdvd.com/guides/ffmpeg.html#decode
if (packet.stream_index == audioStream) {
offset = 0;
int frameSize;
int length = 0;
memset(audioBuffer, 0, sizeof(audioBuffer));
while (packet.size > 0) {
//memset(audioBuffer, 0, sizeof(audioBuffer));
frameSize = numAudioBytes;
//Copy decoded information into audioBuffer
//frameSize gets set as the decoded frameSize, in bytes
length = avcodec_decode_audio3(pAudioCodecCtx, audioBuffer, &frameSize, &packet);
if (length <= 0) { // Error, see if we can recover.
packet.size--;
packet.data++;
}
else {
//Slide pointer to next frame and update size
printf("read %d bytes\n", length);
packet.size -= length;
packet.data += length;
//Slide frame of audiobuffer
memcpy((uint16_t*)(audioBuffer+offset), audioBuffer, frameSize);
//Update offset
offset += frameSize;
}
//Do something with audioBuffer
//in = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * N);
//if (counter%2)
// printf("%f R: %d\n", audioTime, (int16_t)*audioBuffer);
//else
// printf("%f L: %d\n", audioTime, (int16_t)*audioBuffer);
printf("%f %d\n", audioTime, (int16_t)*audioBuffer);
fflush(stdout);
}
if (offset == 0)
samples = 0;
else
samples = (unsigned int)offset/sizeof(short);
totalSamples+=samples;
if (counter%2)
audioTime+=samples*1.0/pAudioCodecCtx->sample_rate;
counter++;
}
}
printf("Total time (s) (per audio sample calculation): %f\n",(float)(totalSamples*1.0/pAudioCodecCtx->sample_rate/pAudioCodecCtx->channels));
//Cut the large fullArray to the movie actual size
int *shortArray = (int*) calloc ( i, sizeof (int));
memcpy(shortArray, fullArray, i*sizeof(int));
free(fullArray);
//Do magic
makeIndexes(shortArray, handle, filename, threshold, i, fps);
// Free the packet that was allocated by av_read_frame
av_free_packet(&packet);
// Free the YUV image
av_free(videoBuffer);
av_free(audioBuffer);
av_free(pVideoFrameYUV);
// Free the YUV frame
av_free(pVideoFrame);
av_free(pAudioFrame);
// Close the codec
avcodec_close(pVideoCodecCtx);
avcodec_close(pAudioCodecCtx);
// Close the video file
av_close_input_file(pFormatCtx);
// Close DB handler
sqlite3_close(handle);
// Free full array
free(shortArray);
return 0;
}
int main(int argc, char **argv)
{
char fntemplate[PATH_MAX];
char pktfilename[PATH_MAX];
AVFormatContext *fctx;
AVPacket pkt;
int64_t pktnum = 0;
int64_t maxpkts = 0;
int donotquit = 0;
int nowrite = 0;
int err;
if ((argc > 1) && !strncmp(argv[1], "-", 1)) {
if (strchr(argv[1], 'w'))
donotquit = 1;
if (strchr(argv[1], 'n'))
nowrite = 1;
argv++;
argc--;
}
if (argc < 2)
return usage(1);
if (argc > 2)
maxpkts = atoi(argv[2]);
strncpy(fntemplate, argv[1], PATH_MAX-1);
if (strrchr(argv[1], '/'))
strncpy(fntemplate, strrchr(argv[1], '/')+1, PATH_MAX-1);
if (strrchr(fntemplate, '.'))
*strrchr(fntemplate, '.') = '\0';
if (strchr(fntemplate, '%')) {
fprintf(stderr, "can't use filenames containing '%%'\n");
return usage(1);
}
if (strlen(fntemplate) + sizeof(PKTFILESUFF) >= PATH_MAX-1) {
fprintf(stderr, "filename too long\n");
return usage(1);
}
strcat(fntemplate, PKTFILESUFF);
printf("FNTEMPLATE: '%s'\n", fntemplate);
// register all file formats
av_register_all();
err = av_open_input_file(&fctx, argv[1], NULL, 0, NULL);
if (err < 0) {
fprintf(stderr, "av_open_input_file: error %d\n", err);
return 1;
}
err = av_find_stream_info(fctx);
if (err < 0) {
fprintf(stderr, "av_find_stream_info: error %d\n", err);
return 1;
}
av_init_packet(&pkt);
while ((err = av_read_frame(fctx, &pkt)) >= 0) {
int fd;
snprintf(pktfilename, PATH_MAX-1, fntemplate, pktnum, pkt.stream_index, pkt.pts, pkt.size, (pkt.flags & PKT_FLAG_KEY)?'K':'_');
printf(PKTFILESUFF"\n", pktnum, pkt.stream_index, pkt.pts, pkt.size, (pkt.flags & PKT_FLAG_KEY)?'K':'_');
//printf("open(\"%s\")\n", pktfilename);
if (!nowrite) {
fd = open(pktfilename, O_WRONLY|O_CREAT, 0644);
write(fd, pkt.data, pkt.size);
close(fd);
}
pktnum++;
if (maxpkts && (pktnum >= maxpkts))
break;
}
while (donotquit)
sleep(60);
return 0;
}
int main(int argc, char **argv){
struct tm start_time_tm;
int outputPorts;
pthread_t *audioThreads;
pthread_attr_t custom_sched_attr;
int fifo_max_prio = 0;
int fifo_min_prio = 0;
int fifo_mid_prio = 0;
struct sched_param fifo_param;
syncbuffer = 0;
normalbuffer = 0;
if(argc < 3){
printf("./<audio_decoder> udp://[IP]:[PORT] [ptsDelay] [Amount of channel] [Channel 0] [Channel n]\n");
return 0;
}
if(argc != 3){
}
ff_ctx = malloc(sizeof(ff_ctx_t));
av_register_all();
avformat_network_init();
InitFF(ff_ctx, argv[1], argv[2]);
if (avformat_open_input (&ff_ctx->avInputCtx, ff_ctx->udp_address, NULL , &ff_ctx->avDic) != 0) {
printf ("Cloud not open UDP input stream at %s\n", ff_ctx->udp_address);
return -1;
}
if (avformat_find_stream_info(ff_ctx->avInputCtx, NULL) < 0) {
printf ("Cloud not get stream info\n");
return -1;
}
if (ff_ctx->audioIndexStream = av_find_best_stream(ff_ctx->avInputCtx, AVMEDIA_TYPE_AUDIO, -1, -1, &ff_ctx->avCodec, 0) < 0) {
printf ("No audio streams found\n");
return -1;
}
printf ("Audio stream found at %d\n", ff_ctx->audioIndexStream);
ff_ctx->avDicentry = av_dict_get(ff_ctx->avInputCtx->metadata, "service_name", NULL, 0);
if(ff_ctx->avDicentry != NULL){
strptime( ff_ctx->avDicentry->value, "%Y-%m-%d %H:%M:%S", &start_time_tm);
start_time = mktime(&start_time_tm);
}
else {
start_time = getSystemTime(NULL);
}
ff_ctx->avCodecCtx = ff_ctx->avInputCtx->streams[ff_ctx->audioIndexStream]->codec;
ff_ctx->avCodec = avcodec_find_decoder(ff_ctx->avCodecCtx->codec_id);
av_dump_format(ff_ctx->avInputCtx, 0, ff_ctx->udp_address, 0);
if (avcodec_open2 (ff_ctx->avCodecCtx, ff_ctx->avCodec, NULL) < 0) {
return -1;
}
outputPorts = ff_ctx->avCodecCtx->channels;
InitBF(ff_ctx->avCodecCtx->channels, &to_audio_buffer, TO_AUDIO_BUFFER_SIZE);
InitBF(ff_ctx->avCodecCtx->channels, &to_jack_buffer, TO_JACK_BUFFER_SIZE);
//One thread for each channel
audioThreads = malloc (sizeof(pthread_t)*outputPorts);
pthread_attr_init(&custom_sched_attr);
pthread_attr_setinheritsched(&custom_sched_attr, PTHREAD_INHERIT_SCHED /* PTHREAD_EXPLICIT_SCHED */);
//Options below only are applied when PTHREAD_EXPLICIT_SCHED is used!
pthread_attr_setscope(&custom_sched_attr, PTHREAD_SCOPE_SYSTEM );
pthread_attr_setschedpolicy(&custom_sched_attr, SCHED_FIFO);
fifo_max_prio = sched_get_priority_max(SCHED_FIFO);
fifo_min_prio = sched_get_priority_min(SCHED_FIFO);
fifo_mid_prio = (fifo_min_prio + fifo_max_prio) / 2;
fifo_param.sched_priority = fifo_mid_prio;
pthread_attr_setschedparam(&custom_sched_attr, &fifo_param);
int i;
threadArgs_t args[outputPorts];
for (i = 0; i < outputPorts; i++) {
args[i].channel = i;
args[i].process_block_size = AUDIO_PROCESS_BLOCK_SIZE;
if (pthread_create(&audioThreads[i], &custom_sched_attr, audioThreadFunction, &args[i])) {
printf ("Unable to create audio_thread %d\n", i);
return 0;
}
}
av_init_packet(&ff_ctx->avPacket);
static AVFrame frame;
int frameFinished;
int nb, ch;
char samplebuf[30];
av_get_sample_fmt_string (samplebuf, 30, ff_ctx->avCodecCtx->sample_fmt);
printf ("Audio sample format is %s\n", samplebuf);
audio_sync_sample_t **sync_samples;
sync_samples = malloc (outputPorts*sizeof(audio_sync_sample_t*));
long double initPTS, PTS, frame_pts_offset;
unsigned long int frame_count, framePTS, sample_count;
int sample_rate = ff_ctx->avCodecCtx->sample_rate;
if (init_jack(&jackCtx, outputPorts)) {
return 1;
}
while(av_read_frame (ff_ctx->avInputCtx, &ff_ctx->avPacket)>=0) {
if(ff_ctx->avPacket.stream_index == ff_ctx->audioIndexStream ) {
int contador = 0;
long double time_1 = getSystemTime(NULL);
int len = avcodec_decode_audio4 (ff_ctx->avCodecCtx, &frame, &frameFinished, &ff_ctx->avPacket);
if (frameFinished) {
int data_size = frame.nb_samples * av_get_bytes_per_sample(frame.format);
int sync_size = frame.nb_samples * sizeof (audio_sync_sample_t);
framePTS = av_frame_get_best_effort_timestamp (&frame);
frame_count = framePTS - ff_ctx->avInputCtx->streams[ff_ctx->audioIndexStream]->start_time;
frame_pts_offset = frame_count * av_q2d(ff_ctx->avInputCtx->streams[ff_ctx->audioIndexStream]->time_base) ;
initPTS = start_time + frame_pts_offset + ff_ctx->ptsDelay;
#ifdef _DBG_PTS
printf ("frame decoded PTS %lu, frame count %lu, TB %d/%d, PTS %Lf\n", framePTS, frame_count, ff_ctx->avInputCtx->streams[ff_ctx->audioIndexStream]->time_base.num, ff_ctx->avInputCtx->streams[ff_ctx->audioIndexStream]->time_base.den, initPTS);
#endif
//Build sync info data, sample timing
for (ch = 0; ch < ff_ctx->avCodecCtx->channels; ch++) {
sync_samples[ch] = malloc(sync_size);
PTS = initPTS;
for (sample_count = 0; sample_count < frame.nb_samples; sample_count++) {
PTS += (1/(float) sample_rate);
sync_samples[ch][sample_count].samplePTS = PTS;
}
}
#ifdef _DBG_PTS
printf ("ended samples PTS %Lf\n", PTS);
#endif
for (ch = 0; ch < ff_ctx->avCodecCtx->channels; ch++) {
ProduceSyncToBuffer (&to_audio_buffer, ch, (uint8_t*) sync_samples[ch], sync_size);
ProduceAudioToBuffer(&to_audio_buffer, ch, (uint8_t*) frame.extended_data[ch], data_size);
free(sync_samples[ch]);
}
}
long double time_2 = getSystemTime(NULL);
adaptativeSleep( (1/READ_INPUT_FRAME_RATE) - (time_2 - time_1));
}
}
}
int main(int argc, char **argv)
{
int ret;
AVPacket packet;
AVFrame *frame = av_frame_alloc();
AVFrame *filt_frame = av_frame_alloc();
int got_frame;
if (!frame || !filt_frame) {
perror("Could not allocate frame");
exit(1);
}
if (argc != 2) {
fprintf(stderr, "Usage: %s file\n", argv[0]);
exit(1);
}
av_register_all();
avfilter_register_all();
if ((ret = open_input_file(argv[1])) < 0)
goto end;
if ((ret = init_filters(filter_descr)) < 0)
goto end;
/* read all packets */
while (1) {
if ((ret = av_read_frame(fmt_ctx, &packet)) < 0)
break;
if (packet.stream_index == video_stream_index) {
got_frame = 0;
ret = avcodec_decode_video2(dec_ctx, frame, &got_frame, &packet);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Error decoding video\n");
break;
}
if (got_frame) {
frame->pts = av_frame_get_best_effort_timestamp(frame);
/* push the decoded frame into the filtergraph */
if (av_buffersrc_add_frame_flags(buffersrc_ctx, frame, AV_BUFFERSRC_FLAG_KEEP_REF) < 0) {
av_log(NULL, AV_LOG_ERROR, "Error while feeding the filtergraph\n");
break;
}
/* pull filtered frames from the filtergraph */
while (1) {
ret = av_buffersink_get_frame(buffersink_ctx, filt_frame);
if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
break;
if (ret < 0)
goto end;
display_frame(filt_frame, buffersink_ctx->inputs[0]->time_base);
av_frame_unref(filt_frame);
}
av_frame_unref(frame);
}
}
av_packet_unref(&packet);
}
end:
avfilter_graph_free(&filter_graph);
avcodec_close(dec_ctx);
avformat_close_input(&fmt_ctx);
av_frame_free(&frame);
av_frame_free(&filt_frame);
if (ret < 0 && ret != AVERROR_EOF) {
fprintf(stderr, "Error occurred: %s\n", av_err2str(ret));
exit(1);
}
exit(0);
}
int main(int argc, char **argv)
{
OutputStream video_st = { 0 }, audio_st = { 0 };
const char *filename;
AVOutputFormat *fmt;
AVFormatContext *oc;
int have_video = 0, have_audio = 0;
int encode_video = 0, encode_audio = 0;
/* Initialize libavcodec, and register all codecs and formats. */
av_register_all();
if (argc != 2) {
printf("usage: %s output_file\n"
"API example program to output a media file with libavformat.\n"
"The output format is automatically guessed according to the file extension.\n"
"Raw images can also be output by using '%%d' in the filename\n"
"\n", argv[0]);
return 1;
}
filename = argv[1];
/* Autodetect the output format from the name. default is MPEG. */
fmt = av_guess_format(NULL, filename, NULL);
if (!fmt) {
printf("Could not deduce output format from file extension: using MPEG.\n");
fmt = av_guess_format("mpeg", NULL, NULL);
}
if (!fmt) {
fprintf(stderr, "Could not find suitable output format\n");
return 1;
}
/* Allocate the output media context. */
oc = avformat_alloc_context();
if (!oc) {
fprintf(stderr, "Memory error\n");
return 1;
}
oc->oformat = fmt;
snprintf(oc->filename, sizeof(oc->filename), "%s", filename);
/* Add the audio and video streams using the default format codecs
* and initialize the codecs. */
if (fmt->video_codec != AV_CODEC_ID_NONE) {
add_video_stream(&video_st, oc, fmt->video_codec);
have_video = 1;
encode_video = 1;
}
if (fmt->audio_codec != AV_CODEC_ID_NONE) {
add_audio_stream(&audio_st, oc, fmt->audio_codec);
have_audio = 1;
encode_audio = 1;
}
/* Now that all the parameters are set, we can open the audio and
* video codecs and allocate the necessary encode buffers. */
if (have_video)
open_video(oc, &video_st);
if (have_audio)
open_audio(oc, &audio_st);
av_dump_format(oc, 0, filename, 1);
/* open the output file, if needed */
if (!(fmt->flags & AVFMT_NOFILE)) {
if (avio_open(&oc->pb, filename, AVIO_FLAG_WRITE) < 0) {
fprintf(stderr, "Could not open '%s'\n", filename);
return 1;
}
}
/* Write the stream header, if any. */
avformat_write_header(oc, NULL);
while (encode_video || encode_audio) {
/* select the stream to encode */
if (encode_video &&
(!encode_audio || av_compare_ts(video_st.next_pts, video_st.enc->time_base,
audio_st.next_pts, audio_st.enc->time_base) <= 0)) {
encode_video = !write_video_frame(oc, &video_st);
} else {
encode_audio = !process_audio_stream(oc, &audio_st);
}
}
/* Write the trailer, if any. The trailer must be written before you
* close the CodecContexts open when you wrote the header; otherwise
* av_write_trailer() may try to use memory that was freed on
* av_codec_close(). */
av_write_trailer(oc);
/* Close each codec. */
if (have_video)
close_stream(oc, &video_st);
if (have_audio)
close_stream(oc, &audio_st);
if (!(fmt->flags & AVFMT_NOFILE))
/* Close the output file. */
avio_close(oc->pb);
/* free the stream */
avformat_free_context(oc);
return 0;
}
int main(int argc, char *argv[]) {
AVFormatContext *pFormatCtx = NULL;
int i, videoStream;
AVCodecContext *pCodecCtx = NULL;
AVCodecParameters *pCodecParam = NULL;
AVCodec *pCodec = NULL;
AVFrame *pFrame = NULL;
AVPacket packet;
int send_packet, receive_frame;
//float aspect_ratio;
AVFrame *pict;
/*
std::unique_ptr<AVFrame, std::function<void(AVFrame*)>> frame_converted{
av_frame_alloc(),
[](AVFrame* f){ av_free(f->data[0]); } };
if (av_frame_copy_props(frame_converted.get(),
frame_decoded.get()) < 0) {
throw std::runtime_error("Copying frame properties");
}
if (av_image_alloc(
frame_converted->data, frame_converted->linesize,
video_decoder_->width(), video_decoder_->height(),
video_decoder_->pixel_format(), 1) < 0) {
throw std::runtime_error("Allocating picture");
}
*/
AVDictionary *optionsDict = NULL;
struct SwsContext *sws_ctx = NULL;
SDL_Texture* pTexture = nullptr;
SDL_Window* pWindows = nullptr;
SDL_Renderer* pRenderer = nullptr;
SDL_Event event;
if (argc < 2) {
fprintf(stderr, "Usage: test <file>\n");
exit(1);
}
// Register all formats and codecs
av_register_all();
if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER)) {
fprintf(stderr, "Could not initialize SDL - %s\n", SDL_GetError());
exit(1);
}
// Open video file
if (avformat_open_input(&pFormatCtx, argv[1], NULL, NULL) != 0)
return -1; // Couldn't open file
// Retrieve stream information
if (avformat_find_stream_info(pFormatCtx, NULL)<0)
return -1; // Couldn't find stream information
// Dump information about file onto standard error
av_dump_format(pFormatCtx, 0, argv[1], 0);
// Find the first video stream
videoStream = -1;
for (i = 0; i<pFormatCtx->nb_streams; i++)
if (pFormatCtx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
videoStream = i;
break;
}
if (videoStream == -1)
return -1; // Didn't find a video stream
// Get a pointer to the codec context for the video stream
//AVCodecContext *codec is deprecated,so use the codecpar struct (AVCodecParameters) instead.
pCodecParam = pFormatCtx->streams[videoStream]->codecpar;
//but function avcodec_open2() need pCodecCtx,so copy (AVCodecParameters) pCodecParam to (AVCodecContext) pCodecCtx
pCodec = avcodec_find_decoder(pCodecParam->codec_id);
// Find the decoder for the video stream
if (pCodec == NULL) {
fprintf(stderr, "Unsupported codec!\n");
return -1; // Codec not found
}
pCodecCtx = avcodec_alloc_context3(pCodec);
avcodec_parameters_to_context(pCodecCtx, pCodecParam);
// Open codec
if (avcodec_open2(pCodecCtx, pCodec, &optionsDict)<0)
return -1; // Could not open codec
// Allocate video frame
pFrame = av_frame_alloc();
// Make a screen to put our video
#ifndef __DARWIN__
pWindows = SDL_CreateWindow(argv[1],SDL_WINDOWPOS_CENTERED,SDL_WINDOWPOS_CENTERED,pCodecParam->width, pCodecParam->height,SDL_WINDOW_BORDERLESS|SDL_WINDOW_RESIZABLE);
#else
screen = SDL_SetVideoMode(pCodecParam->width, pCodecParam->height, 24, 0);
#endif
if (!pWindows) {
fprintf(stderr, "SDL: could not set video mode - exiting\n");
exit(1);
}
// Allocate a place to put our YUV image on that screen
pRenderer = SDL_CreateRenderer(pWindows, -1, 0);
if (!pRenderer) {
fprintf(stderr, "SDL: could not create renderer - exiting\n");
exit(1);
}
pTexture = SDL_CreateTexture(pRenderer, SDL_PIXELFORMAT_YV12, SDL_TEXTUREACCESS_STREAMING, pCodecParam->width, pCodecParam->height);
sws_ctx =
sws_getContext
(
pCodecParam->width,
pCodecParam->height,
(AVPixelFormat)pCodecParam->format,
pCodecParam->width,
pCodecParam->height,
AV_PIX_FMT_YUV420P,
SWS_BILINEAR,
NULL,
NULL,
NULL
);
pict = av_frame_alloc();
if (pict == nullptr){
exit(1);
}
if (av_image_alloc(pict->data, pict->linesize,
pCodecParam->width, pCodecParam->height,
(AVPixelFormat)pCodecParam->format, 1) < 0){
exit(1);
}
// Read frames and save first five frames to disk
i = 0;
while (av_read_frame(pFormatCtx, &packet) >= 0) {
// Is this a packet from the video stream?
if (packet.stream_index == videoStream) {
// Decode video frame
//avcodec_decode_video2 is deprecated Use avcodec_send_packet() and avcodec_receive_frame().
send_packet = avcodec_send_packet(pCodecCtx, &packet);
receive_frame = avcodec_receive_frame(pCodecCtx, pFrame);
// Did we get a video frame?
if (send_packet == SEND_PACKET_SUCCESS && receive_frame == RECEIVE_FRAME_SUCCESS) {
//SDL_LockYUVOverlay(bmp);
//SDL_LockTexture(pTexture,NULL,);
// Convert the image into YUV format that SDL uses
if (av_frame_copy_props(pFrame,
pict) < 0) {
exit(1);
}
sws_scale
(
sws_ctx,
pFrame->data,
pFrame->linesize,
0,
pCodecParam->height,
pict->data,
pict->linesize
);
//SDL_UnlockYUVOverlay(bmp);
SDL_UpdateYUVTexture(pTexture, NULL, pict->data[0], pict->linesize[0], pict->data[1], pict->linesize[1], pict->data[2], pict->linesize[2]);
SDL_RenderCopy(pRenderer, pTexture, NULL, NULL);
SDL_RenderPresent(pRenderer);
}
}
// Free the packet that was allocated by av_read_frame
av_packet_unref(&packet);
SDL_PollEvent(&event);
switch (event.type) {
case SDL_QUIT:
SDL_DestroyRenderer(pRenderer);
SDL_DestroyTexture(pTexture);
SDL_DestroyWindow(pWindows);
SDL_Quit();
exit(0);
break;
default:
break;
}
}
// Free the YUV frame
av_frame_free(&pFrame);
//free pict
av_freep(&pict->data[0]);
av_frame_free(&pict);
// Close the codec
avcodec_close(pCodecCtx);
// Close the video file
avformat_close_input(&pFormatCtx);
return 0;
}
int _tmain(int argc, _TCHAR* argv[])
{
int ret = 0, got_frame;
if (argc != 3) {
fprintf(stderr, "usage: %s input_file fifo_size(in byte)\n"
"\n", argv[0]);
fprintf(stderr, "example: %s \"rtmp://172.16.204.106/live/test01 live=1\" 128000\n", argv[0]);
exit(1);
}
av_register_all();
avfilter_register_all();
avformat_network_init();
//av_log_set_callback(ff_log_callback);
/* open input file, and allocate format context */
if (avformat_open_input(&fmt_ctx, argv[1], NULL, NULL) < 0) {
printf("Could not open source %s\n", argv[1]);
return 1;
}
/* retrieve stream information */
if (avformat_find_stream_info(fmt_ctx, NULL) < 0) {
printf("Could not find stream information\n");
return 1;
}
if (open_codec_context(&audio_stream_idx, fmt_ctx, AVMEDIA_TYPE_AUDIO) >= 0) {
audio_stream = fmt_ctx->streams[audio_stream_idx];
audio_dec_ctx = audio_stream->codec;
audio_dst_bufsize = 192000 * 2;
audio_dst_data = (uint8_t*)av_malloc(audio_dst_bufsize);
if (audio_dst_data == NULL) {
printf("No enough memory for audio conversion\n");
return 1;
}
// it may changed when decode
audio_channel_layout = audio_dec_ctx->channel_layout;
audio_channels = audio_dec_ctx->channels;
swr_ctx = swr_alloc_set_opts(swr_ctx,
AV_CH_LAYOUT_STEREO,
AV_SAMPLE_FMT_S16,
audio_dec_ctx->sample_rate,
audio_dec_ctx->channel_layout,
audio_dec_ctx->sample_fmt,
audio_dec_ctx->sample_rate,
0, 0);
if (!swr_ctx) {
printf("failed to alloc swr_ctx\n");
return 1;
}
if (swr_init(swr_ctx) < 0 || swr_ctx == NULL) {
printf("swr_init failed\n");
goto end;
}
printf("swr_init done!\n");
//if (init_filters(audio_stream, audio_stream_idx) < 0)
// printf("failed to init_filters!\n");
}
/* dump input information to stderr */
av_dump_format(fmt_ctx, 0, argv[1], 0);
frame = av_frame_alloc();
if (!frame) {
fprintf(stderr, "Could not allocate frame\n");
ret = AVERROR(ENOMEM);
goto end;
}
int fifo_size = atoi(argv[2]);
printf("fifo_size %d\n", fifo_size);
audio_fifo.create(fifo_size);
// init sdl audio
SDL_Init(SDL_INIT_AUDIO);
SDL_AudioSpec wanted_spec, spec;
memset(&wanted_spec, 0, sizeof(SDL_AudioSpec));
memset(&spec, 0, sizeof(SDL_AudioSpec));
wanted_spec.freq = audio_dec_ctx->sample_rate;
wanted_spec.format = AUDIO_S16SYS;
wanted_spec.channels = 2;
wanted_spec.silence = 0;
wanted_spec.samples = SDL_AUDIO_SAMPLES;
wanted_spec.callback = audio_callback;
wanted_spec.userdata = &audio_fifo;
if (SDL_OpenAudio(&wanted_spec, &spec) < 0) {
printf("SDL_OpenAudio: %s\n", SDL_GetError());
return 1;
}
printf("SDL_AudioSpec got: chn %d, fmt 0x%x, freq %d\n", spec.channels, spec.format, spec.freq);
SDL_PauseAudio(0);
/* initialize packet, set data to NULL, let the demuxer fill it */
av_init_packet(&pkt);
pkt.data = NULL;
pkt.size = 0;
/* read frames from the file */
while (av_read_frame(fmt_ctx, &pkt) >= 0) {
decode_packet(&got_frame, 0);
av_free_packet(&pkt);
}
end:
if (audio_dec_ctx)
avcodec_close(audio_dec_ctx);
avformat_close_input(&fmt_ctx);
av_free(frame);
av_free(audio_dst_data);
if (swr_ctx)
swr_free(&swr_ctx);
return 0;
}
int main(int argc, char *argv[]) {
AVFormatContext *pFormatCtx = NULL;
int i, videoStream;
AVCodecContext *pCodecCtx;
AVCodec *pCodec;
AVFrame *pFrame;
AVPacket packet;
int frameFinished;
float aspect_ratio;
struct SwsContext *img_convert_ctx;
SDL_Overlay *bmp;
SDL_Surface *screen;
SDL_Rect rect;
SDL_Event event;
if(argc < 2) {
fprintf(stderr, "Usage: test <file>\n");
exit(1);
}
// Register all formats and codecs
av_register_all();
if(SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER)) {
fprintf(stderr, "Could not initialize SDL - %s\n", SDL_GetError());
exit(1);
}
// Open video file
if(avformat_open_input(&pFormatCtx, argv[1], NULL, NULL)!=0)
return -1; // Couldn't open file
// Retrieve stream information
if(avformat_find_stream_info(pFormatCtx, NULL)<0)
return -1; // Couldn't find stream information
// Find the first video stream
videoStream=-1;
for(i=0; i<pFormatCtx->nb_streams; i++)
if(pFormatCtx->streams[i]->codec->codec_type==AVMEDIA_TYPE_VIDEO) {
videoStream=i;
break;
}
if(videoStream==-1)
return -1; // Didn't find a video stream
// Get a pointer to the codec context for the video stream
pCodecCtx=pFormatCtx->streams[videoStream]->codec;
// Find the decoder for the video stream
pCodec=avcodec_find_decoder(pCodecCtx->codec_id);
if(pCodec==NULL) {
fprintf(stderr, "Unsupported codec!\n");
return -1; // Codec not found
}
// Open codec
if(avcodec_open2(pCodecCtx, pCodec, NULL)<0)
return -1; // Could not open codec
// Allocate video frame
pFrame=av_frame_alloc();
// Make a screen to put our video
screen = SDL_SetVideoMode(pCodecCtx->width, pCodecCtx->height, 0, 0);
if(!screen) {
fprintf(stderr, "SDL: could not set video mode - exiting\n");
exit(1);
}
// Allocate a place to put our YUV image on that screen
bmp = SDL_CreateYUVOverlay(pCodecCtx->width,
pCodecCtx->height,
SDL_YV12_OVERLAY,
screen);
// Read frames and save first five frames to disk
i=0;
while(av_read_frame(pFormatCtx, &packet)>=0) {
// Is this a packet from the video stream?
if(packet.stream_index==videoStream) {
// Decode video frame
avcodec_decode_video2(pCodecCtx, pFrame, &frameFinished,
&packet);
// Did we get a video frame?
if(frameFinished) {
SDL_LockYUVOverlay(bmp);
AVPicture pict;
pict.data[0] = bmp->pixels[0];
pict.data[1] = bmp->pixels[2];
pict.data[2] = bmp->pixels[1];
pict.linesize[0] = bmp->pitches[0];
pict.linesize[1] = bmp->pitches[2];
pict.linesize[2] = bmp->pitches[1];
// Convert the image into YUV format that SDL uses
img_convert_ctx = sws_getContext(pCodecCtx->width,
pCodecCtx->height,
pCodecCtx->pix_fmt,
pCodecCtx->width,
pCodecCtx->height,
PIX_FMT_YUV420P,
SWS_BICUBIC,NULL,
NULL,NULL);
sws_scale(img_convert_ctx, pFrame->data,
pFrame->linesize,
0,
pFrame->height,
pict.data,
pict.linesize);
SDL_UnlockYUVOverlay(bmp);
rect.x = 0;
rect.y = 0;
rect.w = pCodecCtx->width;
rect.h = pCodecCtx->height;
SDL_DisplayYUVOverlay(bmp, &rect);
}
}
// Free the packet that was allocated by av_read_frame
av_free_packet(&packet);
SDL_PollEvent(&event);
switch(event.type) {
case SDL_QUIT:
SDL_Quit();
exit(0);
break;
default:
break;
}
}
// Free the YUV frame
av_free(pFrame);
// Close the codec
avcodec_close(pCodecCtx);
// Close the video file
avformat_close_input(&pFormatCtx);
return 0;
}
void AUD_initOnce()
{
#ifdef WITH_FFMPEG
av_register_all();
#endif
}
int main (int argc, char *argv[])
{
av_register_all(); // registed all file format
AVFormatContext *pFormatCtx; // to define the structure *point of which being used
// Open media(video/audio whatever) file
if (avformat_open_input(&pFormatCtx, argv[1], NULL, NULL)!=0){//changed av_open_input_file into the new avformat_open_input, thus no use for the past argument int buf_size inside av_open_input_file.
return -1; // couldn't open file
avformat_input_file(&pFormatCtx);//av_close_input_file has be deprecated
}
// Retrieve stream information
if (avformat_find_stream_info(pFormatCtx,NULL)<0)//also use the new one instead of int av_find_stream_info and set NULL for the AVDictionary **options. But notice that, it could be nb_streams.
return -1; // couldn't find stream information
// Dump information about file onto standard error
av_dump_format (pFormatCtx, 0, argv[1], 0);//use the new av_dump_format instead of dump_format
// Find the first sound stream
int i;
AVCodecContext *aCodecCtx;
int audioStream=-1;
for (i=0;i<pFormatCtx->nb_streams;i++)
if (pFormatCtx->streams[i]->codec->codec_type==AVMEDIA_TYPE_AUDIO && audioStream < 0) //it's new one but not CODEC_TYPE_AUDIO
{
audioStream=i;
break;
}
if(audioStream==-1)
return -1; //didn't find a audio stream
// Get a pointer to the codec context for the video stream
aCodecCtx=pFormatCtx->streams[audioStream]->codec;
// printf ("%d\n",audioStream); //for test
SDL_AudioSpec *wanted_spec;
SDL_AudioSpec *spec;
if(SDL_OpenAudio(&wanted_spec, &spec)<0){
fprintf(stderr,"SDL_OpenAudio:%s\n",SDL_GetError());
return -1;
}
AVCodec *aCodec;
aCodec=avcodec_find_decoder(aCodecCtx->codec_id);
if(!aCodec){
fprintf(stderr,"Unsupported codec!\n");
return -1;
}
avcodec_open2(aCodecCtx,aCodec,NULL);//use the new 2 version instead of the original version
packet_queue_init(&audioq);
SDL_PauseAudio(0);
AVPacket packet;
while (av_read_frame(pFormatCtx, &packet)>=0){
// if(packet.stream_index==videoStream){ //for there's not concern with the viedoStream so no use for the determination
/* } else*/ if (packet.stream_index==audioStream){
packet_queue_put(&audioq, &packet);
} else {
av_free_packet(&packet);
}
}
/* SDL_Event event;
static VideoState *global_video_state;
static int decode_interrupt_cb(void *ctx){
return global_video_state && global_video_state->abort_request;
}
// url_set_interrupt_cb(decode_interrupt_cb);//undefined in the current libavformat/avio.h version. Use above instead.
SDL_PollEvent(&event);
switch(event.type){
case SDL_QUIT:
quit = 1;
}*/
}
int main(int argc, char **argv) {
if(argc<2) {
fprintf(stderr,"Missing arguments\n");
fprintf(stderr,"Usage: %s [-g termsize] filename\n",argv[0]);
return -1;
}
char *filename = argv[1];
char *screensize = 0;
// screen resolution
int tw = TERM_W;
int th = TERM_H;
/* parse arguments*/
if(argc>3) {
int i;
if(strcmp(argv[1],"-g")==0) {
screensize = argv[2];
filename = argv[3];
sscanf(screensize,"%dx%d",&tw,&th);
}
}
printf("before init w = %d, h = %d\n",tw,th);
init_screen(tw,th);
/* init all codecs */
av_register_all();
AVFormatContext *pFmtCtx;
struct SwsContext *pSwsCtx;
pFmtCtx = avformat_alloc_context();
if(avformat_open_input(&pFmtCtx, filename, NULL, NULL) != 0) {
fprintf(stderr,"Failed to open file: %s\n",argv[1]);
return -1;
}
if(avformat_find_stream_info(pFmtCtx,NULL) < 0) {
fprintf(stderr,"No stream found!\n");
return -1;
}
av_dump_format(pFmtCtx, 0, filename,0);
int i;
int videoStream;
AVCodecContext *pCodecCtx;
videoStream = -1;
for(i=0; i<pFmtCtx->nb_streams; i++) {
if(pFmtCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
videoStream = i;
break;
}
}
if(videoStream == -1) {
fprintf(stderr,"No stream found!\n");
return -1;
}
pCodecCtx = pFmtCtx->streams[videoStream]->codec;
/* find suitable codec */
AVCodec * pCodec;
pCodec = avcodec_find_decoder(pCodecCtx->codec_id);
if(!pCodec) {
fprintf(stderr,"No suitable decoder found!\n");
return -1;
}
if(avcodec_open2(pCodecCtx,pCodec,NULL)<0) {
fprintf(stderr,"Could not open codec!\n");
return -1;
}
AVFrame *pFrame;
AVFrame *pPict;
/* allocate data structs */
pFrame = avcodec_alloc_frame();
pPict = avcodec_alloc_frame();
uint8_t *buffer;
int szPict;;
int sw,sh;
sw = pCodecCtx->width;
sh = pCodecCtx->height;
// allocate buffer of picture size
szPict = avpicture_get_size(PIX_FMT_RGB24, sw,sh);
buffer = (uint8_t *)av_malloc(szPict*sizeof(uint8_t));
/* associate frame with out buffer */
avpicture_fill( (AVPicture *)pPict,buffer,PIX_FMT_RGB24, sw, sh);
int frameFinished;
AVPacket packet;
/* init scale context to scale to terminal resolution */
pSwsCtx = sws_getContext(sw,sh,pCodecCtx->pix_fmt,tw,th,PIX_FMT_RGB24, SWS_BICUBIC, NULL, NULL, NULL);
i=0;
/* read as long we have packets in the stream */
while(av_read_frame(pFmtCtx,&packet)>=0) {
/* we only need packets of our video stream*/
if(packet.stream_index == videoStream) {
/* decode video frame */
avcodec_decode_video2(pCodecCtx,pFrame,&frameFinished,
&packet);
if(frameFinished) {
/* scale, display and sleep for ~30ms*/
sws_scale(pSwsCtx,pFrame->data, pFrame->linesize,0,sh,pPict->data, pPict->linesize);
ascii_art(pPict);
usleep(30000);
}
}
/* free current packet struct */
av_free_packet(&packet);
}
/* tidy up.. */
av_free(buffer);
av_free(pPict);
av_free(pFrame);
avcodec_close(pCodecCtx);
avformat_free_context(pFmtCtx);
return 0;
}
int main(int argc, char *argv[]) {
SDL_Event event;
VideoState *is;
is = av_mallocz(sizeof(VideoState));
if(argc < 2) {
fprintf(stderr, "Usage: test <file>\n");
exit(1);
}
// Register all formats and codecs
av_register_all();
if(SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER)) {
fprintf(stderr, "Could not initialize SDL - %s\n", SDL_GetError());
exit(1);
}
// Make a screen to put our video
#ifndef __DARWIN__
screen = SDL_SetVideoMode(640, 480, 0, 0);
#else
screen = SDL_SetVideoMode(640, 480, 24, 0);
#endif
if(!screen) {
fprintf(stderr, "SDL: could not set video mode - exiting\n");
exit(1);
}
av_strlcpy(is->filename, argv[1], 1024);
// 初始化为视频缓冲准备的锁（pictq）
// 因为一旦事件驱动调用视频函数， 视频函数会从 pictq 抽出预解码帧。
// 同时， 视频解码器会把信息放进去， 我们不知道那个动作会先发生。
is->pictq_mutex = SDL_CreateMutex();
is->pictq_cond = SDL_CreateCond();
// schedule_refresh 是一个将要定义的函数。它的动作是告诉系统在某个特定的毫秒数后弹出 FF_REFRESH_EVENT 事件。
schedule_refresh(is, 40);
is->av_sync_type = DEFAULT_AV_SYNC_TYPE;
// 生成一个新线程能完全访问原始进程中的内存，启动我们给的线程,在这种情况下， 调用 decode_thread()并与 VideoState 结构体连接。
is->parse_tid = SDL_CreateThread(decode_thread, is);
if(!is->parse_tid) {
av_free(is);
return -1;
}
// 事件循环
for(;;) {
SDL_WaitEvent(&event);
switch(event.type) {
case FF_QUIT_EVENT:
case SDL_QUIT:
is->quit = 1;
/*
* If the video has finished playing, then both the picture and
* audio queues are waiting for more data. Make them stop
* waiting and terminate normally.
*/
SDL_CondSignal(is->audioq.cond);
SDL_CondSignal(is->videoq.cond);
SDL_Quit();
exit(0);
break;
case FF_ALLOC_EVENT:
alloc_picture(event.user.data1);
break;
case FF_REFRESH_EVENT:
video_refresh_timer(event.user.data1);
break;
default:
break;
}
}
return 0;
}
int main(int argc, char* argv[]) {
AVCodec *ptr_codec;
AVCodecContext *ptr_codec_context = NULL;
int frame_size;
int out_size, outbuf_size;
FILE *f;
uint8_t *samples;
uint8_t *outbuf;
/* register codecs and formats*/
av_register_all();
printf("Audio encoding\n");
/* find the aac encoder */
// ptr_codec = avcodec_find_encoder(CODEC_ID_AAC);
ptr_codec = avcodec_find_encoder(AV_CODEC_ID_SPEEX); //AV_CODEC_ID_SPEEX
if (!ptr_codec) {
fprintf(stderr, "codec not found\n");
exit(1);
}
ptr_codec_context = avcodec_alloc_context3(ptr_codec);
/* put sample parameters */
//libspeexenc.c
// ptr_codec_context->bit_rate = 56000; //the average bitrate
ptr_codec_context->sample_rate = 8000; // Speex has 3 modes, each of which uses a specific sample rate
ptr_codec_context->channels = 1; //number of audio channels
ptr_codec_context->sample_fmt = AV_SAMPLE_FMT_S16; //sample format
// ptr_codec_context->global_quality = 2;
AVDictionary *opts = NULL;
av_dict_set(&opts, "cbr_quality", "8", 0);
/* open it */
if (avcodec_open2(ptr_codec_context, ptr_codec ,&opts) < 0) {
fprintf(stderr, "could not open codec\n");
exit(1);
}
/* the codec gives us the frame size, in samples */
frame_size = ptr_codec_context->frame_size;
printf("c->frame_size = %d ...\n", ptr_codec_context->frame_size);
samples = malloc(frame_size * 2 * ptr_codec_context->channels);
printf("samples = %d \n", frame_size * 2 * ptr_codec_context->channels);
//这里的数值是固定的？2是这样来的
//av_get_bytes_per_sample(ptr_codec_context->sample_fmt) 这里获取的值就是2
//这里是参考ffmpeg.c中这个函数的使用
printf("ptr_codec_context->channels = %d ...\n",
ptr_codec_context->channels);
printf("samples = %d ...\n", frame_size * 2 * ptr_codec_context->channels);
outbuf_size = 10000;
outbuf = malloc(outbuf_size);
f = fopen(argv[1], "wb");
if (!f) {
fprintf(stderr, "could not open %s\n", argv[1]);
exit(1);
}
FILE *p_source = fopen(argv[2], "r+");
printf("before while ....\n");
while (!feof(p_source)) {
fread(samples, 1, frame_size * 2 * ptr_codec_context->channels,
p_source);
// /* encode the samples */
//out packet
AVPacket pkt;
av_init_packet(&pkt);
pkt.data = NULL;
pkt.size = 0;
//in frame
AVFrame *frame = avcodec_alloc_frame();
if (frame == NULL) {
printf("frame malloc failed ...\n");
exit(1);
}
avcodec_get_frame_defaults(frame);
frame->nb_samples = (frame_size * 2 * ptr_codec_context->channels) / 2; //number of audio samples (per channel) described by this frame
/*说明一点frame->nb_samples 这个一定要设置正确哈。。*/
int ret;
if ((ret = avcodec_fill_audio_frame(frame, ptr_codec_context->channels/*2*/, AV_SAMPLE_FMT_S16,
samples, (frame_size * 2 * ptr_codec_context->channels), 1))
< 0) {
av_log(NULL, AV_LOG_FATAL, "Audio encoding failed...\n");
exit(1);
}
int got_packet = 0;
if (avcodec_encode_audio2(ptr_codec_context, &pkt, frame, &got_packet)
< 0) {
av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
exit(1);
}
if (got_packet) {
printf("write data ..pkt.size = %d.\n" ,pkt.size);
fwrite(pkt.data, 1, pkt.size, f);
}
av_free_packet(&pkt);
av_free(frame);
}
fclose(f);
free(outbuf);
free(samples);
avcodec_close(ptr_codec_context);
av_free(ptr_codec_context);
/*free sth*/
return 0;
}
void FFmpegVideo::restart()
{
char chVidName1[200];
int iProcessOrder1 = this->iProcessOrder;
strcpy(chVidName1, this->chVidName);
//结束
// Free the RGB image
av_free(buffer);
av_free(pFrameBGR);
av_free(pFrameRGB);
// Free the YUV frame
av_free(pFrameOri);
// Close the codec
avcodec_close(pCodecCtx);
av_close_input_file(pFormatCtx);
if(imageFrame)
delete imageFrame;
//重新开始
this->iProcessOrder = iProcessOrder1;
strcpy(chVidName, chVidName1);
this->fRate = 0;
iTotalFrameNum = 0;
iNowFrameNum = 0;
frameFinished = 0;
// Register all formats and codecs
av_register_all();
// Open video file
if(av_open_input_file(&pFormatCtx, chVidName, NULL, 0, NULL)!=0)
{
bIfSuccess = false;
return; // Couldn't open file
}
// Retrieve stream information
if(av_find_stream_info(pFormatCtx)<0)
{
bIfSuccess = false;
return; // Couldn't find stream information
}
// Dump information about file onto standard error
dump_format(pFormatCtx, 0, chVidName, 0);
this->iTotalFrameNum = pFormatCtx->streams[0]->duration;
this->fFrmRat = pFormatCtx->streams[0]->r_frame_rate.num/(float)(pFormatCtx->streams[0]->r_frame_rate.den);
// Find the first video stream
videoStream=-1;
for(i=0; i<pFormatCtx->nb_streams; i++)
{
if(pFormatCtx->streams[i]->codec->codec_type==CODEC_TYPE_VIDEO) {
videoStream=i;
break;
}
}
if(videoStream==-1)
{
bIfSuccess = false;
return; // Didn't find a video stream
}
// Get a pointer to the codec context for the video stream
pCodecCtx=pFormatCtx->streams[videoStream]->codec;
// Find the decoder for the video stream
pCodec=avcodec_find_decoder(pCodecCtx->codec_id);
if(pCodec==NULL) {
bIfSuccess = false;
fprintf(stderr, "Unsupported codec!\n");
return; // Codec not found
}
// Open codec
while (avcodec_open(pCodecCtx, pCodec) < 0)/*这个函数总是返回-1*/ {
Sleep(this->iProcessOrder);
}
// Allocate video frame
pFrameOri=avcodec_alloc_frame();
// Allocate an AVFrame structure
pFrameBGR=avcodec_alloc_frame();
if(pFrameBGR==NULL)
{
bIfSuccess = false;
return;
}
pFrameRGB=avcodec_alloc_frame();
if(pFrameRGB==NULL)
{
bIfSuccess = false;
return;
}
// Determine required buffer size and allocate buffer
numBytes=avpicture_get_size(PIX_FMT_BGR24, pCodecCtx->width,pCodecCtx->height);
imageFrame->height = pCodecCtx->height;
imageFrame->width = pCodecCtx->width;
buffer=(uint8_t *)av_malloc(numBytes*sizeof(uint8_t));
imageFrame->imageData = new uint8_t[numBytes*sizeof(uint8_t)];
// Assign appropriate parts of buffer to image planes in pFrameRGB
// Note that pFrameRGB is an AVFrame, but AVFrame is a superset
// of AVPicture
avpicture_fill((AVPicture *)pFrameBGR, buffer, PIX_FMT_BGR24,
pCodecCtx->width, pCodecCtx->height);
avpicture_fill((AVPicture *)pFrameRGB, buffer, PIX_FMT_RGB24,
pCodecCtx->width, pCodecCtx->height);
//注意，这里是PIX_FMT_RGB24，它决定了图片的格式
if(this->bIfUseHD == false)
ctx = sws_getContext(pCodecCtx->width, pCodecCtx->height,
pCodecCtx->pix_fmt, pCodecCtx->width, pCodecCtx->height,
PIX_FMT_BGR24, SWS_BICUBIC, NULL, NULL, NULL);
this->getOneFrame();
bIfSuccess = true;
}
JNIEXPORT jint JNICALL Java_com_leixiaohua1020_sffmpegandroiddecoder_MainActivity_decode(
JNIEnv *env, jobject obj, jstring input_jstr, jstring output_jstr) {
AVFormatContext *pFormatCtx;
int i, videoindex;
AVCodecContext *pCodecCtx;
AVCodec *pCodec;
AVFrame *pFrame, *pFrameYUV;
uint8_t *out_buffer;
AVPacket *packet;
int y_size;
int ret, got_picture;
struct SwsContext *img_convert_ctx;
FILE *fp_yuv;
int frame_cnt;
clock_t time_start, time_finish;
double time_duration = 0.0;
char input_str[500] = { 0 };
char output_str[500] = { 0 };
char info[1000] = { 0 };
sprintf(input_str, "%s", (*env)->GetStringUTFChars(env, input_jstr, NULL));
sprintf(output_str, "%s",
(*env)->GetStringUTFChars(env, output_jstr, NULL));
//FFmpeg av_log() callback
av_log_set_callback(custom_log);
av_register_all();
avformat_network_init();
pFormatCtx = avformat_alloc_context();
if (avformat_open_input(&pFormatCtx, input_str, NULL, NULL) != 0) {
LOGE("Couldn't open input stream.\n");
return -1;
}
if (avformat_find_stream_info(pFormatCtx, NULL) < 0) {
LOGE("Couldn't find stream information.\n");
return -1;
}
videoindex = -1;
for (i = 0; i < pFormatCtx->nb_streams; i++){
if (pFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
videoindex = i;
break;
}
}
if (videoindex == -1) {
LOGE("Couldn't find a video stream.\n");
return -1;
}
pCodecCtx = pFormatCtx->streams[videoindex]->codec;
pCodec = avcodec_find_decoder(pCodecCtx->codec_id);
if (pCodec == NULL) {
LOGE("Couldn't find Codec.\n");
return -1;
}
if (avcodec_open2(pCodecCtx, pCodec, NULL) < 0) {
LOGE("Couldn't open codec.\n");
return -1;
}
pFrame = av_frame_alloc();
pFrameYUV = av_frame_alloc();
out_buffer = (uint8_t *) av_malloc(
avpicture_get_size(PIX_FMT_YUV420P, pCodecCtx->width,
pCodecCtx->height));
avpicture_fill((AVPicture *) pFrameYUV, out_buffer, PIX_FMT_YUV420P,
pCodecCtx->width, pCodecCtx->height);
packet = (AVPacket *) av_malloc(sizeof(AVPacket));
img_convert_ctx = sws_getContext(pCodecCtx->width, pCodecCtx->height,
pCodecCtx->pix_fmt, pCodecCtx->width, pCodecCtx->height,
PIX_FMT_YUV420P, SWS_BICUBIC, NULL, NULL, NULL);
sprintf(info, "[Input ]%s\n", input_str);
sprintf(info, "%s[Output ]%s\n", info, output_str);
sprintf(info, "%s[Format ]%s\n", info, pFormatCtx->iformat->name);
sprintf(info, "%s[Codec ]%s\n", info, pCodecCtx->codec->name);
sprintf(info, "%s[Resolution]%dx%d\n", info, pCodecCtx->width,
pCodecCtx->height);
fp_yuv = fopen(output_str, "wb+");
if (fp_yuv == NULL) {
printf("Cannot open output file.\n");
return -1;
}
frame_cnt = 0;
time_start = clock();
while (av_read_frame(pFormatCtx, packet) >= 0) {
if (packet->stream_index == videoindex) {
ret = avcodec_decode_video2(pCodecCtx, pFrame, &got_picture,
packet);
if (ret < 0) {
LOGE("Decode Error.\n");
return -1;
}
if (got_picture) {
sws_scale(img_convert_ctx,
(const uint8_t* const *) pFrame->data, pFrame->linesize,
0, pCodecCtx->height, pFrameYUV->data,
pFrameYUV->linesize);
y_size = pCodecCtx->width * pCodecCtx->height;
fwrite(pFrameYUV->data[0], 1, y_size, fp_yuv); //Y
fwrite(pFrameYUV->data[1], 1, y_size / 4, fp_yuv); //U
fwrite(pFrameYUV->data[2], 1, y_size / 4, fp_yuv); //V
//Output info
char pictype_str[10] = { 0 };
switch (pFrame->pict_type) {
case AV_PICTURE_TYPE_I:
sprintf(pictype_str, "I");
break;
case AV_PICTURE_TYPE_P:
sprintf(pictype_str, "P");
break;
case AV_PICTURE_TYPE_B:
sprintf(pictype_str, "B");
break;
default:
sprintf(pictype_str, "Other");
break;
}
LOGI("Frame Index: %5d. Type:%s", frame_cnt, pictype_str);
frame_cnt++;
}
}
av_free_packet(packet);
}
//flush decoder
//FIX: Flush Frames remained in Codec
while (1) {
ret = avcodec_decode_video2(pCodecCtx, pFrame, &got_picture, packet);
if (ret < 0)
break;
if (!got_picture)
break;
sws_scale(img_convert_ctx, (const uint8_t* const *) pFrame->data,
pFrame->linesize, 0, pCodecCtx->height, pFrameYUV->data,
pFrameYUV->linesize);
int y_size = pCodecCtx->width * pCodecCtx->height;
fwrite(pFrameYUV->data[0], 1, y_size, fp_yuv); //Y
fwrite(pFrameYUV->data[1], 1, y_size / 4, fp_yuv); //U
fwrite(pFrameYUV->data[2], 1, y_size / 4, fp_yuv); //V
//Output info
char pictype_str[10] = { 0 };
switch (pFrame->pict_type) {
case AV_PICTURE_TYPE_I:
sprintf(pictype_str, "I");
break;
case AV_PICTURE_TYPE_P:
sprintf(pictype_str, "P");
break;
case AV_PICTURE_TYPE_B:
sprintf(pictype_str, "B");
break;
default:
sprintf(pictype_str, "Other");
break;
}
LOGI("Frame Index: %5d. Type:%s", frame_cnt, pictype_str);
frame_cnt++;
}
time_finish = clock();
time_duration = (double) (time_finish - time_start);
sprintf(info, "%s[Time ]%fms\n", info, time_duration);
sprintf(info, "%s[Count ]%d\n", info, frame_cnt);
sws_freeContext(img_convert_ctx);
fclose(fp_yuv);
av_frame_free(&pFrameYUV);
av_frame_free(&pFrame);
avcodec_close(pCodecCtx);
avformat_close_input(&pFormatCtx);
return 0;
}
FFmpegVideo::FFmpegVideo(char* chVidName1, int iProcessOrder1, float fRate1)
{
this->iProcessOrder = iProcessOrder1;
strcpy(chVidName, chVidName1);
this->fRate = fRate1;
iTotalFrameNum = 0;
iNowFrameNum = 0;
frameFinished = 0;
nFps = 0;
buffer = NULL;
pFrameBGR = NULL;
pFrameRGB = NULL;
pFrameOri = NULL;
pCodecCtx = NULL;
imageFrame = new ImageFrame();
// Register all formats and codecs
av_register_all();
// Open video file
if(av_open_input_file(&pFormatCtx, chVidName, NULL, 0, NULL)!=0)
{
bIfSuccess = false;
return; // Couldn't open file
}
// Retrieve stream information
if(av_find_stream_info(pFormatCtx)<0)
{
bIfSuccess = false;
return; // Couldn't find stream information
}
// Dump information about file onto standard error
dump_format(pFormatCtx, 0, chVidName, 0);
this->iTotalFrameNum = pFormatCtx->streams[0]->nb_frames;
this->fFrmRat = pFormatCtx->streams[0]->r_frame_rate.num/(float)(pFormatCtx->streams[0]->r_frame_rate.den);
// Find the first video stream
videoStream=-1;
for(i=0; i<pFormatCtx->nb_streams; i++)
{
if(pFormatCtx->streams[i]->codec->codec_type==CODEC_TYPE_VIDEO) {
videoStream=i;
break;
}
}
if(videoStream==-1)
{
bIfSuccess = false;
return; // Didn't find a video stream
}
// Get a pointer to the codec context for the video stream
pCodecCtx=pFormatCtx->streams[videoStream]->codec;
printf("%d-%d\n", pCodecCtx->height, pCodecCtx->width);
// Find the decoder for the video stream
pCodec=avcodec_find_decoder(pCodecCtx->codec_id);
if(pCodec==NULL) {
bIfSuccess = false;
fprintf(stderr, "Unsupported codec!\n");
return; // Codec not found
}
// Open codec
//while(bIfLockCloseCodec)
//{
// Sleep(10);
//}
//bIfLockCloseCodec = true;
//if(avcodec_open(pCodecCtx, pCodec)<0)
// return -1; // Could not open codec
//bIfLockCloseCodec = false;
while (avcodec_open(pCodecCtx, pCodec) < 0)/*这个函数总是返回-1*/ {
//fprintf(stderr, "could not open codec\n");
Sleep(this->iProcessOrder);
//exit(1);
}
// Allocate video frame
pFrameOri=avcodec_alloc_frame();
// Allocate an AVFrame structure
pFrameBGR=avcodec_alloc_frame();
if(pFrameBGR==NULL)
{
bIfSuccess = false;
return;
}
pFrameRGB=avcodec_alloc_frame();
if(pFrameRGB==NULL)
{
bIfSuccess = false;
return;
}
// Determine required buffer size and allocate buffer
imageFrame->size = numBytes=avpicture_get_size(PIX_FMT_BGR24, pCodecCtx->width, pCodecCtx->height);
imageFrame->widthStep = WIDTHSTEP(pCodecCtx->width);
imageFrame->height = pCodecCtx->height;
imageFrame->width = pCodecCtx->width;
buffer=(uint8_t *)av_malloc(numBytes*sizeof(uint8_t));
imageFrame->imageData = new uint8_t[numBytes*sizeof(uint8_t)];
memset(imageFrame->imageData, 0, numBytes*sizeof(uint8_t));
// Assign appropriate parts of buffer to image planes in pFrameRGB
// Note that pFrameRGB is an AVFrame, but AVFrame is a superset
// of AVPicture
avpicture_fill((AVPicture *)pFrameBGR, buffer, PIX_FMT_BGR24,
pCodecCtx->width, pCodecCtx->height);
avpicture_fill((AVPicture *)pFrameRGB, buffer, PIX_FMT_RGB24,
pCodecCtx->width, pCodecCtx->height);
//注意，这里是PIX_FMT_RGB24，它决定了图片的格式
ctx = sws_getContext(pCodecCtx->width, pCodecCtx->height,
pCodecCtx->pix_fmt, pCodecCtx->width, pCodecCtx->height,
PIX_FMT_BGR24, SWS_BICUBIC, NULL, NULL, NULL);
if(this->getOneFrame()==0)
bIfSuccess = true;
else
bIfSuccess = false;
}
int main(int argc, char *argv[]) {
try {
std::map<std::string, std::string> aopt;
const int param = parse_options(argc, argv, aopt);
// Register all formats and codecs
av_register_all();
if (settings::REF_VIDEO == "")
throw std::runtime_error("Reference video not specified");
bool glb_exit = false;
mt::Semaphore sem_cons;
// create data for reference video
mt::Semaphore ref_prod;
VUCHAR ref_buf;
int ref_frame;
qav::qvideo ref_video(settings::REF_VIDEO.c_str(), settings::VIDEO_SIZE_W, settings::VIDEO_SIZE_H);
// get const values
const qav::scr_size ref_sz = ref_video.get_size();
const int ref_fps_k = ref_video.get_fps_k();
//
//ref_video.get_frame(ref_buf);
//return 0;
//
V_VPDATA v_data;
for(int i = param; i < argc; ++i) {
try {
shared_ptr<vp_data> vpd(new vp_data);
vpd->name = get_filename(argv[i]);
vpd->video = new qav::qvideo(argv[i], ref_sz.x, ref_sz.y);
if (vpd->video->get_fps_k() != ref_fps_k) {
if (settings::IGNORE_FPS) {
LOG_WARNING << '[' << argv[i] << "] has different FPS (" << vpd->video->get_fps_k()/1000 << ')' << std::endl;
v_data.push_back(vpd);
} else LOG_ERROR << '[' << argv[i] << "] skipped different FPS" << std::endl;
} else v_data.push_back(vpd);
} catch(std::exception& e) {
LOG_ERROR << '[' << argv[i] << "] skipped " << e.what() << std::endl;
}
}
if (v_data.empty()) return 0;
// print some infos
LOG_INFO << "Skip frames: " << ((settings::SKIP_FRAMES > 0) ? settings::SKIP_FRAMES : 0) << std::endl;
LOG_INFO << "Max frames: " << ((settings::MAX_FRAMES > 0) ? settings::MAX_FRAMES : 0) << std::endl;
// create the stats analyzer (like the psnr)
LOG_INFO << "Analyzer set: " << settings::ANALYZER << std::endl;
std::auto_ptr<stats::s_base> s_analyzer(stats::get_analyzer(settings::ANALYZER.c_str(), v_data.size(), ref_sz.x, ref_sz.y, std::cout));
// set the default values, in case will get overwritten
s_analyzer->set_parameter("fpa", "25");
s_analyzer->set_parameter("blocksize", "8");
// load the passed parameters
for(std::map<std::string, std::string>::const_iterator it = aopt.begin(); it != aopt.end(); ++it) {
LOG_INFO << "Analyzer parameter: " << it->first << " = " << it->second << std::endl;
s_analyzer->set_parameter(it->first.c_str(), it->second.c_str());
}
// create all the threads
video_producer ref_vpth(ref_frame, ref_prod, sem_cons, ref_buf, ref_video, glb_exit);
V_VPTH v_th;
for(V_VPDATA::iterator it = v_data.begin(); it != v_data.end(); ++it)
v_th.push_back(new video_producer((*it)->frame, (*it)->prod, sem_cons, (*it)->buf, *((*it)->video), glb_exit));
// we'll need some tmp buffers
VUCHAR t_ref_buf;
std::vector<VUCHAR> t_bufs(v_data.size());
// and now the core algorithm
// init all the semaphores
producers_utils::lock(sem_cons, ref_prod, v_data);
// start the threads
producers_utils::start(ref_vpth, v_th);
// print header
std::cout << "Sample,";
for(V_VPDATA::const_iterator it = v_data.begin(); it != v_data.end(); ++it)
std::cout << (*it)->name << ',';
std::cout << std::endl;
while(!glb_exit) {
// wait for the consumer to be signalled 1 + n times
const static int CONS_SIG_NUM = 1 + v_th.size();
producers_utils::sync(sem_cons, CONS_SIG_NUM);
// now check everything is ok
const int cur_ref_frame = ref_frame;
if (-1 == cur_ref_frame) {
glb_exit = true;
// allow the producers to run
producers_utils::unlock(ref_prod, v_data);
continue;
}
// in case we have to skip frames...
if (settings::SKIP_FRAMES > 0 && settings::SKIP_FRAMES >= cur_ref_frame) {
// allow the producers to run
producers_utils::unlock(ref_prod, v_data);
continue;
}
// vector of bool telling if everything is ok
std::vector<bool> v_ok;
for(V_VPDATA::const_iterator it = v_data.begin(); it != v_data.end(); ++it)
if ((*it)->frame == cur_ref_frame) v_ok.push_back(true);
else v_ok.push_back(false);
// then swap the vectors
t_ref_buf.swap(ref_buf);
for(int i = 0; i < v_data.size(); ++i)
t_bufs[i].swap(v_data[i]->buf);
// allow the producers to run
producers_utils::unlock(ref_prod, v_data);
// finally process data
s_analyzer->process(cur_ref_frame, t_ref_buf, v_ok, t_bufs);
// check if we have to exit
if (settings::MAX_FRAMES > 0 && cur_ref_frame >= settings::MAX_FRAMES) {
glb_exit = true;
// allow the producers to run
producers_utils::unlock(ref_prod, v_data);
break;
}
}
// wait for all threads
producers_utils::stop(ref_vpth, v_th);
} catch(std::exception& e) {
LOG_ERROR << e.what() << std::endl;
} catch(...) {
LOG_ERROR << "Unknown exception" << std::endl;
}
}
int main(int argc, char *argv[]) {
AVFormatContext *pFormatCtx = NULL;
int i, videoStream;
AVCodecContext *pCodecCtx;
AVCodec *pCodec;
AVFrame *pFrame;
AVFrame *pFrameRGB;
struct SwsContext * pSwsCtx;
AVPacket packet;
int frameFinished;
int numBytes;
uint8_t *buffer;
if (argc < 2) {
printf("Please provide a movie file\n");
return -1;
}
// Register all formats and codecs
av_register_all();
// Open video file
if (avformat_open_input(&pFormatCtx, argv[1], NULL, NULL) != 0)
return -1; // Couldn't open file
// Retrieve stream information
if (avformat_find_stream_info(pFormatCtx, NULL) < 0)
return -1; // Couldn't find stream information
// Dump information about file onto standard error
av_dump_format(pFormatCtx, 0, argv[1], 0);
// Find the first video stream
videoStream = -1;
for (i = 0; i < pFormatCtx->nb_streams; i++)
if (pFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
videoStream = i;
break;
}
if (videoStream == -1)
return -1; // Didn't find a video stream
// Get a pointer to the codec context for the video stream
pCodecCtx = pFormatCtx->streams[videoStream]->codec;
// Find the decoder for the video stream
pCodec = avcodec_find_decoder(pCodecCtx->codec_id);
if (pCodec == NULL) {
fprintf(stderr, "Unsupported codec!\n");
return -1; // Codec not found
}
// Open codec
if (avcodec_open2(pCodecCtx, pCodec, NULL) < 0)
return -1; // Could not open codec
// Allocate video frame
pFrame = av_frame_alloc();
// Allocate an AVFrame structure
pFrameRGB = av_frame_alloc();
if (pFrameRGB == NULL)
return -1;
// Determine required buffer size and allocate buffer
numBytes = avpicture_get_size(PIX_FMT_RGB24, pCodecCtx->width,
pCodecCtx->height);
buffer = (uint8_t *) av_malloc(numBytes * sizeof(uint8_t));
// Assign appropriate parts of buffer to image planes in pFrameRGB
// Note that pFrameRGB is an AVFrame, but AVFrame is a superset
// of AVPicture
avpicture_fill((AVPicture *) pFrameRGB, buffer, PIX_FMT_RGB24,
pCodecCtx->width, pCodecCtx->height);
pSwsCtx = sws_getContext(pCodecCtx->width,
pCodecCtx->height, pCodecCtx->pix_fmt,
pCodecCtx->width, pCodecCtx->height,
PIX_FMT_RGB24, SWS_FAST_BILINEAR, NULL, NULL, NULL);
if (pSwsCtx == NULL) {
fprintf(stderr, "Cannot initialize the sws context\n");
return -1;
}
// Read frames and save first five frames to disk
i = 0;
while (av_read_frame(pFormatCtx, &packet) >= 0) {
// Is this a packet from the video stream?
if (packet.stream_index == videoStream) {
// Decode video frame
avcodec_decode_video2(pCodecCtx, pFrame, &frameFinished, &packet);
// Did we get a video frame?
if (frameFinished) {
// Convert the image from its native format to RGB
sws_scale(pSwsCtx,
(const uint8_t * const *) pFrame->data,
pFrame->linesize, 0, pCodecCtx->height,
pFrameRGB->data,
pFrameRGB->linesize);
// Save the frame to disk
if (++i <= 5)
SaveFrame(pFrameRGB, pCodecCtx->width, pCodecCtx->height,
i);
}
}
// Free the packet that was allocated by av_read_frame
av_free_packet(&packet);
}
// Free the RGB image
av_free(buffer);
av_free(pFrameRGB);
// Free the YUV frame
av_free(pFrame);
// Close the codec
avcodec_close(pCodecCtx);
// Close the video file
avformat_close_input(&pFormatCtx);
return 0;
}
mfxStatus FFmpeg_Reader_Init(const char *strFileName, mfxU32 videoType)
{
MSDK_CHECK_POINTER(strFileName, MFX_ERR_NULL_PTR);
int res;
g_videoType = videoType;
// Initialize libavcodec, and register all codecs and formats
av_register_all();
// Open input container
res = avformat_open_input(&g_pFormatCtx, strFileName, NULL, NULL);
if(res) {
printf("FFMPEG: Could not open input container\n");
return MFX_ERR_UNKNOWN;
}
// Retrieve stream information
res = avformat_find_stream_info(g_pFormatCtx, NULL);
if(res < 0) {
printf("FFMPEG: Couldn't find stream information\n");
return MFX_ERR_UNKNOWN;
}
// Dump container info to console
av_dump_format(g_pFormatCtx, 0, strFileName, 0);
// Find the streams in the container
g_videoStreamIdx = -1;
for(unsigned int i=0; i<g_pFormatCtx->nb_streams; i++)
{
if(g_pFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO && g_videoStreamIdx == -1)
{
g_videoStreamIdx = i;
// save decoded stream timestamp time base
g_dec_time_base = g_pFormatCtx->streams[i]->time_base;
if(videoType == MFX_CODEC_AVC)
{
// Retrieve required h264_mp4toannexb filter
g_pBsfc = av_bitstream_filter_init("h264_mp4toannexb");
if (!g_pBsfc) {
printf("FFMPEG: Could not aquire h264_mp4toannexb filter\n");
return MFX_ERR_UNKNOWN;
}
}
}
#ifdef PROCESS_AUDIO
else if(g_pFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_AUDIO)
{
g_audioStreamIdx = i;
g_pAudioStream = g_pFormatCtx->streams[i];
g_audio_dec_time_base = g_pAudioStream->time_base;
}
#endif
}
if(g_videoStreamIdx == -1)
return MFX_ERR_UNKNOWN; // Didn't find any video streams in container
return MFX_ERR_NONE;
}
