Attachment #353334 for bug #476536

Line Link Here

(-)file_not_specified_in_diff (-336 / +376 lines)
0	-- HomerMultimedia/include/Header_Ffmpeg.h	0	++ HomerMultimedia/include/Header_Ffmpeg.h
Lines 62-67 Link Here
62	#if (LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(53, 61, 100))	62	#if (LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(53, 61, 100))
63	#include <libswresample/swresample.h>	63	#include <libswresample/swresample.h>
64	#endif	64	#endif
		65	#if (LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(54, 5, 2))
		66	#include <libavutil/time.h>
		67	#endif
		68
65	}	69	}
66		70
67	#ifndef AV_NUM_DATA_POINTERS	71	#ifndef AV_NUM_DATA_POINTERS
Lines 162-167 Link Here
162	#define AVMEDIA_TYPE_UNKNOWN CODEC_TYPE_UNKNOWN	166	#define AVMEDIA_TYPE_UNKNOWN CODEC_TYPE_UNKNOWN
163	#endif	167	#endif
164		168
		169	#if (LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(53, 25, 0))
		170	#define AVCODEC_MAX_AUDIO_FRAME_SIZE 192000
		171	#endif
		172
		173	#if (LIBAVCODEC_VERSION_INT <= AV_VERSION_INT(54, 51, 100))
		174	#define AVCodecID CodecID
		175	#define AV_CODEC_ID_AAC CODEC_ID_AAC
		176	#define AV_CODEC_ID_AC3 CODEC_ID_AC3
		177	#define AV_CODEC_ID_ADPCM CODEC_ID_ADPCM
		178	#define AV_CODEC_ID_ADPCM_G722 CODEC_ID_ADPCM_G722
		179	#define AV_CODEC_ID_AMR CODEC_ID_AMR
		180	#define AV_CODEC_ID_AMR_NB CODEC_ID_AMR_NB
		181	#define AV_CODEC_ID_GSM CODEC_ID_GSM
		182	#define AV_CODEC_ID_H261 CODEC_ID_H261
		183	#define AV_CODEC_ID_H263 CODEC_ID_H263
		184	#define AV_CODEC_ID_H263P CODEC_ID_H263P
		185	#define AV_CODEC_ID_H264 CODEC_ID_H264
		186	#define AV_CODEC_ID_MJPEG CODEC_ID_MJPEG
		187	#define AV_CODEC_ID_MP3 CODEC_ID_MP3
		188	#define AV_CODEC_ID_MPEG1VIDEO CODEC_ID_MPEG1VIDEO
		189	#define AV_CODEC_ID_MPEG2TS CODEC_ID_MPEG2TS
		190	#define AV_CODEC_ID_MPEG2VIDEO CODEC_ID_MPEG2VIDEO
		191	#define AV_CODEC_ID_MPEG4 CODEC_ID_MPEG4
		192	#define AV_CODEC_ID_NONE CODEC_ID_NONE
		193	#define AV_CODEC_ID_PCM CODEC_ID_PCM
		194	#define AV_CODEC_ID_PCM_ALAW CODEC_ID_PCM_ALAW
		195	#define AV_CODEC_ID_PCM_MULAW CODEC_ID_PCM_MULAW
		196	#define AV_CODEC_ID_PCM_S16BE CODEC_ID_PCM_S16BE
		197	#define AV_CODEC_ID_PCM_S16LE CODEC_ID_PCM_S16LE
		198	#define AV_CODEC_ID_THEORA CODEC_ID_THEORA
		199	#define AV_CODEC_ID_VORBIS CODEC_ID_VORBIS
		200	#define AV_CODEC_ID_VP8 CODEC_ID_VP8
		201	#define AV_CODEC_ID_WMAV2 CODEC_ID_WMAV2
		202	#define AV_CODEC_ID_WMV3 CODEC_ID_WMV3
		203	#endif
		204
