/***********************************************************************
 * AUTHOR: Andrew Bachmann, Marcus Overhagen
 *   FILE: MediaDecoder.cpp
 *  DESCR: 
 ***********************************************************************/
#include <MediaDecoder.h>
#include <DecoderPlugin.h>
#include <new>
#include "PluginManager.h"
#include "MediaDebug.h"

/*************************************************************
 * public BMediaDecoder
 *************************************************************/

BMediaDecoder::BMediaDecoder()
 :      fDecoder(NULL),
        fInitStatus(B_NO_INIT)
{
}


BMediaDecoder::BMediaDecoder(const media_format *in_format,
                                                         const void *info,
                                                         size_t info_size)
 :      fDecoder(NULL),
        fInitStatus(B_NO_INIT)
{
        SetTo(in_format, info, info_size);
}


BMediaDecoder::BMediaDecoder(const media_codec_info *mci)
 :      fDecoder(NULL),
        fInitStatus(B_NO_INIT)
{
        SetTo(mci);
}


/* virtual */
BMediaDecoder::~BMediaDecoder()
{
        gPluginManager.DestroyDecoder(fDecoder);
}


status_t 
BMediaDecoder::InitCheck() const
{
        return fInitStatus;
}


status_t 
BMediaDecoder::SetTo(const media_format *in_format,
                                         const void *info,
                                         size_t info_size)
{
        gPluginManager.DestroyDecoder(fDecoder);
        fDecoder = NULL;

        status_t err = gPluginManager.CreateDecoder(&fDecoder, *in_format);
        if (err < B_OK)
                goto fail;

        err = AttachToDecoder();
        if (err < B_OK)
                goto fail;

        err = SetInputFormat(in_format, info, info_size);
        if (err < B_OK)
                goto fail;

        fInitStatus = B_OK;
        return B_OK;

fail:
        gPluginManager.DestroyDecoder(fDecoder);
        fDecoder = NULL;
        fInitStatus = B_NO_INIT;
        return err;
}


status_t 
BMediaDecoder::SetTo(const media_codec_info *mci)
{
        gPluginManager.DestroyDecoder(fDecoder);
        fDecoder = NULL;

        status_t err = gPluginManager.CreateDecoder(&fDecoder, *mci);
        if (err < B_OK)
                goto fail;

        err = AttachToDecoder();
        if (err < B_OK)
                goto fail;

        fInitStatus = B_OK;
        return B_OK;

fail:
        gPluginManager.DestroyDecoder(fDecoder);
        fDecoder = NULL;
        fInitStatus = B_NO_INIT;
        return err;
}


/**     SetInputFormat() sets the input data format to in_format.
 *      Unlike SetTo(), the SetInputFormat() function does not
 *      select a codec, so the currently-selected codec will
 *      continue to be used.  You should only use SetInputFormat()
 *      to refine the format settings if it will not require the
 *      use of a different decoder.
 */

status_t 
BMediaDecoder::SetInputFormat(const media_format *in_format,
                                                          const void *in_info,
                                                          size_t in_size)
{
        if (!fDecoder)
                return B_NO_INIT;

        media_format format = *in_format;
        return fDecoder->Setup(&format, in_info, in_size);
}


/**     SetOutputFormat() sets the format the decoder should output.
 *      On return, the output_format is changed to match the actual
 *      format that will be output; this can be different if you
 *      specified any wildcards.
 */

status_t 
BMediaDecoder::SetOutputFormat(media_format *output_format)
{
        if (!fDecoder)
                return B_NO_INIT;

        return fDecoder->NegotiateOutputFormat(output_format);
}


/**     Decodes a chunk of media data into the output buffer specified
 *      by out_buffer.  On return, out_frameCount is set to indicate how
 *      many frames of data were decoded, and out_mh is the header for
 *      the decoded buffer.  The media_decode_info structure info is used
 *      on input to specify decoding parameters.
 *
 *      The amount of data decoded is part of the format determined by
 *      SetTo() or SetInputFormat().  For audio, it's the buffer_size.
 *      For video, it's one frame, which is height*row_bytes.  The data
 *      to be decoded will be fetched from the source by the decoder
 *      add-on calling the derived class' GetNextChunk() function.
 */

status_t 
BMediaDecoder::Decode(void *out_buffer, 
                                          int64 *out_frameCount,
                                          media_header *out_mh, 
                                          media_decode_info *info)
{
        if (!fDecoder)
                return B_NO_INIT;

        return fDecoder->Decode(out_buffer, out_frameCount, out_mh, info);
}


status_t 
BMediaDecoder::GetDecoderInfo(media_codec_info *out_info) const
{
        if (!fDecoder)
                return B_NO_INIT;

        return gPluginManager.GetDecoderInfo(fDecoder, out_info);
}


