stream-deploy/ZLM/3rdpart/media-server/librtsp/test/media/ffmpeg-live-source.cpp

#if defined(_HAVE_FFMPEG_)
#include "ffmpeg-live-source.h"
#include "rtp-profile.h"
#include "rtp-payload.h"
#include "mov-format.h"
#include "mpeg4-avc.h"
#include "mpeg4-aac.h"
#include "sys/system.h"
#include "sys/path.h"
#include "base64.h"
#include "rtp.h"
#include <assert.h>

extern "C" uint32_t rtp_ssrc(void);

static AVCodecContext* FFLiveCreateEncoder(AVCodecParameters* codecpar, AVDictionary** opts)
{
	int ret;
	const AVCodec* codec = NULL;
	AVCodecContext* avctx = NULL;

	codec = avcodec_find_encoder(codecpar->codec_id);
	if (NULL == codec)
	{
		printf("[%s] avcodec_find_encoder(%d) not found.\n", __FUNCTION__, codecpar->codec_id);
		return NULL;
	}

	avctx = avcodec_alloc_context3(codec);
	if (NULL == avctx)
		return NULL;

	ret = avcodec_parameters_to_context(avctx, codecpar);
	if (ret < 0)
	{
		avcodec_free_context(&avctx);
		return NULL;
	}
	avctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;

	if (codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
	{
		avctx->time_base = av_make_q(1, 90000); // 90kHZ
		avctx->max_b_frames = 1;
		avctx->thread_count = 4;
		avctx->gop_size = 25;
		//av_dict_set(&opts, "preset", "fast", 0);
		//av_dict_set(&opts, "crt", "23", 0);
	}
	else if (codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
	{
		avctx->time_base = av_make_q(1, codecpar->sample_rate);
	}
	avctx->time_base = av_make_q(1, 1000); // 1ms

	ret = avcodec_open2(avctx, codec, opts);
	if (ret < 0)
	{
		printf("[%s] avcodec_open2(%d) => %d.\n", __FUNCTION__, codecpar->codec_id, ret);
		avcodec_free_context(&avctx);
		return NULL;
	}

	avcodec_parameters_from_context(codecpar, avctx);
	return avctx;
}

static AVCodecContext* FFLiveCreateDecoder(AVStream* stream)
{
	int ret;
	const AVCodec* codec = NULL;
	AVDictionary *opts = NULL;
	AVCodecContext* avctx = NULL;

	if (!stream || !stream->codecpar)
		return NULL;

	codec = avcodec_find_decoder(stream->codecpar->codec_id);
	if (NULL == codec)
	{
		printf("[%s] avcodec_find_decoder(%d) not found.\n", __FUNCTION__, stream->codecpar->codec_id);
		return NULL;
	}

	avctx = avcodec_alloc_context3(codec);
	if (NULL == avctx)
		return NULL;

	if (stream->codecpar)
	{
		ret = avcodec_parameters_to_context(avctx, stream->codecpar);
		if (ret < 0)
		{
			avcodec_free_context(&avctx);
			return NULL;
		}
	}
	avctx->time_base = av_make_q(1, 1000); // 1ms

	ret = avcodec_open2(avctx, codec, &opts);
	av_dict_free(&opts);
	if (ret < 0)
	{
		printf("[%s] avcodec_open2(%d) => %d.\n", __FUNCTION__, stream->codecpar->codec_id, ret);
		avcodec_free_context(&avctx);
		return NULL;
	}

	return avctx;
}

FFLiveSource::FFLiveSource(const char *camera)
{
	static int s_init = 0;
	if (0 == s_init)
	{
		s_init = 1;
		avformat_network_init();
		avdevice_register_all();
	}

	m_speed = 1.0;
	m_status = 0;
	m_clock = 0;
	m_count = 0;
	av_init_packet(&m_pkt);

	if (0 == Open(camera))
	{
		for (unsigned int i = 0; i < m_ic->nb_streams; i++)
		{
			if ( AVMEDIA_TYPE_VIDEO == m_ic->streams[i]->codecpar->codec_type)
			{
				OnVideo(m_ic->streams[i]);
			}
			else if (AVMEDIA_TYPE_AUDIO == m_ic->streams[i]->codecpar->codec_type)
			{
				OnAudio(m_ic->streams[i]);
			}
		}
	}

	for (int i = 0; i < m_count; i++)
	{
		struct media_t* m = &m_media[i];
		rtp_set_info(m->rtp, "RTSPServer", path_basename(camera));
	}
}

FFLiveSource::~FFLiveSource()
{
	for (int i = 0; i < m_count; i++)
	{
		struct media_t* m = &m_media[i];
		if (m->rtp)
		{
			rtp_destroy(m->rtp);
			m->rtp = NULL;
		}

		if (m->packer)
		{
			rtp_payload_encode_destroy(m->packer);
			m->packer = NULL;
		}

		if(m->encoder)
			avcodec_free_context(&m->encoder);
		if (m->decoder)
			avcodec_free_context(&m->decoder);
		if (m->audio_swr)
			swr_free(&m->audio_swr);
	}

	if (m_ic)
	{
		avformat_close_input(&m_ic);
		avformat_free_context(m_ic);
	}
}

int FFLiveSource::Open(const char* camera)
{
	int r;
	AVDictionary* opt = NULL;
	m_ic = avformat_alloc_context();
	if (NULL == m_ic)
	{
		printf("%s(%s): avformat_alloc_context failed.\n", __FUNCTION__, camera);
		return -ENOMEM;
	}

	//if (!av_dict_get(ff->opt, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
	//	av_dict_set(&ff->opt, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
	//	scan_all_pmts_set = 1;
	//}

	const AVInputFormat *ifmt = av_find_input_format("dshow");
	r = avformat_open_input(&m_ic, camera, ifmt, NULL/*&opt*/);
	if (0 != r)
	{
		printf("%s: avformat_open_input(%s) => %d\n", __FUNCTION__, camera, r);
		return r;
	}

	//if (scan_all_pmts_set)
	//	av_dict_set(&format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);

	//ff->ic->probesize = 100 * 1024;
	//ff->ic->max_analyze_duration = 5 * AV_TIME_BASE;

	/* If not enough info to get the stream parameters, we decode the
	first frames to get it. (used in mpeg case for example) */
	r = avformat_find_stream_info(m_ic, NULL/*&opt*/);
	if (r < 0) {
		printf("%s(%s): could not find codec parameters\n", __FUNCTION__, camera);
		return r;
	}

	av_dict_free(&opt);
	return 0;
}

int FFLiveSource::SetTransport(const char* track, std::shared_ptr<IRTPTransport> transport)
{
	int t = atoi(track + 5/*track*/);
	for (int i = 0; i < m_count; i++)
	{
		struct media_t* m = &m_media[i];
		if (t != m->track)
			continue;

		m->transport = transport;
		return 0;
	}
	return -1;
}


int FFLiveSource::ReadFrame(AVPacket* avpkt)
{
	AVPacket* pkt = av_packet_alloc();
	std::shared_ptr<AVPacket*> __packet(&pkt, av_packet_free);

	int r = av_read_frame(m_ic, pkt);
	if (r < 0)
		return r;
	
	struct media_t* m = NULL;
	for (r = 0; r < m_count; r++)
	{
		m = &m_media[r];
		if (m->track == pkt->stream_index)
			break;
	}
	if (r == m_count)
	{
		assert(0);
		return AVERROR(EAGAIN);
	}

	r = avcodec_send_packet(m->decoder, pkt);
	if (r < 0)
	{
		if(r != AVERROR(EAGAIN) && r != AVERROR_EOF)
			printf("[%s] avcodec_send_packet(%d) => %d\n", __FUNCTION__, pkt->size, r);
		return r;
	}

	AVFrame* frame = av_frame_alloc();
	std::shared_ptr<AVFrame*> __frame(&frame, av_frame_free);

	if (AVMEDIA_TYPE_AUDIO == m->encoder->codec_type)
	{
		// audio
		if (!m->audio_swr || !m->audio_fifo)
			return AVERROR(EAGAIN);

		AVFrame* out = av_frame_alloc();
		out->format = AV_SAMPLE_FMT_FLTP;
		out->channels = 2;
		out->channel_layout = av_get_default_channel_layout(frame->channels);
		out->sample_rate = frame->sample_rate;
		out->nb_samples = frame->nb_samples;
		out->pkt_dts = frame->pkt_dts;
		out->pts = frame->pts;
		av_frame_get_buffer(out, 0);
		std::shared_ptr<AVFrame*> ___out(&out, av_frame_free);

		r = swr_convert(m->audio_swr, out->data, out->nb_samples, (const uint8_t**)frame->data, frame->nb_samples);
		if (r < 0)
			return r;

		r = av_audio_fifo_write(m->audio_fifo.get(), (void**)out->data, r);
		if (av_audio_fifo_size(m->audio_fifo.get()) < 1024)
			return AVERROR(EAGAIN);
		
		AVFrame* audio = av_frame_alloc();
		audio->nb_samples = 1024;
		audio->sample_rate = out->sample_rate;
		audio->format = out->format;
		audio->channels = out->channels;
		audio->channel_layout = out->channel_layout;
		audio->pkt_dts = frame->pkt_dts;
		audio->pts = frame->pts;
		r = av_frame_get_buffer(audio, 0);
		std::shared_ptr<AVFrame*> __audio(&audio, av_frame_free);
		if (r < 0)
		{
			printf("[%s] av_frame_get_buffer() => %d\n", __FUNCTION__, r);
			return r;
		}

		if (av_audio_fifo_read(m->audio_fifo.get(), (void**)audio->data, 1024) != 1024)
			return AVERROR(EAGAIN);
		return avcodec_send_frame(m->decoder, audio);
	}
	else
	{
		// video
		r = avcodec_receive_frame(m->decoder, frame);
		if (r < 0)
			return r;

		r = avcodec_send_frame(m->encoder, frame);
		if (r < 0)
		{
			if (r != AVERROR(EAGAIN) && r != AVERROR_EOF)
				printf("[%s] avcodec_send_frame() => %d\n", __FUNCTION__, r);
			return r;
		}

		return avcodec_receive_packet(m->encoder, avpkt);
	}
}

int FFLiveSource::Play()
{
	bool sendframe = false;
	if (3 == m_status)
		return 0;

SEND_PACKET:
	if (0 == m_pkt.buf)
	{
		int r = ReadFrame(&m_pkt);
		if (r == AVERROR_EOF)
		{
			// 0-EOF
			m_status = 3;
			SendBye();
			return 0;
		}
		else if (r == AVERROR(EAGAIN))
		{
			goto SEND_PACKET;
		}
		else if (r < 0)
		{
			// error
			return r;
		}

		AVRational time_base = { 1, 1000/*ms*/ };
		m_pkt.dts = (AV_NOPTS_VALUE == m_pkt.dts ? m_pkt.pts : m_pkt.dts);
		m_pkt.pts = (AV_NOPTS_VALUE == m_pkt.pts ? m_pkt.dts : m_pkt.pts);
		m_pkt.dts = av_rescale_q(m_pkt.dts, m_ic->streams[m_pkt.stream_index]->time_base, time_base);
		m_pkt.pts = av_rescale_q(m_pkt.pts, m_ic->streams[m_pkt.stream_index]->time_base, time_base);
	}

	m_status = 1;
	uint64_t clock = system_time();
	for (int i = 0; i < m_count; i++)
	{
		struct media_t* m = &m_media[i];
		if (m->track != m_pkt.stream_index)
			continue;

		if (0 == m_clock || m_clock > clock)
			m_clock = clock;
		if (-1 == m_dts)
			m_dts = m_pkt.dts;

		if (0 == strcmp("H264", m->name))
		{
			// MPEG4 -> H.264 byte stream
			//uint8_t* p = m_pkt.data;
			//size_t bytes = m_pkt.size;
			//while (bytes > 0)
			//{
			//	// nalu size -> start code
			//	assert(bytes > 4);
			//	uint32_t n = (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
			//	p[0] = 0;
			//	p[1] = 0;
			//	p[2] = 0;
			//	p[3] = 1;
			//	bytes -= n + 4;
			//	p += n + 4;
			//}

			//printf("[V] pts: %lld, dts: %lld, clock: %llu\n", m_pkt.pts, m_pkt.dts, clock);
		}
		else if (0 == strcmp("MP4A-LATM", m->name) || 0 == strcmp("MPEG4-GENERIC", m->name))
		{
			// add ADTS header
			//printf("[A] pts: %lld, dts: %lld, clock: %llu\n", m_pkt.pts, m_pkt.dts, clock);
		}
		else
		{
			assert(0);
		}

		if (-1 == m->dts_first)
			m->dts_first = m_pkt.pts;
		m->dts_last = m_pkt.pts;
		uint32_t timestamp = m->timestamp + m->dts_last - m->dts_first;

		rtp_payload_encode_input(m->packer, m_pkt.data, m_pkt.size, (uint32_t)(timestamp * (m->frequency / 1000) /*kHz*/));

		av_packet_unref(&m_pkt); // send flag
		sendframe = 1;
		goto SEND_PACKET;
	}

	return sendframe ? 1 : 0;
}

int FFLiveSource::Pause()
{
	m_status = 2;
	m_clock = 0;
	m_dts = -1;
	return 0;
}

int FFLiveSource::Seek(int64_t pos)
{
	return 0;
}

int FFLiveSource::SetSpeed(double speed)
{
	return 0;
}

int FFLiveSource::GetDuration(int64_t& duration) const
{
	return -1;
}

int FFLiveSource::GetSDPMedia(std::string& sdp) const
{
	sdp = m_sdp;
	return m_ic ? 0 : -1;
}

int FFLiveSource::GetRTPInfo(const char* uri, char *rtpinfo, size_t bytes) const
{
	int n = 0;
	uint16_t seq;
	uint32_t timestamp;

	// RTP-Info: url=rtsp://foo.com/bar.avi/streamid=0;seq=45102,
	//			 url=rtsp://foo.com/bar.avi/streamid=1;seq=30211
	for (int i = 0; i < m_count; i++)
	{
		const struct media_t* m = &m_media[i];
		rtp_payload_encode_getinfo(m->packer, &seq, &timestamp);

		if (i > 0)
			rtpinfo[n++] = ',';
		n += snprintf(rtpinfo + n, bytes - n, "url=%s/track%d;seq=%hu;rtptime=%u", uri, m->track, seq, (unsigned int)(m->timestamp * (m->frequency / 1000) /*kHz*/));
	}
	return 0;
}

void FFLiveSource::OnVideo(AVStream* stream)
{
	int n = 0;
	uint8_t buffer[8 * 1024];
	struct media_t* m = &m_media[m_count++];
	
	AVCodecParameters* codecpar = avcodec_parameters_alloc();
	std::shared_ptr<AVCodecParameters*> __codecpar(&codecpar, avcodec_parameters_free);
	codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
	codecpar->codec_id = AV_CODEC_ID_H264;
	codecpar->format = AV_PIX_FMT_YUV420P;
	codecpar->width = 1280;
	codecpar->height = 720;
	codecpar->bit_rate = 2000000;
	AVDictionary* opts = NULL;
	av_dict_set(&opts, "preset", "fast", 0);
	av_dict_set(&opts, "crt", "23", 0);
	//av_dict_set(&opts, "x264opts", "annexb=0", 0);
	m->encoder = FFLiveCreateEncoder(codecpar, &opts);
	av_dict_free(&opts);

	m->track = m_count-1;
	m->rtcp_clock = 0;
	m->ssrc = rtp_ssrc();
	m->timestamp = rtp_ssrc();
	m->bandwidth = codecpar->bit_rate;
	m->dts_last = m->dts_first = -1;
	m->decoder = FFLiveCreateDecoder(stream);
	m->audio_swr = NULL;
	
	if (AV_CODEC_ID_H264 == codecpar->codec_id)
	{
		int vcl, update;
		struct mpeg4_avc_t avc;
		memset(&avc, 0, sizeof(avc));
		uint8_t extra[128] = { 0 };
		h264_annexbtomp4(&avc, m->encoder->extradata, m->encoder->extradata_size, extra, sizeof(extra), &vcl, &update);
		//mpeg4_avc_decoder_configuration_record_load(m->encoder->extradata, m->encoder->extradata_size, &avc);
		assert(avc.nb_pps + avc.nb_sps > 0);

		static const char* pattern =
			"m=video 0 RTP/AVP %d\n"
			"a=rtpmap:%d H264/90000\n"
			"a=fmtp:%d profile-level-id=%02X%02X%02X;packetization-mode=1;sprop-parameter-sets=";

		n = snprintf((char*)buffer, sizeof(buffer), pattern,
			RTP_PAYLOAD_H264, RTP_PAYLOAD_H264, RTP_PAYLOAD_H264,
			(unsigned int)avc.profile, (unsigned int)avc.compatibility, (unsigned int)avc.level);

		for (uint8_t i = 0; i < avc.nb_sps; i++)
		{
			if (i > 0) buffer[n++] = ',';
			n += base64_encode((char*)buffer + n, avc.sps[i].data, avc.sps[i].bytes);
			buffer[n] = '\0';
		}

		for (uint8_t i = 0; i < avc.nb_pps; i++)
		{
			buffer[n++] = ',';
			n += base64_encode((char*)buffer + n, avc.pps[i].data, avc.pps[i].bytes);
			buffer[n] = '\0';
		}

		buffer[n++] = '\n';
		m->frequency = 90000;
		m->payload = RTP_PAYLOAD_H264;
		snprintf(m->name, sizeof(m->name), "%s", "H264");
	}
	else
	{
		assert(0);
		return;
	}

	struct rtp_payload_t rtpfunc = {
		FFLiveSource::RTPAlloc,
		FFLiveSource::RTPFree,
		FFLiveSource::RTPPacket,
	};
	m->packer = rtp_payload_encode_create(m->payload, m->name, (uint16_t)m->timestamp, m->ssrc, &rtpfunc, m);

	struct rtp_event_t event;
	event.on_rtcp = OnRTCPEvent;
	m->rtp = rtp_create(&event, this, m->ssrc, m->timestamp, m->frequency, m->bandwidth, 1);

	n += snprintf((char*)buffer + n, sizeof(buffer) - n, "a=control:track%d\n", m->track);
	m_sdp += (const char*)buffer;
}

void FFLiveSource::OnAudio(AVStream* stream)
{
	int n = 0;
	uint8_t buffer[2 * 1024];
	struct media_t* m = &m_media[m_count++];
	if (!stream->codecpar)
		return;

	AVCodecParameters* codecpar = avcodec_parameters_alloc();
	std::shared_ptr<AVCodecParameters*> __codecpar(&codecpar, avcodec_parameters_free);
	codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
	codecpar->codec_id = AV_CODEC_ID_AAC;
	codecpar->format = AV_SAMPLE_FMT_FLTP;
	codecpar->channels = 2;
	codecpar->sample_rate = stream->codecpar->sample_rate;
	codecpar->channel_layout = av_get_default_channel_layout(codecpar->channels);
	codecpar->bit_rate = 128000;
	m->encoder = FFLiveCreateEncoder(codecpar, NULL);

	m->audio_swr = swr_alloc_set_opts(NULL, av_get_default_channel_layout(codecpar->channels), (AVSampleFormat)codecpar->format, codecpar->sample_rate, av_get_default_channel_layout(stream->codecpar->channels), (AVSampleFormat)stream->codecpar->format, stream->codecpar->sample_rate, 0, NULL);
	swr_init(m->audio_swr);
	m->audio_fifo.reset(av_audio_fifo_alloc((AVSampleFormat)codecpar->format, codecpar->channels, codecpar->sample_rate / 2), av_audio_fifo_free); // 500ms

	m->track = m_count-1;
	m->rtcp_clock = 0;
	m->ssrc = rtp_ssrc();
	m->timestamp = rtp_ssrc();
	m->bandwidth = codecpar->bit_rate;
	m->dts_last = m->dts_first = -1;
	m->decoder = FFLiveCreateDecoder(stream);

	if (AV_CODEC_ID_AAC == codecpar->codec_id)
	{
		struct mpeg4_aac_t aac;
		//aac.profile = MPEG4_AAC_LC;
		//aac.channel_configuration = (uint8_t)channel_count;
		//aac.sampling_frequency_index = (uint8_t)mpeg4_aac_audio_frequency_from(sample_rate);
		mpeg4_aac_audio_specific_config_load(m->encoder->extradata, m->encoder->extradata_size, &aac);
		//assert(aac.sampling_frequency_index == (uint8_t)mpeg4_aac_audio_frequency_from(sample_rate));
		//assert(aac.channel_configuration == channel_count);

		if (0)
		{
			// RFC 6416
			// In the presence of SBR, the sampling rates for the core encoder/
			// decoder and the SBR tool are different in most cases. Therefore,
			// this parameter SHALL NOT be considered as the definitive sampling rate.
			static const char* pattern =
				"m=audio 0 RTP/AVP %d\n"
				"a=rtpmap:%d MP4A-LATM/%d/%d\n"
				"a=fmtp:%d profile-level-id=%d;object=%d;cpresent=0;config=";

			n = snprintf((char*)buffer, sizeof(buffer), pattern,
				RTP_PAYLOAD_LATM, RTP_PAYLOAD_LATM, 90000, m->encoder->channels,
				RTP_PAYLOAD_LATM, mpeg4_aac_profile_level(&aac), aac.profile);

			uint8_t config[6];
			int r = mpeg4_aac_stream_mux_config_save(&aac, config, sizeof(config));
			static const char* hex = "0123456789abcdef";
			for (int i = 0; i < r; i++)
			{
				buffer[n++] = hex[config[i] >> 4];
				buffer[n++] = hex[config[i] & 0x0F];
			}
			buffer[n] = '\0';

			snprintf(m->name, sizeof(m->name), "%s", "MP4A-LATM");
			m->payload = RTP_PAYLOAD_LATM;
		}
		else
		{
			// RFC 3640 3.3.1. General (p21)
			// a=rtpmap:<payload type> <encoding name>/<clock rate>[/<encoding parameters > ]
			// For audio streams, <encoding parameters> specifies the number of audio channels
			// streamType: AudioStream
			// When using SDP, the clock rate of the RTP time stamp MUST be expressed using the "rtpmap" attribute. 
			// If an MPEG-4 audio stream is transported, the rate SHOULD be set to the same value as the sampling rate of the audio stream. 
			// If an MPEG-4 video stream transported, it is RECOMMENDED that the rate be set to 90 kHz.
			static const char* pattern =
				"m=audio 0 RTP/AVP %d\n"
				"a=rtpmap:%d MPEG4-GENERIC/%d/%d\n"
				"a=fmtp:%d streamType=5;profile-level-id=1;mode=AAC-hbr;sizelength=13;indexlength=3;indexdeltalength=3;config=";

			n = snprintf((char*)buffer, sizeof(buffer), pattern,
				RTP_PAYLOAD_MP4A, RTP_PAYLOAD_MP4A, m->encoder->sample_rate, m->encoder->channels, RTP_PAYLOAD_MP4A);

			// For MPEG-4 Audio streams, config is the audio object type specific
			// decoder configuration data AudioSpecificConfig()
			n += base64_encode((char*)buffer + n, m->encoder->extradata, m->encoder->extradata_size);
			buffer[n] = '\0';

			snprintf(m->name, sizeof(m->name), "%s", "MPEG4-GENERIC");
			m->payload = RTP_PAYLOAD_MP4A;
		}

		m->frequency = m->encoder->sample_rate;
		buffer[n++] = '\n';
	}
	else
	{
		assert(0);
		return;
	}

	struct rtp_payload_t rtpfunc = {
		FFLiveSource::RTPAlloc,
		FFLiveSource::RTPFree,
		FFLiveSource::RTPPacket,
	};
	m->packer = rtp_payload_encode_create(m->payload, m->name, (uint16_t)m->timestamp, m->ssrc, &rtpfunc, m);

	struct rtp_event_t event;
	event.on_rtcp = OnRTCPEvent;
	m->rtp = rtp_create(&event, this, m->ssrc, m->timestamp, m->frequency, m->bandwidth, 1);

	n += snprintf((char*)buffer + n, sizeof(buffer) - n, "a=control:track%d\n", m->track);
	m_sdp += (const char*)buffer;
}

void FFLiveSource::OnRTCPEvent(const struct rtcp_msg_t* msg)
{
	msg;
}

void FFLiveSource::OnRTCPEvent(void* param, const struct rtcp_msg_t* msg)
{
	FFLiveSource *self = (FFLiveSource *)param;
	self->OnRTCPEvent(msg);
}

int FFLiveSource::SendBye()
{
	char rtcp[1024] = { 0 };
	for (int i = 0; i < m_count; i++)
	{
		struct media_t* m = &m_media[i];

		size_t n = rtp_rtcp_bye(m->rtp, rtcp, sizeof(rtcp));

		// send RTCP packet
		m->transport->Send(true, rtcp, n);
	}

	return 0;
}

int FFLiveSource::SendRTCP(struct media_t* m, uint64_t clock)
{
	// make sure have sent RTP packet

	int interval = rtp_rtcp_interval(m->rtp);
	if (0 == m->rtcp_clock || m->rtcp_clock + interval < clock)
	{
		char rtcp[1024] = { 0 };
		size_t n = rtp_rtcp_report(m->rtp, rtcp, sizeof(rtcp));

		// send RTCP packet
		m->transport->Send(true, rtcp, n);

		m->rtcp_clock = clock;
	}

	return 0;
}

void* FFLiveSource::RTPAlloc(void* param, int bytes)
{
	struct media_t* m = (struct media_t*)param;
	assert(bytes <= sizeof(m->packet));
	return m->packet;
}

void FFLiveSource::RTPFree(void* param, void *packet)
{
	struct media_t* m = (struct media_t*)param;
	assert(m->packet == packet);
}

int FFLiveSource::RTPPacket(void* param, const void *packet, int bytes, uint32_t /*timestamp*/, int /*flags*/)
{
	struct media_t* m = (struct media_t*)param;
	assert(m->packet == packet);

	// Hack: Send an initial RTCP "SR" packet, before the initial RTP packet, 
	// so that receivers will (likely) be able to get RTCP-synchronized presentation times immediately:
	rtp_onsend(m->rtp, packet, bytes/*, time*/);
	SendRTCP(m, system_time());

	int r = m->transport->Send(false, packet, bytes);
	assert(r == (int)bytes);
	return 0;
}
#endif