/*
 * Copyright (c) 2004-2007 Marcus Overhagen <marcus@overhagen.de>
 *
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated documentation
 * files (the "Software"), to deal in the Software without restriction, 
 * including without limitation the rights to use, copy, modify, 
 * merge, publish, distribute, sublicense, and/or sell copies of 
 * the Software, and to permit persons to whom the Software is 
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be 
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 
 * OTHER DEALINGS IN THE SOFTWARE.
 */
#ifndef __DVB_MEDIA_NODE_H
#define __DVB_MEDIA_NODE_H


#include <OS.h>
#include <media/BufferProducer.h>
#include <media/Controllable.h>
#include <media/MediaDefs.h>
#include <media/MediaEventLooper.h>
#include <media/MediaNode.h>
#include <support/Locker.h>

#include "TransportStreamDemux.h"
#include "MediaStreamDecoder.h"
#include "DVBCard.h"
#include "StringList.h"

class BDiscreteParameter;
class BParameterGroup;
class PacketQueue;
class DVBCard;


class DVBMediaNode : public virtual BBufferProducer,
        public virtual BControllable, public virtual BMediaEventLooper {
public:
                                                DVBMediaNode(BMediaAddOn *addon,
                                                                const char *name, int32 internal_id, DVBCard *card);
virtual                                 ~DVBMediaNode();

virtual status_t                InitCheck() const { return fInitStatus; }

/* BMediaNode */
public:
virtual BMediaAddOn     *AddOn(int32 * internal_id) const;
virtual status_t        HandleMessage(int32 message, const void *data,
                                                        size_t size);
protected:      
virtual void            Preroll();
virtual void            SetTimeSource(BTimeSource * time_source);
virtual void            SetRunMode(run_mode mode);

/* BMediaEventLooper */
protected:
virtual void            NodeRegistered();
virtual void            Stop(bigtime_t performance_time, bool immediate);

virtual void            HandleEvent(const media_timed_event *event,
                                                        bigtime_t lateness, bool realTimeEvent = false);

/* BBufferProducer */                                                                   
protected:
virtual status_t        FormatSuggestionRequested(media_type type, int32 quality,
                                                        media_format * format);
virtual status_t        FormatProposal(const media_source &source,
                                                        media_format *format);
virtual status_t        FormatChangeRequested(const media_source &source,
                                                        const media_destination &destination,
                                                        media_format *io_format, int32 *_deprecated_);
virtual status_t        GetNextOutput(int32 * cookie, media_output * out_output);
virtual status_t        DisposeOutputCookie(int32 cookie);
virtual status_t        SetBufferGroup(const media_source &for_source,
                                                        BBufferGroup * group);
virtual status_t        VideoClippingChanged(const media_source &for_source,
                                                        int16 num_shorts, int16 *clip_data,
                                                        const media_video_display_info &display,
                                                        int32 * _deprecated_);
virtual status_t        GetLatency(bigtime_t * out_latency);
virtual status_t        PrepareToConnect(const media_source &what,
                                                        const media_destination &where,
                                                        media_format *format,
                                                        media_source *out_source, char *out_name);
virtual void            Connect(status_t error, const media_source &source,
                                                        const media_destination &destination,
                                                        const media_format & format, char *io_name);
virtual void            Disconnect(const media_source & what,
                                                        const media_destination & where);
virtual void            LateNoticeReceived(const media_source & what,
                                                        bigtime_t how_much, bigtime_t performance_time);
virtual void            EnableOutput(const media_source & what, bool enabled,
                                                        int32 * _deprecated_);
virtual status_t        SetPlayRate(int32 numer,int32 denom);
virtual void            AdditionalBufferRequested(const media_source & source,
                                                        media_buffer_id prev_buffer, bigtime_t prev_time,
                                                        const media_seek_tag * prev_tag);
virtual void            LatencyChanged(const media_source & source,
                                                        const media_destination & destination,
                                                        bigtime_t new_latency, uint32 flags);

/* BControllable */                                                                     
protected:
virtual status_t        GetParameterValue(int32 id, bigtime_t *last_change,
                                                        void *value, size_t *size);
virtual void            SetParameterValue(int32 id, bigtime_t when,
                                                        const void *value, size_t size);

/* state */
private:
                void                            HandleStart(bigtime_t performance_time);
                void                            HandleStop();
                void                            HandleTimeWarp(bigtime_t performance_time);
                void                            HandleSeek(bigtime_t performance_time);

                void                            InitDefaultFormats();
                void                            SpecializeFormatRawVideo(media_raw_video_format *format);
                void                            SpecializeFormatRawAudio(media_multi_audio_format *format);
                void                            SpecializeFormatEncVideo(media_encoded_video_format *format);
                void                            SpecializeFormatEncAudio(media_encoded_audio_format *format);
                void                            SpecializeFormatTS(media_multistream_format *format);

                bool                            VerifyFormatRawVideo(const media_raw_video_format &format);
                bool                            VerifyFormatRawAudio(const media_multi_audio_format &format);
                
                status_t                        GetStreamFormat(PacketQueue *queue, media_format *format);
                
                status_t                        SetOutput(const media_source &source, const media_destination &destination, const media_format &format);
                status_t                        ResetOutput(const media_source &source);
                const char *            SourceDefaultName(const media_source &source);
                
                BParameterWeb *         CreateParameterWeb();
                void                            SetAboutInfo(BParameterGroup *about);

                
                void                            RefreshParameterWeb();
                
                void                            LoadSettings();
                
                void                            AddStateItems(BDiscreteParameter *param);
                void                            AddRegionItems(BDiscreteParameter *param);
                void                            AddChannelItems(BDiscreteParameter *param);
                void                            AddAudioItems(BDiscreteParameter *param);
                
                void                            RefreshStateList();
                void                            RefreshRegionList();
                void                            RefreshChannelList();
                void                            RefreshAudioList();

                status_t                        StartCapture();
                status_t                        StopCapture();
                status_t                        StartCaptureThreads();
                status_t                        StopCaptureThreads();           
                status_t                        Tune();
                
                status_t                        ExtractTuningParams(const char *description, int audio_pid_index,
                                                                                                dvb_tuning_parameters_t *param, 
                                                                                                int *video_pid, int *audio_pid, int *pcr_pid);

                static int32            _card_reader_thread_(void *arg);
                static int32            _mpeg_demux_thread_(void *arg);
                static int32            _enc_audio_thread_(void *arg);
                static int32            _enc_video_thread_(void *arg);
                static int32            _mpeg_ts_thread_(void *arg);
                static int32            _raw_audio_thread_(void *arg);
                static int32            _raw_video_thread_(void *arg);

                void                            card_reader_thread();
                void                            mpeg_demux_thread();
                void                            enc_audio_thread();
                void                            enc_video_thread();
                void                            mpeg_ts_thread();
                void                            raw_audio_thread();
                void                            raw_video_thread();

                status_t                        GetNextVideoChunk(const void **chunkData, size_t *chunkLen, media_header *mh);
                status_t                        GetNextAudioChunk(const void **chunkData, size_t *chunkLen, media_header *mh);

                static status_t         _GetNextVideoChunk(const void **chunkData, size_t *chunkLen, media_header *mh, void *cookie);
                static status_t         _GetNextAudioChunk(const void **chunkData, size_t *chunkLen, media_header *mh, void *cookie);

                status_t                        fInitStatus;
                
                int32                           fInternalID;
                BMediaAddOn                     *fAddOn;
                
                bool                            fStopDisabled;

                bool                            fOutputEnabledRawVideo;
                bool                            fOutputEnabledRawAudio;
                bool                            fOutputEnabledEncVideo;
                bool                            fOutputEnabledEncAudio;
                bool                            fOutputEnabledTS;

                media_output            fOutputRawVideo;
                media_output            fOutputRawAudio;
                media_output            fOutputEncVideo;
                media_output            fOutputEncAudio;
                media_output            fOutputTS;
                
                media_format            fDefaultFormatRawVideo;
                media_format            fDefaultFormatRawAudio;
                media_format            fDefaultFormatEncVideo;
                media_format            fDefaultFormatEncAudio;
                media_format            fDefaultFormatTS;

                media_format            fRequiredFormatRawVideo;
                media_format            fRequiredFormatRawAudio;
                media_format            fRequiredFormatEncVideo;
                media_format            fRequiredFormatEncAudio;
                media_format            fRequiredFormatTS;
                
                PacketQueue *           fCardDataQueue; // holds MPEG TS data read from the card
                PacketQueue *           fRawVideoQueue; // holds encoded PES frames for video decoding
                PacketQueue *           fRawAudioQueue; // holds encoded PES frames for audio decoding
                PacketQueue *           fEncVideoQueue; // holds encoded PES frames for enc video out
                PacketQueue *           fEncAudioQueue; // holds encoded PES frames for enc audio out
                PacketQueue *           fMpegTsQueue;   // holds encoded PES frames for MPEG TS out
                
                DVBCard *                       fCard;
                
                bool                            fCaptureThreadsActive;
                
                thread_id                       fThreadIdCardReader;
                thread_id                       fThreadIdMpegDemux;
                thread_id                       fThreadIdRawAudio;
                thread_id                       fThreadIdRawVideo;
                thread_id                       fThreadIdEncAudio;
                thread_id                       fThreadIdEncVideo;
                thread_id                       fThreadIdMpegTS;
                
                volatile bool           fTerminateThreads;
                
                TransportStreamDemux * fDemux;
                
                BBufferGroup *          fBufferGroupRawVideo;
                BBufferGroup *          fBufferGroupRawAudio;
                
                BParameterWeb *         fWeb;
                
        dvb_tuning_parameters_t fTuningParam;
        dvb_type_t                              fInterfaceType;
        
                int                                     fAudioPid;
                int                                     fVideoPid;
                int                                     fPcrPid;
                
                bool                            fTuningSuccess;
                bool                            fCaptureActive;
                
                sem_id                          fVideoDelaySem;
                sem_id                          fAudioDelaySem;
                
                int                                     fSelectedState;
                int                                     fSelectedRegion;
                int                                     fSelectedChannel;
                int                                     fSelectedAudio;

                StringList *            fStateList;
                StringList *            fRegionList;
                StringList *            fChannelList;
                StringList *            fAudioList;
                
                MediaStreamDecoder *fVideoDecoder;
                MediaStreamDecoder *fAudioDecoder;

                Packet *                        fCurrentVideoPacket;
                Packet *                        fCurrentAudioPacket;

                BLocker lock;
                
                // used only for debugging:
                int                                     fVideoFile;
                int                                     fAudioFile;
                int                                     fRawAudioFile;
                int                                     fMpegTsFile;
};

#endif  // __DVB_MEDIA_NODE_H