/*************************************************************
 * protected BMediaDecoder
 *************************************************************/


/*************************************************************
 * private BMediaDecoder
 *************************************************************/

/*
// unimplemented
BMediaDecoder::BMediaDecoder(const BMediaDecoder &);
BMediaDecoder::BMediaDecoder & operator=(const BMediaDecoder &);
*/

status_t
BMediaDecoder::AttachToDecoder()
{
        class MediaDecoderChunkProvider : public ChunkProvider {
        private:
                BMediaDecoder * fDecoder;
        public:
                MediaDecoderChunkProvider(BMediaDecoder * decoder) {
                        fDecoder = decoder;
                }
                virtual status_t GetNextChunk(const void **chunkBuffer, size_t *chunkSize,
                                              media_header *mediaHeader) {
                        return fDecoder->GetNextChunk(chunkBuffer, chunkSize, mediaHeader);
                }
        } * provider = new(std::nothrow) MediaDecoderChunkProvider(this);
        
        if (!provider)
                return B_NO_MEMORY;
        
        fDecoder->SetChunkProvider(provider);
        return B_OK;
}


status_t BMediaDecoder::_Reserved_BMediaDecoder_0(int32 arg, ...) { return B_ERROR; }
status_t BMediaDecoder::_Reserved_BMediaDecoder_1(int32 arg, ...) { return B_ERROR; }
status_t BMediaDecoder::_Reserved_BMediaDecoder_2(int32 arg, ...) { return B_ERROR; }
status_t BMediaDecoder::_Reserved_BMediaDecoder_3(int32 arg, ...) { return B_ERROR; }
status_t BMediaDecoder::_Reserved_BMediaDecoder_4(int32 arg, ...) { return B_ERROR; }
status_t BMediaDecoder::_Reserved_BMediaDecoder_5(int32 arg, ...) { return B_ERROR; }
status_t BMediaDecoder::_Reserved_BMediaDecoder_6(int32 arg, ...) { return B_ERROR; }
status_t BMediaDecoder::_Reserved_BMediaDecoder_7(int32 arg, ...) { return B_ERROR; }
status_t BMediaDecoder::_Reserved_BMediaDecoder_8(int32 arg, ...) { return B_ERROR; }
status_t BMediaDecoder::_Reserved_BMediaDecoder_9(int32 arg, ...) { return B_ERROR; }
status_t BMediaDecoder::_Reserved_BMediaDecoder_10(int32 arg, ...) { return B_ERROR; }
status_t BMediaDecoder::_Reserved_BMediaDecoder_11(int32 arg, ...) { return B_ERROR; }
status_t BMediaDecoder::_Reserved_BMediaDecoder_12(int32 arg, ...) { return B_ERROR; }
status_t BMediaDecoder::_Reserved_BMediaDecoder_13(int32 arg, ...) { return B_ERROR; }
status_t BMediaDecoder::_Reserved_BMediaDecoder_14(int32 arg, ...) { return B_ERROR; }
status_t BMediaDecoder::_Reserved_BMediaDecoder_15(int32 arg, ...) { return B_ERROR; }

/*************************************************************
 * public BMediaBufferDecoder
 *************************************************************/

BMediaBufferDecoder::BMediaBufferDecoder()
 :      BMediaDecoder()
 ,      fBufferSize(0)
{
}


BMediaBufferDecoder::BMediaBufferDecoder(const media_format *in_format,
                                                                                 const void *info,
                                                                                 size_t info_size)
 :      BMediaDecoder(in_format, info, info_size)
 ,      fBufferSize(0)
{
}


BMediaBufferDecoder::BMediaBufferDecoder(const media_codec_info *mci)
 :      BMediaDecoder(mci)
 ,      fBufferSize(0)
{
}


status_t 
BMediaBufferDecoder::DecodeBuffer(const void *input_buffer, 
                                                                  size_t input_size,
                                                                  void *out_buffer, 
                                                                  int64 *out_frameCount,
                                                                  media_header *out_mh,
                                                                  media_decode_info *info)
{
        fBuffer = input_buffer;
        fBufferSize = input_size;
        return Decode(out_buffer, out_frameCount, out_mh,info);
}


/*************************************************************
 * protected BMediaBufferDecoder
 *************************************************************/

/* virtual */
status_t
BMediaBufferDecoder::GetNextChunk(const void **chunkData,
                                                                  size_t *chunkLen,
                                  media_header *mh)
{
        if (!fBufferSize)
                return B_LAST_BUFFER_ERROR;

        *chunkData = fBuffer;
        *chunkLen = fBufferSize;
        fBufferSize = 0;
        return B_OK;
}