/*
 * Copyright 2009-2010, Stephan Aßmus <superstippi@gmx.de>.
 * All rights reserved. Distributed under the terms of the MIT license.
 */


#include "MediaWriter.h"

#include <new>

#include <stdio.h>
#include <string.h>

#include <Autolock.h>

#include "MediaDebug.h"

#include "PluginManager.h"



class MediaExtractorChunkWriter : public ChunkWriter {
public:
        MediaExtractorChunkWriter(MediaWriter* writer, int32 streamIndex)
                :
                fWriter(writer),
                fStreamIndex(streamIndex)
        {
        }

        virtual status_t WriteChunk(const void* chunkBuffer, size_t chunkSize,
                media_encode_info* encodeInfo)
        {
                return fWriter->WriteChunk(fStreamIndex, chunkBuffer, chunkSize,
                        encodeInfo);
        }

private:
        MediaWriter*    fWriter;
        int32                   fStreamIndex;
};


// #pragma mark -


MediaWriter::MediaWriter(BDataIO* target, const media_file_format& fileFormat)
        :
        fTarget(target),
        fWriter(NULL),
        fStreamInfos(),
        fFileFormat(fileFormat)
{
        CALLED();

        gPluginManager.CreateWriter(&fWriter, fFileFormat, fTarget);
}


MediaWriter::~MediaWriter()
{
        CALLED();

        if (fWriter != NULL) {
                // free all stream cookies
                // and chunk caches
                StreamInfo* info;
                for (fStreamInfos.Rewind(); fStreamInfos.GetNext(&info);)
                        fWriter->FreeCookie(info->cookie);

                gPluginManager.DestroyWriter(fWriter);
        }

        // fTarget is owned by the BMediaFile
}


status_t
MediaWriter::InitCheck()
{
        CALLED();

        return fWriter != NULL ? fWriter->Init(&fFileFormat) : B_NO_INIT;
}


BDataIO*
MediaWriter::Target() const
{
        return fTarget;
}


void
MediaWriter::GetFileFormatInfo(media_file_format* _fileFormat) const
{
        CALLED();

        if (_fileFormat != NULL)
                *_fileFormat = fFileFormat;
}


status_t
MediaWriter::CreateEncoder(Encoder** _encoder,
        const media_codec_info* codecInfo, media_format* format, uint32 flags)
{
        CALLED();

        if (fWriter == NULL)
                return B_NO_INIT;

        // TODO: Here we should work out a way so that if there is a setup
        // failure we can try the next encoder.
        Encoder* encoder;
        status_t ret = gPluginManager.CreateEncoder(&encoder, codecInfo, flags);
        if (ret != B_OK) {
                ERROR("MediaWriter::CreateEncoder gPluginManager.CreateEncoder "
                        "failed, codec: %s\n", codecInfo->pretty_name);
                return ret;
        }

        StreamInfo info;
        ret = fWriter->AllocateCookie(&info.cookie, format, codecInfo);
        if (ret != B_OK) {
                gPluginManager.DestroyEncoder(encoder);
                return ret;
        }

        int32 streamIndex = fStreamInfos.CountItems();

        if (!fStreamInfos.Insert(info)) {
                gPluginManager.DestroyEncoder(encoder);
                ERROR("MediaWriter::CreateEncoder can't create StreamInfo "
                        "for stream %" B_PRId32 "\n", streamIndex);
                return B_NO_MEMORY;
        }

        ChunkWriter* chunkWriter = new(std::nothrow) MediaExtractorChunkWriter(
                this, streamIndex);
        if (chunkWriter == NULL) {
                gPluginManager.DestroyEncoder(encoder);
                ERROR("MediaWriter::CreateEncoder can't create ChunkWriter "
                        "for stream %" B_PRId32 "\n", streamIndex);
                return B_NO_MEMORY;
        }

        encoder->SetChunkWriter(chunkWriter);
        *_encoder = encoder;

        return B_OK;
}


status_t
MediaWriter::SetCopyright(const char* copyright)
{
        if (fWriter == NULL)
                return B_NO_INIT;

        return fWriter->SetCopyright(copyright);
}


status_t
MediaWriter::SetCopyright(int32 streamIndex, const char* copyright)
{
        if (fWriter == NULL)
                return B_NO_INIT;

        StreamInfo* info;
        if (!fStreamInfos.Get(streamIndex, &info))
                return B_BAD_INDEX;

        return fWriter->SetCopyright(info->cookie, copyright);
}


status_t
MediaWriter::CommitHeader()
{
        if (fWriter == NULL)
                return B_NO_INIT;

        return fWriter->CommitHeader();
}


status_t
MediaWriter::Flush()
{
        if (fWriter == NULL)
                return B_NO_INIT;

        return fWriter->Flush();
}


status_t
MediaWriter::Close()
{
        if (fWriter == NULL)
                return B_NO_INIT;

        return fWriter->Close();
}


status_t
MediaWriter::AddTrackInfo(int32 streamIndex, uint32 code,
        const void* data, size_t size, uint32 flags)
{
        if (fWriter == NULL)
                return B_NO_INIT;

        StreamInfo* info;
        if (!fStreamInfos.Get(streamIndex, &info))
                return B_BAD_INDEX;

        return fWriter->AddTrackInfo(info->cookie, code, data, size, flags);
}


status_t
MediaWriter::WriteChunk(int32 streamIndex, const void* chunkBuffer,
        size_t chunkSize, media_encode_info* encodeInfo)
{
        if (fWriter == NULL)
                return B_NO_INIT;

        StreamInfo* info;
        if (!fStreamInfos.Get(streamIndex, &info))
                return B_BAD_INDEX;

        return fWriter->WriteChunk(info->cookie, chunkBuffer, chunkSize,
                encodeInfo);
}