/*
 * Copyright 2014, Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 */
#ifndef _MEDIA_RECORDER_H
#define _MEDIA_RECORDER_H


#include <MediaDefs.h>
#include <MediaNode.h>


namespace BPrivate { namespace media {
class BMediaRecorderNode;
}
}


class BMediaRecorder {
public:
        enum notification {
                B_WILL_START = 1,       // performance_time
                B_WILL_STOP,            // performance_time immediate
                B_WILL_SEEK,            // performance_time media_time
                B_WILL_TIMEWARP,        // real_time performance_time
        };

        typedef void                            (*ProcessFunc)(void* cookie,
                                                                        bigtime_t timestamp, void* data,
                                                                        size_t size, const media_format& format);

        typedef void                            (*NotifyFunc)(void* cookie,
                                                                        notification what, ...);

public:
                                                                BMediaRecorder(const char* name,
                                                                        media_type type
                                                                                = B_MEDIA_UNKNOWN_TYPE);

        virtual                                         ~BMediaRecorder();

                        status_t                        InitCheck() const;

                        status_t                        SetHooks(ProcessFunc recordFunc = NULL,
                                                                        NotifyFunc notifyFunc = NULL,
                                                                        void* cookie = NULL);

                        void                            SetAcceptedFormat(
                                                                        const media_format& format);
                        const media_format&     AcceptedFormat() const;

        virtual status_t                        Start(bool force = false);
        virtual status_t                        Stop(bool force = false);

        virtual status_t                        Connect(const media_format& format);

        virtual status_t                        Connect(const dormant_node_info& dormantInfo,
                                                                        const media_format& format);

        virtual status_t                        Connect(const media_node& node,
                                                                        const media_output* output = NULL,
                                                                        const media_format* format = NULL);

        virtual status_t                        Disconnect();

                        bool                            IsConnected() const;
                        bool                            IsRunning() const;

                        const media_format&     Format() const;

protected:
                        // Get the producer node source
                        const media_source&     MediaSource() const;
                        // This is the our own input
                        const media_input       MediaInput() const;

        virtual void                            BufferReceived(void* buffer, size_t size,
                                                                        const media_header& header);

                        status_t                        SetUpConnection(media_source outputSource);

private:

                        status_t                        _Connect(const media_node& mediaNode,
                                                                        const media_output* output,
                                                                        const media_format& format);

        virtual void                            _ReservedMediaRecorder0();
        virtual void                            _ReservedMediaRecorder1();
        virtual void                            _ReservedMediaRecorder2();
        virtual void                            _ReservedMediaRecorder3();
        virtual void                            _ReservedMediaRecorder4();
        virtual void                            _ReservedMediaRecorder5();
        virtual void                            _ReservedMediaRecorder6();
        virtual void                            _ReservedMediaRecorder7();

                        status_t                        fInitErr;

                        bool                            fConnected;
                        bool                            fRunning;
                        bool                            fReleaseOutputNode;

                        ProcessFunc                     fRecordHook;
                        NotifyFunc                      fNotifyHook;

                        media_node                      fOutputNode;
                        media_source            fOutputSource;

                        BPrivate::media::BMediaRecorderNode* fNode;

                        void*                           fBufferCookie;
                        uint32                          fPadding[32];

                        friend class            BPrivate::media::BMediaRecorderNode;
};

#endif  //      _MEDIA_RECORDER_H