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


#include <MediaFormats.h>

namespace BPrivate {
        namespace media {
                class Encoder;
                class EncoderPlugin;
        }
}

using namespace BPrivate::media;


class BMediaEncoder {
public:
                                                                BMediaEncoder();
                                                                BMediaEncoder(
                                                                        const media_format* outputFormat);
                                                                BMediaEncoder(const media_codec_info* info);
        virtual                                         ~BMediaEncoder();

                        status_t                        InitCheck() const;

                        status_t                        SetTo(const media_format* outputFormat);
                        status_t                        SetTo(const media_codec_info* info);
                        status_t                        SetFormat(media_format* inputFormat,
                                                                        media_format* outputFormat,
                                                                        media_file_format* fileFormat = NULL);

                        status_t                        Encode(const void* buffer, int64 frameCount,
                                                                        media_encode_info* info);

                        status_t                        GetEncodeParameters(
                                                                        encode_parameters* parameters) const;
                        status_t                        SetEncodeParameters(
                                                                        encode_parameters* parameters);

protected:
        virtual status_t                        WriteChunk(const void* buffer, size_t size,
                                                                        media_encode_info* info) = 0;

        virtual status_t                        AddTrackInfo(uint32 code, const char* data,
                                                                        size_t size);

        // TODO: Needs Perform() method for FBC!

private:
        // FBC padding and forbidden methods
        virtual status_t                        _Reserved_BMediaEncoder_0(int32 arg, ...);
        virtual status_t                        _Reserved_BMediaEncoder_1(int32 arg, ...);
        virtual status_t                        _Reserved_BMediaEncoder_2(int32 arg, ...);
        virtual status_t                        _Reserved_BMediaEncoder_3(int32 arg, ...);
        virtual status_t                        _Reserved_BMediaEncoder_4(int32 arg, ...);
        virtual status_t                        _Reserved_BMediaEncoder_5(int32 arg, ...);
        virtual status_t                        _Reserved_BMediaEncoder_6(int32 arg, ...);
        virtual status_t                        _Reserved_BMediaEncoder_7(int32 arg, ...);
        virtual status_t                        _Reserved_BMediaEncoder_8(int32 arg, ...);
        virtual status_t                        _Reserved_BMediaEncoder_9(int32 arg, ...);
        virtual status_t                        _Reserved_BMediaEncoder_10(int32 arg, ...);
        virtual status_t                        _Reserved_BMediaEncoder_11(int32 arg, ...);
        virtual status_t                        _Reserved_BMediaEncoder_12(int32 arg, ...);
        virtual status_t                        _Reserved_BMediaEncoder_13(int32 arg, ...);
        virtual status_t                        _Reserved_BMediaEncoder_14(int32 arg, ...);
        virtual status_t                        _Reserved_BMediaEncoder_15(int32 arg, ...);

                                                                BMediaEncoder(const BMediaEncoder& other);
                        BMediaEncoder&          operator=(const BMediaEncoder& other);

private:
                        status_t                        _AttachToEncoder();

        static  status_t                        write_chunk(void* classPtr,
                                                                        const void* buffer, size_t size,
                                                                        media_encode_info* info);

                        void                            Init();
                        void                            ReleaseEncoder();

                        uint32                          _reserved_was_fEncoderMgr;
                        Encoder*                        fEncoder;

                        int32                           fEncoderID;
                        bool                            fFormatValid;
                        bool                            fEncoderStarted;
                        status_t                        fInitStatus;

                        uint32                          _reserved_BMediaEncoder_[32];
};


class BMediaBufferEncoder : public BMediaEncoder {
public:
                                                                BMediaBufferEncoder();
                                                                BMediaBufferEncoder(
                                                                        const media_format* outputFormat);
                                                                BMediaBufferEncoder(
                                                                        const media_codec_info* info);

                        status_t                        EncodeToBuffer(void* outputBuffer,
                                                                        size_t* _size, const void* inputBuffer,
                                                                        int64 frameCount, media_encode_info* info);

protected:
        virtual status_t                        WriteChunk(const void* buffer, size_t size,
                                                                        media_encode_info* info);

protected:
                        void*                           fBuffer;
                        int32                           fBufferSize;
};

#endif // _MEDIA_ENCODER_H