static int init_input(){
int ret;
//get input format
/* open input file, and allocate format context */
if (avformat_open_input(&fmt_ctx, src_filename, NULL, NULL) < 0) {
fprintf(stderr, "Could not open source file %s\n", src_filename);
exit(1);
}
/* retrieve stream information */
if (avformat_find_stream_info(fmt_ctx, NULL) < 0) {
fprintf(stderr, "Could not find stream information\n");
exit(1);
}
//get input codec and stream
if (open_codec_context(&video_stream_idx, fmt_ctx, AVMEDIA_TYPE_VIDEO) >= 0) {
video_stream = fmt_ctx->streams[video_stream_idx];
video_dec_ctx = video_stream->codec;
pCodecCtx = video_stream->codec;
video_dst_file = fopen(video_dst_filename, "wb");
if (!video_dst_file) {
fprintf(stderr, "Could not open destination file %s\n", video_dst_filename);
ret = 1;
return 1;
}
/* allocate image where the decoded image will be put */
width = video_dec_ctx->width;
height = video_dec_ctx->height;
pix_fmt = video_dec_ctx->pix_fmt;
ret = av_image_alloc(video_dst_data, video_dst_linesize,
width, height, pix_fmt, 1);
if (ret < 0) {
fprintf(stderr, "Could not allocate raw video buffer\n");
return 1;
}
video_dst_bufsize = ret;
}
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;
AudCodecCtx = audio_stream->codec;
audio_dst_file = fopen(audio_dst_filename, "wb");
if (!audio_dst_file) {
fprintf(stderr, "Could not open destination file %s\n", audio_dst_filename);
return 1;
}
}
/* dump input information to stderr */
av_dump_format(fmt_ctx, 0, src_filename, 0);
return 0;
}
jint Java_com_panahit_ui_Components_AnimatedFileDrawable_createDecoder(JNIEnv *env, jclass clazz, jstring src, jintArray data) {
VideoInfo *info = new VideoInfo();
char const *srcString = env->GetStringUTFChars(src, 0);
int len = strlen(srcString);
info->src = new char[len + 1];
memcpy(info->src, srcString, len);
info->src[len] = '\0';
if (srcString != 0) {
env->ReleaseStringUTFChars(src, srcString);
}
int ret;
if ((ret = avformat_open_input(&info->fmt_ctx, info->src, NULL, NULL)) < 0) {
LOGE("can't open source file %s, %s", info->src, av_err2str(ret));
delete info;
return 0;
}
if ((ret = avformat_find_stream_info(info->fmt_ctx, NULL)) < 0) {
LOGE("can't find stream information %s, %s", info->src, av_err2str(ret));
delete info;
return 0;
}
if (open_codec_context(&info->video_stream_idx, info->fmt_ctx, AVMEDIA_TYPE_VIDEO) >= 0) {
info->video_stream = info->fmt_ctx->streams[info->video_stream_idx];
info->video_dec_ctx = info->video_stream->codec;
}
if (info->video_stream <= 0) {
LOGE("can't find video stream in the input, aborting %s", info->src);
delete info;
return 0;
}
info->frame = av_frame_alloc();
if (info->frame == nullptr) {
LOGE("can't allocate frame %s", info->src);
delete info;
return 0;
}
av_init_packet(&info->pkt);
info->pkt.data = NULL;
info->pkt.size = 0;
jint *dataArr = env->GetIntArrayElements(data, 0);
if (dataArr != nullptr) {
dataArr[0] = info->video_dec_ctx->width;
dataArr[1] = info->video_dec_ctx->height;
env->ReleaseIntArrayElements(data, dataArr, 0);
}
//LOGD("successfully opened file %s", info->src);
return (int) info;
}
static int rtsp_connect(netcam_context_ptr netcam)
{
if (netcam->rtsp == NULL) {
netcam->rtsp = rtsp_new_context();
if (netcam->rtsp == NULL) {
MOTION_LOG(ALR, TYPE_NETCAM, NO_ERRNO, "%s: unable to create context(%s)", netcam->rtsp->path);
return -1;
}
}
// open the network connection
AVDictionary *opts = 0;
av_dict_set(&opts, "rtsp_transport", "tcp", 0);
int ret = avformat_open_input(&netcam->rtsp->format_context, netcam->rtsp->path, NULL, &opts);
if (ret < 0) {
MOTION_LOG(ALR, TYPE_NETCAM, NO_ERRNO, "%s: unable to open input(%s): %d - %s", netcam->rtsp->path, ret, av_err2str(ret));
rtsp_free_context(netcam->rtsp);
netcam->rtsp = NULL;
return -1;
}
// fill out stream information
ret = avformat_find_stream_info(netcam->rtsp->format_context, NULL);
if (ret < 0) {
MOTION_LOG(ALR, TYPE_NETCAM, NO_ERRNO, "%s: unable to find stream info: %d", ret);
rtsp_free_context(netcam->rtsp);
netcam->rtsp = NULL;
return -1;
}
ret = open_codec_context(&netcam->rtsp->video_stream_index, netcam->rtsp->format_context, AVMEDIA_TYPE_VIDEO);
if (ret < 0) {
MOTION_LOG(ALR, TYPE_NETCAM, NO_ERRNO, "%s: unable to open codec context: %d", ret);
rtsp_free_context(netcam->rtsp);
netcam->rtsp = NULL;
return -1;
}
netcam->rtsp->codec_context = netcam->rtsp->format_context->streams[netcam->rtsp->video_stream_index]->codec;
// start up the feed
av_read_play(netcam->rtsp->format_context);
return 0;
}
int main (int argc, char **argv)
{
int ret = 0, got_frame;
if (argc != 4 && argc != 5) {
fprintf(stderr, "usage: %s [-refcount] input_file video_output_file audio_output_file\n"
"API example program to show how to read frames from an input file.\n"
"This program reads frames from a file, decodes them, and writes decoded\n"
"video frames to a rawvideo file named video_output_file, and decoded\n"
"audio frames to a rawaudio file named audio_output_file.\n\n"
"If the -refcount option is specified, the program use the\n"
"reference counting frame system which allows keeping a copy of\n"
"the data for longer than one decode call.\n"
"\n", argv[0]);
exit(1);
}
if (argc == 5 && !strcmp(argv[1], "-refcount")) {
refcount = 1;
argv++;
}
src_filename = argv[1];
video_dst_filename = argv[2];
audio_dst_filename = argv[3];
/* register all formats and codecs */
av_register_all();
/* open input file, and allocate format context */
if (avformat_open_input(&fmt_ctx, src_filename, NULL, NULL) < 0) {
fprintf(stderr, "Could not open source file %s\n", src_filename);
exit(1);
}
/* retrieve stream information */
if (avformat_find_stream_info(fmt_ctx, NULL) < 0) {
fprintf(stderr, "Could not find stream information\n");
exit(1);
}
if (open_codec_context(&video_stream_idx, fmt_ctx, AVMEDIA_TYPE_VIDEO) >= 0) {
video_stream = fmt_ctx->streams[video_stream_idx];
video_dec_ctx = video_stream->codec;
video_dst_file = fopen(video_dst_filename, "wb");
if (!video_dst_file) {
fprintf(stderr, "Could not open destination file %s\n", video_dst_filename);
ret = 1;
goto end;
}
/* allocate image where the decoded image will be put */
width = video_dec_ctx->width;
height = video_dec_ctx->height;
pix_fmt = video_dec_ctx->pix_fmt;
ret = av_image_alloc(video_dst_data, video_dst_linesize,
width, height, pix_fmt, 1);
if (ret < 0) {
fprintf(stderr, "Could not allocate raw video buffer\n");
goto end;
}
video_dst_bufsize = ret;
}
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_file = fopen(audio_dst_filename, "wb");
if (!audio_dst_file) {
fprintf(stderr, "Could not open destination file %s\n", audio_dst_filename);
ret = 1;
goto end;
}
}
/* dump input information to stderr */
av_dump_format(fmt_ctx, 0, src_filename, 0);
if (!audio_stream && !video_stream) {
fprintf(stderr, "Could not find audio or video stream in the input, aborting\n");
ret = 1;
goto end;
}
frame = av_frame_alloc();
if (!frame) {
fprintf(stderr, "Could not allocate frame\n");
ret = AVERROR(ENOMEM);
goto end;
}
/* initialize packet, set data to NULL, let the demuxer fill it */
av_init_packet(&pkt);
pkt.data = NULL;
pkt.size = 0;
if (video_stream)
printf("Demuxing video from file '%s' into '%s'\n", src_filename, video_dst_filename);
if (audio_stream)
printf("Demuxing audio from file '%s' into '%s'\n", src_filename, audio_dst_filename);
/* read frames from the file */
while (av_read_frame(fmt_ctx, &pkt) >= 0) {
AVPacket orig_pkt = pkt;
do {
ret = decode_packet(&got_frame, 0);
if (ret < 0)
break;
pkt.data += ret;
pkt.size -= ret;
} while (pkt.size > 0);
av_packet_unref(&orig_pkt);
}
/* flush cached frames */
pkt.data = NULL;
pkt.size = 0;
do {
decode_packet(&got_frame, 1);
} while (got_frame);
printf("Demuxing succeeded.\n");
if (video_stream) {
printf("Play the output video file with the command:\n"
"ffplay -f rawvideo -pix_fmt %s -video_size %dx%d %s\n",
av_get_pix_fmt_name(pix_fmt), width, height,
video_dst_filename);
}
if (audio_stream) {
enum AVSampleFormat sfmt = audio_dec_ctx->sample_fmt;
int n_channels = audio_dec_ctx->channels;
const char *fmt;
if (av_sample_fmt_is_planar(sfmt)) {
const char *packed = av_get_sample_fmt_name(sfmt);
printf("Warning: the sample format the decoder produced is planar "
"(%s). This example will output the first channel only.\n",
packed ? packed : "?");
sfmt = av_get_packed_sample_fmt(sfmt);
n_channels = 1;
}
if ((ret = get_format_from_sample_fmt(&fmt, sfmt)) < 0)
goto end;
printf("Play the output audio file with the command:\n"
"ffplay -f %s -ac %d -ar %d %s\n",
fmt, n_channels, audio_dec_ctx->sample_rate,
audio_dst_filename);
}
end:
avcodec_close(video_dec_ctx);
avcodec_close(audio_dec_ctx);
avformat_close_input(&fmt_ctx);
if (video_dst_file)
fclose(video_dst_file);
if (audio_dst_file)
fclose(audio_dst_file);
av_frame_free(&frame);
av_free(video_dst_data[0]);
return ret < 0;
}
int main (int argc, char **argv)
{
int ret = 0, got_frame;
if (argc != 3 && argc != 4) {
fprintf(stderr, "usage: %s [-refcount] input_file video_output_file audio_output_file\n"
"API example program to show how to read frames from an input file.\n"
"This program reads frames from a file, decodes them, and writes decoded\n"
"video frames to a rawvideo file named video_output_file, and decoded\n"
"audio frames to a rawaudio file named audio_output_file.\n\n"
"If the -refcount option is specified, the program use the\n"
"reference counting frame system which allows keeping a copy of\n"
"the data for longer than one decode call.\n"
"\n", argv[0]);
exit(1);
}
// if (argc == 4 && !strcmp(argv[1], "-refcount")) {
// refcount = 1;
// argv++;
// }
src_filename = argv[1];
video_dst_filename = argv[2];
/* register all formats and codecs */
avdevice_register_all();
av_register_all();
// const char* format_name = "avfoundation";
AVInputFormat* input_format = av_find_input_format("avfoundation");
printf("input_format: %p\n", input_format);
// printf("input_format: %s", input_format->long_name);
AVDictionary* open_options = NULL;
av_dict_set(&open_options, "pixel_format", "uyvy422", 0);
av_dict_set(&open_options, "framerate", "30.000030", 0);
av_dict_set(&open_options, "video_size", "1280x720", 0);
/* open input file, and allocate format context */
// if (avformat_open_input(&fmt_ctx, src_filename, NULL, NULL) < 0) {
if (avformat_open_input(&fmt_ctx, src_filename, input_format, &open_options) < 0) {
fprintf(stderr, "Could not open source file %s\n", src_filename);
exit(1);
}
printf("fmt_ctx: %p\n", fmt_ctx);
video_stream = fmt_ctx->streams[0];
printf("video_stream: %p\n", video_stream);
video_dec_ctx = video_stream->codec;
printf("video_dec_ctx: %p\n", video_dec_ctx);
/* allocate image where the decoded image will be put */
width = video_dec_ctx->width;
height = video_dec_ctx->height;
pix_fmt = video_dec_ctx->pix_fmt;
printf("width: %d\n", width);
printf("height: %d\n", height);
printf("pix_fmt: %d\n", pix_fmt);
/* retrieve stream information */
if (avformat_find_stream_info(fmt_ctx, NULL) < 0) {
fprintf(stderr, "Could not find stream information\n");
exit(1);
}
if (open_codec_context(&video_stream_idx, fmt_ctx, AVMEDIA_TYPE_VIDEO) >= 0) {
video_stream = fmt_ctx->streams[video_stream_idx];
video_dec_ctx = video_stream->codec;
video_dst_file = fopen(video_dst_filename, "wb");
if (!video_dst_file) {
fprintf(stderr, "Could not open destination file %s\n", video_dst_filename);
ret = 1;
goto end;
}
/* allocate image where the decoded image will be put */
width = video_dec_ctx->width;
height = video_dec_ctx->height;
pix_fmt = video_dec_ctx->pix_fmt;
printf("width: %d\n", width);
printf("height: %d\n", height);
printf("pix_fmt: %d\n", pix_fmt);
ret = av_image_alloc(video_dst_data, video_dst_linesize,
width, height, pix_fmt, 1);
if (ret < 0) {
fprintf(stderr, "Could not allocate raw video buffer\n");
goto end;
}
video_dst_bufsize = ret;
}
/* dump input information to stderr */
av_dump_format(fmt_ctx, 0, src_filename, 0);
if (!video_stream) {
fprintf(stderr, "Could not find video stream in the input, aborting\n");
ret = 1;
goto end;
}
frame = av_frame_alloc();
if (!frame) {
fprintf(stderr, "Could not allocate frame\n");
ret = AVERROR(ENOMEM);
goto end;
}
/* initialize packet, set data to NULL, let the demuxer fill it */
av_init_packet(&pkt);
pkt.data = NULL;
pkt.size = 0;
if (video_stream)
printf("Demuxing video from file '%s' into '%s'\n", src_filename, video_dst_filename);
/* read frames from the file */
int frame_index = 0;
while (av_read_frame(fmt_ctx, &pkt) >= 0) {
AVPacket orig_pkt = pkt;
do {
ret = decode_packet(&got_frame, 0);
if (ret < 0)
break;
pkt.data += ret;
pkt.size -= ret;
} while (pkt.size > 0);
av_free_packet(&orig_pkt);
frame_index++;
if (frame_index > 5) {
break;
}
}
/* flush cached frames */
pkt.data = NULL;
pkt.size = 0;
do {
decode_packet(&got_frame, 1);
} while (got_frame);
printf("Demuxing succeeded.\n");
if (video_stream) {
printf("Play the output video file with the command:\n"
"ffplay -f rawvideo -pix_fmt %s -video_size %dx%d %s\n",
av_get_pix_fmt_name(pix_fmt), width, height,
video_dst_filename);
}
end:
avcodec_close(video_dec_ctx);
avformat_close_input(&fmt_ctx);
if (video_dst_file)
fclose(video_dst_file);
av_frame_free(&frame);
av_free(video_dst_data[0]);
return ret < 0;
}
/*----------------------------------------------------------------------
| main
+---------------------------------------------------------------------*/
int main(int argc, char** argv)
{
QApplication a(argc, argv);
QStringList arguments = a.arguments();
if (arguments.size() < 2) {
LOG_ERROR(LOG_TAG, "Wrong syntax.");
return -1;
}
if (!QFile(arguments.at(1)).exists()) {
LOG_ERROR(LOG_TAG, "Input file does not exist.");
return -1;
}
// Init codecs.
av_register_all();
// Open input file.
if (avformat_open_input(&fmt_ctx, argv[1], NULL, NULL) < 0) {
LOG_ERROR(LOG_TAG, "Could not open source file %s.", argv[1]);
return -1;
}
// Retrieve stream information.
if (avformat_find_stream_info(fmt_ctx, NULL) < 0) {
LOG_ERROR(LOG_TAG, "Could not find stream information.");
return -1;
}
if (open_codec_context(&video_stream_idx, fmt_ctx, AVMEDIA_TYPE_VIDEO) >= 0) {
video_stream = fmt_ctx->streams[video_stream_idx];
video_dec_ctx = video_stream->codec;
#if 0
video_dst_file = fopen(video_dst_filename, "wb");
if (!video_dst_file) {
fprintf(stderr, "Could not open destination file %s\n", video_dst_filename);
ret = 1;
goto end;
}
/* allocate image where the decoded image will be put */
ret = av_image_alloc(video_dst_data, video_dst_linesize,
video_dec_ctx->width, video_dec_ctx->height,
video_dec_ctx->pix_fmt, 1);
if (ret < 0) {
fprintf(stderr, "Could not allocate raw video buffer\n");
goto end;
}
video_dst_bufsize = ret;
#endif
}
if (open_codec_context(&audio_stream_idx, fmt_ctx, AVMEDIA_TYPE_AUDIO) >= 0) {
int nb_planes;
audio_stream = fmt_ctx->streams[audio_stream_idx];
audio_dec_ctx = audio_stream->codec;
#if 0
audio_dst_file = fopen(audio_dst_filename, "wb");
if (!audio_dst_file) {
fprintf(stderr, "Could not open destination file %s\n", video_dst_filename);
ret = 1;
goto end;
}
nb_planes = av_sample_fmt_is_planar(audio_dec_ctx->sample_fmt) ?
audio_dec_ctx->channels : 1;
audio_dst_data = av_mallocz(sizeof(uint8_t *) * nb_planes);
if (!audio_dst_data) {
fprintf(stderr, "Could not allocate audio data buffers\n");
ret = AVERROR(ENOMEM);
goto end;
}
#endif
}
// Dump input information to stderr.
av_dump_format(fmt_ctx, 0, argv[1], 0);
// initialize packet, set data to NULL, let the demuxer fill it.
av_init_packet(&pkt);
pkt.data = NULL;
pkt.size = 0;
QFile outFile(argv[2]);
if (!outFile.open(QIODevice::ReadWrite)) {
LOG_ERROR(LOG_TAG, "Cannot create output file.");
return -1;
}
while (av_read_frame(fmt_ctx, &pkt) >= 0) {
if (pkt.stream_index == audio_stream_idx) {
LOG_VERBOSE(LOG_TAG, "Frame read.");
}
else
continue;
outFile.write((const char*)pkt.data, pkt.size);
}
LOG_INFORMATION(LOG_TAG, "Data written successfully.");
outFile.close();
// Cleanup.
if (video_dec_ctx)
avcodec_close(video_dec_ctx);
if (audio_dec_ctx)
avcodec_close(audio_dec_ctx);
avformat_close_input(&fmt_ctx);
return 0;
}
int main (int argc, char **argv)
{
int ret = 0, got_frame;
if (argc != 4) {
fprintf(stderr, "usage: %s input_file video_output_file audio_output_file\n"
"API example program to show how to read frames from an input file.\n"
"This program reads frames from a file, decodes them, and writes decoded\n"
"video frames to a rawvideo file named video_output_file, and decoded\n"
"audio frames to a rawaudio file named audio_output_file.\n"
"\n", argv[0]);
exit(1);
}
src_filename = argv[1];
video_dst_filename = argv[2];
audio_dst_filename = argv[3];
/* register all formats and codecs */
av_register_all();
/* open input file, and allocate format context */
if (avformat_open_input(&fmt_ctx, src_filename, NULL, NULL) < 0) {
fprintf(stderr, "Could not open source file %s\n", src_filename);
exit(1);
}
/* retrieve stream information */
if (avformat_find_stream_info(fmt_ctx, NULL) < 0) {
fprintf(stderr, "Could not find stream information\n");
exit(1);
}
if (open_codec_context(&video_stream_idx, fmt_ctx, AVMEDIA_TYPE_VIDEO) >= 0) {
video_stream = fmt_ctx->streams[video_stream_idx];
video_dec_ctx = video_stream->codec;
video_dst_file = fopen(video_dst_filename, "wb");
if (!video_dst_file) {
fprintf(stderr, "Could not open destination file %s\n", video_dst_filename);
ret = 1;
goto end;
}
/* allocate image where the decoded image will be put */
ret = av_image_alloc(video_dst_data, video_dst_linesize,
video_dec_ctx->width, video_dec_ctx->height,
video_dec_ctx->pix_fmt, 1);
if (ret < 0) {
fprintf(stderr, "Could not allocate raw video buffer\n");
goto end;
}
video_dst_bufsize = ret;
}
if (open_codec_context(&audio_stream_idx, fmt_ctx, AVMEDIA_TYPE_AUDIO) >= 0) {
int nb_planes;
audio_stream = fmt_ctx->streams[audio_stream_idx];
audio_dec_ctx = audio_stream->codec;
audio_dst_file = fopen(audio_dst_filename, "wb");
if (!audio_dst_file) {
fprintf(stderr, "Could not open destination file %s\n", video_dst_filename);
ret = 1;
goto end;
}
nb_planes = av_sample_fmt_is_planar(audio_dec_ctx->sample_fmt) ? audio_dec_ctx->channels : 1;
audio_dst_data = (uint8_t**)av_mallocz(sizeof(uint8_t *) * nb_planes);
if (!audio_dst_data) {
fprintf(stderr, "Could not allocate audio data buffers\n");
ret = AVERROR(ENOMEM);
goto end;
}
}
/* dump input information to stderr */
av_dump_format(fmt_ctx, 0, src_filename, 0);
if (!audio_stream && !video_stream) {
fprintf(stderr, "Could not find audio or video stream in the input, aborting\n");
ret = 1;
goto end;
}
frame = avcodec_alloc_frame();
if (!frame) {
fprintf(stderr, "Could not allocate frame\n");
ret = AVERROR(ENOMEM);
goto end;
}
/* initialize packet, set data to NULL, let the demuxer fill it */
av_init_packet(&pkt);
pkt.data = NULL;
pkt.size = 0;
if (video_stream)
printf("Demuxing video from file '%s' into '%s'\n", src_filename, video_dst_filename);
if (audio_stream)
printf("Demuxing audio from file '%s' into '%s'\n", src_filename, audio_dst_filename);
/* read frames from the file */
while (av_read_frame(fmt_ctx, &pkt) >= 0) {
//decode_packet(&got_frame, 0);
if (audio_stream_idx == pkt.stream_index)
printf("Frame found!\n");
else
continue;
fwrite(pkt.data, 1, pkt.size, audio_dst_file);
}
/* flush cached frames */
#if 0
pkt.data = NULL;
pkt.size = 0;
do {
decode_packet(&got_frame, 1);
} while (got_frame);
#endif
printf("Demuxing succeeded.\n");
if (video_stream) {
printf("Play the output video file with the command:\n"
"ffplay -f rawvideo -pix_fmt %s -video_size %dx%d %s\n",
av_get_pix_fmt_name(video_dec_ctx->pix_fmt), video_dec_ctx->width, video_dec_ctx->height,
video_dst_filename);
}
if (audio_stream) {
const char *fmt;
if ((ret = get_format_from_sample_fmt(&fmt, audio_dec_ctx->sample_fmt) < 0))
goto end;
printf("Play the output audio file with the command:\n"
"ffplay -f %s -ac %d -ar %d %s\n",
fmt, audio_dec_ctx->channels, audio_dec_ctx->sample_rate,
audio_dst_filename);
}
end:
if (video_dec_ctx)
avcodec_close(video_dec_ctx);
if (audio_dec_ctx)
avcodec_close(audio_dec_ctx);
avformat_close_input(&fmt_ctx);
if (video_dst_file)
fclose(video_dst_file);
if (audio_dst_file)
fclose(audio_dst_file);
av_free(frame);
av_free(video_dst_data[0]);
av_free(audio_dst_data);
return ret < 0;
}
/**
* Opens the input file/url, allocates a AVFormatContext for it and opens the audio stream with an
* appropriate decoder.
*
* @param env JNIEnv
* @param format_context AVFormatContext
* @param openedStream opened audio AVStream
* @param stream_index[in] index of the desired <em>audio</em> stream
* @param stream_index[out] index of the selected stream (index of <em>all</em> streams)
* @param url URL to open
* @return negative value, if something went wrong
*/
int ff_open_file(JNIEnv *env, AVFormatContext **format_context, AVStream **openedStream, AVCodecContext **context, int *stream_index, const char *url) {
int res = 0;
res = ff_open_format_context(env, format_context, url);
if (res) {
// exception has already been thrown
goto bail;
}
#ifdef DEBUG
fprintf(stderr, "Desired audio stream index: %i.\n", *stream_index);
#endif
if (*stream_index < 0) {
// use best audio stream
res = open_codec_context(stream_index, *format_context, *context, AVMEDIA_TYPE_AUDIO);
if (res) {
throwUnsupportedAudioFileExceptionIfError(env, res, "Failed to open codec context.");
goto bail;
}
*openedStream = (*format_context)->streams[*stream_index];
} else {
// find xth audio stream
// count possible audio streams
int i;
int audio_stream_number = 0;
AVStream* stream = NULL;
AVFormatContext* deref_format_context = *format_context;
for (i=0; i<deref_format_context->nb_streams; i++) {
stream = deref_format_context->streams[i];
if (stream->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
if (audio_stream_number == *stream_index) {
*stream_index = i;
#ifdef DEBUG
fprintf(stderr, "Found desired audio stream at index: %i.\n", i);
#endif
break;
}
audio_stream_number++;
}
stream = NULL;
}
if (stream == NULL) {
// we didn't find a stream with the given index
res = -1;
throwIndexOutOfBoundsExceptionIfError(env, res, *stream_index);
goto bail;
}
res = ff_open_stream(env, stream, context);
if (res) {
goto bail;
}
*openedStream = stream;
}
#ifdef DEBUG
fprintf(stderr, "Opened stream index: %i.\n", *stream_index);
fprintf(stderr, "Opened stream: %ld.\n", (long) *openedStream);
#endif
bail:
return res;
}
int main(int argc, char **argv)
{
int ret = 0, got_frame;
if (argc != 2) {
fprintf(stderr, "Usage: %s <video>\n", argv[0]);
exit(1);
}
src_filename = argv[1];
av_register_all();
if (avformat_open_input(&fmt_ctx, src_filename, NULL, NULL) < 0) {
fprintf(stderr, "Could not open source file %s\n", src_filename);
exit(1);
}
if (avformat_find_stream_info(fmt_ctx, NULL) < 0) {
fprintf(stderr, "Could not find stream information\n");
exit(1);
}
if (open_codec_context(&video_stream_idx, fmt_ctx, AVMEDIA_TYPE_VIDEO) >= 0) {
video_stream = fmt_ctx->streams[video_stream_idx];
video_dec_ctx = video_stream->codec;
}
//av_dump_format(fmt_ctx, 0, src_filename, 0);
if (!video_stream) {
fprintf(stderr, "Could not find video stream in the input, aborting\n");
ret = 1;
goto end;
}
frame = av_frame_alloc();
if (!frame) {
fprintf(stderr, "Could not allocate frame\n");
ret = AVERROR(ENOMEM);
goto end;
}
//printf("framenum,source,blockw,blockh,srcx,srcy,dstx,dsty,flags\n");
/* initialize packet, set data to NULL, let the demuxer fill it */
av_init_packet(&pkt);
pkt.data = NULL;
pkt.size = 0;
/* print the csv header */
printf(";Bildtyp: ;Eingangsbitrate: ;Kodierte Bildgröße: ;Zeitstempel des Bildes: ;Aktuelles Bild: ;Anzeigedauer des Bildes: ;Bisherige Spielzeit: ;Quelldateiname: ;Decoderbildrate: ;Decoder: ;Filmbildrate:\n");
/* read frames from the file */
while (av_read_frame(fmt_ctx, &pkt) >= 0) {
AVPacket orig_pkt = pkt;
do {
ret = decode_packet(&got_frame, 0);
if (ret < 0)
break;
pkt.data += ret;
pkt.size -= ret;
} while (pkt.size > 0);
av_free_packet(&orig_pkt);
}
/* flush cached frames */
pkt.data = NULL;
pkt.size = 0;
do {
decode_packet(&got_frame, 1);
} while (got_frame);
end:
avcodec_close(video_dec_ctx);
avformat_close_input(&fmt_ctx);
av_frame_free(&frame);
return ret < 0;
}
int main (int argc, char **argv)
{
int ret = 0;
const char *src_filename = NULL;
const char *dst_filename = NULL;
char* format = NULL;
char* codec = NULL;
if (argc != 5 && argc != 3) {
fprintf(stderr, "usage: %s input_file output_file [format codec]\n"
"API example program to show how to read frames from an input file.\n"
"This program reads frames from a file, decodes them, and writes decoded\n"
"frames to a rawvideo/rawaudio file named output_file.\n"
"Optionally format and codec can be specified.\n\n", argv[0]);
exit(1);
}
src_filename = argv[1];
dst_filename = argv[2];
if (argc == 5) {
format = argv[3];
codec = argv[4];
}
/* log all debug messages */
av_log_set_level(AV_LOG_DEBUG);
/* register all formats and codecs */
av_register_all();
#ifdef __AFL_HAVE_MANUAL_CONTROL
while (__AFL_LOOP(1000))
#endif
{
AVFormatContext *fmt_ctx = NULL;
AVInputFormat *fmt = NULL;
AVCodecContext *dec_ctx = NULL;
FILE *dst_file = NULL;
AVFrame *frame = NULL;
int got_frame = 0;
int frame_count = 0;
AVPacket pkt = { 0 };
AVDictionary *opts = NULL;
ret = 0;
width = 0;
height = 0;
pix_fmt = AV_PIX_FMT_NONE;
video_dst_bufsize = 0;
memset(video_dst_data, 0, sizeof(video_dst_data));
memset(video_dst_linesize, 0, sizeof(video_dst_linesize));
/* set the whitelists for formats and codecs */
if (av_dict_set(&opts, "codec_whitelist", codec, 0) < 0) {
fprintf(stderr, "Could not set codec_whitelist.\n");
ret = 1;
goto end;
}
if (av_dict_set(&opts, "format_whitelist", format, 0) < 0) {
fprintf(stderr, "Could not set format_whitelist.\n");
ret = 1;
goto end;
}
if (format) {
fmt = av_find_input_format(format);
if (!fmt) {
fprintf(stderr, "Could not find input format %s\n", format);
ret = 1;
goto end;
}
}
/* open input file, and allocate format context */
if (avformat_open_input(&fmt_ctx, src_filename, fmt, &opts) < 0) {
fprintf(stderr, "Could not open source file %s\n", src_filename);
ret = 1;
goto end;
}
/* retrieve stream information */
if (avformat_find_stream_info(fmt_ctx, NULL) < 0) {
fprintf(stderr, "Could not find stream information\n");
}
/* find stream with specified codec */
if (open_codec_context(&dec_ctx, fmt_ctx, codec) < 0) {
fprintf(stderr, "Could not open any stream in input file '%s'\n",
src_filename);
ret = 1;
goto end;
}
/* open output file */
dst_file = fopen(dst_filename, "wb");
if (!dst_file) {
fprintf(stderr, "Could not open destination file %s\n", dst_filename);
ret = 1;
goto end;
}
if (dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO) {
/* allocate image where the decoded image will be put */
width = dec_ctx->width;
height = dec_ctx->height;
pix_fmt = dec_ctx->pix_fmt;
video_dst_bufsize = av_image_alloc(video_dst_data, video_dst_linesize,
width, height, pix_fmt, 1);
if (video_dst_bufsize < 0) {
fprintf(stderr, "Could not allocate raw video buffer\n");
ret = 1;
goto end;
}
}
/* dump input information to stderr */
av_dump_format(fmt_ctx, 0, src_filename, 0);
/* allocate frame */
frame = av_frame_alloc();
if (!frame) {
fprintf(stderr, "Could not allocate frame\n");
ret = 1;
goto end;
}
printf("Demuxing from file '%s' into '%s'\n", src_filename, dst_filename);
/* read frames from the file */
while (av_read_frame(fmt_ctx, &pkt) >= 0) {
do {
int decoded = decode_packet(dec_ctx, dst_file, frame, &got_frame, &frame_count, &pkt);
if (decoded < 0)
break;
/* increase data pointer and decrease size of remaining data buffer */
pkt.data += decoded;
pkt.size -= decoded;
} while (pkt.size > 0);
av_free_packet(&pkt);
}
printf("Flushing cached frames.\n");
pkt.data = NULL;
pkt.size = 0;
do {
decode_packet(dec_ctx, dst_file, frame, &got_frame, &frame_count, &pkt);
} while (got_frame);
printf("Demuxing done.\n");
end:
/* free allocated memory */
av_dict_free(&opts);
avcodec_close(dec_ctx);
avformat_close_input(&fmt_ctx);
if (dst_file)
fclose(dst_file);
av_frame_free(&frame);
av_free(video_dst_data[0]);
}
return ret;
}
int main(int argc, const char *argv[]) {
int ret = 0, got_frame, got_output;
int video_stream_idx = -1;
int video_dst_bufsize;
const char *src_filename;
const char *dst_filename;
FILE *dst_file = NULL;
AVCodec *codec_enc = NULL;
AVFormatContext *fmt_ctx = NULL;
AVStream *video_stream = NULL;
AVCodecContext *video_dec_ctx = NULL;
AVCodecContext *video_enc_ctx = NULL;
AVFrame *frame = NULL;
AVPacket pkt_dec, pkt_enc;
uint8_t *video_dst_data[4] = {NULL};
int video_dst_linesize[4];
if (argc != 3) {
printf("Usage: %s <in_file> <out_file>\n", argv[0]);
exit(1);
}
av_register_all();
av_log_set_level(AV_LOG_DEBUG);
src_filename = argv[1];
dst_filename = argv[2];
codec_enc = avcodec_find_encoder(AV_CODEC_ID_JPEG2000);
if (!codec_enc) {
fprintf(stderr, "Codec not found\n");
exit(1);
}
video_enc_ctx = avcodec_alloc_context3(codec_enc);
if (!video_enc_ctx) {
fprintf(stderr, "Could not allocate video codec context\n");
exit(1);
}
// j2kenc_init(video_enc_ctx);
/* open input file, and allocate format context */
if (avformat_open_input(&fmt_ctx, src_filename, NULL, NULL) < 0) {
fprintf(stderr, "Could not open source file %s\n", src_filename);
exit(1);
}
/* retrieve stream information */
if (avformat_find_stream_info(fmt_ctx, NULL) < 0) {
fprintf(stderr, "Could not find stream information\n");
exit(1);
}
if (open_codec_context(&video_stream_idx, fmt_ctx, AVMEDIA_TYPE_VIDEO, src_filename) >= 0) {
video_stream = fmt_ctx->streams[video_stream_idx];
video_dec_ctx = video_stream->codec;
video_enc_ctx->width = video_dec_ctx->width;
video_enc_ctx->height = video_dec_ctx->height;
video_enc_ctx->pix_fmt = video_dec_ctx->pix_fmt;
// make ffmpeg not complain about j2k being experiemntal
video_enc_ctx->strict_std_compliance = -2;
// printf("About to open encoder\n");
if (avcodec_open2(video_enc_ctx, codec_enc, NULL) < 0) {
fprintf(stderr, "Could not open codec\n");
exit(1);
}
dst_file = fopen(dst_filename, "wb");
if (!dst_file) {
fprintf(stderr, "Could not open destination file %s\n", dst_filename);
ret = 1;
goto end;
}
/* allocate image where the decoded image will be put */
ret = av_image_alloc(video_dst_data, video_dst_linesize,
video_dec_ctx->width, video_dec_ctx->height,
video_dec_ctx->pix_fmt, 1);
if (ret < 0) {
fprintf(stderr, "Could not allocate raw video buffer\n");
goto end;
}
video_dst_bufsize = ret;
}
/* dump input information to stderr */
av_dump_format(fmt_ctx, 0, src_filename, 0);
frame = av_frame_alloc();
if (!frame) {
fprintf(stderr, "Could not allocate frame\n");
ret = AVERROR(ENOMEM);
goto end;
}
/* initialize packet, set data to NULL, let the demuxer fill it */
av_init_packet(&pkt_dec);
pkt_dec.data = NULL;
pkt_dec.size = 0;
if (video_stream)
printf("Demuxing video from file '%s' into '%s'\n", src_filename, dst_filename);
/* read frames from the file */
while (av_read_frame(fmt_ctx, &pkt_dec) >= 0) {
// AVPacket orig_pkt = pkt;
do {
ret = decode_packet(&got_frame, 0, &pkt_dec, video_dec_ctx, frame);
if (ret < 0)
break;
pkt_dec.data += ret;
pkt_dec.size -= ret;
} while (pkt_dec.size > 0);
// av_free_packet(&orig_pkt);
}
/* flush cached frames */
pkt_dec.data = NULL;
pkt_dec.size = 0;
do {
decode_packet(&got_frame, 1, &pkt_dec, video_dec_ctx, frame);
if (got_frame) {
// DO SOME ENCODING HERE
av_init_packet(&pkt_enc);
pkt_enc.data = NULL;
pkt_enc.size = 0;
ret = avcodec_encode_video2(video_enc_ctx, &pkt_enc, frame, &got_output);
if (ret < 0) {
fprintf(stderr, "Error encoding frame\n");
goto end;
}
if (got_output) {
printf("Write frame (size=%5d)\n", pkt_enc.size);
fwrite(pkt_enc.data, 1, pkt_enc.size, dst_file);
}
}
} while (got_frame);
printf("Demuxing succeeded.\n");
end:
av_free_packet(&pkt_enc);
av_free_packet(&pkt_dec);
if (video_dec_ctx)
avcodec_close(video_dec_ctx);
if (video_enc_ctx)
avcodec_close(video_enc_ctx);
// if (codec_enc)
// av_free(codec_enc);
avformat_close_input(&fmt_ctx);
if (dst_file)
fclose(dst_file);
else
av_frame_free(&frame);
av_free(video_dst_data[0]);
return ret < 0;
}
int main (int argc, char **argv)
{
double v1 = 1 / (29.97 * 90000);
double v2 = 1 / 29.97 * 90000;
AVInputFormat* fmtInput ;
char deviceBuffer[256] ={0};
int ret = 0, got_frame;
//if (argc != 4) {
// fprintf(stderr, "usage: %s input_file video_output_file audio_output_file\n"
// "API example program to show how to read frames from an input file.\n"
// "This program reads frames from a file, decodes them, and writes decoded\n"
// "video frames to a rawvideo file named video_output_file, and decoded\n"
// "audio frames to a rawaudio file named audio_output_file.\n"
// "\n", argv[0]);
// exit(1);
//}
//src_filename = argv[1];
//video_dst_filename = argv[2];
//audio_dst_filename = argv[3];
//src_filename = "rtsp://*****:*****@192.168.0.6/ch1/main/av_stream"; //"d:\\wildlife.wmv";
//src_filename = "video=Integrated Camera";
//src_filename = "d:\\pgm\\2.jpg";
src_filename = "dummy";
video_dst_filename = "d:\\pgm\\wildlife.pgm";
audio_dst_filename = "d:\\pgm\\wildlife.pcm";
/* register all formats and codecs */
av_register_all();
avdevice_register_all();
avformat_network_init();
fmtInput = av_find_input_format("dshow");
/* open input file, and allocate format context */
if (avformat_open_input(&fmt_ctx, src_filename, fmtInput, NULL) < 0) {
//if (avformat_open_input(&fmt_ctx, src_filename, NULL, NULL) < 0) {
fprintf(stderr, "Could not open source file %s\n", src_filename);
exit(1);
}
/* retrieve stream information */
if (avformat_find_stream_info(fmt_ctx, NULL) < 0) {
fprintf(stderr, "Could not find stream information\n");
exit(1);
}
if (open_codec_context(&video_stream_idx, fmt_ctx, AVMEDIA_TYPE_VIDEO) >= 0) {
video_stream = fmt_ctx->streams[video_stream_idx];
video_dec_ctx = video_stream->codec;
video_dst_file = fopen(video_dst_filename, "wb");
if (!video_dst_file) {
fprintf(stderr, "Could not open destination file %s\n", video_dst_filename);
ret = 1;
goto end;
}
/* allocate image where the decoded image will be put */
ret = av_image_alloc(video_dst_data, video_dst_linesize,
video_dec_ctx->width, video_dec_ctx->height,
video_dec_ctx->pix_fmt, 1);
if (ret < 0) {
fprintf(stderr, "Could not allocate raw video buffer\n");
goto end;
}
video_dst_bufsize = ret;
}
if (open_codec_context(&audio_stream_idx, fmt_ctx, AVMEDIA_TYPE_AUDIO) >= 0) {
int nb_planes;
audio_stream = fmt_ctx->streams[audio_stream_idx];
audio_dec_ctx = audio_stream->codec;
audio_dst_file = fopen(audio_dst_filename, "wb");
if (!audio_dst_file) {
fprintf(stderr, "Could not open destination file %s\n", video_dst_filename);
ret = 1;
goto end;
}
nb_planes = av_sample_fmt_is_planar(audio_dec_ctx->sample_fmt) ?
audio_dec_ctx->channels : 1;
audio_dst_data = av_mallocz(sizeof(uint8_t *) * nb_planes);
if (!audio_dst_data) {
fprintf(stderr, "Could not allocate audio data buffers\n");
ret = AVERROR(ENOMEM);
goto end;
}
}
/* dump input information to stderr */
av_dump_format(fmt_ctx, 0, src_filename, 0);
if (!audio_stream && !video_stream) {
fprintf(stderr, "Could not find audio or video stream in the input, aborting\n");
ret = 1;
goto end;
}
frame = avcodec_alloc_frame();
if (!frame) {
fprintf(stderr, "Could not allocate frame\n");
ret = AVERROR(ENOMEM);
goto end;
}
/* initialize packet, set data to NULL, let the demuxer fill it */
av_init_packet(&pkt);
pkt.data = NULL;
pkt.size = 0;
if (video_stream)
printf("Demuxing video from file '%s' into '%s'\n", src_filename, video_dst_filename);
if (audio_stream)
printf("Demuxing audio from file '%s' into '%s'\n", src_filename, audio_dst_filename);
/* read frames from the file */
while (av_read_frame(fmt_ctx, &pkt) >= 0) {
decode_packet(&got_frame, 0);
av_free_packet(&pkt);
}
/* flush cached frames */
pkt.data = NULL;
pkt.size = 0;
do {
decode_packet(&got_frame, 1);
} while (got_frame);
printf("Demuxing succeeded.\n");
if (video_stream) {
printf("Play the output video file with the command:\n"
"ffplay -f rawvideo -pix_fmt %s -video_size %dx%d %s\n",
av_get_pix_fmt_name(video_dec_ctx->pix_fmt), video_dec_ctx->width, video_dec_ctx->height,
video_dst_filename);
}
if (audio_stream) {
const char *fmt;
if ((ret = get_format_from_sample_fmt(&fmt, audio_dec_ctx->sample_fmt)) < 0)
goto end;
printf("Play the output audio file with the command:\n"
"ffplay -f %s -ac %d -ar %d %s\n",
fmt, audio_dec_ctx->channels, audio_dec_ctx->sample_rate,
audio_dst_filename);
}
end:
if (video_dec_ctx)
avcodec_close(video_dec_ctx);
if (audio_dec_ctx)
avcodec_close(audio_dec_ctx);
avformat_close_input(&fmt_ctx);
if (video_dst_file)
fclose(video_dst_file);
if (audio_dst_file)
fclose(audio_dst_file);
av_free(frame);
av_free(video_dst_data[0]);
av_free(audio_dst_data);
return ret < 0;
}
int _tmain(int argc, _TCHAR* argv[])
{
ISubtitles* subtitle = NULL;
if (!ISubtitles::create(&subtitle)) {
printf("failed to create subtitle instance.\n");
return 1;
}
#ifdef EMBEDDING_SUBTITLE
av_register_all();
avformat_network_init();
AVFormatContext *fmt_ctx = NULL;
char *url = LOCAL_FILE;
int subtitle_stream_idx = -1;
AVStream* subtitle_stream;
AVCodecContext* subtitle_dec_ctx;
AVPacket pkt;
AVSubtitle sub;
int got_sub;
int ret;
int index = 0;
/* open input file, and allocate format context */
if (avformat_open_input(&fmt_ctx, url, NULL, NULL) < 0) {
LOGE("Could not open source file");
return 1;
}
/* retrieve stream information */
if (avformat_find_stream_info(fmt_ctx, NULL) < 0) {
LOGE("Could not find stream information\n");
return 1;
}
if (open_codec_context(fmt_ctx, &subtitle_stream_idx, AVMEDIA_TYPE_SUBTITLE) < 0) {
LOGE("failed to find subttile track");
return 1;
}
subtitle_stream = fmt_ctx->streams[subtitle_stream_idx];
subtitle_dec_ctx = subtitle_stream->codec;
/* dump input information to stderr */
av_dump_format(fmt_ctx, 0, url, 0);
SubtitleCodecId codec_id;
if (subtitle_dec_ctx->codec_id == AV_CODEC_ID_ASS ||
subtitle_dec_ctx->codec_id == AV_CODEC_ID_SSA)
codec_id = SUBTITLE_CODEC_ID_ASS;
else
codec_id = SUBTITLE_CODEC_ID_TEXT;
ret = subtitle->addEmbeddingSubtitle(codec_id, "chs", "chs",
(const char *)subtitle_dec_ctx->extradata, subtitle_dec_ctx->extradata_size);
if (ret < 0) {
LOGE("failed to addEmbeddingSubtitle");
return 1;
}
/* 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 && index < 10 ) {
if (pkt.stream_index == subtitle_stream_idx) {
AVPacket orig_pkt = pkt;
do {
ret = avcodec_decode_subtitle2(subtitle_dec_ctx, &sub, &got_sub, &pkt);
if (ret < 0) {
break;
}
if (got_sub) {
LOGI("got subtitle");
for (int i=0;i<sub.num_rects;i++) {
if (sub.rects[i]->ass) {
int64_t start_time ,stop_time;
AVRational ra;
ra.num = 1;
ra.den = AV_TIME_BASE;
start_time = av_rescale_q(sub.pts + sub.start_display_time * 1000,
ra, subtitle_stream->time_base);
stop_time = av_rescale_q(sub.pts + sub.end_display_time * 1000,
ra, subtitle_stream->time_base);
subtitle->addEmbeddingSubtitleEntity(0, start_time, stop_time - start_time,
sub.rects[i]->ass, strlen(sub.rects[i]->ass)); // my_strlen_utf8_c
index++;
}
}
avsubtitle_free(&sub);
}
pkt.data += ret;
pkt.size -= ret;
} while (pkt.size > 0);
av_free_packet(&orig_pkt);
}
else {
av_free_packet(&pkt);
}
}
#else
if (!subtitle->loadSubtitle(SUB_FILE_PATH, false)) {
printf("failed to load subtitle: %s", SUB_FILE_PATH);
return 1;
}
#endif
STSSegment* segment = NULL;
char subtitleText[1024] = {0};
int line = 0;
while(line < 20 && subtitle->getNextSubtitleSegment(&segment)) {
int64_t startTime = segment->getStartTime();
int64_t stopTime = segment->getStopTime();
segment->getSubtitleText(subtitleText, 1024);
LOGI("%01d:%02d:%02d.%02d --> %01d:%02d:%02d.%02d %s",
int(startTime/1000/3600), int(startTime/1000%3600/60), int(startTime/1000%60), int(startTime%1000)/10,
int(stopTime/1000/3600), int(stopTime/1000%3600/60), int(stopTime/1000%60), int(stopTime%1000)/10,
CW2A(CA2W(subtitleText, CP_UTF8)));
//getchar();
line++;
}
subtitle->close();
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;
}