transmit video and audio via RTSP - c

Question

I need to implement server that allows to connect to two types of clients. The first type must stream live video and audio to server. The second type must stream this video from server. I've choosen h.264 encoding for video, vorbis ogg encoding for audio. I want to use RTSP protocol for streaming video from the first type of clients to server. I've implemented clients part using "libavformat" from ffmpeg.My code is given below.
#include "v_out_video_stream.h"
#include <stdint.h>
#ifdef __cplusplus
extern "C" {
#endif
#include <libavformat/avformat.h>
#include <libavutil/opt.h>
#include <libavutil/avstring.h>
#include <libavformat/avio.h>
#ifdef __cplusplus
}
#endif
#include <stdexcept>
struct VStatticRegistrar
{
VStatticRegistrar( )
{
av_register_all( );
avformat_network_init( );
}
};
VStatticRegistrar __registrar;
struct VOutVideoStream::Private
{
AVFormatContext * m_context;
int m_audioStreamIndex;
int m_videoStreamIndex;
int m_videoBitrate;
int m_width;
int m_height;
int m_fps;
int m_audioSamplerate;
};
VOutVideoStream::VOutVideoStream( int videoBitrate, int width, int height, int fps, int audioSamplerate )
{
d = new Private( );
d->m_videoBitrate = videoBitrate;
d->m_width = width;
d->m_height = height;
d->m_fps = fps;
d->m_audioSamplerate = audioSamplerate;
d->m_context = 0;
d->m_audioStreamIndex = -1;
d->m_videoStreamIndex = -1;
}
bool VOutVideoStream::connectToServer( const std::string& rtp_address, int rtp_port )
{
assert( ! d->m_context );
// initalize the AV context
d->m_context = avformat_alloc_context();
if( !d->m_context )
return false;
// get the output format
d->m_context->oformat = av_guess_format( "rtsp", NULL, NULL );
if( ! d->m_context->oformat )
return false;
// try to open the RTSP stream
snprintf( d->m_context->filename, sizeof( d->m_context->filename ), "rtsp://%s:%d", rtp_address.c_str(), rtp_port );
if( avio_open( &d->m_context->pb, d->m_context->filename, AVIO_FLAG_WRITE ) < 0 )
return false;
// add an H.264 stream
AVStream *stream = avformat_new_stream( d->m_context, NULL );
if ( ! stream )
return false;
// initalize codec
AVCodecContext* codec = stream->codec;
if( d->m_context->oformat->flags & AVFMT_GLOBALHEADER )
codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
codec->codec_id = CODEC_ID_H264;
codec->codec_type = AVMEDIA_TYPE_VIDEO;
//codec->bit_rate = d->m_videoBitrate;
codec->width = d->m_width;
codec->height = d->m_height;
codec->time_base.den = d->m_fps;
codec->time_base.num = 1;
d->m_audioStreamIndex = stream->index;
stream = avformat_new_stream( d->m_context, NULL );
if ( ! stream )
return false;
// initalize codec
codec = stream->codec;
if( d->m_context->oformat->flags & AVFMT_GLOBALHEADER )
codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
codec->codec_id = CODEC_ID_VORBIS;
codec->codec_type = AVMEDIA_TYPE_AUDIO;
codec->sample_fmt = AV_SAMPLE_FMT_S16;
codec->channels = 2;
codec->bit_rate = d->m_audioSamplerate * codec->channels * 16;
codec->sample_rate = d->m_audioSamplerate;
d->m_videoStreamIndex = stream->index;
// write the header
return avformat_write_header( d->m_context, NULL ) == 0;
}
void VOutVideoStream::disconnect( )
{
assert( d->m_context );
avio_close( d->m_context->pb );
avformat_free_context( d->m_context );
d->m_context = 0;
}
VOutVideoStream::~VOutVideoStream( )
{
if( d->m_context )
disconnect( );
delete d;
}
bool VOutVideoStream::send( VNetworkAbstractionLayer& nal )
{
AVPacket p;
av_init_packet( &p );
p.data = nal.getPayload( );
p.size = nal.getSize( );
p.stream_index = nal.getType( ) == VNetworkAbstractionLayer::AUDIO_PACKET ? d->m_audioStreamIndex :
d->m_videoStreamIndex;
return av_write_frame( d->m_context, &p ) >= 0;
}
VNetworkAbstractionLayer is defined so:
#ifndef _V_NETWORK_ABSTRACTION_LAYER_H_
#define _V_NETWORK_ABSTRACTION_LAYER_H_
#include <cs/v_cs_global.h>
#include <stdint.h>
#include <cstring>
#include <boost/noncopyable.hpp>
#include <boost/enable_shared_from_this.hpp>
class VNetworkAbstractionLayer : public boost::enable_shared_from_this<VNetworkAbstractionLayer>,
private boost::noncopyable
{
public:
enum PacketType
{
AUDIO_PACKET,
VIDEO_PACKET
};
~VNetworkAbstractionLayer( ) {
delete[] m_payload;
}
static VNetworkAbstractionLayerPtr factory( int size, const uint8_t* payload, PacketType type ) {
return VNetworkAbstractionLayerPtr( new VNetworkAbstractionLayer( size, payload, type ) );
}
uint8_t* getPayload( ) {
return m_payload;
}
int getSize( ) const {
return m_size;
}
PacketType getType( ) const {
return m_type;
}
private:
VNetworkAbstractionLayer( int size, const uint8_t* payload, PacketType type ) :
m_size( size ),
m_payload( new uint8_t[ size ] ),
m_type( type )
{
memcpy( m_payload, payload, size );
}
int m_size;
uint8_t *m_payload;
PacketType m_type;
};
#endif // _V_NETWORK_ABSTRACTION_LAYER_H_
Now I need to implement server. But I have not found any 'listen' method in libavformat. Can anyone explain me how to implement RTSP server. May be I can use any other library?

Answer 1

I would go with GStreamer on this. There are many examples out there.

Answer 2

It is pretty complex to code a RTSP/RTCP/RTP stack from scratch. You can have a look at the live555 library that implement such a stack in c++. It works well with ffmpeg/libav

Answer 3

You can also use https://net7mma.codeplex.com/ as your server!

Answer 4

You can use VLC as your streaming server.