/*
 * Copyright (C) 2001 Carlos Hasan.
 * Copyright (C) 2001 François Revol.
 * Copyright (C) 2001 Axel Dörfler.
 * Copyright (C) 2004 Marcus Overhagen.
 * Copyright (C) 2009 Stephan Aßmus <superstippi@gmx.de>.
 * Copyright (C) 2015 Adrien Destugues <pulkomandy@pulkomandy.tk>.
 *
 * All rights reserved. Distributed under the terms of the MIT License.
 */
#ifndef AVCODEC_DECODER_H
#define AVCODEC_DECODER_H

//! libavcodec based decoder for Haiku


#include <MediaFormats.h>


extern "C" {
	#include "avcodec.h"
	#include "avfilter.h"
	#include "buffersink.h"
	#include "buffersrc.h"
	#include "imgutils.h"
	#include "swresample.h"
	#include "swscale.h"
	#include "timestamp.h"
}


#include "DecoderPlugin.h"
#include "ReaderPlugin.h"

#include "CodecTable.h"
#include "gfx_util.h"


#if 1
#define USE_SWS_FOR_COLOR_SPACE_CONVERSION 1
#else
#define USE_SWS_FOR_COLOR_SPACE_CONVERSION 0
// NOTE: David's color space conversion is much faster than the FFmpeg
// version. Perhaps the SWS code can be used for unsupported conversions?
// Otherwise the alternative code could simply be removed from this file.
#endif


class AVCodecDecoder : public Decoder {
public:
						AVCodecDecoder();

	virtual				~AVCodecDecoder();

	virtual	void		GetCodecInfo(media_codec_info* mci);

	virtual	status_t	Setup(media_format* ioEncodedFormat,
							const void* infoBuffer, size_t infoSize);

	virtual	status_t	NegotiateOutputFormat(media_format* inOutFormat);

	virtual	status_t	Decode(void* outBuffer, int64* outFrameCount,
							media_header* mediaHeader,
							media_decode_info* info);

	virtual	status_t	SeekedTo(int64 trame, bigtime_t time);


private:
			void		_ResetTempPacket();

			status_t	_NegotiateAudioOutputFormat(media_format* inOutFormat);

			status_t	_NegotiateVideoOutputFormat(media_format* inOutFormat);

			status_t	_DecodeAudio(void* outBuffer, int64* outFrameCount,
							media_header* mediaHeader,
							media_decode_info* info);

			status_t	_DecodeVideo(void* outBuffer, int64* outFrameCount,
							media_header* mediaHeader,
							media_decode_info* info);

			status_t	_DecodeNextAudioFrame();
			void		_ApplyEssentialAudioContainerPropertiesToContext();
			status_t	_ResetRawDecodedAudio();
			void		_CheckAndFixConditionsThatHintAtBrokenAudioCodeBelow();
			void		_MoveAudioFramesToRawDecodedAudioAndUpdateStartTimes();
			status_t	_DecodeNextAudioFrameChunk();
			status_t	_DecodeSomeAudioFramesIntoEmptyDecodedDataBuffer();
			void		_UpdateMediaHeaderForAudioFrame();

			status_t	_DecodeNextVideoFrame();
			void		_ApplyEssentialVideoContainerPropertiesToContext();
			status_t	_LoadNextChunkIfNeededAndAssignStartTime();
			status_t	_CopyChunkToChunkBufferAndAddPadding(const void* chunk,
							size_t chunkSize);
			status_t	_HandleNewVideoFrameAndUpdateSystemState();
			status_t	_FlushOneVideoFrameFromDecoderBuffer();
			void		_UpdateMediaHeaderForVideoFrame();
			status_t	_DeinterlaceAndColorConvertVideoFrame();

			// video deinterlace filter graph
			status_t	_InitFilterGraph(enum AVPixelFormat pixfmt,
							int32 width, int32 height);
			status_t	_ProcessFilterGraph(AVFrame *dst,
							const AVFrame *src, enum AVPixelFormat pixfmt,
							int32 width, int32 height);

			media_header		fHeader;
									// Contains the properties of the current
									// decoded audio / video frame

			media_format		fInputFormat;

			int64				fFrame;
			bool				fIsAudio;

			// FFmpeg related members
			const AVCodec*		fCodec;
			AVCodecContext*		fCodecContext;
			SwrContext*			fResampleContext;
			uint8_t*			fDecodedData;
			size_t				fDecodedDataSizeInBytes;
			AVFrame*			fPostProcessedDecodedPicture;
			AVFrame*			fRawDecodedPicture;
			AVFrame*			fRawDecodedAudio;

			bool 				fCodecInitDone;

			gfx_convert_func	fFormatConversionFunc;
#if USE_SWS_FOR_COLOR_SPACE_CONVERSION
			SwsContext*			fSwsContext;
#endif

			char*				fExtraData;
			int					fExtraDataSize;
			int					fBlockAlign;

			color_space			fOutputColorSpace;
			int32				fOutputFrameCount;
			float				fOutputFrameRate;
									// only for audio streams
			int					fOutputFrameSize;
									// sample size * channel count
			int					fInputFrameSize;
									// sample size * channel count
									// or just sample size for planar formats

			uint8_t*			fChunkBuffer;
			size_t				fChunkBufferSize;
			bool				fAudioDecodeError;

			AVFrame*			fDecodedDataBuffer;
			int32				fDecodedDataBufferOffset;
			int32				fDecodedDataBufferSize;

			AVPacket*			fTempPacket;

			// video deinterlace feature
			AVFilterContext*	fBufferSinkContext;
			AVFilterContext*	fBufferSourceContext;
			AVFilterGraph*		fFilterGraph;
			AVFrame*			fFilterFrame;
			int32				fLastWidth;
			int32				fLastHeight;
			enum AVPixelFormat	fLastPixfmt;
};

#endif // AVCODEC_DECODER_H