Recherche avancée
Médias (2)
-
Valkaama DVD Label
4 octobre 2011, par
Mis à jour : Février 2013
Langue : English
Type : Image
-
Podcasting Legal guide
16 mai 2011, par
Mis à jour : Mai 2011
Langue : English
Type : Texte
Autres articles (67)
-
Submit bugs and patches
13 avril 2011Unfortunately a software is never perfect.
If you think you have found a bug, report it using our ticket system. Please to help us to fix it by providing the following information : the browser you are using, including the exact version as precise an explanation as possible of the problem if possible, the steps taken resulting in the problem a link to the site / page in question
If you think you have solved the bug, fill in a ticket and attach to it a corrective patch.
You may also (...) -
Possibilité de déploiement en ferme
12 avril 2011, parMediaSPIP peut être installé comme une ferme, avec un seul "noyau" hébergé sur un serveur dédié et utilisé par une multitude de sites différents.
Cela permet, par exemple : de pouvoir partager les frais de mise en œuvre entre plusieurs projets / individus ; de pouvoir déployer rapidement une multitude de sites uniques ; d’éviter d’avoir à mettre l’ensemble des créations dans un fourre-tout numérique comme c’est le cas pour les grandes plate-formes tout public disséminées sur le (...) -
Ajouter des informations spécifiques aux utilisateurs et autres modifications de comportement liées aux auteurs
12 avril 2011, parLa manière la plus simple d’ajouter des informations aux auteurs est d’installer le plugin Inscription3. Il permet également de modifier certains comportements liés aux utilisateurs (référez-vous à sa documentation pour plus d’informations).
Il est également possible d’ajouter des champs aux auteurs en installant les plugins champs extras 2 et Interface pour champs extras.
Sur d’autres sites (9302)
-
FFmpeg how to apply "aac_adtstoasc" and "h264_mp4toannexb" bitstream filters to transcode to h.264 with AAC
9 juillet 2015, par larodI’ve been struggling with this issue for about a month, I have studied FFmpeg documentation more specifically transcode_aac.c, transcoding.c, decoding_encoding.c and Handbrake’s implementation which is really dense.
The error that I’m getting is the following :
[mp4 @ 0x11102f800] Malformed AAC bitstream detected: use the audio bitstream filter 'aac_adtstoasc' to fix it ('-bsf:a aac_adtstoasc' option with ffmpeg).The research I’ve done points to a filter that needs to be implemented.
FIX:AAC in some container format (FLV, MP4, MKV etc.) need "aac_adtstoasc" bitstream filter (BSF).I know I can do the following :
AVBitStreamFilterContext* aacbsfc = av_bitstream_filter_init("aac_adtstoasc");And then do something like this :
av_bitstream_filter_filter(aacbsfc, in_stream->codec, NULL, &pkt.data, &pkt.size, pkt.data, pkt.size, 0);What eludes me is when to filter the
AVPacket, is it before callingav_packet_rescale_tsor insideinit_filter. I would greatly appreciate if someone can point me in the right direction. Thanks in advance.// Variables
AVFormatContext *_ifmt_ctx, *_ofmt_ctx;
FilteringContext *_filter_ctx;
AVBitStreamFilterContext *_h264bsfc;
AVBitStreamFilterContext *_aacbsfc;
NSURL *_srcURL, *_dstURL;
- (IBAction)trancode:(id)sender {
NSLog(@"%s %@",__func__, _mediaFile.fsName);
int ret, got_frame;
int (*dec_func)(AVCodecContext *, AVFrame *, int *, const AVPacket *);
unsigned int stream_index, i;
enum AVMediaType type;
AVPacket packet = {.data = NULL, .size = 0};
AVFrame *frame = NULL;
_h264bsfc = av_bitstream_filter_init("h264_mp4toannexb");
_aacbsfc = av_bitstream_filter_init("aac_adtstoasc");
_srcURL = [Utility urlFromBookmark:_mediaFile.bookmark];
if ([_srcURL startAccessingSecurityScopedResource]) {
NSString *newFileName = [[_srcURL.lastPathComponent stringByDeletingPathExtension]stringByAppendingPathExtension:@"mp4"];
_dstURL = [NSURL fileURLWithPath:[[_srcURL URLByDeletingLastPathComponent]URLByAppendingPathComponent:newFileName].path isDirectory:NO];
[AppDelegate ffmpegRegisterAll];
ret = open_input_file(_srcURL.path.fileSystemRepresentation);
if (ret < 0) {
NSLog(@"Error openning input file.");
}
ret = open_output_file(_dstURL.path.fileSystemRepresentation);
if (ret < 0) {
NSLog(@"Error openning output file.");
}
ret = init_filters();
if (ret < 0) {
NSLog(@"Error initializing filters.");
}
AVBitStreamFilterContext *h264bsfc = av_bitstream_filter_init("h264_mp4toannexb");
AVBitStreamFilterContext* aacbsfc = av_bitstream_filter_init("aac_adtstoasc");
// Transcode *******************************************************************************
while (1) {
if ((ret = av_read_frame(_ifmt_ctx, &packet)) < 0) {
break;
}
stream_index = packet.stream_index;
type = _ifmt_ctx->streams[packet.stream_index]->codec->codec_type;
av_log(NULL, AV_LOG_DEBUG, "Demuxer gave frame of stream_index %u\n", stream_index);
if (_filter_ctx[stream_index].filter_graph) {
av_log(NULL, AV_LOG_DEBUG, "Going to reencode&filter the frame\n");
frame = av_frame_alloc();
if (!frame) {
ret = AVERROR(ENOMEM);
break;
}
av_packet_rescale_ts(&packet, _ifmt_ctx->streams[stream_index]->time_base, _ifmt_ctx->streams[stream_index]->codec->time_base);
dec_func = (type == AVMEDIA_TYPE_VIDEO) ? avcodec_decode_video2 : avcodec_decode_audio4;
ret = dec_func(_ifmt_ctx->streams[stream_index]->codec, frame, &got_frame, &packet);
if (ret < 0) {
av_frame_free(&frame);
av_log(NULL, AV_LOG_ERROR, "Decoding failed\n");
break;
}
if (got_frame) {
frame->pts = av_frame_get_best_effort_timestamp(frame);
ret = filter_encode_write_frame(frame, stream_index);
av_frame_free(&frame);
if (ret < 0)
goto end;
} else {
av_frame_free(&frame);
}
} else {
/* remux this frame without reencoding */
av_packet_rescale_ts(&packet,
_ifmt_ctx->streams[stream_index]->time_base,
_ofmt_ctx->streams[stream_index]->time_base);
ret = av_interleaved_write_frame(_ofmt_ctx, &packet);
if (ret < 0)
goto end;
}
av_free_packet(&packet);
}
// *****************************************************************************************
/* flush filters and encoders */
for (i = 0; i < _ifmt_ctx->nb_streams; i++) {
/* flush filter */
if (!_filter_ctx[i].filter_graph)
continue;
ret = filter_encode_write_frame(NULL, i);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Flushing filter failed\n");
goto end;
}
/* flush encoder */
ret = flush_encoder(i);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Flushing encoder failed\n");
goto end;
}
}
av_write_trailer(_ofmt_ctx);
av_bitstream_filter_close(h264bsfc);
av_bitstream_filter_close(aacbsfc);
} else {
NSLog(@"Unable to resolve url for %@",_mediaFile.url.lastPathComponent);
}
[_srcURL stopAccessingSecurityScopedResource];
end:
av_free_packet(&packet);
av_frame_free(&frame);
for (i = 0; i < _ifmt_ctx->nb_streams; i++) {
avcodec_close(_ifmt_ctx->streams[i]->codec);
if (_ofmt_ctx && _ofmt_ctx->nb_streams > i && _ofmt_ctx->streams[i] && _ofmt_ctx->streams[i]->codec)
avcodec_close(_ofmt_ctx->streams[i]->codec);
if (_filter_ctx && _filter_ctx[i].filter_graph)
avfilter_graph_free(&_filter_ctx[i].filter_graph);
}
av_free(_filter_ctx);
avformat_close_input(&_ifmt_ctx);
if (_ofmt_ctx && !(_ofmt_ctx->oformat->flags & AVFMT_NOFILE))
avio_closep(&_ofmt_ctx->pb);
avformat_free_context(_ofmt_ctx);
}The following method is used to open the input file and create the ifmt_ctx.
int open_input_file(const char *filename) {
int ret;
unsigned int i;
_ifmt_ctx = NULL;
if ((ret = avformat_open_input(&_ifmt_ctx, filename, NULL, NULL)) < 0) {
av_log(NULL, AV_LOG_ERROR, "Cannot open input file\n");
return ret;
}
if ((ret = avformat_find_stream_info(_ifmt_ctx, NULL)) < 0) {
av_log(NULL, AV_LOG_ERROR, "Cannot find stream information\n");
return ret;
}
for (i = 0; i < _ifmt_ctx->nb_streams; i++) {
AVStream *stream;
AVCodecContext *codec_ctx;
stream = _ifmt_ctx->streams[i];
codec_ctx = stream->codec;
/* Reencode video & audio and remux subtitles etc. */
if (codec_ctx->codec_type == AVMEDIA_TYPE_VIDEO
|| codec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) {
/* Open decoder */
ret = avcodec_open2(codec_ctx,
avcodec_find_decoder(codec_ctx->codec_id), NULL);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Failed to open decoder for stream #%u\n", i);
return ret;
}
}
}
// Remove later
av_dump_format(_ifmt_ctx, 0, filename, 0);
return 0;
}This method is used to open the output file and create the output format context.
int open_output_file(const char *filename) {
AVStream *out_stream;
AVStream *in_stream;
AVCodecContext *dec_ctx, *enc_ctx;
AVCodec *encoder;
int ret;
unsigned int i;
_ofmt_ctx = NULL;
avformat_alloc_output_context2(&_ofmt_ctx, NULL, NULL, filename);
if (!_ofmt_ctx) {
av_log(NULL, AV_LOG_ERROR, "Could not create output context\n");
return AVERROR_UNKNOWN;
}
for (i = 0; i < _ifmt_ctx->nb_streams; i++) {
out_stream = avformat_new_stream(_ofmt_ctx, NULL);
if (!out_stream) {
av_log(NULL, AV_LOG_ERROR, "Failed allocating output stream\n");
return AVERROR_UNKNOWN;
}
in_stream = _ifmt_ctx->streams[i];
dec_ctx = in_stream->codec;
enc_ctx = out_stream->codec;
if (dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO) {
// set video stream
encoder = avcodec_find_encoder(AV_CODEC_ID_H264);
avcodec_get_context_defaults3(enc_ctx, encoder);
av_opt_set(enc_ctx->priv_data, "preset", "slow", 0);
enc_ctx->height = dec_ctx->height;
enc_ctx->width = dec_ctx->width;
enc_ctx->bit_rate = dec_ctx->bit_rate;
enc_ctx->time_base = out_stream->time_base = dec_ctx->time_base;
enc_ctx->pix_fmt = encoder->pix_fmts[0];
ret = avcodec_open2(enc_ctx, encoder, NULL);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Cannot open video encoder for stream #%u\n", i);
return ret;
}
} else if (dec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) {
// set audio stream
//encoder = avcodec_find_encoder(AV_CODEC_ID_AAC);
encoder = avcodec_find_encoder_by_name("libfdk_aac");
avcodec_get_context_defaults3(enc_ctx, encoder);
enc_ctx->profile = FF_PROFILE_AAC_HE_V2;
enc_ctx->sample_rate = dec_ctx->sample_rate;
enc_ctx->channel_layout = dec_ctx->channel_layout;
enc_ctx->channels = av_get_channel_layout_nb_channels(enc_ctx->channel_layout);
enc_ctx->sample_fmt = encoder->sample_fmts[0];
enc_ctx->time_base = out_stream->time_base = (AVRational){1, enc_ctx->sample_rate};
enc_ctx->bit_rate = dec_ctx->bit_rate;
ret = avcodec_open2(enc_ctx, encoder, NULL);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Cannot open video encoder for stream #%u\n", i);
return ret;
}
} else if (dec_ctx->codec_type == AVMEDIA_TYPE_UNKNOWN) {
// deal with error
av_log(NULL, AV_LOG_FATAL, "Elementary stream #%d is of unknown type, cannot proceed\n", i);
return AVERROR_INVALIDDATA;
} else {
// remux stream
ret = avcodec_copy_context(_ofmt_ctx->streams[i]->codec,
_ifmt_ctx->streams[i]->codec);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Copying stream context failed\n");
return ret;
}
}
if (_ofmt_ctx->oformat->flags & AVFMT_GLOBALHEADER) {
enc_ctx->flags |= CODEC_FLAG_GLOBAL_HEADER;
}
}
av_dump_format(_ofmt_ctx, 0, filename, 1);
NSURL *openFileURL = [Utility openPanelAt:[NSURL URLWithString:_dstURL.URLByDeletingLastPathComponent.path]
withTitle:@"Transcode File"
message:@"Please allow Maví to create the new file."
andPrompt:@"Grant Access"];
openFileURL = [openFileURL URLByAppendingPathComponent:_dstURL.lastPathComponent isDirectory:NO];
if (!(_ofmt_ctx->oformat->flags & AVFMT_NOFILE)) {
ret = avio_open(&_ofmt_ctx->pb, openFileURL.fileSystemRepresentation, AVIO_FLAG_WRITE);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Could not open output file '%s'", filename);
return ret;
}
}
/* init muxer, write output file header */
ret = avformat_write_header(_ofmt_ctx, NULL);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Error occurred when opening output file\n");
return ret;
}
return 0;
}These two methods deal with initialising the filters and filtering.
int init_filters(void) {
const char *filter_spec;
unsigned int i;
int ret;
_filter_ctx = av_malloc_array(_ifmt_ctx->nb_streams, sizeof(*_filter_ctx));
if (!_filter_ctx)
return AVERROR(ENOMEM);
for (i = 0; i < _ifmt_ctx->nb_streams; i++) {
_filter_ctx[i].buffersrc_ctx = NULL;
_filter_ctx[i].buffersink_ctx = NULL;
_filter_ctx[i].filter_graph = NULL;
if (!(_ifmt_ctx->streams[i]->codec->codec_type == AVMEDIA_TYPE_AUDIO
|| _ifmt_ctx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO))
continue;
if (_ifmt_ctx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO)
filter_spec = "null"; /* passthrough (dummy) filter for video */
else
filter_spec = "anull"; /* passthrough (dummy) filter for audio */
ret = init_filter(&_filter_ctx[i], _ifmt_ctx->streams[i]->codec,
_ofmt_ctx->streams[i]->codec, filter_spec);
if (ret)
return ret;
}
return 0;
}
int init_filter(FilteringContext* fctx, AVCodecContext *dec_ctx, AVCodecContext *enc_ctx, const char *filter_spec) {
char args[512];
int ret = 0;
AVFilter *buffersrc = NULL;
AVFilter *buffersink = NULL;
AVFilterContext *buffersrc_ctx = NULL;
AVFilterContext *buffersink_ctx = NULL;
AVFilterInOut *outputs = avfilter_inout_alloc();
AVFilterInOut *inputs = avfilter_inout_alloc();
AVFilterGraph *filter_graph = avfilter_graph_alloc();
if (!outputs || !inputs || !filter_graph) {
ret = AVERROR(ENOMEM);
goto end;
}
if (dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO) {
buffersrc = avfilter_get_by_name("buffer");
buffersink = avfilter_get_by_name("buffersink");
if (!buffersrc || !buffersink) {
av_log(NULL, AV_LOG_ERROR, "filtering source or sink element not found\n");
ret = AVERROR_UNKNOWN;
goto end;
}
snprintf(args, sizeof(args),
"video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",
dec_ctx->width, dec_ctx->height, dec_ctx->pix_fmt,
dec_ctx->time_base.num, dec_ctx->time_base.den,
dec_ctx->sample_aspect_ratio.num,
dec_ctx->sample_aspect_ratio.den);
ret = avfilter_graph_create_filter(&buffersrc_ctx, buffersrc, "in",
args, NULL, filter_graph);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Cannot create buffer source\n");
goto end;
}
ret = avfilter_graph_create_filter(&buffersink_ctx, buffersink, "out",
NULL, NULL, filter_graph);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Cannot create buffer sink\n");
goto end;
}
ret = av_opt_set_bin(buffersink_ctx, "pix_fmts",
(uint8_t*)&enc_ctx->pix_fmt, sizeof(enc_ctx->pix_fmt),
AV_OPT_SEARCH_CHILDREN);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Cannot set output pixel format\n");
goto end;
}
} else if (dec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) {
buffersrc = avfilter_get_by_name("abuffer");
buffersink = avfilter_get_by_name("abuffersink");
if (!buffersrc || !buffersink) {
av_log(NULL, AV_LOG_ERROR, "filtering source or sink element not found\n");
ret = AVERROR_UNKNOWN;
goto end;
}
if (!dec_ctx->channel_layout)
dec_ctx->channel_layout =
av_get_default_channel_layout(dec_ctx->channels);
snprintf(args, sizeof(args),
"time_base=%d/%d:sample_rate=%d:sample_fmt=%s:channel_layout=0x%"PRIx64,
dec_ctx->time_base.num, dec_ctx->time_base.den, dec_ctx->sample_rate,
av_get_sample_fmt_name(dec_ctx->sample_fmt),
dec_ctx->channel_layout);
ret = avfilter_graph_create_filter(&buffersrc_ctx, buffersrc, "in",
args, NULL, filter_graph);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Cannot create audio buffer source\n");
goto end;
}
ret = avfilter_graph_create_filter(&buffersink_ctx, buffersink, "out",
NULL, NULL, filter_graph);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Cannot create audio buffer sink\n");
goto end;
}
ret = av_opt_set_bin(buffersink_ctx, "sample_fmts",
(uint8_t*)&enc_ctx->sample_fmt, sizeof(enc_ctx->sample_fmt),
AV_OPT_SEARCH_CHILDREN);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Cannot set output sample format\n");
goto end;
}
ret = av_opt_set_bin(buffersink_ctx, "channel_layouts",
(uint8_t*)&enc_ctx->channel_layout,
sizeof(enc_ctx->channel_layout), AV_OPT_SEARCH_CHILDREN);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Cannot set output channel layout\n");
goto end;
}
ret = av_opt_set_bin(buffersink_ctx, "sample_rates",
(uint8_t*)&enc_ctx->sample_rate, sizeof(enc_ctx->sample_rate),
AV_OPT_SEARCH_CHILDREN);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Cannot set output sample rate\n");
goto end;
}
} else {
ret = AVERROR_UNKNOWN;
goto end;
}
/* Endpoints for the filter graph. */
outputs->name = av_strdup("in");
outputs->filter_ctx = buffersrc_ctx;
outputs->pad_idx = 0;
outputs->next = NULL;
inputs->name = av_strdup("out");
inputs->filter_ctx = buffersink_ctx;
inputs->pad_idx = 0;
inputs->next = NULL;
if (!outputs->name || !inputs->name) {
ret = AVERROR(ENOMEM);
goto end;
}
if ((ret = avfilter_graph_parse_ptr(filter_graph, filter_spec,
&inputs, &outputs, NULL)) < 0)
goto end;
if ((ret = avfilter_graph_config(filter_graph, NULL)) < 0)
goto end;
/* Fill FilteringContext */
fctx->buffersrc_ctx = buffersrc_ctx;
fctx->buffersink_ctx = buffersink_ctx;
fctx->filter_graph = filter_graph;
end:
avfilter_inout_free(&inputs);
avfilter_inout_free(&outputs);
return ret;
}Finally these two methods take care of writing the frames.
int encode_write_frame(AVFrame *filt_frame, unsigned int stream_index, int *got_frame) {
int ret;
int got_frame_local;
AVPacket enc_pkt;
int (*enc_func)(AVCodecContext *, AVPacket *, const AVFrame *, int *) =
(_ifmt_ctx->streams[stream_index]->codec->codec_type ==
AVMEDIA_TYPE_VIDEO) ? avcodec_encode_video2 : avcodec_encode_audio2;
if (!got_frame)
got_frame = &got_frame_local;
av_log(NULL, AV_LOG_INFO, "Encoding frame\n");
/* encode filtered frame */
enc_pkt.data = NULL;
enc_pkt.size = 0;
av_init_packet(&enc_pkt);
ret = enc_func(_ofmt_ctx->streams[stream_index]->codec, &enc_pkt,
filt_frame, got_frame);
av_frame_free(&filt_frame);
if (ret < 0)
return ret;
if (!(*got_frame))
return 0;
/* prepare packet for muxing */
enc_pkt.stream_index = stream_index;
av_packet_rescale_ts(&enc_pkt,
_ofmt_ctx->streams[stream_index]->codec->time_base,
_ofmt_ctx->streams[stream_index]->time_base);
av_log(NULL, AV_LOG_DEBUG, "Muxing frame\n");
/* mux encoded frame */
ret = av_interleaved_write_frame(_ofmt_ctx, &enc_pkt);
return ret;
}
int filter_encode_write_frame(AVFrame *frame, unsigned int stream_index)
{
int ret;
AVFrame *filt_frame;
av_log(NULL, AV_LOG_INFO, "Pushing decoded frame to filters\n");
/* push the decoded frame into the filtergraph */
ret = av_buffersrc_add_frame_flags(_filter_ctx[stream_index].buffersrc_ctx,
frame, 0);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Error while feeding the filtergraph\n");
return ret;
}
/* pull filtered frames from the filtergraph */
while (1) {
filt_frame = av_frame_alloc();
if (!filt_frame) {
ret = AVERROR(ENOMEM);
break;
}
av_log(NULL, AV_LOG_INFO, "Pulling filtered frame from filters\n");
ret = av_buffersink_get_frame(_filter_ctx[stream_index].buffersink_ctx,
filt_frame);
if (ret < 0) {
/* if no more frames for output - returns AVERROR(EAGAIN)
* if flushed and no more frames for output - returns AVERROR_EOF
* rewrite retcode to 0 to show it as normal procedure completion
*/
if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
ret = 0;
av_frame_free(&filt_frame);
break;
}
filt_frame->pict_type = AV_PICTURE_TYPE_NONE;
ret = encode_write_frame(filt_frame, stream_index, NULL);
if (ret < 0)
break;
}
return ret;
} -
ffmpeg stops randomly with "No more output streams to write to, finishing" when reading rtsp stream [on hold]
7 juin 2016, par ImagineDragonBasically I am running the following ffmpeg command to read an h264 rtsp stream using hls muxer, under Ubuntu 14.04 64bit with i7 CPU and 8GB memory :
ffmpeg -v debug -i rtsp://172.16.11.247:554/live/ch00_0?token=hQttXvrjSPOcClQB -codec copy -flags -global_header -f hls -hls_time 5 -use_localtime 1 -hls_segment_filename '/home/eason/ffmpeg-test/%s.ts' '/home/eason/ffmpeg-test/live.m3u8'
ffmpeg version N-79139-gde1a0d4 Copyright (c) 2000-2016 the FFmpeg developers
built with gcc 4.8 (Ubuntu 4.8.4-2ubuntu1~14.04.1)
configuration: --extra-libs=-ldl --prefix=/opt/ffmpeg --mandir=/usr/share/man --enable-avresample --disable-debug --enable-nonfree --enable-gpl --enable-version3 --enable-libopencore-amrnb --enable-libopencore-amrwb --disable-decoder=amrnb --disable-decoder=amrwb --enable-libpulse --enable-libfreetype --enable-gnutls --enable-libx264 --enable-libx265 --enable-libfdk-aac --enable-libvorbis --enable-libmp3lame --enable-libopus --enable-libvpx --enable-libspeex --enable-libass --enable-avisynth --enable-libsoxr --enable-libxvid --enable-libvidstab
libavutil 55. 19.100 / 55. 19.100
libavcodec 57. 30.100 / 57. 30.100
libavformat 57. 29.101 / 57. 29.101
libavdevice 57. 0.101 / 57. 0.101
libavfilter 6. 40.102 / 6. 40.102
libavresample 3. 0. 0 / 3. 0. 0
libswscale 4. 0.100 / 4. 0.100
libswresample 2. 0.101 / 2. 0.101
libpostproc 54. 0.100 / 54. 0.100
Splitting the commandline.
Reading option '-v' ... matched as option 'v' (set logging level) with argument 'debug'.
Reading option '-re' ... matched as option 're' (read input at native frame rate) with argument '1'.
Reading option '-i' ... matched as input file with argument 'rtsp://172.16.11.247:554/live/ch00_0?token=hQttXvrjSPOcClQB'.
Reading option '-codec' ... matched as option 'codec' (codec name) with argument 'copy'.
Reading option '-flags' ... matched as AVOption 'flags' with argument '-global_header'.
Reading option '-f' ... matched as option 'f' (force format) with argument 'hls'.
Reading option '-hls_time' ... matched as AVOption 'hls_time' with argument '5'.
Reading option '-use_localtime' ... matched as AVOption 'use_localtime' with argument '1'.
Reading option '-hls_segment_filename' ... matched as AVOption 'hls_segment_filename' with argument '/home/eason/ffmpeg-test/%s.ts'.
Reading option '/home/eason/ffmpeg-test/live.m3u8' ... matched as output file.
Finished splitting the commandline.
Parsing a group of options: global .
Applying option v (set logging level) with argument debug.
Successfully parsed a group of options.
Parsing a group of options: input file rtsp://172.16.11.247:554/live/ch00_0?token=hQttXvrjSPOcClQB.
Applying option re (read input at native frame rate) with argument 1.
Successfully parsed a group of options.
Opening an input file: rtsp://172.16.11.247:554/live/ch00_0?token=hQttXvrjSPOcClQB.
[tcp @ 0x29c4d60] No default whitelist set
[rtsp @ 0x29c2e20] SDP:
m=video 0 RTP/AVP 96
a=rtpmap:96 H264/90000
a=fmtp:96 packetization-mode=1;profile-level-id=640028;sprop-parameter-sets=Z2QAKKzoBQBbkA==,aO48sA==
a=control:trackID=0
m=audio 0 RTP/AVP 98
a=rtpmap:98 MPEG4-GENERIC/16000/1
a=fmtp:98 profile-level-id=1;mode=AAC-lbr;sizelength=13;indexlength=3;indexdeltalength=3;config=1408;cpresent=0;
a=control:trackID=1
[rtsp @ 0x29c2e20] video codec set to: h264
[rtsp @ 0x29c2e20] RTP Packetization Mode: 1
[rtsp @ 0x29c2e20] RTP Profile IDC: 64 Profile IOP: 0 Level: 28
[rtsp @ 0x29c2e20] Extradata set to 0x29c4ff0 (size: 22)
[rtsp @ 0x29c2e20] audio codec set to: aac
[rtsp @ 0x29c2e20] audio samplerate set to: 16000
[rtsp @ 0x29c2e20] audio channels set to: 1
[rtp @ 0x29c50a0] No default whitelist set
[udp @ 0x29c5200] No default whitelist set
[udp @ 0x29c5200] end receive buffer size reported is 131072
[udp @ 0x29d9480] No default whitelist set
[udp @ 0x29d9480] end receive buffer size reported is 131072
[rtsp @ 0x29c2e20] method SETUP failed: 461 Unsupported transport
[rtsp @ 0x29c2e20] CSeq: 3
[rtsp @ 0x29c2e20] setting jitter buffer size to 0
Last message repeated 1 times
[rtsp @ 0x29c2e20] hello state=0
[rtsp @ 0x29c2e20] All info found
[rtsp @ 0x29c2e20] rfps: 24.250000 0.018062
[rtsp @ 0x29c2e20] rfps: 24.333333 0.012911
[rtsp @ 0x29c2e20] rfps: 24.416667 0.008627
[rtsp @ 0x29c2e20] rfps: 24.500000 0.005207
Last message repeated 1 times
[rtsp @ 0x29c2e20] rfps: 24.583333 0.002653
Last message repeated 1 times
[rtsp @ 0x29c2e20] rfps: 24.666667 0.000965
Last message repeated 1 times
[rtsp @ 0x29c2e20] rfps: 24.750000 0.000142
Last message repeated 1 times
[rtsp @ 0x29c2e20] rfps: 24.833333 0.000185
Last message repeated 1 times
[rtsp @ 0x29c2e20] rfps: 24.916667 0.001093
Last message repeated 1 times
[rtsp @ 0x29c2e20] rfps: 25.000000 0.002867
Last message repeated 1 times
[rtsp @ 0x29c2e20] rfps: 25.083333 0.005507
Last message repeated 1 times
[rtsp @ 0x29c2e20] rfps: 25.166667 0.009011
[rtsp @ 0x29c2e20] rfps: 25.250000 0.013382
[rtsp @ 0x29c2e20] rfps: 25.333333 0.018618
[rtsp @ 0x29c2e20] rfps: 50.000000 0.011469
Input #0, rtsp, from 'rtsp://172.16.11.247:554/live/ch00_0?token=hQttXvrjSPOcClQB':
Duration: N/A, start: 0.000000, bitrate: N/A
Stream #0:0, 28, 1/90000: Video: h264 (High), 1 reference frame, yuv420p(left), 1280x720, 1/180000, 24.75 tbr, 90k tbn, 180k tbc
Stream #0:1, 23, 1/16000: Audio: aac (LC), 16000 Hz, mono, fltp
Successfully opened the file.
Parsing a group of options: output file /home/eason/ffmpeg-test/live.m3u8.
Applying option codec (codec name) with argument copy.
Applying option f (force format) with argument hls.
Successfully parsed a group of options.
Opening an output file: /home/eason/ffmpeg-test/live.m3u8.
Successfully opened the file.
[file @ 0x2cae180] Setting default whitelist 'file,crypto'
[mpegts @ 0x29f7ce0] muxrate VBR, pcr every 9000 pkts, sdt every 2147483647, pat/pmt every 2147483647 pkts
Output #0, hls, to '/home/eason/ffmpeg-test/live.m3u8':
Metadata:
encoder : Lavf57.29.101
Stream #0:0, 0, 1/90000: Video: h264, 1 reference frame, yuv420p(left), 1280x720 (0x0), 1/90000, q=2-31, 24.75 tbr, 90k tbn, 90k tbc
Stream #0:1, 0, 1/90000: Audio: aac (LC), 16000 Hz, mono
Stream mapping:
Stream #0:0 -> #0:0 (copy)
Stream #0:1 -> #0:1 (copy)
Press [q] to stop, [?] for help
cur_dts is invalid (this is harmless if it occurs once at the start per stream)
Last message repeated 103 times
[hls @ 0x2a0fc00] Timestamps are unset in a packet for stream 0. This is deprecated and will stop working in the future. Fix your code to set the timestamps properly
[AVIOContext @ 0x2c998c0] Statistics: 0 seeks, 155 writeouts=N/A speed=1.01x
[file @ 0x2ba60e0] Setting default whitelist 'file,crypto'
[file @ 0x2ca9fc0] Setting default whitelist 'file,crypto'
[hls @ 0x2a0fc00] EXT-X-MEDIA-SEQUENCE:0
[AVIOContext @ 0x2caa080] Statistics: 0 seeks, 1 writeouts
[AVIOContext @ 0x2c99480] Statistics: 0 seeks, 103 writeouts=N/A speed= 1x
[file @ 0x2ba60e0] Setting default whitelist 'file,crypto'
[file @ 0x2c97c60] Setting default whitelist 'file,crypto'
[hls @ 0x2a0fc00] EXT-X-MEDIA-SEQUENCE:0
[AVIOContext @ 0x2c97d20] Statistics: 0 seeks, 1 writeouts
[AVIOContext @ 0x2c99480] Statistics: 0 seeks, 104 writeouts=N/A speed= 1x
[file @ 0x2ba60e0] Setting default whitelist 'file,crypto'
[file @ 0x2c99680] Setting default whitelist 'file,crypto'
[hls @ 0x2a0fc00] EXT-X-MEDIA-SEQUENCE:0
[AVIOContext @ 0x2c99820] Statistics: 0 seeks, 1 writeouts
[AVIOContext @ 0x2c99480] Statistics: 0 seeks, 28 writeoutse=N/A speed= 1x
[file @ 0x29c50c0] Setting default whitelist 'file,crypto'
[file @ 0x2ba60e0] Setting default whitelist 'file,crypto'
[hls @ 0x2a0fc00] EXT-X-MEDIA-SEQUENCE:0
[AVIOContext @ 0x29c2ce0] Statistics: 0 seeks, 1 writeouts
[AVIOContext @ 0x2c99480] Statistics: 0 seeks, 111 writeouts=N/A speed= 1x
[file @ 0x2c97d40] Setting default whitelist 'file,crypto'
[file @ 0x2a134e0] Setting default whitelist 'file,crypto'
[hls @ 0x2a0fc00] EXT-X-MEDIA-SEQUENCE:0
[AVIOContext @ 0x2a11000] Statistics: 0 seeks, 1 writeouts
[AVIOContext @ 0x2c99480] Statistics: 0 seeks, 105 writeouts=N/A speed= 1x
[file @ 0x29c50c0] Setting default whitelist 'file,crypto'
[file @ 0x2a10c00] Setting default whitelist 'file,crypto'
[hls @ 0x2a0fc00] EXT-X-MEDIA-SEQUENCE:1
[AVIOContext @ 0x2a10cc0] Statistics: 0 seeks, 1 writeouts
[AVIOContext @ 0x2c99480] Statistics: 0 seeks, 103 writeouts=N/A speed= 1x
[file @ 0x29c50c0] Setting default whitelist 'file,crypto'
[file @ 0x2c99480] Setting default whitelist 'file,crypto'
.......repeat........
[hls @ 0x2a0fc00] EXT-X-MEDIA-SEQUENCE:71
[AVIOContext @ 0x2c97fa0] Statistics: 0 seeks, 1 writeouts
[rtsp @ 0x29c2e20] Too short data for FU-A H264 RTP packette=N/A speed= 1x
[AVIOContext @ 0x2ba60e0] Statistics: 0 seeks, 103 writeouts=N/A speed= 1x
[file @ 0x2c97b20] Setting default whitelist 'file,crypto'
[file @ 0x2c97c60] Setting default whitelist 'file,crypto'
[hls @ 0x2a0fc00] EXT-X-MEDIA-SEQUENCE:72
[AVIOContext @ 0x2c99480] Statistics: 0 seeks, 1 writeouts
[AVIOContext @ 0x2ba60e0] Statistics: 0 seeks, 156 writeouts=N/A speed= 1x
[file @ 0x2c99480] Setting default whitelist 'file,crypto'
[file @ 0x2cab600] Setting default whitelist 'file,crypto'
[hls @ 0x2a0fc00] EXT-X-MEDIA-SEQUENCE:73
[AVIOContext @ 0x2cab6c0] Statistics: 0 seeks, 1 writeouts
[AVIOContext @ 0x2ba60e0] Statistics: 0 seeks, 104 writeouts=N/A speed= 1x
[file @ 0x2cadc00] Setting default whitelist 'file,crypto'
[file @ 0x2c99480] Setting default whitelist 'file,crypto'
[hls @ 0x2a0fc00] EXT-X-MEDIA-SEQUENCE:74
[AVIOContext @ 0x29c2ce0] Statistics: 0 seeks, 1 writeouts
[AVIOContext @ 0x2ba60e0] Statistics: 0 seeks, 103 writeouts=N/A speed= 1x
[file @ 0x2a13540] Setting default whitelist 'file,crypto'
[file @ 0x2cab680] Setting default whitelist 'file,crypto'
[hls @ 0x2a0fc00] EXT-X-MEDIA-SEQUENCE:75
[AVIOContext @ 0x2c99480] Statistics: 0 seeks, 1 writeouts
No more output streams to write to, finishing.:46.09 bitrate=N/A speed=0.993x
[AVIOContext @ 0x2ba60e0] Statistics: 0 seeks, 138 writeouts
[file @ 0x29c50c0] Setting default whitelist 'file,crypto'
[hls @ 0x2a0fc00] EXT-X-MEDIA-SEQUENCE:76
[AVIOContext @ 0x2ba60e0] Statistics: 0 seeks, 1 writeouts
frame= 8423 fps= 21 q=-1.0 Lsize=N/A time=00:06:46.09 bitrate=N/A speed=0.993x
video:37031kB audio:1586kB subtitle:0kB other streams:0kB global headers:0kB muxing overhead: unknown
Input file #0 (rtsp://172.16.11.247:554/live/ch00_0?token=hQttXvrjSPOcClQB):
Input stream #0:0 (video): 8423 packets read (37919815 bytes);
Input stream #0:1 (audio): 6345 packets read (1624337 bytes);
Total: 14768 packets (39544152 bytes) demuxed
Output file #0 (/home/eason/ffmpeg-test/live.m3u8):
Output stream #0:0 (video): 8423 packets muxed (37919815 bytes);
Output stream #0:1 (audio): 6345 packets muxed (1624337 bytes);
Total: 14768 packets (39544152 bytes) muxed
0 frames successfully decoded, 0 decoding errorsThe problem is that ffmpeg exits randomly after 5 to 20 minutes. The RTSP is a live stream so stopping every 5 minute is really not acceptable. In the ffmpeg log I can’t see any noticeable error except "No more output streams to write to, finishing." near the end. Can someone shed some light upon this ? How can I make ffmpeg run without stopping ? Thanks
-
How to reparse video with stable "overall bit rate" ? (FFmpeg)
20 février 2018, par user3360601I have such code below :
#include
#include
#include
extern "C"
{
#include <libavcodec></libavcodec>avcodec.h>
#include <libavformat></libavformat>avformat.h>
#include <libavfilter></libavfilter>buffersink.h>
#include <libavfilter></libavfilter>buffersrc.h>
#include <libavutil></libavutil>opt.h>
#include <libavutil></libavutil>pixdesc.h>
}
static AVFormatContext *ifmt_ctx;
static AVFormatContext *ofmt_ctx;
typedef struct StreamContext {
AVCodecContext *dec_ctx;
AVCodecContext *enc_ctx;
} StreamContext;
static StreamContext *stream_ctx;
static int open_input_file(const char *filename)
{
int ret;
unsigned int i;
ifmt_ctx = NULL;
if ((ret = avformat_open_input(&ifmt_ctx, filename, NULL, NULL)) < 0) {
av_log(NULL, AV_LOG_ERROR, "Cannot open input file\n");
return ret;
}
if ((ret = avformat_find_stream_info(ifmt_ctx, NULL)) < 0) {
av_log(NULL, AV_LOG_ERROR, "Cannot find stream information\n");
return ret;
}
stream_ctx = (StreamContext *) av_mallocz_array(ifmt_ctx->nb_streams, sizeof(*stream_ctx));
if (!stream_ctx)
return AVERROR(ENOMEM);
for (i = 0; i < ifmt_ctx->nb_streams; i++) {
AVStream *stream = ifmt_ctx->streams[i];
AVCodec *dec = avcodec_find_decoder(stream->codecpar->codec_id);
AVCodecContext *codec_ctx;
if (!dec) {
av_log(NULL, AV_LOG_ERROR, "Failed to find decoder for stream #%u\n", i);
return AVERROR_DECODER_NOT_FOUND;
}
codec_ctx = avcodec_alloc_context3(dec);
if (!codec_ctx) {
av_log(NULL, AV_LOG_ERROR, "Failed to allocate the decoder context for stream #%u\n", i);
return AVERROR(ENOMEM);
}
ret = avcodec_parameters_to_context(codec_ctx, stream->codecpar);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Failed to copy decoder parameters to input decoder context "
"for stream #%u\n", i);
return ret;
}
/* Reencode video & audio and remux subtitles etc. */
if (codec_ctx->codec_type == AVMEDIA_TYPE_VIDEO
|| codec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) {
if (codec_ctx->codec_type == AVMEDIA_TYPE_VIDEO)
codec_ctx->framerate = av_guess_frame_rate(ifmt_ctx, stream, NULL);
/* Open decoder */
ret = avcodec_open2(codec_ctx, dec, NULL);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Failed to open decoder for stream #%u\n", i);
return ret;
}
}
stream_ctx[i].dec_ctx = codec_ctx;
}
av_dump_format(ifmt_ctx, 0, filename, 0);
return 0;
}
static int open_output_file(const char *filename)
{
AVStream *out_stream;
AVStream *in_stream;
AVCodecContext *dec_ctx, *enc_ctx;
AVCodec *encoder;
int ret;
unsigned int i;
ofmt_ctx = NULL;
avformat_alloc_output_context2(&ofmt_ctx, NULL, NULL, filename);
if (!ofmt_ctx) {
av_log(NULL, AV_LOG_ERROR, "Could not create output context\n");
return AVERROR_UNKNOWN;
}
for (i = 0; i < ifmt_ctx->nb_streams; i++) {
out_stream = avformat_new_stream(ofmt_ctx, NULL);
if (!out_stream) {
av_log(NULL, AV_LOG_ERROR, "Failed allocating output stream\n");
return AVERROR_UNKNOWN;
}
in_stream = ifmt_ctx->streams[i];
dec_ctx = stream_ctx[i].dec_ctx;
//ofmt_ctx->bit_rate = ifmt_ctx->bit_rate;
ofmt_ctx->duration = ifmt_ctx->duration;
if (dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO
|| dec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) {
/* in this example, we choose transcoding to same codec */
encoder = avcodec_find_encoder(dec_ctx->codec_id);
if (!encoder) {
av_log(NULL, AV_LOG_FATAL, "Necessary encoder not found\n");
return AVERROR_INVALIDDATA;
}
enc_ctx = avcodec_alloc_context3(encoder);
if (!enc_ctx) {
av_log(NULL, AV_LOG_FATAL, "Failed to allocate the encoder context\n");
return AVERROR(ENOMEM);
}
/* In this example, we transcode to same properties (picture size,
* sample rate etc.). These properties can be changed for output
* streams easily using filters */
if (dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO) {
enc_ctx->gop_size = dec_ctx->gop_size;
enc_ctx->bit_rate = dec_ctx->bit_rate;
enc_ctx->height = dec_ctx->height;
enc_ctx->width = dec_ctx->width;
enc_ctx->sample_aspect_ratio = dec_ctx->sample_aspect_ratio;
/* take first format from list of supported formats */
if (encoder->pix_fmts)
enc_ctx->pix_fmt = encoder->pix_fmts[0];
else
enc_ctx->pix_fmt = dec_ctx->pix_fmt;
/* video time_base can be set to whatever is handy and supported by encoder */
enc_ctx->time_base = av_inv_q(dec_ctx->framerate);
enc_ctx->framerate = av_guess_frame_rate(ifmt_ctx, in_stream, NULL);
}
else {
enc_ctx->gop_size = dec_ctx->gop_size;
enc_ctx->bit_rate = dec_ctx->bit_rate;
enc_ctx->sample_rate = dec_ctx->sample_rate;
enc_ctx->channel_layout = dec_ctx->channel_layout;
enc_ctx->channels = av_get_channel_layout_nb_channels(enc_ctx->channel_layout);
/* take first format from list of supported formats */
enc_ctx->sample_fmt = encoder->sample_fmts[0];
//enc_ctx->time_base = (AVRational){ 1, enc_ctx->sample_rate };
enc_ctx->time_base.num = 1;
enc_ctx->time_base.den = enc_ctx->sample_rate;
enc_ctx->framerate = av_guess_frame_rate(ifmt_ctx, in_stream, NULL);
}
/* Third parameter can be used to pass settings to encoder */
ret = avcodec_open2(enc_ctx, encoder, NULL);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Cannot open video encoder for stream #%u\n", i);
return ret;
}
ret = avcodec_parameters_from_context(out_stream->codecpar, enc_ctx);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Failed to copy encoder parameters to output stream #%u\n", i);
return ret;
}
if (ofmt_ctx->oformat->flags & AVFMT_GLOBALHEADER)
enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
out_stream->time_base = enc_ctx->time_base;
stream_ctx[i].enc_ctx = enc_ctx;
}
else if (dec_ctx->codec_type == AVMEDIA_TYPE_UNKNOWN) {
av_log(NULL, AV_LOG_FATAL, "Elementary stream #%d is of unknown type, cannot proceed\n", i);
return AVERROR_INVALIDDATA;
}
else {
/* if this stream must be remuxed */
ret = avcodec_parameters_copy(out_stream->codecpar, in_stream->codecpar);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Copying parameters for stream #%u failed\n", i);
return ret;
}
out_stream->time_base = in_stream->time_base;
}
}
av_dump_format(ofmt_ctx, 0, filename, 1);
if (!(ofmt_ctx->oformat->flags & AVFMT_NOFILE)) {
ret = avio_open(&ofmt_ctx->pb, filename, AVIO_FLAG_WRITE);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Could not open output file '%s'", filename);
return ret;
}
}
/* init muxer, write output file header */
ret = avformat_write_header(ofmt_ctx, NULL);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Error occurred when opening output file\n");
return ret;
}
return 0;
}
int main(int argc, char **argv)
{
int ret;
AVPacket packet = {0};
packet.data = NULL;
packet.size = 0 ;
AVFrame *frame = NULL;
enum AVMediaType type;
unsigned int stream_index;
unsigned int i;
int got_frame;
int(*dec_func)(AVCodecContext *, AVFrame *, int *, const AVPacket *);
if (argc != 3) {
av_log(NULL, AV_LOG_ERROR, "Usage: %s <input file="file" /> <output file="file">\n", argv[0]);
return 1;
}
av_register_all();
avfilter_register_all();
if ((ret = open_input_file(argv[1])) < 0)
goto end;
if ((ret = open_output_file(argv[2])) < 0)
goto end;
/* read all packets */
while (1) {
if ((ret = av_read_frame(ifmt_ctx, &packet)) < 0)
break;
stream_index = packet.stream_index;
type = ifmt_ctx->streams[packet.stream_index]->codecpar->codec_type;
av_log(NULL, AV_LOG_DEBUG, "Demuxer gave frame of stream_index %u\n", stream_index);
/* remux this frame without reencoding */
av_packet_rescale_ts(&packet,
ifmt_ctx->streams[stream_index]->time_base,
ofmt_ctx->streams[stream_index]->time_base);
ret = av_interleaved_write_frame(ofmt_ctx, &packet);
if (ret < 0)
goto end;
av_packet_unref(&packet);
}
av_write_trailer(ofmt_ctx);
end:
av_packet_unref(&packet);
av_frame_free(&frame);
for (i = 0; i < ifmt_ctx->nb_streams; i++) {
avcodec_free_context(&stream_ctx[i].dec_ctx);
if (ofmt_ctx && ofmt_ctx->nb_streams > i && ofmt_ctx->streams[i] && stream_ctx[i].enc_ctx)
avcodec_free_context(&stream_ctx[i].enc_ctx);
}
av_free(stream_ctx);
avformat_close_input(&ifmt_ctx);
if (ofmt_ctx && !(ofmt_ctx->oformat->flags & AVFMT_NOFILE))
avio_closep(&ofmt_ctx->pb);
avformat_free_context(ofmt_ctx);
return ret ? 1 : 0;
}
</output>This is a little bit changed code from official example of using ffmpeg called transcoding.c
I only read packets from one stream and write them to another stream. It works fine.
Proof below.
then I add to main a condition. If it is a packet with video frame, I will decode it, then encode and write to another stream. No other actions with frame.
My addition code below :
static int encode_write_frame(AVFrame *filt_frame, unsigned int stream_index, int *got_frame) {
int ret;
int got_frame_local;
AVPacket enc_pkt;
int(*enc_func)(AVCodecContext *, AVPacket *, const AVFrame *, int *) = avcodec_encode_video2 ;
if (!got_frame)
got_frame = &got_frame_local;
av_log(NULL, AV_LOG_INFO, "Encoding frame\n");
/* encode filtered frame */
enc_pkt.data = NULL;
enc_pkt.size = 0;
av_init_packet(&enc_pkt);
ret = enc_func(stream_ctx[stream_index].enc_ctx, &enc_pkt,
filt_frame, got_frame);
if (ret < 0)
return ret;
if (!(*got_frame))
return 0;
/* prepare packet for muxing */
enc_pkt.stream_index = stream_index;
av_packet_rescale_ts(&enc_pkt,
stream_ctx[stream_index].enc_ctx->time_base,
ofmt_ctx->streams[stream_index]->time_base);
av_log(NULL, AV_LOG_DEBUG, "Muxing frame\n");
/* mux encoded frame */
ret = av_interleaved_write_frame(ofmt_ctx, &enc_pkt);
return ret;
}
static int filter_encode_write_frame(AVFrame *frame, unsigned int stream_index)
{
int ret;
av_log(NULL, AV_LOG_INFO, "Pushing decoded frame to filters\n");
while (1) {
av_log(NULL, AV_LOG_INFO, "Pulling filtered frame from filters\n");
ret = encode_write_frame(frame, stream_index, NULL);
if (ret < 0)
break;
break;
}
return ret;
}
int main(int argc, char **argv)
{
int ret;
AVPacket packet = {0};
packet.data = NULL;
packet.size = 0 ;
AVFrame *frame = NULL;
enum AVMediaType type;
unsigned int stream_index;
unsigned int i;
int got_frame;
int(*dec_func)(AVCodecContext *, AVFrame *, int *, const AVPacket *);
if (argc != 3) {
av_log(NULL, AV_LOG_ERROR, "Usage: %s <input file="file" /> <output file="file">\n", argv[0]);
return 1;
}
av_register_all();
avfilter_register_all();
if ((ret = open_input_file(argv[1])) < 0)
goto end;
if ((ret = open_output_file(argv[2])) < 0)
goto end;
/* read all packets */
while (1) {
if ((ret = av_read_frame(ifmt_ctx, &packet)) < 0)
break;
stream_index = packet.stream_index;
type = ifmt_ctx->streams[packet.stream_index]->codecpar->codec_type;
av_log(NULL, AV_LOG_DEBUG, "Demuxer gave frame of stream_index %u\n",
stream_index);
if (type == AVMEDIA_TYPE_VIDEO)
{
av_log(NULL, AV_LOG_DEBUG, "Going to reencode&filter the frame\n");
frame = av_frame_alloc();
if (!frame) {
ret = AVERROR(ENOMEM);
break;
}
av_packet_rescale_ts(&packet,
ifmt_ctx->streams[stream_index]->time_base,
stream_ctx[stream_index].dec_ctx->time_base);
dec_func = avcodec_decode_video2;
ret = dec_func(stream_ctx[stream_index].dec_ctx, frame,
&got_frame, &packet);
if (ret < 0) {
av_frame_free(&frame);
av_log(NULL, AV_LOG_ERROR, "Decoding failed\n");
break;
}
if (got_frame) {
frame->pts = frame->best_effort_timestamp;
ret = filter_encode_write_frame(frame, stream_index);
av_frame_free(&frame);
if (ret < 0)
goto end;
}
else {
av_frame_free(&frame);
}
}
else
{
/* remux this frame without reencoding */
av_packet_rescale_ts(&packet,
ifmt_ctx->streams[stream_index]->time_base,
ofmt_ctx->streams[stream_index]->time_base);
ret = av_interleaved_write_frame(ofmt_ctx, &packet);
if (ret < 0)
goto end;
}
av_packet_unref(&packet);
}
av_write_trailer(ofmt_ctx);
end:
av_packet_unref(&packet);
av_frame_free(&frame);
for (i = 0; i < ifmt_ctx->nb_streams; i++) {
avcodec_free_context(&stream_ctx[i].dec_ctx);
if (ofmt_ctx && ofmt_ctx->nb_streams > i && ofmt_ctx->streams[i] && stream_ctx[i].enc_ctx)
avcodec_free_context(&stream_ctx[i].enc_ctx);
}
av_free(stream_ctx);
avformat_close_input(&ifmt_ctx);
if (ofmt_ctx && !(ofmt_ctx->oformat->flags & AVFMT_NOFILE))
avio_closep(&ofmt_ctx->pb);
avformat_free_context(ofmt_ctx);
return ret ? 1 : 0;
}
</output>And the result is different.
For a test I took a SampleVideo_1280x720_1mb.flv.
It hasFile size : 1.00 MiB
Overall bit rate : 1 630 kb/sAfter my decode/encode actions the result became :
File size : 1.23 MiB
Overall bit rate : 2 005 kb/sOther parameters (video bit rate, audio bit rate, etc) are the same.
What am I doing wrong ? How to control overall bit rate ? I suppose, something wrong with encoder/decoder, but what ?
UPD :
I get that when in functionopen_input_fileI writeif (codec_ctx->codec_type == AVMEDIA_TYPE_VIDEO)
{
codec_ctx->framerate = av_guess_frame_rate(ifmt_ctx, stream, NULL);
}I get what I get (bigger size and bit rate).
And when in this function I write
if (codec_ctx->codec_type == AVMEDIA_TYPE_VIDEO)
{
codec_ctx = ifmt_ctx->streams[i]->codec;
}I get smaller size and bit rate.
File size : 900 KiB
Overall bit rate : 1 429 kb/sBut how to get the exactly size and frame rate as in the original file ?
Syndiquer tout le site
