Enregistrement de flux RTSP avec FFmpeg démultiplexeur

Voici comment je le fais. Ce que j'ai trouvé lors de la réception de H264, la fréquence d'images dans le flux de données n'est pas correcte. Il envoie 1/90000 base de temps. - Je me passer de l'initialisation du nouveau flux à partir des flux entrant et il suffit de copier certains paramètres. Les entrants r_frame_rate doit être exacte si max_analyze_frames fonctionne correctement.

#include <stdio.h>
#include <stdlib.h>
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
#include <libavformat/avio.h>
#include <sys/time.h>
time_t get_time()
{
struct timeval tv;
gettimeofday( &tv, NULL );
return tv.tv_sec; 
} 
int main( int argc, char* argv[] )
{
AVFormatContext *ifcx = NULL;
AVInputFormat *ifmt;
AVCodecContext *iccx;
AVCodec *icodec;
AVStream *ist;
int i_index;
time_t timenow, timestart;
int got_key_frame = 0;
AVFormatContext *ofcx;
AVOutputFormat *ofmt;
AVCodecContext *occx;
AVCodec *ocodec;
AVStream *ost;
int o_index;
AVPacket pkt;
int ix;
const char *sProg = argv[ 0 ];
const char *sFileInput;
const char *sFileOutput;
int bRunTime;
if ( argc != 4 ) {
printf( "Usage: %s url outfile runtime\n", sProg );
return EXIT_FAILURE;
} 
sFileInput = argv[ 1 ];
sFileOutput = argv[ 2 ];
bRunTime = atoi( argv[ 3 ] );
//Initialize library
av_log_set_level( AV_LOG_DEBUG );
av_register_all();
avcodec_register_all(); 
avformat_network_init();
//
//Input
//
//open rtsp
if ( avformat_open_input( &ifcx, sFileInput, NULL, NULL) != 0 ) {
printf( "ERROR: Cannot open input file\n" );
return EXIT_FAILURE;
}
if ( avformat_find_stream_info( ifcx, NULL ) < 0 ) {
printf( "ERROR: Cannot find stream info\n" );
avformat_close_input( &ifcx );
return EXIT_FAILURE;
}
snprintf( ifcx->filename, sizeof( ifcx->filename ), "%s", sFileInput );
//search video stream
i_index = -1;
for ( ix = 0; ix < ifcx->nb_streams; ix++ ) {
iccx = ifcx->streams[ ix ]->codec;
if ( iccx->codec_type == AVMEDIA_TYPE_VIDEO ) {
ist = ifcx->streams[ ix ];
i_index = ix;
break;
}
}
if ( i_index < 0 ) {
printf( "ERROR: Cannot find input video stream\n" );
avformat_close_input( &ifcx );
return EXIT_FAILURE;
}
//
//Output
//
//open output file
ofmt = av_guess_format( NULL, sFileOutput, NULL );
ofcx = avformat_alloc_context();
ofcx->oformat = ofmt;
avio_open2( &ofcx->pb, sFileOutput, AVIO_FLAG_WRITE, NULL, NULL );
//Create output stream
//ost = avformat_new_stream( ofcx, (AVCodec *) iccx->codec );
ost = avformat_new_stream( ofcx, NULL );
avcodec_copy_context( ost->codec, iccx );
ost->sample_aspect_ratio.num = iccx->sample_aspect_ratio.num;
ost->sample_aspect_ratio.den = iccx->sample_aspect_ratio.den;
//Assume r_frame_rate is accurate
ost->r_frame_rate = ist->r_frame_rate;
ost->avg_frame_rate = ost->r_frame_rate;
ost->time_base = av_inv_q( ost->r_frame_rate );
ost->codec->time_base = ost->time_base;
avformat_write_header( ofcx, NULL );
snprintf( ofcx->filename, sizeof( ofcx->filename ), "%s", sFileOutput );
//start reading packets from stream and write them to file
av_dump_format( ifcx, 0, ifcx->filename, 0 );
av_dump_format( ofcx, 0, ofcx->filename, 1 );
timestart = timenow = get_time();
ix = 0;
//av_read_play(context);//play RTSP (Shouldn't need this since it defaults to playing on connect)
av_init_packet( &pkt );
while ( av_read_frame( ifcx, &pkt ) >= 0 && timenow - timestart <= bRunTime ) {
if ( pkt.stream_index == i_index ) { //packet is video               
//Make sure we start on a key frame
if ( timestart == timenow && ! ( pkt.flags & AV_PKT_FLAG_KEY ) ) {
timestart = timenow = get_time();
continue;
}
got_key_frame = 1;
pkt.stream_index = ost->id;
pkt.pts = ix++;
pkt.dts = pkt.pts;
av_interleaved_write_frame( ofcx, &pkt );
}
av_free_packet( &pkt );
av_init_packet( &pkt );
timenow = get_time();
}
av_read_pause( ifcx );
av_write_trailer( ofcx );
avio_close( ofcx->pb );
avformat_free_context( ofcx );
avformat_network_deinit();
return EXIT_SUCCESS;
}

OriginalL'auteur Ryan Ayers

Mon expérience avec moderne H. 264 encodeur, je suis la recherche que la durée retourné par ffmpeg n'est qu'une "suggestion" et qu'il y a de "jitter" dans le PTS. La seule façon de déterminer avec précision le taux d'image ou la durée est de mesurer vous-même à l'aide de l'PTS valeurs.

Pour un H. 264 encodeur de course à 30fps, la durée est toujours signalé comme 3000/90000, tandis que mesuré la durée est généralement de +/- 1 mais périodiquement sauts dire 3000+25 un cadre et 3000-25 la prochaine. Je suis de lissage pour l'enregistrement par la constatation des images adjacentes à l'opposé de la déviation et en ajustant les PTS de la 2ème image, tout en préservant la durée totale.

Cette me donner un ruisseau avec une occasionnelle (calculé) durée de 30001 ou 2999, reflétant la dérive de l'horloge.

Lors de l'enregistrement d'un 29,97 i /s en flux, av_read_frame() retourne toujours une durée de 3 000, tandis que le nominal calculé la durée est 3003 (correct pour 29.97) avec la même gigue et de la dérive comme décrit ci-dessus.

Dans mon cas, je viens de construire une machine d'état pour nettoyer le moment. En espérant que cela aide quelqu'un.

OriginalL'auteur Steve Sisak