165	inline int HM_av_samples_fill_arrays(uint8_t *audio_data, int linesize, uint8_t *buf, int nb_channels, int nb_samples, enum AVSampleFormat sample_fmt, int align)	205	inline int HM_av_samples_fill_arrays(uint8_t *audio_data, int linesize, uint8_t *buf, int nb_channels, int nb_samples, enum AVSampleFormat sample_fmt, int align)
166	{	206	{
167	#if (LIBAVUTIL_VERSION_INT < AV_VERSION_INT(51, 54, 100))	207	#if (LIBAVUTIL_VERSION_INT < AV_VERSION_INT(51, 54, 100))
168	-- HomerMultimedia/include/MediaSinkMem.h	208	++ HomerMultimedia/include/MediaSinkMem.h
Lines 82-88 Link Here
82	int64_t mIncomingAVStreamStartPts;	82	int64_t mIncomingAVStreamStartPts;
83	int64_t mIncomingAVStreamLastPts;	83	int64_t mIncomingAVStreamLastPts;
84	bool mIncomingFirstPacket;	84	bool mIncomingFirstPacket;
85	enum CodecID mIncomingAVStreamCodecID;	85	enum AVCodecID mIncomingAVStreamCodecID;
86	AVStream* mIncomingAVStream;	86	AVStream* mIncomingAVStream;
87	AVCodecContext* mIncomingAVStreamCodecContext;	87	AVCodecContext* mIncomingAVStreamCodecContext;
88	/* general stream handling */	88	/* general stream handling */
89	-- HomerMultimedia/include/MediaSource.h	89	++ HomerMultimedia/include/MediaSource.h
Lines 215-223 Link Here
215	virtual MediaSource* GetMediaSource();	215	virtual MediaSource* GetMediaSource();
216		216
217	/* codec identifier translation */	217	/* codec identifier translation */
218	enum CodecID GetCodecIDFromGuiName(std::string pName);	218	enum AVCodecID GetCodecIDFromGuiName(std::string pName);
219	static std::string GetGuiNameFromCodecID(enum CodecID pCodecId);	219	static std::string GetGuiNameFromCodecID(enum AVCodecID pCodecId);
220	std::string GetFormatName(enum CodecID pCodecId);	220	std::string GetFormatName(enum AVCodecID pCodecId);
221		221
222	/* audio */	222	/* audio */
223	static int AudioQuality2BitRate(int pQuality);	223	static int AudioQuality2BitRate(int pQuality);
Lines 269-275 Link Here
269	/* grabbing control */	269	/* grabbing control */
270	virtual void StopGrabbing();	270	virtual void StopGrabbing();
271	virtual bool Reset(enum MediaType = MEDIA_UNKNOWN);	271	virtual bool Reset(enum MediaType = MEDIA_UNKNOWN);
272	virtual enum CodecID GetSourceCodec();	272	virtual enum AVCodecID GetSourceCodec();
273	virtual std::string GetSourceCodecStr();	273	virtual std::string GetSourceCodecStr();
274	virtual std::string GetSourceCodecDescription();	274	virtual std::string GetSourceCodecDescription();
275	virtual bool SetInputStreamPreferences(std::string pStreamCodec, bool pRtpActivated = false, bool pDoReset = false);	275	virtual bool SetInputStreamPreferences(std::string pStreamCodec, bool pRtpActivated = false, bool pDoReset = false);
Lines 408-414 Link Here
408	void EventGrabChunkFailed(std::string pSource, int pLine, std::string pReason);	408	void EventGrabChunkFailed(std::string pSource, int pLine, std::string pReason);
409		409
410	/* FFMPEG helpers */	410	/* FFMPEG helpers */
411	bool FfmpegDescribeInput(string pSource/* caller source /, int pLine / caller line /, CodecID pCodecId, AVInputFormat *pFormat);	411	bool FfmpegDescribeInput(string pSource/* caller source /, int pLine / caller line /, AVCodecID pCodecId, AVInputFormat *pFormat);
412		412
413	public:	413	public:
414	static bool FfmpegCreateIOContext(string pSource/* caller source /, int pLine / caller line /, char pPacketBuffer, int pPacketBufferSize, IOFunction pReadFunction, IOFunction pWriteFunction, void pOpaque, AVIOContext *pIoContext);	414	static bool FfmpegCreateIOContext(string pSource/* caller source /, int pLine / caller line /, char pPacketBuffer, int pPacketBufferSize, IOFunction pReadFunction, IOFunction pWriteFunction, void pOpaque, AVIOContext *pIoContext);
Lines 442-448 Link Here
442	double mSourceTimeShiftForRTGrabbing;	442	double mSourceTimeShiftForRTGrabbing;
443	double mInputStartPts;	443	double mInputStartPts;
444	double mNumberOfFrames;	444	double mNumberOfFrames;
445	enum CodecID mSourceCodecId;	445	enum AVCodecID mSourceCodecId;
446	bool mEOFReached;	446	bool mEOFReached;
447	/* RT grabbing */	447	/* RT grabbing */
448	std::list<int64_t> mRTGrabbingFrameTimestamps;	448	std::list<int64_t> mRTGrabbingFrameTimestamps;
449	-- HomerMultimedia/include/MediaSourceMem.h	449	++ HomerMultimedia/include/MediaSourceMem.h
Lines 179-185 Link Here
179	bool mOpenInputStream;	179	bool mOpenInputStream;
180	int mWrappingHeaderSize;	180	int mWrappingHeaderSize;
181	int mPacketStatAdditionalFragmentSize; // used to adapt packet statistic to additional fragment header, which is used for TCP transmission	181	int mPacketStatAdditionalFragmentSize; // used to adapt packet statistic to additional fragment header, which is used for TCP transmission
182	enum CodecID mRtpSourceCodecIdHint;	182	enum AVCodecID mRtpSourceCodecIdHint;
183	/* grabber */	183	/* grabber */
184	double mCurrentOutputFrameIndex; // we have to determine this manually during grabbing because cur_dts and everything else in AVStream is buggy for some video/audio files	184	double mCurrentOutputFrameIndex; // we have to determine this manually during grabbing because cur_dts and everything else in AVStream is buggy for some video/audio files
185	double mLastBufferedOutputFrameIndex; // we use this for calibrating RT grabbing	185	double mLastBufferedOutputFrameIndex; // we use this for calibrating RT grabbing
186	-- HomerMultimedia/include/MediaSourceMuxer.h	186	++ HomerMultimedia/include/MediaSourceMuxer.h
Lines 108-114 Link Here
108		108
109	/* streaming control */	109	/* streaming control */
110	bool SetOutputStreamPreferences(std::string pStreamCodec, int pMediaStreamQuality, int pBitRate, int pMaxPacketSize = 1300 /* works only with RTP packetizing */, bool pDoReset = false, int pResX = 352, int pResY = 288, bool pRtpActivated = true, int pMaxFps = 0);	110	bool SetOutputStreamPreferences(std::string pStreamCodec, int pMediaStreamQuality, int pBitRate, int pMaxPacketSize = 1300 /* works only with RTP packetizing */, bool pDoReset = false, int pResX = 352, int pResY = 288, bool pRtpActivated = true, int pMaxFps = 0);
111	enum CodecID GetStreamCodecId() { return mStreamCodecId; } // used in RTSPListenerMediaSession	111	enum AVCodecID GetStreamCodecId() { return mStreamCodecId; } // used in RTSPListenerMediaSession
112		112
113	/* frame stats */	113	/* frame stats */
114	virtual bool SupportsDecoderFrameStatistics();	114	virtual bool SupportsDecoderFrameStatistics();
Lines 135-141 Link Here
135	/* grabbing control */	135	/* grabbing control */
136	virtual void StopGrabbing();	136	virtual void StopGrabbing();
137	virtual bool Reset(enum MediaType = MEDIA_UNKNOWN);	137	virtual bool Reset(enum MediaType = MEDIA_UNKNOWN);
138	virtual enum CodecID GetSourceCodec();	138	virtual enum AVCodecID GetSourceCodec();
139	virtual std::string GetSourceCodecStr();	139	virtual std::string GetSourceCodecStr();
140	virtual std::string GetSourceCodecDescription();	140	virtual std::string GetSourceCodecDescription();
141	virtual bool SetInputStreamPreferences(std::string pStreamCodec, bool pRtpActivated = false, bool pDoReset = false);	141	virtual bool SetInputStreamPreferences(std::string pStreamCodec, bool pRtpActivated = false, bool pDoReset = false);
Lines 197-203 Link Here
197		197
198	private:	198	private:
199	/* video resolution limitation depending on video codec capabilities */	199	/* video resolution limitation depending on video codec capabilities */
200	void ApplyVideoResolutionToEncoderCodec(int &pResX, int &pResY, enum CodecID pCodec);	200	void ApplyVideoResolutionToEncoderCodec(int &pResX, int &pResY, enum AVCodecID pCodec);
201		201
202	bool OpenVideoMuxer(int pResX = 352, int pResY = 288, float pFps = 29.97);	202	bool OpenVideoMuxer(int pResX = 352, int pResY = 288, float pFps = 29.97);
203	bool OpenAudioMuxer(int pSampleRate = 44100, int pChannels = 2);	203	bool OpenAudioMuxer(int pSampleRate = 44100, int pChannels = 2);
Lines 217-223 Link Here
217	static int DistributePacket(void pOpaque, uint8_t pBuffer, int pBufferSize);	217	static int DistributePacket(void pOpaque, uint8_t pBuffer, int pBufferSize);
218		218
219	MediaSource *mMediaSource;	219	MediaSource *mMediaSource;
220	enum CodecID mStreamCodecId;	220	enum AVCodecID mStreamCodecId;
221	int mStreamMaxPacketSize;	221	int mStreamMaxPacketSize;
222	int mStreamQuality;	222	int mStreamQuality;
223	int mStreamBitRate;	223	int mStreamBitRate;
224	-- HomerMultimedia/include/RTP.h	224	++ HomerMultimedia/include/RTP.h
Lines 135-143 Link Here
135	static unsigned int CodecToPayloadId(std::string pName);	135	static unsigned int CodecToPayloadId(std::string pName);
136	static std::string PayloadIdToCodec(int pId);	136	static std::string PayloadIdToCodec(int pId);
137	static std::string PayloadType(int pId);	137	static std::string PayloadType(int pId);
138	static bool IsPayloadSupported(enum CodecID pId);	138	static bool IsPayloadSupported(enum AVCodecID pId);
139	static int GetPayloadHeaderSizeMax(enum CodecID pCodec);// calculate the maximum header size of the RTP payload (not the RTP header!)	139	static int GetPayloadHeaderSizeMax(enum AVCodecID pCodec);// calculate the maximum header size of the RTP payload (not the RTP header!)
140	static int GetHeaderSizeMax(enum CodecID pCodec);	140	static int GetHeaderSizeMax(enum AVCodecID pCodec);
141	static void SetH261PayloadSizeMax(unsigned int pMaxSize);	141	static void SetH261PayloadSizeMax(unsigned int pMaxSize);
142	static unsigned int GetH261PayloadSizeMax();	142	static unsigned int GetH261PayloadSizeMax();
143		143
Lines 154-160 Link Here
154		154
155	static void LogRtpHeader(RtpHeader *pRtpHeader);	155	static void LogRtpHeader(RtpHeader *pRtpHeader);
156	bool ReceivedCorrectPayload(unsigned int pType);	156	bool ReceivedCorrectPayload(unsigned int pType);
157	bool RtpParse(char *&pData, int &pDataSize, bool &pIsLastFragment, enum RtcpType &pRtcpType, enum CodecID pCodecId, bool pLoggingOnly);	157	bool RtpParse(char *&pData, int &pDataSize, bool &pIsLastFragment, enum RtcpType &pRtcpType, enum AVCodecID pCodecId, bool pLoggingOnly);
158	bool ResetRrtpParser();	158	bool ResetRrtpParser();
159	bool OpenRtpEncoder(std::string pTargetHost, unsigned int pTargetPort, AVStream *pInnerStream);	159	bool OpenRtpEncoder(std::string pTargetHost, unsigned int pTargetPort, AVStream *pInnerStream);
160	bool CloseRtpEncoder();	160	bool CloseRtpEncoder();
Lines 206-212 Link Here
206	uint64_t mLostPackets;	206	uint64_t mLostPackets;
207	float mRelativeLostPackets;	207	float mRelativeLostPackets;
208	unsigned int mLocalSourceIdentifier;	208	unsigned int mLocalSourceIdentifier;
209	enum CodecID mStreamCodecID;	209	enum AVCodecID mStreamCodecID;
210	uint64_t mRemoteSequenceNumber; // without overflows	210	uint64_t mRemoteSequenceNumber; // without overflows
211	unsigned short int mLastSequenceNumberFromRTPHeader; // for overflow check	211	unsigned short int mLastSequenceNumberFromRTPHeader; // for overflow check
212	uint64_t mRemoteSequenceNumberOverflowShift; // offset for shifting the value range	212	uint64_t mRemoteSequenceNumberOverflowShift; // offset for shifting the value range
213	-- HomerMultimedia/src/MediaSinkMem.cpp	213	++ HomerMultimedia/src/MediaSinkMem.cpp
Lines 55-61 Link Here
55	mLastPacketPts = 0;	55	mLastPacketPts = 0;
56	mMediaId = pMediaId;	56	mMediaId = pMediaId;
57	mIncomingAVStream = NULL;	57	mIncomingAVStream = NULL;
58	mIncomingAVStreamCodecID = CODEC_ID_NONE;	58	mIncomingAVStreamCodecID = AV_CODEC_ID_NONE;
59	mTargetHost = "";	59	mTargetHost = "";
60	mTargetPort = 0;	60	mTargetPort = 0;
61	mRtpStreamOpened = false;	61	mRtpStreamOpened = false;
62	-- HomerMultimedia/src/MediaSinkNet.cpp	62	++ HomerMultimedia/src/MediaSinkNet.cpp
Lines 201-207 Link Here
201	if (pStream != NULL)	201	if (pStream != NULL)
202	{	202	{
203	// save maximum network packet size to use it later within SendPacket() function	203	// save maximum network packet size to use it later within SendPacket() function
204	if (pStream->codec->codec_id == CODEC_ID_H261)	204	if (pStream->codec->codec_id == AV_CODEC_ID_H261)
205	tNewMaxNetworkPacketSize = RTP::GetH261PayloadSizeMax() + RTP_HEADER_SIZE + 4 /* H.261 rtp payload header */;	205	tNewMaxNetworkPacketSize = RTP::GetH261PayloadSizeMax() + RTP_HEADER_SIZE + 4 /* H.261 rtp payload header */;
206	else	206	else
207	tNewMaxNetworkPacketSize = pStream->codec->rtp_payload_size;	207	tNewMaxNetworkPacketSize = pStream->codec->rtp_payload_size;
208	-- HomerMultimedia/src/MediaSource.cpp	208	++ HomerMultimedia/src/MediaSource.cpp
Lines 522-642 Link Here
522	* AMR CODEC_ID_AMR_NB	522	* AMR CODEC_ID_AMR_NB
523	*	523	*
524	****************************************************/	524	****************************************************/
525	enum CodecID MediaSource::GetCodecIDFromGuiName(std::string pName)	525	enum AVCodecID MediaSource::GetCodecIDFromGuiName(std::string pName)
526	{	526	{
527	enum CodecID tResult = (GetMediaType() == MEDIA_AUDIO) ? CODEC_ID_MP3 : CODEC_ID_H261;	527	enum AVCodecID tResult = (GetMediaType() == MEDIA_AUDIO) ? AV_CODEC_ID_MP3 : AV_CODEC_ID_H261;
528		528
529	/* video */	529	/* video */
530	if (pName == "H.261")	530	if (pName == "H.261")
531	tResult = CODEC_ID_H261;	531	tResult = AV_CODEC_ID_H261;
532	if (pName == "H.263")	532	if (pName == "H.263")
533	tResult = CODEC_ID_H263;	533	tResult = AV_CODEC_ID_H263;
534	if (pName == "MPEG1")	534	if (pName == "MPEG1")
535	tResult = CODEC_ID_MPEG1VIDEO;	535	tResult = AV_CODEC_ID_MPEG1VIDEO;
536	if (pName == "MPEG2")	536	if (pName == "MPEG2")
537	tResult = CODEC_ID_MPEG2VIDEO;	537	tResult = AV_CODEC_ID_MPEG2VIDEO;
538	if (pName == "H.263+")	538	if (pName == "H.263+")
539	tResult = CODEC_ID_H263P;	539	tResult = AV_CODEC_ID_H263P;
540	if (pName == "H.264")	540	if (pName == "H.264")
541	tResult = CODEC_ID_H264;	541	tResult = AV_CODEC_ID_H264;
542	if (pName == "MPEG4")	542	if (pName == "MPEG4")
543	tResult = CODEC_ID_MPEG4;	543	tResult = AV_CODEC_ID_MPEG4;
544	if (pName == "MJPEG")	544	if (pName == "MJPEG")
545	tResult = CODEC_ID_MJPEG;	545	tResult = AV_CODEC_ID_MJPEG;
546	if (pName == "THEORA")	546	if (pName == "THEORA")
547	tResult = CODEC_ID_THEORA;	547	tResult = AV_CODEC_ID_THEORA;
548	if (pName == "VP8")	548	if (pName == "VP8")
549	tResult = CODEC_ID_VP8;	549	tResult = AV_CODEC_ID_VP8;
550		550
551	/* audio */	551	/* audio */
552	if ((pName == "G711 µ-law") \|\| (pName == "G711 µ-law (PCMU)" /historic/))	552	if ((pName == "G711 µ-law") \|\| (pName == "G711 µ-law (PCMU)" /historic/))
553	tResult = CODEC_ID_PCM_MULAW;	553	tResult = AV_CODEC_ID_PCM_MULAW;
554	if (pName == "GSM")	554	if (pName == "GSM")
555	tResult = CODEC_ID_GSM;	555	tResult = AV_CODEC_ID_GSM;
556	if ((pName == "G711 A-law") \|\| (pName == "G711 A-law (PCMA)" /historic/))	556	if ((pName == "G711 A-law") \|\| (pName == "G711 A-law (PCMA)" /historic/))
557	tResult = CODEC_ID_PCM_ALAW;	557	tResult = AV_CODEC_ID_PCM_ALAW;
558	if (pName == "G722 adpcm")	558	if (pName == "G722 adpcm")
559	tResult = CODEC_ID_ADPCM_G722;	559	tResult = AV_CODEC_ID_ADPCM_G722;
560	if ((pName == "PCM16") \|\| (pName == "PCM_S16_LE" /historic/))	560	if ((pName == "PCM16") \|\| (pName == "PCM_S16_LE" /historic/))
561	tResult = CODEC_ID_PCM_S16BE;	561	tResult = AV_CODEC_ID_PCM_S16BE;
562	if ((pName == "MP3") \|\| (pName == "MP3 (MPA)" /historic/))	562	if ((pName == "MP3") \|\| (pName == "MP3 (MPA)" /historic/))
563	tResult = CODEC_ID_MP3;	563	tResult = AV_CODEC_ID_MP3;
564	if (pName == "AAC")	564	if (pName == "AAC")
565	tResult = CODEC_ID_AAC;	565	tResult = AV_CODEC_ID_AAC;
566	if (pName == "AMR")	566	if (pName == "AMR")
567	tResult = CODEC_ID_AMR_NB;	567	tResult = AV_CODEC_ID_AMR_NB;
568	if (pName == "AC3")	568	if (pName == "AC3")
569	tResult = CODEC_ID_AC3;	569	tResult = AV_CODEC_ID_AC3;
570		570
571	//LOG(LOG_VERBOSE, "Translated %s to %d", pName.c_str(), tResult);	571	//LOG(LOG_VERBOSE, "Translated %s to %d", pName.c_str(), tResult);
572		572
573	return tResult;	573	return tResult;
574	}	574	}
575		575
576	string MediaSource::GetGuiNameFromCodecID(enum CodecID pCodecId)	576	string MediaSource::GetGuiNameFromCodecID(enum AVCodecID pCodecId)
577	{	577	{
578	string tResult = "";	578	string tResult = "";
579		579
580	switch(pCodecId)	580	switch(pCodecId)
581	{	581	{
582	/* video */	582	/* video */
583	case CODEC_ID_H261:	583	case AV_CODEC_ID_H261:
584	tResult = "H.261";	584	tResult = "H.261";
585	break;	585	break;
586	case CODEC_ID_H263:	586	case AV_CODEC_ID_H263:
587	tResult = "H.263";	587	tResult = "H.263";
588	break;	588	break;
589	case CODEC_ID_MPEG1VIDEO:	589	case AV_CODEC_ID_MPEG1VIDEO:
590	tResult = "MPEG1";	590	tResult = "MPEG1";
591	break;	591	break;
592	case CODEC_ID_MPEG2VIDEO:	592	case AV_CODEC_ID_MPEG2VIDEO:
593	tResult = "MPEG2";	593	tResult = "MPEG2";
594	break;	594	break;
595	case CODEC_ID_H263P:	595	case AV_CODEC_ID_H263P:
596	tResult = "H.263+";	596	tResult = "H.263+";
597	break;	597	break;
598	case CODEC_ID_H264:	598	case AV_CODEC_ID_H264:
599	tResult = "H.264";	599	tResult = "H.264";
600	break;	600	break;
601	case CODEC_ID_MPEG4:	601	case AV_CODEC_ID_MPEG4:
602	tResult = "MPEG4";	602	tResult = "MPEG4";
603	break;	603	break;
604	case CODEC_ID_MJPEG:	604	case AV_CODEC_ID_MJPEG:
605	tResult = "MJPEG";	605	tResult = "MJPEG";
606	break;	606	break;
607	case CODEC_ID_THEORA:	607	case AV_CODEC_ID_THEORA:
608	tResult = "THEORA";	608	tResult = "THEORA";
609	break;	609	break;
610	case CODEC_ID_VP8:	610	case AV_CODEC_ID_VP8:
611	tResult = "VP8";	611	tResult = "VP8";
612	break;	612	break;
613		613
614	/* audio */	614	/* audio */
615	case CODEC_ID_PCM_MULAW:	615	case AV_CODEC_ID_PCM_MULAW:
616	tResult = "G711 µ-law";	616	tResult = "G711 µ-law";
617	break;	617	break;
618	case CODEC_ID_GSM:	618	case AV_CODEC_ID_GSM:
619	tResult = "GSM";	619	tResult = "GSM";
620	break;	620	break;
621	case CODEC_ID_PCM_ALAW:	621	case AV_CODEC_ID_PCM_ALAW:
622	tResult = "G711 A-law";	622	tResult = "G711 A-law";
623	break;	623	break;
624	case CODEC_ID_ADPCM_G722:	624	case AV_CODEC_ID_ADPCM_G722:
625	tResult = "G722 adpcm";	625	tResult = "G722 adpcm";
626	break;	626	break;
627	case CODEC_ID_PCM_S16BE:	627	case AV_CODEC_ID_PCM_S16BE:
628	tResult = "PCM16";	628	tResult = "PCM16";
629	break;	629	break;
630	case CODEC_ID_MP3:	630	case AV_CODEC_ID_MP3:
631	tResult = "MP3";	631	tResult = "MP3";
632	break;	632	break;
633	case CODEC_ID_AAC:	633	case AV_CODEC_ID_AAC:
634	tResult = "AAC";	634	tResult = "AAC";
635	break;	635	break;
636	case CODEC_ID_AMR_NB:	636	case AV_CODEC_ID_AMR_NB:
637	tResult = "AMR";	637	tResult = "AMR";
638	break;	638	break;
639	case CODEC_ID_AC3:	639	case AV_CODEC_ID_AC3:
640	tResult = "AC3";	640	tResult = "AC3";
641	break;	641	break;
642		642
Lines 653-746 Link Here
653	/*************************************************	653	/*************************************************
654	* video codec ID to format mapping:	654	* video codec ID to format mapping:
655	* ================================	655	* ================================
656	* CODEC_ID_H261 h261	656	* AV_CODEC_ID_H261 h261
657	* CODEC_ID_H263 h263	657	* AV_CODEC_ID_H263 h263
658	* CODEC_ID_MPEG1VIDEO mpeg1video	658	* AV_CODEC_ID_MPEG1VIDEO mpeg1video
659	* CODEC_ID_MPEG2VIDEO mpeg2video	659	* AV_CODEC_ID_MPEG2VIDEO mpeg2video
660	* CODEC_ID_H263P+ h263 // same like H263	660	* AV_CODEC_ID_H263P+ h263 // same like H263
661	* CODEC_ID_H264 h264	661	* AV_CODEC_ID_H264 h264
662	* CODEC_ID_MPEG4 m4v	662	* AV_CODEC_ID_MPEG4 m4v
663	* CODEC_ID_MJPEG mjpeg	663	* AV_CODEC_ID_MJPEG mjpeg
664	* CODEC_ID_THEORA ogg	664	* AV_CODEC_ID_THEORA ogg
665	* CODEC_ID_VP8 webm	665	* AV_CODEC_ID_VP8 webm
666	*	666	*
667	*	667	*
668	* audio codec ID to format mapping:	668	* audio codec ID to format mapping:
669	* ================================	669	* ================================
670	* CODEC_ID_PCM_MULAW mulaw	670	* AV_CODEC_ID_PCM_MULAW mulaw
671	* CODEC_ID_GSM libgsm	671	* AV_CODEC_ID_GSM libgsm
672	* CODEC_ID_PCM_ALAW alaw	672	* AV_CODEC_ID_PCM_ALAW alaw
673	* CODEC_ID_ADPCM_G722 g722	673	* AV_CODEC_ID_ADPCM_G722 g722
674	* CODEC_ID_PCM_S16BE s16be	674	* AV_CODEC_ID_PCM_S16BE s16be
675	* CODEC_ID_MP3 mp3	675	* AV_CODEC_ID_MP3 mp3
676	* CODEC_ID_AAC aac	676	* AV_CODEC_ID_AAC aac
677	* CODEC_ID_AMR_NB amr	677	* AV_CODEC_ID_AMR_NB amr
678	*	678	*
679	****************************************************/	679	****************************************************/
680	string MediaSource::GetFormatName(enum CodecID pCodecId)	680	string MediaSource::GetFormatName(enum AVCodecID pCodecId)
681	{	681	{
682	string tResult = "";	682	string tResult = "";
683		683
684	switch(pCodecId)	684	switch(pCodecId)
685	{	685	{
686	/* video */	686	/* video */
687	case CODEC_ID_H261:	687	case AV_CODEC_ID_H261:
688	tResult = "h261";	688	tResult = "h261";
689	break;	689	break;
690	case CODEC_ID_H263:	690	case AV_CODEC_ID_H263:
691	tResult = "h263";	691	tResult = "h263";
692	break;	692	break;
693	case CODEC_ID_MPEG1VIDEO:	693	case AV_CODEC_ID_MPEG1VIDEO:
694	tResult = "mpeg1video";	694	tResult = "mpeg1video";
695	break;	695	break;
696	case CODEC_ID_MPEG2VIDEO:	696	case AV_CODEC_ID_MPEG2VIDEO:
697	tResult = "mpeg2video";	697	tResult = "mpeg2video";
698	break;	698	break;
699	case CODEC_ID_H263P:	699	case AV_CODEC_ID_H263P:
700	tResult = "h263"; // ffmpeg has no separate h263+ format	700	tResult = "h263"; // ffmpeg has no separate h263+ format
701	break;	701	break;
702	case CODEC_ID_H264:	702	case AV_CODEC_ID_H264:
703	tResult = "h264";	703	tResult = "h264";
704	break;	704	break;
705	case CODEC_ID_MPEG4:	705	case AV_CODEC_ID_MPEG4:
706	tResult = "m4v";	706	tResult = "m4v";
707	break;	707	break;
708	case CODEC_ID_MJPEG:	708	case AV_CODEC_ID_MJPEG:
709	tResult = "mjpeg";	709	tResult = "mjpeg";
710	break;	710	break;
711	case CODEC_ID_THEORA:	711	case AV_CODEC_ID_THEORA:
712	tResult = "ogg";	712	tResult = "ogg";
713	break;	713	break;
714	case CODEC_ID_VP8:	714	case AV_CODEC_ID_VP8:
715	tResult = "webm";	715	tResult = "webm";
716	break;	716	break;
717		717
718	/* audio */	718	/* audio */
719	case CODEC_ID_PCM_MULAW:	719	case AV_CODEC_ID_PCM_MULAW:
720	tResult = "mulaw";	720	tResult = "mulaw";
721	break;	721	break;
722	case CODEC_ID_GSM:	722	case AV_CODEC_ID_GSM:
723	tResult = "gsm";	723	tResult = "gsm";
724	break;	724	break;
725	case CODEC_ID_PCM_ALAW:	725	case AV_CODEC_ID_PCM_ALAW:
726	tResult = "alaw";	726	tResult = "alaw";
727	break;	727	break;
728	case CODEC_ID_ADPCM_G722:	728	case AV_CODEC_ID_ADPCM_G722:
729	tResult = "g722";	729	tResult = "g722";
730	break;	730	break;
731	case CODEC_ID_PCM_S16BE:	731	case AV_CODEC_ID_PCM_S16BE:
732	tResult = "s16be";	732	tResult = "s16be";
733	break;	733	break;
734	case CODEC_ID_MP3:	734	case AV_CODEC_ID_MP3:
735	tResult = "mp3";	735	tResult = "mp3";
736	break;	736	break;
737	case CODEC_ID_AAC:	737	case AV_CODEC_ID_AAC:
738	tResult = "aac";	738	tResult = "aac";
739	break;	739	break;
740	case CODEC_ID_AMR_NB:	740	case AV_CODEC_ID_AMR_NB:
741	tResult = "amr";	741	tResult = "amr";
742	break;	742	break;
743	case CODEC_ID_AC3:	743	case AV_CODEC_ID_AC3:
744	tResult = "ac3";	744	tResult = "ac3";
745	break;	745	break;
746		746
Lines 1205-1211 Link Here
1205	return tResult;	1205	return tResult;
1206	}	1206	}
1207		1207
1208	enum CodecID MediaSource::GetSourceCodec()	1208	enum AVCodecID MediaSource::GetSourceCodec()
1209	{	1209	{
1210	return mSourceCodecId;	1210	return mSourceCodecId;
1211	}	1211	}
Lines 1753-1759 Link Here
1753	AVOutputFormat *tFormat;	1753	AVOutputFormat *tFormat;
1754	AVCodec *tCodec;	1754	AVCodec *tCodec;
1755	AVDictionary *tOptions = NULL;	1755	AVDictionary *tOptions = NULL;
1756	CodecID tSaveFileCodec = CODEC_ID_NONE;	1756	AVCodecID tSaveFileCodec = AV_CODEC_ID_NONE;
1757		1757
1758	LOG(LOG_VERBOSE, "Going to open recorder, media type is \"%s\"", GetMediaTypeStr().c_str());	1758	LOG(LOG_VERBOSE, "Going to open recorder, media type is \"%s\"", GetMediaTypeStr().c_str());
1759		1759
Lines 1851-1857 Link Here
1851	// add some extra parameters depending on the selected codec	1851	// add some extra parameters depending on the selected codec
1852	switch(tFormat->video_codec)	1852	switch(tFormat->video_codec)
1853	{	1853	{
1854	case CODEC_ID_MPEG4:	1854	case AV_CODEC_ID_MPEG4:
1855	mRecorderCodecContext->flags \|= CODEC_FLAG_4MV \| CODEC_FLAG_AC_PRED;	1855	mRecorderCodecContext->flags \|= CODEC_FLAG_4MV \| CODEC_FLAG_AC_PRED;
1856	break;	1856	break;
1857	}	1857	}
Lines 1910-1916 Link Here
1910		1910
1911	// define audio format for recording	1911	// define audio format for recording
1912	mRecorderAudioChannels = 2;	1912	mRecorderAudioChannels = 2;
1913	if (mRecorderCodecContext->codec_id == CODEC_ID_MP3)	1913	if (mRecorderCodecContext->codec_id == AV_CODEC_ID_MP3)
1914	mRecorderAudioFormat = AV_SAMPLE_FMT_S16P;	1914	mRecorderAudioFormat = AV_SAMPLE_FMT_S16P;
1915	else	1915	else
1916	mRecorderAudioFormat = AV_SAMPLE_FMT_S16;	1916	mRecorderAudioFormat = AV_SAMPLE_FMT_S16;
Lines 3079-3085 Link Here
3079	// ####################################################################################	3079	// ####################################################################################
3080	// ### FFMPEG helpers	3080	// ### FFMPEG helpers
3081	// ####################################################################################	3081	// ####################################################################################
3082	bool MediaSource::FfmpegDescribeInput(string pSource, int pLine, CodecID pCodecId, AVInputFormat **pFormat)	3082	bool MediaSource::FfmpegDescribeInput(string pSource, int pLine, AVCodecID pCodecId, AVInputFormat **pFormat)
3083	{	3083	{
3084	AVInputFormat *tResult = NULL;	3084	AVInputFormat *tResult = NULL;
3085		3085
Lines 3212-3221 Link Here
3212	}else{	3212	}else{
3213	switch(mSourceCodecId)	3213	switch(mSourceCodecId)
3214	{	3214	{
3215	case CODEC_ID_MPEG1VIDEO:	3215	case AV_CODEC_ID_MPEG1VIDEO:
3216	case CODEC_ID_MPEG2VIDEO:	3216	case AV_CODEC_ID_MPEG2VIDEO:
3217	case CODEC_ID_MPEG4:	3217	case AV_CODEC_ID_MPEG4:
3218	case CODEC_ID_H264:	3218	case AV_CODEC_ID_H264:
3219	// we shouldn't limit the analyzing time because the analyzer needs the entire time period to deliver a reliable result	3219	// we shouldn't limit the analyzing time because the analyzer needs the entire time period to deliver a reliable result
3220	break;	3220	break;
3221	default:	3221	default:
Lines 3411-3429 Link Here
3411	// try to find a vdpau decoder	3411	// try to find a vdpau decoder
3412	switch(mCodecContext->codec_id)	3412	switch(mCodecContext->codec_id)
3413	{	3413	{
3414	case CODEC_ID_H264:	3414	case AV_CODEC_ID_H264:
3415	tCodec = avcodec_find_decoder_by_name("h264_vdpau");	3415	tCodec = avcodec_find_decoder_by_name("h264_vdpau");
3416	break;	3416	break;
3417	case CODEC_ID_MPEG1VIDEO:	3417	case AV_CODEC_ID_MPEG1VIDEO:
3418	tCodec = avcodec_find_decoder_by_name("mpeg1video_vdpau");	3418	tCodec = avcodec_find_decoder_by_name("mpeg1video_vdpau");
3419	break;	3419	break;
3420	case CODEC_ID_MPEG2VIDEO:	3420	case AV_CODEC_ID_MPEG2VIDEO:
3421	tCodec = avcodec_find_decoder_by_name("mpegvideo_vdpau");	3421	tCodec = avcodec_find_decoder_by_name("mpegvideo_vdpau");
3422	break;	3422	break;
3423	case CODEC_ID_MPEG4:	3423	case AV_CODEC_ID_MPEG4:
3424	tCodec = avcodec_find_decoder_by_name("mpeg4_vdpau");	3424	tCodec = avcodec_find_decoder_by_name("mpeg4_vdpau");
3425	break;	3425	break;
3426	case CODEC_ID_WMV3:	3426	case AV_CODEC_ID_WMV3:
3427	tCodec = avcodec_find_decoder_by_name("wmv3_vdpau");	3427	tCodec = avcodec_find_decoder_by_name("wmv3_vdpau");
3428	break;	3428	break;
3429	default:	3429	default:
Lines 3449-3455 Link Here
3449	LOG_REMOTE(LOG_VERBOSE, pSource, pLine, "..successfully found %s decoder", GetMediaTypeStr().c_str());	3449	LOG_REMOTE(LOG_VERBOSE, pSource, pLine, "..successfully found %s decoder", GetMediaTypeStr().c_str());
3450		3450
3451	//H.264: force thread count to 1 since the h264 decoder will not extract SPS and PPS to extradata during multi-threaded decoding	3451	//H.264: force thread count to 1 since the h264 decoder will not extract SPS and PPS to extradata during multi-threaded decoding
3452	if (mCodecContext->codec_id == CODEC_ID_H264)	3452	if (mCodecContext->codec_id == AV_CODEC_ID_H264)
3453	{	3453	{
3454	if (strcmp(mFormatContext->filename, "") == 0)	3454	if (strcmp(mFormatContext->filename, "") == 0)
3455	{// we have a net/mem based media source	3455	{// we have a net/mem based media source
3456	-- HomerMultimedia/src/MediaSourceFile.cpp	3456	++ HomerMultimedia/src/MediaSourceFile.cpp
Lines 300-306 Link Here
300	}	300	}
301		301
302	// avoid frame dropping during decoding (mDecoderExpectedMaxOutputPerInputFrame might be wrong otherwise), assume 64 kB as max. input per read cycle	302	// avoid frame dropping during decoding (mDecoderExpectedMaxOutputPerInputFrame might be wrong otherwise), assume 64 kB as max. input per read cycle
303	if ((tIsNetworkStream) && (mCodecContext->codec_id == CODEC_ID_WMAV2))	303	if ((tIsNetworkStream) && (mCodecContext->codec_id == AV_CODEC_ID_WMAV2))
304	{	304	{
305	LOG(LOG_VERBOSE, "Detected WMAV2 codec in hidden network stream, will assume a default frame size of 64kB to prevent frame dropping");	305	LOG(LOG_VERBOSE, "Detected WMAV2 codec in hidden network stream, will assume a default frame size of 64kB to prevent frame dropping");
306	mCodecContext->frame_size = 64 * 1024;	306	mCodecContext->frame_size = 64 * 1024;
307	-- HomerMultimedia/src/MediaSourceMem.cpp	307	++ HomerMultimedia/src/MediaSourceMem.cpp
Lines 103-110 Link Here
103	mOpenInputStream = false;	103	mOpenInputStream = false;
104	RTPRegisterPacketStatistic(this);	104	RTPRegisterPacketStatistic(this);
105		105
106	mRtpSourceCodecIdHint = CODEC_ID_NONE;	106	mRtpSourceCodecIdHint = AV_CODEC_ID_NONE;
107	mSourceCodecId = CODEC_ID_NONE;	107	mSourceCodecId = AV_CODEC_ID_NONE;
108		108
109	mDecoderFragmentFifo = new MediaFifo(MEDIA_SOURCE_MEM_FRAGMENT_INPUT_QUEUE_SIZE_LIMIT, MEDIA_SOURCE_MEM_FRAGMENT_BUFFER_SIZE, "MediaSourceMem");	109	mDecoderFragmentFifo = new MediaFifo(MEDIA_SOURCE_MEM_FRAGMENT_INPUT_QUEUE_SIZE_LIMIT, MEDIA_SOURCE_MEM_FRAGMENT_BUFFER_SIZE, "MediaSourceMem");
110	LOG(LOG_VERBOSE, "Listen for video/audio frames with queue of %d bytes", MEDIA_SOURCE_MEM_FRAGMENT_INPUT_QUEUE_SIZE_LIMIT * MEDIA_SOURCE_MEM_FRAGMENT_BUFFER_SIZE);	110	LOG(LOG_VERBOSE, "Listen for video/audio frames with queue of %d bytes", MEDIA_SOURCE_MEM_FRAGMENT_INPUT_QUEUE_SIZE_LIMIT * MEDIA_SOURCE_MEM_FRAGMENT_BUFFER_SIZE);
Lines 475-481 Link Here
475	bool MediaSourceMem::HasInputStreamChanged()	475	bool MediaSourceMem::HasInputStreamChanged()
476	{	476	{
477	bool tResult = HasSourceChangedFromRTP();	477	bool tResult = HasSourceChangedFromRTP();
478	enum CodecID tNewCodecId = CODEC_ID_NONE;	478	enum AVCodecID tNewCodecId = AV_CODEC_ID_NONE;
479		479
480	// try to detect the right source codec based on RTP data	480	// try to detect the right source codec based on RTP data
481	if ((tResult) && (mRtpActivated))	481	if ((tResult) && (mRtpActivated))
Lines 484-546 Link Here
484	{	484	{
485	//video	485	//video
486	case 31:	486	case 31:
487	tNewCodecId = CODEC_ID_H261;	487	tNewCodecId = AV_CODEC_ID_H261;
488	break;	488	break;
489	case 32:	489	case 32:
490	tNewCodecId = CODEC_ID_MPEG2VIDEO;	490	tNewCodecId = AV_CODEC_ID_MPEG2VIDEO;
491	break;	491	break;
492	case 34:	492	case 34:
493	case 118:	493	case 118:
494	tNewCodecId = CODEC_ID_H263;	494	tNewCodecId = AV_CODEC_ID_H263;
495	break;	495	break;
496	case 119:	496	case 119:
497	tNewCodecId = CODEC_ID_H263P;	497	tNewCodecId = AV_CODEC_ID_H263P;
498	break;	498	break;
499	case 120:	499	case 120:
500	tNewCodecId = CODEC_ID_H264;	500	tNewCodecId = AV_CODEC_ID_H264;
501	break;	501	break;
502	case 121:	502	case 121:
503	tNewCodecId = CODEC_ID_MPEG4;	503	tNewCodecId = AV_CODEC_ID_MPEG4;
504	break;	504	break;
505	case 122:	505	case 122:
506	tNewCodecId = CODEC_ID_THEORA;	506	tNewCodecId = AV_CODEC_ID_THEORA;
507	break;	507	break;
508	case 123:	508	case 123:
509	tNewCodecId = CODEC_ID_VP8;	509	tNewCodecId = AV_CODEC_ID_VP8;
510	break;	510	break;
511		511
512	//audio	512	//audio
513	case 0:	513	case 0:
514	tNewCodecId = CODEC_ID_PCM_MULAW;	514	tNewCodecId = AV_CODEC_ID_PCM_MULAW;
515	break;	515	break;
516	case 3:	516	case 3:
517	tNewCodecId = CODEC_ID_GSM;	517	tNewCodecId = AV_CODEC_ID_GSM;
518	break;	518	break;
519	case 8:	519	case 8:
520	tNewCodecId = CODEC_ID_PCM_ALAW;	520	tNewCodecId = AV_CODEC_ID_PCM_ALAW;
521	break;	521	break;
522	case 9:	522	case 9:
523	tNewCodecId = CODEC_ID_ADPCM_G722;	523	tNewCodecId = AV_CODEC_ID_ADPCM_G722;
524	break;	524	break;
525	case 10:	525	case 10:
526	tNewCodecId = CODEC_ID_PCM_S16BE;	526	tNewCodecId = AV_CODEC_ID_PCM_S16BE;
527	break;	527	break;
528	case 11:	528	case 11:
529	tNewCodecId = CODEC_ID_PCM_S16BE;	529	tNewCodecId = AV_CODEC_ID_PCM_S16BE;
530	break;	530	break;
531	case 14:	531	case 14:
532	tNewCodecId = CODEC_ID_MP3;	532	tNewCodecId = AV_CODEC_ID_MP3;
533	break;	533	break;
534	case 100:	534	case 100:
535	tNewCodecId = CODEC_ID_AAC;	535	tNewCodecId = AV_CODEC_ID_AAC;
536	break;	536	break;
537	case 101:	537	case 101:
538	tNewCodecId = CODEC_ID_AMR_NB;	538	tNewCodecId = AV_CODEC_ID_AMR_NB;
539	break;	539	break;
540	default:	540	default:
541	break;	541	break;
542	}	542	}
543	if ((tNewCodecId != CODEC_ID_NONE) && (tNewCodecId != mSourceCodecId))	543	if ((tNewCodecId != AV_CODEC_ID_NONE) && (tNewCodecId != mSourceCodecId))
544	{	544	{
545	LOG(LOG_VERBOSE, "Suggesting codec change from %d(%s) to %d(%s)", mSourceCodecId, avcodec_get_name(mSourceCodecId), tNewCodecId, avcodec_get_name(tNewCodecId));	545	LOG(LOG_VERBOSE, "Suggesting codec change from %d(%s) to %d(%s)", mSourceCodecId, avcodec_get_name(mSourceCodecId), tNewCodecId, avcodec_get_name(tNewCodecId));
546	mRtpSourceCodecIdHint = tNewCodecId;	546	mRtpSourceCodecIdHint = tNewCodecId;
Lines 657-663 Link Here
657	bool MediaSourceMem::SetInputStreamPreferences(std::string pStreamCodec, bool pRtpActivated, bool pDoReset)	657	bool MediaSourceMem::SetInputStreamPreferences(std::string pStreamCodec, bool pRtpActivated, bool pDoReset)
658	{	658	{
659	bool tResult = false;	659	bool tResult = false;
660	enum CodecID tStreamCodecId = GetCodecIDFromGuiName(pStreamCodec);	660	enum AVCodecID tStreamCodecId = GetCodecIDFromGuiName(pStreamCodec);
661		661
662	if ((mSourceCodecId != tStreamCodecId) \|\| (mRtpActivated != pRtpActivated))	662	if ((mSourceCodecId != tStreamCodecId) \|\| (mRtpActivated != pRtpActivated))
663	{	663	{
Lines 727-738 Link Here
727	ClassifyStream(DATA_TYPE_VIDEO, SOCKET_RAW);	727	ClassifyStream(DATA_TYPE_VIDEO, SOCKET_RAW);
728		728
729	// check if we have a suggestion from RTP parser	729	// check if we have a suggestion from RTP parser
730	if (mRtpSourceCodecIdHint != CODEC_ID_NONE)	730	if (mRtpSourceCodecIdHint != AV_CODEC_ID_NONE)
731	mSourceCodecId = mRtpSourceCodecIdHint;	731	mSourceCodecId = mRtpSourceCodecIdHint;
732		732
733	// there is no differentiation between H.263+ and H.263 when decoding an incoming video stream	733	// there is no differentiation between H.263+ and H.263 when decoding an incoming video stream
734	if (mSourceCodecId == CODEC_ID_H263P)	734	if (mSourceCodecId == AV_CODEC_ID_H263P)
735	mSourceCodecId = CODEC_ID_H263;	735	mSourceCodecId = AV_CODEC_ID_H263;
736		736
737	// get a format description	737	// get a format description
738	if (!DescribeInput(mSourceCodecId, &tFormat))	738	if (!DescribeInput(mSourceCodecId, &tFormat))
Lines 801-807 Link Here
801	ClassifyStream(DATA_TYPE_AUDIO, SOCKET_RAW);	801	ClassifyStream(DATA_TYPE_AUDIO, SOCKET_RAW);
802		802
803	// check if we have a suggestion from RTP parser	803	// check if we have a suggestion from RTP parser
804	if (mRtpSourceCodecIdHint != CODEC_ID_NONE)	804	if (mRtpSourceCodecIdHint != AV_CODEC_ID_NONE)
805	mSourceCodecId = mRtpSourceCodecIdHint;	805	mSourceCodecId = mRtpSourceCodecIdHint;
806		806
807	// get a format description	807	// get a format description
Lines 839-872 Link Here
839	AVCodecContext *tCodec = mFormatContext->streams[mMediaStreamIndex]->codec;	839	AVCodecContext *tCodec = mFormatContext->streams[mMediaStreamIndex]->codec;
840	switch(mSourceCodecId)	840	switch(mSourceCodecId)
841	{	841	{
842	case CODEC_ID_AMR_NB:	842	case AV_CODEC_ID_AMR_NB:
843	tCodec->channels = 1;	843	tCodec->channels = 1;
844	tCodec->bit_rate = 7950;	844	tCodec->bit_rate = 7950;
845	tCodec->sample_rate = 8000;	845	tCodec->sample_rate = 8000;
846	mFormatContext->streams[mMediaStreamIndex]->time_base.den = tCodec->sample_rate;	846	mFormatContext->streams[mMediaStreamIndex]->time_base.den = tCodec->sample_rate;
847	mFormatContext->streams[mMediaStreamIndex]->time_base.num = 1;	847	mFormatContext->streams[mMediaStreamIndex]->time_base.num = 1;
848	break;	848	break;
849	case CODEC_ID_ADPCM_G722:	849	case AV_CODEC_ID_ADPCM_G722:
850	tCodec->channels = 1;	850	tCodec->channels = 1;
851	tCodec->sample_rate = 16000;	851	tCodec->sample_rate = 16000;
852	mFormatContext->streams[mMediaStreamIndex]->time_base.den = 8000; // different time base as defined in RFC	852	mFormatContext->streams[mMediaStreamIndex]->time_base.den = 8000; // different time base as defined in RFC
853	mFormatContext->streams[mMediaStreamIndex]->time_base.num = 1;	853	mFormatContext->streams[mMediaStreamIndex]->time_base.num = 1;
854	break;	854	break;
855	case CODEC_ID_GSM:	855	case AV_CODEC_ID_GSM:
856	case CODEC_ID_PCM_ALAW:	856	case AV_CODEC_ID_PCM_ALAW:
857	case CODEC_ID_PCM_MULAW:	857	case AV_CODEC_ID_PCM_MULAW:
858	tCodec->channels = 1;	858	tCodec->channels = 1;
859	tCodec->sample_rate = 8000;	859	tCodec->sample_rate = 8000;
860	mFormatContext->streams[mMediaStreamIndex]->time_base.den = tCodec->sample_rate;	860	mFormatContext->streams[mMediaStreamIndex]->time_base.den = tCodec->sample_rate;
861	mFormatContext->streams[mMediaStreamIndex]->time_base.num = 1;	861	mFormatContext->streams[mMediaStreamIndex]->time_base.num = 1;
862	break;	862	break;
863	case CODEC_ID_PCM_S16BE:	863	case AV_CODEC_ID_PCM_S16BE:
864	tCodec->channels = 2;	864	tCodec->channels = 2;
865	tCodec->sample_rate = 44100;	865	tCodec->sample_rate = 44100;
866	mFormatContext->streams[mMediaStreamIndex]->time_base.den = tCodec->sample_rate;	866	mFormatContext->streams[mMediaStreamIndex]->time_base.den = tCodec->sample_rate;
867	mFormatContext->streams[mMediaStreamIndex]->time_base.num = 1;	867	mFormatContext->streams[mMediaStreamIndex]->time_base.num = 1;
868	break;	868	break;
869	case CODEC_ID_MP3:	869	case AV_CODEC_ID_MP3:
870	mFormatContext->streams[mMediaStreamIndex]->time_base.den = tCodec->sample_rate;	870	mFormatContext->streams[mMediaStreamIndex]->time_base.den = tCodec->sample_rate;
871	mFormatContext->streams[mMediaStreamIndex]->time_base.num = 1;	871	mFormatContext->streams[mMediaStreamIndex]->time_base.num = 1;
872	break;	872	break;
873	-- HomerMultimedia/src/MediaSourceMuxer.cpp	873	++ HomerMultimedia/src/MediaSourceMuxer.cpp
Lines 66-72 Link Here
66	mSourceType = SOURCE_MUXER;	66	mSourceType = SOURCE_MUXER;
67	mStreamPacketBuffer = (char*)av_malloc(MEDIA_SOURCE_MUX_STREAM_PACKET_BUFFER_SIZE);	67	mStreamPacketBuffer = (char*)av_malloc(MEDIA_SOURCE_MUX_STREAM_PACKET_BUFFER_SIZE);
68	SetOutgoingStream();	68	SetOutgoingStream();
69	mStreamCodecId = CODEC_ID_NONE;	69	mStreamCodecId = AV_CODEC_ID_NONE;
70	mStreamMaxPacketSize = 500;	70	mStreamMaxPacketSize = 500;
71	mStreamQuality = 20;	71	mStreamQuality = 20;
72	mStreamBitRate = -1;	72	mStreamBitRate = -1;
Lines 195-201 Link Here
195	{	195	{
196	// HINT: returns if something has changed	196	// HINT: returns if something has changed
197	bool tResult = false;	197	bool tResult = false;
198	enum CodecID tStreamCodecId = GetCodecIDFromGuiName(pStreamCodec);	198	enum AVCodecID tStreamCodecId = GetCodecIDFromGuiName(pStreamCodec);
199		199
200	pMaxPacketSize -= IP6_HEADER_SIZE; // IPv6 overhead is bigger than IPv4	200	pMaxPacketSize -= IP6_HEADER_SIZE; // IPv6 overhead is bigger than IPv4
201	pMaxPacketSize -= IP_OPTIONS_SIZE; // IP options size: used for QoS signaling	201	pMaxPacketSize -= IP_OPTIONS_SIZE; // IP options size: used for QoS signaling
Lines 285-295 Link Here
285	return tResult;	285	return tResult;
286	}	286	}
287		287
288	void MediaSourceMuxer::ApplyVideoResolutionToEncoderCodec(int &pResX, int &pResY, enum CodecID pCodec)	288	void MediaSourceMuxer::ApplyVideoResolutionToEncoderCodec(int &pResX, int &pResY, enum AVCodecID pCodec)
289	{	289	{
290	switch(pCodec)	290	switch(pCodec)
291	{	291	{
292	case CODEC_ID_H261: // supports QCIF, CIF	292	case AV_CODEC_ID_H261: // supports QCIF, CIF
293	if (pResX > 176)	293	if (pResX > 176)
294	{// CIF	294	{// CIF
295	pResX = 352;	295	pResX = 352;
Lines 301-307 Link Here
301	}	301	}
302	LOG(LOG_VERBOSE, "Resolution %d*%d for codec H.261 automatically selected", pResX, pResY);	302	LOG(LOG_VERBOSE, "Resolution %d*%d for codec H.261 automatically selected", pResX, pResY);
303	break;	303	break;
304	case CODEC_ID_H263: // supports SQCIF, QCIF, CIF, CIF4,CIF16	304	case AV_CODEC_ID_H263: // supports SQCIF, QCIF, CIF, CIF4,CIF16
305	if(pResX > 704)	305	if(pResX > 704)
306	{// CIF16	306	{// CIF16
307	pResX = 1408;	307	pResX = 1408;
Lines 325-331 Link Here
325	}	325	}
326	LOG(LOG_VERBOSE, "Resolution %d*%d for codec H.263 automatically selected", pResX, pResY);	326	LOG(LOG_VERBOSE, "Resolution %d*%d for codec H.263 automatically selected", pResX, pResY);
327	break;	327	break;
328	case CODEC_ID_H263P:	328	case AV_CODEC_ID_H263P:
329	if ((pResX > 2048) \|\| (pResY > 1152))	329	if ((pResX > 2048) \|\| (pResY > 1152))
330	{// max. video resolution is 2048x1152	330	{// max. video resolution is 2048x1152
331	pResX = 2048;	331	pResX = 2048;
Lines 334-340 Link Here
334	{// everythin is fine, use the source resolution	334	{// everythin is fine, use the source resolution
335	}	335	}
336	break;	336	break;
337	case CODEC_ID_THEORA:	337	case AV_CODEC_ID_THEORA:
338	pResX = 352;	338	pResX = 352;
339	pResY = 288;	339	pResY = 288;
340	break;	340	break;
Lines 429-438 Link Here
429	LOG(LOG_VERBOSE, "Using format \"%s\" for VIDEO codec %d", tFormat->name, mStreamCodecId);	429	LOG(LOG_VERBOSE, "Using format \"%s\" for VIDEO codec %d", tFormat->name, mStreamCodecId);
430		430
431	// explicit codec selection for H263, otherwise ffmpeg would use the last H263-selection	431	// explicit codec selection for H263, otherwise ffmpeg would use the last H263-selection
432	if (mStreamCodecId == CODEC_ID_H263P)	432	if (mStreamCodecId == AV_CODEC_ID_H263P)
433	tFormat->video_codec = CODEC_ID_H263P;	433	tFormat->video_codec = AV_CODEC_ID_H263P;
434	if (mStreamCodecId == CODEC_ID_H263)	434	if (mStreamCodecId == AV_CODEC_ID_H263)
435	tFormat->video_codec = CODEC_ID_H263;	435	tFormat->video_codec = AV_CODEC_ID_H263;
436		436
437	// set correct output format	437	// set correct output format
438	mFormatContext->oformat = tFormat;	438	mFormatContext->oformat = tFormat;
Lines 456-475 Link Here
456	// add some extra parameters depending on the selected codec	456	// add some extra parameters depending on the selected codec
457	switch(tFormat->video_codec)	457	switch(tFormat->video_codec)
458	{	458	{
459	case CODEC_ID_MPEG2VIDEO:	459	case AV_CODEC_ID_MPEG2VIDEO:
460	// force low delay	460	// force low delay
461	if (tCodec->capabilities & CODEC_CAP_DELAY)	461	if (tCodec->capabilities & CODEC_CAP_DELAY)
462	mCodecContext->flags \|= CODEC_FLAG_LOW_DELAY;	462	mCodecContext->flags \|= CODEC_FLAG_LOW_DELAY;
463	break;	463	break;
464	case CODEC_ID_H263P:	464	case AV_CODEC_ID_H263P:
465	// old codec codext flag CODEC_FLAG_H263P_SLICE_STRUCT	465	// old codec codext flag CODEC_FLAG_H263P_SLICE_STRUCT
466	av_dict_set(&tOptions, "structured_slices", "1", 0);	466	av_dict_set(&tOptions, "structured_slices", "1", 0);
467	// old codec codext flag CODEC_FLAG_H263P_UMV	467	// old codec codext flag CODEC_FLAG_H263P_UMV
468	av_dict_set(&tOptions, "umv", "1", 0);	468	av_dict_set(&tOptions, "umv", "1", 0);
469	// old codec codext flag CODEC_FLAG_H263P_AIV	469	// old codec codext flag CODEC_FLAG_H263P_AIV
470	av_dict_set(&tOptions, "aiv", "1", 0);	470	av_dict_set(&tOptions, "aiv", "1", 0);
471	case CODEC_ID_H263:	471	case AV_CODEC_ID_H263:
472	case CODEC_ID_MPEG4:	472	case AV_CODEC_ID_MPEG4:
473	mCodecContext->flags \|= CODEC_FLAG_4MV \| CODEC_FLAG_AC_PRED;	473	mCodecContext->flags \|= CODEC_FLAG_4MV \| CODEC_FLAG_AC_PRED;
474	break;	474	break;
475	}	475	}
Lines 490-496 Link Here
490	}	490	}
491		491
492	// for H.263+ both width and height must be multiples of 4	492	// for H.263+ both width and height must be multiples of 4
493	if (mStreamCodecId == CODEC_ID_H263P)	493	if (mStreamCodecId == AV_CODEC_ID_H263P)
494	{	494	{
495	mCurrentStreamingResX += 3;	495	mCurrentStreamingResX += 3;
496	mCurrentStreamingResX /= 4;	496	mCurrentStreamingResX /= 4;
Lines 502-508 Link Here
502	}	502	}
503		503
504	// for H.2634 both width and height must be multiples of 2	504	// for H.2634 both width and height must be multiples of 2
505	if (mStreamCodecId == CODEC_ID_H264)	505	if (mStreamCodecId == AV_CODEC_ID_H264)
506	{	506	{
507	mCurrentStreamingResX += 1;	507	mCurrentStreamingResX += 1;
508	mCurrentStreamingResX /= 2;	508	mCurrentStreamingResX /= 2;
Lines 523-529 Link Here
523	* identically to 1.	523	* identically to 1.
524	*/	524	*/
525	// mpeg1/2 codecs support only non-rational frame rates	525	// mpeg1/2 codecs support only non-rational frame rates
526	if (((tFormat->video_codec == CODEC_ID_MPEG1VIDEO) \|\| (tFormat->video_codec == CODEC_ID_MPEG2VIDEO)) && (mInputFrameRate = 29.97))	526	if (((tFormat->video_codec == AV_CODEC_ID_MPEG1VIDEO) \|\| (tFormat->video_codec == AV_CODEC_ID_MPEG2VIDEO)) && (mInputFrameRate = 29.97))
527	{	527	{
528	//HACK: pretend a frame rate of 30 fps, the actual frame rate corresponds to the frame rate from the base media source	528	//HACK: pretend a frame rate of 30 fps, the actual frame rate corresponds to the frame rate from the base media source
529	mCodecContext->time_base = (AVRational){100, (int)(30 * 100)};	529	mCodecContext->time_base = (AVRational){100, (int)(30 * 100)};
Lines 534-540 Link Here
534	mEncoderStream->time_base = (AVRational){100, (int)(mInputFrameRate * 100)};	534	mEncoderStream->time_base = (AVRational){100, (int)(mInputFrameRate * 100)};
535	}	535	}
536	// set i frame distance: GOP = group of pictures	536	// set i frame distance: GOP = group of pictures
537	if (mStreamCodecId != CODEC_ID_THEORA)	537	if (mStreamCodecId != AV_CODEC_ID_THEORA)
538	mCodecContext->gop_size = (100 - mStreamQuality) / 5; // default is 12	538	mCodecContext->gop_size = (100 - mStreamQuality) / 5; // default is 12
539	else	539	else
540	mCodecContext->gop_size = 0; // force GOP size of 0 for THEORA	540	mCodecContext->gop_size = 0; // force GOP size of 0 for THEORA
Lines 545-557 Link Here
545	// set max. packet size for RTP based packets	545	// set max. packet size for RTP based packets
546	//HINT: don't set if we use H261, otherwise ffmpeg internal functions in mpegvideo_enc.c (MPV_*) would get confused because H261 support is missing in ffmpeg's RTP support	546	//HINT: don't set if we use H261, otherwise ffmpeg internal functions in mpegvideo_enc.c (MPV_*) would get confused because H261 support is missing in ffmpeg's RTP support
547	//TODO: fix packet size limitation here, ffmpegs lacks support for RTP encaps. for H.261 based video streams	547	//TODO: fix packet size limitation here, ffmpegs lacks support for RTP encaps. for H.261 based video streams
548	if (tFormat->video_codec != CODEC_ID_H261)	548	if (tFormat->video_codec != AV_CODEC_ID_H261)
549	mCodecContext->rtp_payload_size = mStreamMaxPacketSize;	549	mCodecContext->rtp_payload_size = mStreamMaxPacketSize;
550	else	550	else
551	RTP::SetH261PayloadSizeMax(mStreamMaxPacketSize);	551	RTP::SetH261PayloadSizeMax(mStreamMaxPacketSize);
552		552
553	// set pixel format	553	// set pixel format
554	if (tFormat->video_codec == CODEC_ID_MJPEG)	554	if (tFormat->video_codec == AV_CODEC_ID_MJPEG)
555	mCodecContext->pix_fmt = PIX_FMT_YUVJ420P;	555	mCodecContext->pix_fmt = PIX_FMT_YUVJ420P;
556	else	556	else
557	mCodecContext->pix_fmt = PIX_FMT_YUV420P;	557	mCodecContext->pix_fmt = PIX_FMT_YUV420P;
Lines 763-792 Link Here
763	mCodecContext->codec_type = AVMEDIA_TYPE_AUDIO;	763	mCodecContext->codec_type = AVMEDIA_TYPE_AUDIO;
764	switch(mCodecContext->codec_id)	764	switch(mCodecContext->codec_id)
765	{	765	{
766	case CODEC_ID_ADPCM_G722:	766	case AV_CODEC_ID_ADPCM_G722:
767	mOutputAudioChannels = 1;	767	mOutputAudioChannels = 1;
768	mOutputAudioSampleRate = 16000;	768	mOutputAudioSampleRate = 16000;
769	mCodecContext->sample_fmt = AV_SAMPLE_FMT_S16; // packed	769	mCodecContext->sample_fmt = AV_SAMPLE_FMT_S16; // packed
770	break;	770	break;
771	case CODEC_ID_AMR_NB:	771	case AV_CODEC_ID_AMR_NB:
772	mOutputAudioChannels = 1;	772	mOutputAudioChannels = 1;
773	mCodecContext->bit_rate = 7950; // force to 7.95kHz , limit is given by libopencore_amrnb	773	mCodecContext->bit_rate = 7950; // force to 7.95kHz , limit is given by libopencore_amrnb
774	mOutputAudioSampleRate = 8000; //force 8 kHz for AMR-NB	774	mOutputAudioSampleRate = 8000; //force 8 kHz for AMR-NB
775	mCodecContext->sample_fmt = AV_SAMPLE_FMT_S16; // packed	775	mCodecContext->sample_fmt = AV_SAMPLE_FMT_S16; // packed
776	break;	776	break;
777	case CODEC_ID_GSM:	777	case AV_CODEC_ID_GSM:
778	case CODEC_ID_PCM_ALAW:	778	case AV_CODEC_ID_PCM_ALAW:
779	case CODEC_ID_PCM_MULAW:	779	case AV_CODEC_ID_PCM_MULAW:
780	mOutputAudioChannels = 1;	780	mOutputAudioChannels = 1;
781	mOutputAudioSampleRate = 8000;	781	mOutputAudioSampleRate = 8000;
782	mCodecContext->sample_fmt = AV_SAMPLE_FMT_S16; // packed	782	mCodecContext->sample_fmt = AV_SAMPLE_FMT_S16; // packed
783	break;	783	break;
784	case CODEC_ID_PCM_S16BE:	784	case AV_CODEC_ID_PCM_S16BE:
785	mOutputAudioChannels = 2;	785	mOutputAudioChannels = 2;
786	mOutputAudioSampleRate = 44100;	786	mOutputAudioSampleRate = 44100;
787	mCodecContext->sample_fmt = AV_SAMPLE_FMT_S16; // packed	787	mCodecContext->sample_fmt = AV_SAMPLE_FMT_S16; // packed
788	break;	788	break;
789	case CODEC_ID_MP3:	789	case AV_CODEC_ID_MP3:
790	mOutputAudioChannels = pChannels;	790	mOutputAudioChannels = pChannels;
791	mOutputAudioSampleRate = pSampleRate;	791	mOutputAudioSampleRate = pSampleRate;
792	mCodecContext->sample_fmt = AV_SAMPLE_FMT_S16P; // planar	792	mCodecContext->sample_fmt = AV_SAMPLE_FMT_S16P; // planar
Lines 1995-2001 Link Here
1995	int tResY = pResY;	1995	int tResY = pResY;
1996	switch(mStreamCodecId)	1996	switch(mStreamCodecId)
1997	{	1997	{
1998	case CODEC_ID_H261: // supports QCIF, CIF	1998	case AV_CODEC_ID_H261: // supports QCIF, CIF
1999	if (((pResX == 176) && (pResY == 144)) \|\| ((pResX == 352) && (pResY == 288)))	1999	if (((pResX == 176) && (pResY == 144)) \|\| ((pResX == 352) && (pResY == 288)))
2000	{	2000	{
2001	LOG(LOG_VERBOSE, "Resolution %d*%d supported by H.261", pResX, pResY);	2001	LOG(LOG_VERBOSE, "Resolution %d*%d supported by H.261", pResX, pResY);
Lines 2015-2021 Link Here
2015	if (pResY < 144)	2015	if (pResY < 144)
2016	tResY = 144;	2016	tResY = 144;
2017	break;	2017	break;
2018	case CODEC_ID_H263: // supports QCIF, CIF, CIF4	2018	case AV_CODEC_ID_H263: // supports QCIF, CIF, CIF4
2019	if (((pResX == 128) && (pResY == 96)) \|\| ((pResX == 176) && (pResY == 144)) \|\| ((pResX == 352) && (pResY == 288)) \|\| ((pResX == 704) && (pResY == 576)) \|\| ((pResX == 1408) && (pResY == 1152)))	2019	if (((pResX == 128) && (pResY == 96)) \|\| ((pResX == 176) && (pResY == 144)) \|\| ((pResX == 352) && (pResY == 288)) \|\| ((pResX == 704) && (pResY == 576)) \|\| ((pResX == 1408) && (pResY == 1152)))
2020	{	2020	{
2021	LOG(LOG_VERBOSE, "Resolution %d*%d supported by H.263", pResX, pResY);	2021	LOG(LOG_VERBOSE, "Resolution %d*%d supported by H.263", pResX, pResY);
Lines 2035-2041 Link Here
2035	if (pResY < 144)	2035	if (pResY < 144)
2036	tResY = 144;	2036	tResY = 144;
2037	break;	2037	break;
2038	case CODEC_ID_H263P:	2038	case AV_CODEC_ID_H263P:
2039	default:	2039	default:
2040	break;	2040	break;
2041	}	2041	}
Lines 2177-2188 Link Here
2177	return tResult;	2177	return tResult;
2178	}	2178	}
2179		2179
2180	enum CodecID MediaSourceMuxer::GetSourceCodec()	2180	enum AVCodecID MediaSourceMuxer::GetSourceCodec()
2181	{	2181	{
2182	if (mMediaSource != NULL)	2182	if (mMediaSource != NULL)
2183	return mMediaSource->GetSourceCodec();	2183	return mMediaSource->GetSourceCodec();
2184	else	2184	else
2185	return CODEC_ID_NONE;	2185	return AV_CODEC_ID_NONE;
2186	}	2186	}
2187		2187
2188	string MediaSourceMuxer::GetSourceCodecStr()	2188	string MediaSourceMuxer::GetSourceCodecStr()
2189	-- HomerMultimedia/src/MediaSourceNet.cpp	2189	++ HomerMultimedia/src/MediaSourceNet.cpp
Lines 595-601 Link Here
595	mSourceType = SOURCE_NETWORK;	595	mSourceType = SOURCE_NETWORK;
596	mOpenInputStream = false;	596	mOpenInputStream = false;
597		597
598	mSourceCodecId = CODEC_ID_NONE;	598	mSourceCodecId = AV_CODEC_ID_NONE;
599	}	599	}
600		600
601	MediaSourceNet::MediaSourceNet(Socket *pDataSocket):	601	MediaSourceNet::MediaSourceNet(Socket *pDataSocket):
602	-- HomerMultimedia/src/MediaSourceOss.cpp	602	++ HomerMultimedia/src/MediaSourceOss.cpp
Lines 150-156 Link Here
150	tFormatParams.channels = mOutputAudioChannels;	150	tFormatParams.channels = mOutputAudioChannels;
151	tFormatParams.initial_pause = 0;	151	tFormatParams.initial_pause = 0;
152	tFormatParams.prealloced_context = 0;	152	tFormatParams.prealloced_context = 0;
153	//deprecated: tFormatParams.audio_codec_id = CODEC_ID_PCM_S16LE;	153	//deprecated: tFormatParams.audio_codec_id = AV_CODEC_ID_PCM_S16LE;
154	tFormat = av_find_input_format("oss");	154	tFormat = av_find_input_format("oss");
155	if (tFormat == NULL)	155	if (tFormat == NULL)
156	{	156	{
157	-- HomerMultimedia/src/RTP.cpp	157	++ HomerMultimedia/src/RTP.cpp
Lines 421-427 Link Here
421	mRtpPacketBuffer = NULL;	421	mRtpPacketBuffer = NULL;
422	mTargetHost = "";	422	mTargetHost = "";
423	mTargetPort = 0;	423	mTargetPort = 0;
424	mStreamCodecID = CODEC_ID_NONE;	424	mStreamCodecID = AV_CODEC_ID_NONE;
425	mLocalSourceIdentifier = 0;	425	mLocalSourceIdentifier = 0;
426	Init();	426	Init();
427	}	427	}
Lines 562-568 Link Here
562	// set SRC ID	562	// set SRC ID
563	mLocalSourceIdentifier = av_get_random_seed();	563	mLocalSourceIdentifier = av_get_random_seed();
564		564
565	if (mStreamCodecID == CODEC_ID_H261)	565	if (mStreamCodecID == AV_CODEC_ID_H261)
566	return OpenRtpEncoderH261(pTargetHost, pTargetPort, pInnerStream);	566	return OpenRtpEncoderH261(pTargetHost, pTargetPort, pInnerStream);
567		567
568	int tResult;	568	int tResult;
Lines 630-636 Link Here
630		630
631	switch(mStreamCodecID)	631	switch(mStreamCodecID)
632	{	632	{
633	case CODEC_ID_H263:	633	case AV_CODEC_ID_H263:
634	// use older rfc2190 for RTP packetizing	634	// use older rfc2190 for RTP packetizing
635	if ((tRes = av_opt_set(mRtpFormatContext->priv_data, "rtpflags", "rfc2190", 0)) < 0)	635	if ((tRes = av_opt_set(mRtpFormatContext->priv_data, "rtpflags", "rfc2190", 0)) < 0)
636	LOG(LOG_ERROR, "Failed to set A/V option \"rtpflags\" because %s(0x%x)", strerror(AVUNERROR(tRes)), tRes);	636	LOG(LOG_ERROR, "Failed to set A/V option \"rtpflags\" because %s(0x%x)", strerror(AVUNERROR(tRes)), tRes);
Lines 737-743 Link Here
737	return mPayloadId;	737	return mPayloadId;
738	}	738	}
739		739
740	bool RTP::IsPayloadSupported(enum CodecID pId)	740	bool RTP::IsPayloadSupported(enum AVCodecID pId)
741	{	741	{
742	bool tResult = false;	742	bool tResult = false;
743		743
Lines 745-768 Link Here
745	switch(pId)	745	switch(pId)
746	{	746	{
747	// list from "libavformat::rtpenc.c::is_supported"	747	// list from "libavformat::rtpenc.c::is_supported"
748	case CODEC_ID_H261:	748	case AV_CODEC_ID_H261:
749	case CODEC_ID_H263:	749	case AV_CODEC_ID_H263:
750	case CODEC_ID_H263P:	750	case AV_CODEC_ID_H263P:
751	case CODEC_ID_H264:	751	case AV_CODEC_ID_H264:
752	case CODEC_ID_MPEG1VIDEO:	752	case AV_CODEC_ID_MPEG1VIDEO:
753	case CODEC_ID_MPEG2VIDEO:	753	case AV_CODEC_ID_MPEG2VIDEO:
754	case CODEC_ID_MPEG4:	754	case AV_CODEC_ID_MPEG4:
755	case CODEC_ID_MP3:	755	case AV_CODEC_ID_MP3:
756	case CODEC_ID_AMR_NB:	756	case AV_CODEC_ID_AMR_NB:
757	case CODEC_ID_PCM_ALAW:	757	case AV_CODEC_ID_PCM_ALAW:
758	case CODEC_ID_PCM_MULAW:	758	case AV_CODEC_ID_PCM_MULAW:
759	case CODEC_ID_PCM_S16BE:	759	case AV_CODEC_ID_PCM_S16BE:
760	// case CODEC_ID_MPEG2TS:	760	// case AV_CODEC_ID_MPEG2TS:
761	// case CODEC_ID_VORBIS:	761	// case AV_CODEC_ID_VORBIS:
762	case CODEC_ID_THEORA:	762	case AV_CODEC_ID_THEORA:
763	case CODEC_ID_VP8:	763	case AV_CODEC_ID_VP8:
764	case CODEC_ID_ADPCM_G722:	764	case AV_CODEC_ID_ADPCM_G722:
765	// case CODEC_ID_ADPCM_G726:	765	// case AV_CODEC_ID_ADPCM_G726:
766	tResult = true;	766	tResult = true;
767	break;	767	break;
768	default:	768	default:
Lines 772-778 Link Here
772	return tResult;	772	return tResult;
773	}	773	}
774		774
775	int RTP::GetPayloadHeaderSizeMax(enum CodecID pCodec)	775	int RTP::GetPayloadHeaderSizeMax(enum AVCodecID pCodec)
776	{	776	{
777	int tResult = 0;	777	int tResult = 0;
778		778
Lines 782-833 Link Here
782	switch(pCodec)	782	switch(pCodec)
783	{	783	{
784	// list from "libavformat::rtpenc.c::is_supported"	784	// list from "libavformat::rtpenc.c::is_supported"
785	case CODEC_ID_H261:	785	case AV_CODEC_ID_H261:
786	tResult = sizeof(H261Header);	786	tResult = sizeof(H261Header);
787	break;	787	break;
788	case CODEC_ID_H263:	788	case AV_CODEC_ID_H263:
789	tResult = sizeof(H263Header);	789	tResult = sizeof(H263Header);
790	break;	790	break;
791	case CODEC_ID_H263P:	791	case AV_CODEC_ID_H263P:
792	tResult = sizeof(H263PHeader);	792	tResult = sizeof(H263PHeader);
793	break;	793	break;
794	case CODEC_ID_H264:	794	case AV_CODEC_ID_H264:
795	tResult = sizeof(H264Header);	795	tResult = sizeof(H264Header);
796	break;	796	break;
797	case CODEC_ID_MPEG1VIDEO:	797	case AV_CODEC_ID_MPEG1VIDEO:
798	case CODEC_ID_MPEG2VIDEO:	798	case AV_CODEC_ID_MPEG2VIDEO:
799	tResult = sizeof(MPVHeader); //HINT: we neglect the MPEG2 add-on header	799	tResult = sizeof(MPVHeader); //HINT: we neglect the MPEG2 add-on header
800	break;	800	break;
801	case CODEC_ID_MPEG4:	801	case AV_CODEC_ID_MPEG4:
802	tResult = 0;	802	tResult = 0;
803	break;	803	break;
804	case CODEC_ID_AMR_NB:	804	case AV_CODEC_ID_AMR_NB:
805	tResult = sizeof(AMRNBHeader);	805	tResult = sizeof(AMRNBHeader);
806	break;	806	break;
807	case CODEC_ID_PCM_ALAW:	807	case AV_CODEC_ID_PCM_ALAW:
808	tResult = 0;	808	tResult = 0;
809	break;	809	break;
810	case CODEC_ID_PCM_MULAW:	810	case AV_CODEC_ID_PCM_MULAW:
811	tResult = 0;	811	tResult = 0;
812	break;	812	break;
813	case CODEC_ID_ADPCM_G722:	813	case AV_CODEC_ID_ADPCM_G722:
814	tResult = 0;	814	tResult = 0;
815	break;	815	break;
816	case CODEC_ID_PCM_S16BE:	816	case AV_CODEC_ID_PCM_S16BE:
817	tResult = 0;	817	tResult = 0;
818	break;	818	break;
819	case CODEC_ID_MP3:	819	case AV_CODEC_ID_MP3:
820	tResult = sizeof(MPAHeader);	820	tResult = sizeof(MPAHeader);
821	break;	821	break;
822	// case CODEC_ID_MPEG2TS:	822	// case AV_CODEC_ID_MPEG2TS:
823	// case CODEC_ID_VORBIS:	823	// case AV_CODEC_ID_VORBIS:
824	case CODEC_ID_THEORA:	824	case AV_CODEC_ID_THEORA:
825	tResult = sizeof(THEORAHeader);	825	tResult = sizeof(THEORAHeader);
826	break;	826	break;
827	case CODEC_ID_VP8:	827	case AV_CODEC_ID_VP8:
828	tResult = sizeof(VP8Header); // we neglect the extended header and the 3 other optional header bytes	828	tResult = sizeof(VP8Header); // we neglect the extended header and the 3 other optional header bytes
829	break;	829	break;
830	// case CODEC_ID_ADPCM_G726:	830	// case AV_CODEC_ID_ADPCM_G726:
831	default:	831	default:
832	tResult = 0;	832	tResult = 0;
833	break;	833	break;
Lines 836-842 Link Here
836	return tResult;	836	return tResult;
837	}	837	}
838		838
839	int RTP::GetHeaderSizeMax(enum CodecID pCodec)	839	int RTP::GetHeaderSizeMax(enum AVCodecID pCodec)
840	{	840	{
841	return RTP_HEADER_SIZE + GetPayloadHeaderSizeMax(pCodec);	841	return RTP_HEADER_SIZE + GetPayloadHeaderSizeMax(pCodec);
842	}	842	}
Lines 963-969 Link Here
963	tMp3Hack_EntireBufferSize = pDataSize;	963	tMp3Hack_EntireBufferSize = pDataSize;
964		964
965	// adapt clock rate for G.722	965	// adapt clock rate for G.722
966	if (mStreamCodecID == CODEC_ID_ADPCM_G722)	966	if (mStreamCodecID == AV_CODEC_ID_ADPCM_G722)
967	pPacketPts /= 2; // transform from 16 kHz to 8kHz	967	pPacketPts /= 2; // transform from 16 kHz to 8kHz
968		968
969	av_init_packet(&tPacket);	969	av_init_packet(&tPacket);
Lines 1098-1117 Link Here
1098	// -> don't know for what reason, but they should be kept as they are	1098	// -> don't know for what reason, but they should be kept as they are
1099	switch(mStreamCodecID)	1099	switch(mStreamCodecID)
1100	{	1100	{
1101	case CODEC_ID_PCM_MULAW:	1101	case AV_CODEC_ID_PCM_MULAW:
1102	tRtpHeader->PayloadType = 0;	1102	tRtpHeader->PayloadType = 0;
1103	break;	1103	break;
1104	case CODEC_ID_PCM_ALAW:	1104	case AV_CODEC_ID_PCM_ALAW:
1105	tRtpHeader->PayloadType = 8;	1105	tRtpHeader->PayloadType = 8;
1106	break;	1106	break;
1107	case CODEC_ID_ADPCM_G722:	1107	case AV_CODEC_ID_ADPCM_G722:
1108	tRtpHeader->PayloadType = 9;	1108	tRtpHeader->PayloadType = 9;
1109	break;	1109	break;
1110	// case CODEC_ID_ADPCM_G726:	1110	// case AV_CODEC_ID_ADPCM_G726:
1111	case CODEC_ID_PCM_S16BE:	1111	case AV_CODEC_ID_PCM_S16BE:
1112	tRtpHeader->PayloadType = 10;	1112	tRtpHeader->PayloadType = 10;
1113	break;	1113	break;
1114	case CODEC_ID_MP3:	1114	case AV_CODEC_ID_MP3:
1115	// HACK: some modification of the standard MPA payload header: use MBZ to signalize the size of the original audio packet	1115	// HACK: some modification of the standard MPA payload header: use MBZ to signalize the size of the original audio packet
1116	tMPAHeader = (MPAHeader*)(tRtpPacket + RTP_HEADER_SIZE);	1116	tMPAHeader = (MPAHeader*)(tRtpPacket + RTP_HEADER_SIZE);
1117		1117
Lines 1128-1166 Link Here
1128		1128
1129	tRtpHeader->PayloadType = 14;	1129	tRtpHeader->PayloadType = 14;
1130	break;	1130	break;
1131	case CODEC_ID_H261:	1131	case AV_CODEC_ID_H261:
1132	tRtpHeader->PayloadType = 31;	1132	tRtpHeader->PayloadType = 31;
1133	break;	1133	break;
1134	case CODEC_ID_MPEG1VIDEO:	1134	case AV_CODEC_ID_MPEG1VIDEO:
1135	case CODEC_ID_MPEG2VIDEO:	1135	case AV_CODEC_ID_MPEG2VIDEO:
1136	tRtpHeader->PayloadType = 32;	1136	tRtpHeader->PayloadType = 32;
1137	break;	1137	break;
1138	case CODEC_ID_H263:	1138	case AV_CODEC_ID_H263:
1139	tRtpHeader->PayloadType = 34;	1139	tRtpHeader->PayloadType = 34;
1140	break;	1140	break;
1141	case CODEC_ID_AAC:	1141	case AV_CODEC_ID_AAC:
1142	tRtpHeader->PayloadType = 100;	1142	tRtpHeader->PayloadType = 100;
1143	break;	1143	break;
1144	case CODEC_ID_AMR_NB:	1144	case AV_CODEC_ID_AMR_NB:
1145	tRtpHeader->PayloadType = 101;	1145	tRtpHeader->PayloadType = 101;
1146	break;	1146	break;
1147	case CODEC_ID_H263P:	1147	case AV_CODEC_ID_H263P:
1148	tRtpHeader->PayloadType = 119;	1148	tRtpHeader->PayloadType = 119;
1149	break;	1149	break;
1150	case CODEC_ID_H264:	1150	case AV_CODEC_ID_H264:
1151	tRtpHeader->PayloadType = 120;	1151	tRtpHeader->PayloadType = 120;
1152	break;	1152	break;
1153	case CODEC_ID_MPEG4:	1153	case AV_CODEC_ID_MPEG4:
1154	tRtpHeader->PayloadType = 121;	1154	tRtpHeader->PayloadType = 121;
1155	break;	1155	break;
1156	case CODEC_ID_THEORA:	1156	case AV_CODEC_ID_THEORA:
1157	tRtpHeader->PayloadType = 122;	1157	tRtpHeader->PayloadType = 122;
1158	break;	1158	break;
1159	case CODEC_ID_VP8:	1159	case AV_CODEC_ID_VP8:
1160	tRtpHeader->PayloadType = 123;	1160	tRtpHeader->PayloadType = 123;
1161	break;	1161	break;
1162	// case CODEC_ID_MPEG2TS:	1162	// case AV_CODEC_ID_MPEG2TS:
1163	// case CODEC_ID_VORBIS:	1163	// case AV_CODEC_ID_VORBIS:
1164	}	1164	}
1165		1165
1166	//#################################################################################	1166	//#################################################################################
Lines 1421-1427 Link Here
1421		1421
1422	// clock rate adaption	1422	// clock rate adaption
1423	tResult = mRemoteTimestamp / CalculateClockRateFactor();	1423	tResult = mRemoteTimestamp / CalculateClockRateFactor();
1424	if (mStreamCodecID == CODEC_ID_ADPCM_G722)	1424	if (mStreamCodecID == AV_CODEC_ID_ADPCM_G722)
1425	tResult *= 2; // transform from 8 kHz to 16kHz	1425	tResult *= 2; // transform from 8 kHz to 16kHz
1426		1426
1427	return tResult;	1427	return tResult;
Lines 1435-1441 Link Here
1435		1435
1436	// clock rate adaption	1436	// clock rate adaption
1437	pReferencePts = mRtcpLastRemoteTimestamp / CalculateClockRateFactor();	1437	pReferencePts = mRtcpLastRemoteTimestamp / CalculateClockRateFactor();
1438	if (mStreamCodecID == CODEC_ID_ADPCM_G722)	1438	if (mStreamCodecID == AV_CODEC_ID_ADPCM_G722)
1439	pReferencePts *= 2; // transform from 8 kHz to 16kHz	1439	pReferencePts *= 2; // transform from 8 kHz to 16kHz
1440		1440
1441	mSynchDataMutex.unlock();	1441	mSynchDataMutex.unlock();
Lines 1462-1490 Link Here
1462		1462
1463	switch(mStreamCodecID)	1463	switch(mStreamCodecID)
1464	{	1464	{
1465	case CODEC_ID_PCM_MULAW:	1465	case AV_CODEC_ID_PCM_MULAW:
1466	case CODEC_ID_PCM_ALAW:	1466	case AV_CODEC_ID_PCM_ALAW:
1467	case CODEC_ID_PCM_S16BE:	1467	case AV_CODEC_ID_PCM_S16BE:
1468	case CODEC_ID_MP3:	1468	case AV_CODEC_ID_MP3:
1469	case CODEC_ID_ADPCM_G722:	1469	case AV_CODEC_ID_ADPCM_G722:
1470	// case CODEC_ID_ADPCM_G726:	1470	// case AV_CODEC_ID_ADPCM_G726:
1471	case CODEC_ID_THEORA:	1471	case AV_CODEC_ID_THEORA:
1472	tResult = 1;	1472	tResult = 1;
1473	break;	1473	break;
1474	case CODEC_ID_H261:	1474	case AV_CODEC_ID_H261:
1475	case CODEC_ID_H263:	1475	case AV_CODEC_ID_H263:
1476	case CODEC_ID_H263P:	1476	case AV_CODEC_ID_H263P:
1477	case CODEC_ID_H264:	1477	case AV_CODEC_ID_H264:
1478	case CODEC_ID_MPEG1VIDEO:	1478	case AV_CODEC_ID_MPEG1VIDEO:
1479	case CODEC_ID_MPEG2VIDEO:	1479	case AV_CODEC_ID_MPEG2VIDEO:
1480	case CODEC_ID_MPEG4: //TODO: mpeg 4 is buggy?	1480	case AV_CODEC_ID_MPEG4: //TODO: mpeg 4 is buggy?
1481	tResult = 90;	1481	tResult = 90;
1482	break;	1482	break;
1483	case CODEC_ID_VP8:	1483	case AV_CODEC_ID_VP8:
1484	tResult = 1; //TODO	1484	tResult = 1; //TODO
1485	break;	1485	break;
1486	// case CODEC_ID_MPEG2TS:	1486	// case AV_CODEC_ID_MPEG2TS:
1487	// case CODEC_ID_VORBIS:	1487	// case AV_CODEC_ID_VORBIS:
1488	default:	1488	default:
1489	break;	1489	break;
1490	}	1490	}
Lines 1498-1546 Link Here
1498		1498
1499	switch(mStreamCodecID)	1499	switch(mStreamCodecID)
1500	{	1500	{
1501	case CODEC_ID_PCM_MULAW:	1501	case AV_CODEC_ID_PCM_MULAW:
1502	if (pType == 0)	1502	if (pType == 0)
1503	tResult = true;	1503	tResult = true;
1504	break;	1504	break;
1505	case CODEC_ID_PCM_ALAW:	1505	case AV_CODEC_ID_PCM_ALAW:
1506	if (pType == 8)	1506	if (pType == 8)
1507	tResult = true;	1507	tResult = true;
1508	break;	1508	break;
1509	case CODEC_ID_ADPCM_G722:	1509	case AV_CODEC_ID_ADPCM_G722:
1510	if (pType == 9)	1510	if (pType == 9)
1511	tResult = true;	1511	tResult = true;
1512	break;	1512	break;
1513	// case CODEC_ID_ADPCM_G726:	1513	// case AV_CODEC_ID_ADPCM_G726:
1514	case CODEC_ID_PCM_S16BE:	1514	case AV_CODEC_ID_PCM_S16BE:
1515	if (pType == 10)	1515	if (pType == 10)
1516	tResult = true;	1516	tResult = true;
1517	break;	1517	break;
1518	case CODEC_ID_MP3:	1518	case AV_CODEC_ID_MP3:
1519	if (pType == 14)	1519	if (pType == 14)
1520	tResult = true;	1520	tResult = true;
1521	break;	1521	break;
1522	case CODEC_ID_H261:	1522	case AV_CODEC_ID_H261:
1523	if (pType == 31)	1523	if (pType == 31)
1524	tResult = true;	1524	tResult = true;
1525	break;	1525	break;
1526	case CODEC_ID_MPEG1VIDEO:	1526	case AV_CODEC_ID_MPEG1VIDEO:
1527	case CODEC_ID_MPEG2VIDEO:	1527	case AV_CODEC_ID_MPEG2VIDEO:
1528	if (pType == 32)	1528	if (pType == 32)
1529	tResult = true;	1529	tResult = true;
1530	break;	1530	break;
1531	case CODEC_ID_H263:	1531	case AV_CODEC_ID_H263:
1532	if ((pType == 34) \|\| (pType >= 96))	1532	if ((pType == 34) \|\| (pType >= 96))
1533	tResult = true;	1533	tResult = true;
1534	break;	1534	break;
1535	case CODEC_ID_AAC:	1535	case AV_CODEC_ID_AAC:
1536	case CODEC_ID_AMR_NB:	1536	case AV_CODEC_ID_AMR_NB:
1537	case CODEC_ID_H263P:	1537	case AV_CODEC_ID_H263P:
1538	case CODEC_ID_H264:	1538	case AV_CODEC_ID_H264:
1539	case CODEC_ID_MPEG4:	1539	case AV_CODEC_ID_MPEG4:
1540	case CODEC_ID_THEORA:	1540	case AV_CODEC_ID_THEORA:
1541	case CODEC_ID_VP8:	1541	case AV_CODEC_ID_VP8:
1542	// case CODEC_ID_MPEG2TS:	1542	// case AV_CODEC_ID_MPEG2TS:
1543	// case CODEC_ID_VORBIS:	1543	// case AV_CODEC_ID_VORBIS:
1544	if (pType >= 96)	1544	if (pType >= 96)
1545	tResult = true;	1545	tResult = true;
1546	break;	1546	break;
Lines 1552-1558 Link Here
1552	}	1552	}
1553		1553
1554	// assumption: we are getting one single RTP encapsulated packet, not auto detection of following additional packets included	1554	// assumption: we are getting one single RTP encapsulated packet, not auto detection of following additional packets included
1555	bool RTP::RtpParse(char *&pData, int &pDataSize, bool &pIsLastFragment, enum RtcpType &pRtcpType, enum CodecID pCodecId, bool pLoggingOnly)	1555	bool RTP::RtpParse(char *&pData, int &pDataSize, bool &pIsLastFragment, enum RtcpType &pRtcpType, enum AVCodecID pCodecId, bool pLoggingOnly)
1556	{	1556	{
1557	pIsLastFragment = false;	1557	pIsLastFragment = false;
1558		1558
Lines 1563-1569 Link Here
1563	bool tOldH263PayloadDetected = false;	1563	bool tOldH263PayloadDetected = false;
1564	char *tRtpPacketStart = pData;	1564	char *tRtpPacketStart = pData;
1565		1565
1566	if ((mStreamCodecID != CODEC_ID_NONE) && (mStreamCodecID != pCodecId))	1566	if ((mStreamCodecID != AV_CODEC_ID_NONE) && (mStreamCodecID != pCodecId))
1567	LOG(LOG_WARN, "Codec change from %d(%s) to %d(%s) in inout stream detected", mStreamCodecID, avcodec_get_name(mStreamCodecID), pCodecId, avcodec_get_name(pCodecId));	1567	LOG(LOG_WARN, "Codec change from %d(%s) to %d(%s) in inout stream detected", mStreamCodecID, avcodec_get_name(mStreamCodecID), pCodecId, avcodec_get_name(pCodecId));
1568		1568
1569	mStreamCodecID = pCodecId;	1569	mStreamCodecID = pCodecId;
Lines 1572-1596 Link Here
1572	switch(mStreamCodecID)	1572	switch(mStreamCodecID)
1573	{	1573	{
1574	//supported audio codecs	1574	//supported audio codecs
1575	case CODEC_ID_AMR_NB:	1575	case AV_CODEC_ID_AMR_NB:
1576	case CODEC_ID_PCM_MULAW:	1576	case AV_CODEC_ID_PCM_MULAW:
1577	case CODEC_ID_PCM_ALAW:	1577	case AV_CODEC_ID_PCM_ALAW:
1578	case CODEC_ID_PCM_S16BE:	1578	case AV_CODEC_ID_PCM_S16BE:
1579	case CODEC_ID_MP3:	1579	case AV_CODEC_ID_MP3:
1580	case CODEC_ID_ADPCM_G722:	1580	case AV_CODEC_ID_ADPCM_G722:
1581	// case CODEC_ID_ADPCM_G726:	1581	// case AV_CODEC_ID_ADPCM_G726:
1582	//supported video codecs	1582	//supported video codecs
1583	case CODEC_ID_H261:	1583	case AV_CODEC_ID_H261:
1584	case CODEC_ID_H263:	1584	case AV_CODEC_ID_H263:
1585	case CODEC_ID_H263P:	1585	case AV_CODEC_ID_H263P:
1586	case CODEC_ID_H264:	1586	case AV_CODEC_ID_H264:
1587	case CODEC_ID_MPEG1VIDEO:	1587	case AV_CODEC_ID_MPEG1VIDEO:
1588	case CODEC_ID_MPEG2VIDEO:	1588	case AV_CODEC_ID_MPEG2VIDEO:
1589	case CODEC_ID_MPEG4:	1589	case AV_CODEC_ID_MPEG4:
1590	case CODEC_ID_THEORA:	1590	case AV_CODEC_ID_THEORA:
1591	case CODEC_ID_VP8:	1591	case AV_CODEC_ID_VP8:
1592	// case CODEC_ID_MPEG2TS:	1592	// case AV_CODEC_ID_MPEG2TS:
1593	// case CODEC_ID_VORBIS:	1593	// case AV_CODEC_ID_VORBIS:
1594	break;	1594	break;
1595	default:	1595	default:
1596	LOG(LOG_ERROR, "Codec %d is unsupported by internal RTP parser", mStreamCodecID);	1596	LOG(LOG_ERROR, "Codec %d is unsupported by internal RTP parser", mStreamCodecID);
Lines 1921-1934 Link Here
1921	switch(mStreamCodecID)	1921	switch(mStreamCodecID)
1922	{	1922	{
1923	// audio	1923	// audio
1924	case CODEC_ID_AMR_NB:	1924	case AV_CODEC_ID_AMR_NB:
1925	#ifdef RTP_DEBUG_PACKET_DECODER	1925	#ifdef RTP_DEBUG_PACKET_DECODER
1926	LOG(LOG_VERBOSE, "#################### AMR-NB header #######################");	1926	LOG(LOG_VERBOSE, "#################### AMR-NB header #######################");
1927	LOG(LOG_VERBOSE, "No additional information");//TODO	1927	LOG(LOG_VERBOSE, "No additional information");//TODO
1928	#endif	1928	#endif
1929	mIntermediateFragment = false;//TODO	1929	mIntermediateFragment = false;//TODO
1930	break;	1930	break;
1931	case CODEC_ID_PCM_ALAW:	1931	case AV_CODEC_ID_PCM_ALAW:
1932	#ifdef RTP_DEBUG_PACKET_DECODER	1932	#ifdef RTP_DEBUG_PACKET_DECODER
1933	LOG(LOG_VERBOSE, "#################### PCMA header #######################");	1933	LOG(LOG_VERBOSE, "#################### PCMA header #######################");
1934	LOG(LOG_VERBOSE, "No additional information");	1934	LOG(LOG_VERBOSE, "No additional information");
Lines 1936-1942 Link Here
1936	// no fragmentation because our encoder sends raw data	1936	// no fragmentation because our encoder sends raw data
1937	mIntermediateFragment = false;	1937	mIntermediateFragment = false;
1938	break;	1938	break;
1939	case CODEC_ID_PCM_MULAW:	1939	case AV_CODEC_ID_PCM_MULAW:
1940	#ifdef RTP_DEBUG_PACKET_DECODER	1940	#ifdef RTP_DEBUG_PACKET_DECODER
1941	LOG(LOG_VERBOSE, "#################### PCMU header #######################");	1941	LOG(LOG_VERBOSE, "#################### PCMU header #######################");
1942	LOG(LOG_VERBOSE, "No additional information");	1942	LOG(LOG_VERBOSE, "No additional information");
Lines 1944-1950 Link Here
1944	// no fragmentation because our encoder sends raw data	1944	// no fragmentation because our encoder sends raw data
1945	mIntermediateFragment = false;	1945	mIntermediateFragment = false;
1946	break;	1946	break;
1947	case CODEC_ID_PCM_S16BE:	1947	case AV_CODEC_ID_PCM_S16BE:
1948	#ifdef RTP_DEBUG_PACKET_DECODER	1948	#ifdef RTP_DEBUG_PACKET_DECODER
1949	LOG(LOG_VERBOSE, "#################### PCM_S16BE header #######################");	1949	LOG(LOG_VERBOSE, "#################### PCM_S16BE header #######################");
1950	LOG(LOG_VERBOSE, "No additional information");	1950	LOG(LOG_VERBOSE, "No additional information");
Lines 1952-1958 Link Here
1952	// no fragmentation because our encoder sends raw data	1952	// no fragmentation because our encoder sends raw data
1953	mIntermediateFragment = false;	1953	mIntermediateFragment = false;
1954	break;	1954	break;
1955	case CODEC_ID_ADPCM_G722:	1955	case AV_CODEC_ID_ADPCM_G722:
1956	#ifdef RTP_DEBUG_PACKET_DECODER	1956	#ifdef RTP_DEBUG_PACKET_DECODER
1957	LOG(LOG_VERBOSE, "#################### G.722 header #######################");	1957	LOG(LOG_VERBOSE, "#################### G.722 header #######################");
1958	LOG(LOG_VERBOSE, "No additional information");	1958	LOG(LOG_VERBOSE, "No additional information");
Lines 1960-1967 Link Here
1960	// no fragmentation because our encoder sends raw data	1960	// no fragmentation because our encoder sends raw data
1961	mIntermediateFragment = false;	1961	mIntermediateFragment = false;
1962	break;	1962	break;
1963	// case CODEC_ID_ADPCM_G726:	1963	// case AV_CODEC_ID_ADPCM_G726:
1964	case CODEC_ID_MP3:	1964	case AV_CODEC_ID_MP3:
1965	// convert from network to host byte order	1965	// convert from network to host byte order
1966	tMPAHeader->Data[0] = ntohl(tMPAHeader->Data[0]);	1966	tMPAHeader->Data[0] = ntohl(tMPAHeader->Data[0]);
1967		1967
Lines 2022-2028 Link Here
2022		2022
2023	break;	2023	break;
2024	// video	2024	// video
2025	case CODEC_ID_H261:	2025	case AV_CODEC_ID_H261:
2026	#ifdef RTP_DEBUG_PACKET_DECODER	2026	#ifdef RTP_DEBUG_PACKET_DECODER
2027	// convert from network to host byte order	2027	// convert from network to host byte order
2028	tH261Header->Data[0] = ntohl(tH261Header->Data[0]);	2028	tH261Header->Data[0] = ntohl(tH261Header->Data[0]);
Lines 2051-2058 Link Here
2051	// go to the start of the h261 payload	2051	// go to the start of the h261 payload
2052	pData += H261_HEADER_SIZE;	2052	pData += H261_HEADER_SIZE;
2053	break;	2053	break;
2054	case CODEC_ID_H263:	2054	case AV_CODEC_ID_H263:
2055	case CODEC_ID_H263P:	2055	case AV_CODEC_ID_H263P:
2056	// HINT: do we have RTP packets with payload id 34?	2056	// HINT: do we have RTP packets with payload id 34?
2057	// => yes: parse rtp packet according to RFC2190	2057	// => yes: parse rtp packet according to RFC2190
2058	// => no: parse rtp packet according to RFC4629	2058	// => no: parse rtp packet according to RFC4629
Lines 2165-2171 Link Here
2165	}	2165	}
2166	}	2166	}
2167	break;	2167	break;
2168	case CODEC_ID_H264:	2168	case AV_CODEC_ID_H264:
2169	// convert from network to host byte order	2169	// convert from network to host byte order
2170	tH264Header->Data[0] = ntohl(tH264Header->Data[0]);	2170	tH264Header->Data[0] = ntohl(tH264Header->Data[0]);
2171		2171
Lines 2269-2276 Link Here
2269	}	2269	}
2270		2270
2271	break;	2271	break;
2272	case CODEC_ID_MPEG1VIDEO:	2272	case AV_CODEC_ID_MPEG1VIDEO:
2273	case CODEC_ID_MPEG2VIDEO:	2273	case AV_CODEC_ID_MPEG2VIDEO:
2274	// convert from network to host byte order	2274	// convert from network to host byte order
2275	tMPVHeader->Data[0] = ntohl(tMPVHeader->Data[0]);	2275	tMPVHeader->Data[0] = ntohl(tMPVHeader->Data[0]);
2276		2276
Lines 2312-2324 Link Here
2312	// convert from host to network byte order	2312	// convert from host to network byte order
2313	tMPVHeader->Data[0] = htonl(tMPVHeader->Data[0]);	2313	tMPVHeader->Data[0] = htonl(tMPVHeader->Data[0]);
2314	break;	2314	break;
2315	case CODEC_ID_MPEG4:	2315	case AV_CODEC_ID_MPEG4:
2316	#ifdef RTP_DEBUG_PACKET_DECODER	2316	#ifdef RTP_DEBUG_PACKET_DECODER
2317	LOG(LOG_VERBOSE, "#################### MPEG4 header #######################");	2317	LOG(LOG_VERBOSE, "#################### MPEG4 header #######################");
2318	LOG(LOG_VERBOSE, "No additional information");	2318	LOG(LOG_VERBOSE, "No additional information");
2319	#endif	2319	#endif
2320	break;	2320	break;
2321	case CODEC_ID_THEORA:	2321	case AV_CODEC_ID_THEORA:
2322	// convert from network to host byte order	2322	// convert from network to host byte order
2323	tTHEORAHeader->Data[0] = ntohl(tTHEORAHeader->Data[0]);	2323	tTHEORAHeader->Data[0] = ntohl(tTHEORAHeader->Data[0]);
2324	pData += sizeof(THEORAHeader);	2324	pData += sizeof(THEORAHeader);
Lines 2350-2356 Link Here
2350	// convert from host to network byte order	2350	// convert from host to network byte order
2351	tTHEORAHeader->Data[0] = htonl(tTHEORAHeader->Data[0]);	2351	tTHEORAHeader->Data[0] = htonl(tTHEORAHeader->Data[0]);
2352	break;	2352	break;
2353	case CODEC_ID_VP8:	2353	case AV_CODEC_ID_VP8:
2354	pData++; // default VP 8 header = 1 byte	2354	pData++; // default VP 8 header = 1 byte
2355		2355
2356	// do we have extended control bits?	2356	// do we have extended control bits?
Lines 2379-2386 Link Here
2379	LOG(LOG_VERBOSE, "Start of partition: %d", tVP8Header->S);	2379	LOG(LOG_VERBOSE, "Start of partition: %d", tVP8Header->S);
2380	#endif	2380	#endif
2381	break;	2381	break;
2382	// case CODEC_ID_MPEG2TS:	2382	// case AV_CODEC_ID_MPEG2TS:
2383	// case CODEC_ID_VORBIS:	2383	// case AV_CODEC_ID_VORBIS:
2384	default:	2384	default:
2385	LOG(LOG_ERROR, "Unsupported codec %d dropped by internal RTP parser", mStreamCodecID);	2385	LOG(LOG_ERROR, "Unsupported codec %d dropped by internal RTP parser", mStreamCodecID);
2386	break;	2386	break;
Lines 2793-2799 Link Here
2793	LOG(LOG_VERBOSE, "New synchronization for %d codec: %u, clock: %.2f, RTP timestamp: %.2f, timestamp offset: %lu", mStreamCodecID, pReferencePts, CalculateClockRateFactor(), (float)pReferencePts * CalculateClockRateFactor(), mLocalTimestampOffset);	2793	LOG(LOG_VERBOSE, "New synchronization for %d codec: %u, clock: %.2f, RTP timestamp: %.2f, timestamp offset: %lu", mStreamCodecID, pReferencePts, CalculateClockRateFactor(), (float)pReferencePts * CalculateClockRateFactor(), mLocalTimestampOffset);
2794	#endif	2794	#endif
2795		2795
2796	if (mStreamCodecID == CODEC_ID_ADPCM_G722)	2796	if (mStreamCodecID == AV_CODEC_ID_ADPCM_G722)
2797	pReferencePts /= 2; // transform from 16 kHz to 8kHz	2797	pReferencePts /= 2; // transform from 16 kHz to 8kHz
2798		2798
2799	mSyncDataMutex.lock();	2799	mSyncDataMutex.lock();

Return to bug 476536