/*
 * Copyright 2014 Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Colin Günther, coling@gmx.de
 */


/*! Tests video stream decoding functionality of the FFMPEG decoder plugin.

        This test is designed with testing the dvb media-addon video decoding
        capability in mind. Thus we are restricting this test to MPEG2-Video.

        The test requires a MPEG2 test file at the same directory you start the
        test from. Normally there is a test file included at the same location
        this source file is located if not have a look at the git history.

        Successful completion of this test results in a series of PNG image
        files created at the same location you start the test from.

        The originally included test file results in 85 PNG images,
        representing a movie sequence with the actress Anne Hathaway.
        This test file has the following properties:
                - The first frames cannot be decoded, due to missing I-Frames
                  This is by intention, and helps identifying possible bugs in the
                  FFMPEG decoder plugin regarding decoding of video streams, where
                  the stream may start in the middle of a group of pictures (GoP).
                - encoded_video.output.first_active = 0
                - encoded_video.output.last_active = 575
                - encoded_video.output.orientation = B_VIDEO_TOP_LEFT_RIGHT
                - encoded_video.output.display.format = B_YUV420
                - encoded_video.output.display.line_width = 720
                - encoded_video.output.display.line_count = 576

        In any way, there -MUST- be no need to properly initialize those video
        properties for this test to succeed. To put it in other terms: The
        FFMPEG decoder plugin should determine those properties by its own and
        decode the video accordingly.
*/


#include <stdlib.h>
#include <string.h>

#include <AppKit.h>
#include <InterfaceKit.h>
#include <MediaKit.h>
#include <SupportKit.h>
#include <TranslationKit.h>

#include <media/Buffer.h>
#include <media/BufferGroup.h>
#include <media/MediaDecoder.h>
#include <storage/File.h>
#include <support/Errors.h>


extern "C" {
        #include "avcodec.h"

#ifdef DEBUG
        // Needed to fix debug build, otherwise the linker complains about
        // "undefined reference to `ff_log2_tab'"
        const uint8_t ff_log2_tab[256] = {0};
#endif

}       // extern "C"


const char* kTestVideoFilename = "./AVCodecTestMpeg2VideoStreamRaw";


class FileDecoder : public BMediaDecoder {
private:
        BFile* sourceFile;

public:
        FileDecoder(BFile* file) : BMediaDecoder() {
                sourceFile = file;
        }

protected:
        virtual status_t        GetNextChunk(const void **chunkData, size_t* chunkLen,
                                                        media_header* mh) {
                static const uint kReadSizeInBytes = 4096;

                memset(mh, 0, sizeof(media_header));

                void* fileData = malloc(kReadSizeInBytes);
                ssize_t readLength = this->sourceFile->Read(fileData,
                        kReadSizeInBytes);
                if (readLength < 0)
                        return B_ERROR;

                if (readLength == 0)
                        return B_LAST_BUFFER_ERROR;

                *chunkData = fileData;
                *chunkLen = readLength;

                return B_OK;
        }
};


media_format* CreateMpeg2MediaFormat();
media_format CreateRawMediaFormat();
void WriteBufferToImageFileAndRecycleIt(BBuffer* buffer);
BBitmap* CreateBitmapUsingMediaFormat(media_format mediaFormat);
status_t SaveBitmapAtPathUsingFormat(BBitmap* bitmap, BString* filePath,
        uint32 bitmapStorageFormat);


int
main(int argc, char* argv[])
{
        BApplication app("application/x-vnd.mpeg2-decoder-test");

        BFile* mpeg2EncodedFile = new BFile(kTestVideoFilename, O_RDONLY);
        BMediaDecoder* mpeg2Decoder = new FileDecoder(mpeg2EncodedFile);

        media_format* mpeg2MediaFormat = CreateMpeg2MediaFormat();
        mpeg2Decoder->SetTo(mpeg2MediaFormat);
        status_t settingMpeg2DecoderStatus = mpeg2Decoder->InitCheck();
        if (settingMpeg2DecoderStatus < B_OK)
                exit(1);

        media_format rawMediaFormat = CreateRawMediaFormat();
        status_t settingMpeg2DecoderOutputStatus
                = mpeg2Decoder->SetOutputFormat(&rawMediaFormat);
        if (settingMpeg2DecoderOutputStatus < B_OK)
                exit(2);

        static const uint32 kVideoBufferRequestTimeout = 20000;
        uint32 videoBufferSizeInBytesMax = 720 * 576 * 4;
        BBufferGroup* rawVideoFramesGroup
                = new BBufferGroup(videoBufferSizeInBytesMax, 4);
        BBuffer* rawVideoFrame = NULL;

        int64 rawVideoFrameCount = 0;
        media_header mh;
        while (true) {
                rawVideoFrame = rawVideoFramesGroup->RequestBuffer(
                        videoBufferSizeInBytesMax, kVideoBufferRequestTimeout);
                status_t decodingVideoFrameStatus = mpeg2Decoder->Decode(
                        rawVideoFrame->Data(), &rawVideoFrameCount, &mh, NULL);
                if (decodingVideoFrameStatus < B_OK) {
                        rawVideoFrame->Recycle();
                        break;
                }

                WriteBufferToImageFileAndRecycleIt(rawVideoFrame);
        }

        // Cleaning up
        rawVideoFramesGroup->ReclaimAllBuffers();
}


/*!     The caller takes ownership of the returned media_format value.
        Thus the caller needs to free the returned value.
        The returned value may be NULL, when there was an error.
*/
media_format*
CreateMpeg2MediaFormat()
{
        // The following code is mainly copy 'n' paste from src/add-ons/media/
        // media-add-ons/dvb/MediaFormat.cpp:GetHeaderFormatMpegVideo()

        status_t status;
        media_format_description desc;
        desc.family = B_MISC_FORMAT_FAMILY;
        desc.u.misc.file_format = 'ffmp';
        desc.u.misc.codec = CODEC_ID_MPEG2VIDEO;
        static media_format* kFailedToCreateMpeg2MediaFormat = NULL;

        BMediaFormats formats;
        status = formats.InitCheck();
        if (status < B_OK) {
                printf("formats.InitCheck failed, error %lu\n", status);
                return kFailedToCreateMpeg2MediaFormat;
        }

        media_format* mpeg2MediaFormat
                = static_cast<media_format*>(malloc(sizeof(media_format)));
        memset(mpeg2MediaFormat, 0, sizeof(media_format));
        status = formats.GetFormatFor(desc, mpeg2MediaFormat);
        if (status) {
                printf("formats.GetFormatFor failed, error %lu\n", status);
                free(mpeg2MediaFormat);
                return kFailedToCreateMpeg2MediaFormat;
        }

        return mpeg2MediaFormat;
}


media_format
CreateRawMediaFormat()
{
        media_format rawMediaFormat;
        memset(&rawMediaFormat, 0, sizeof(media_format));

        rawMediaFormat.type = B_MEDIA_RAW_VIDEO;
        rawMediaFormat.u.raw_video.display.format = B_RGB32;
        rawMediaFormat.u.raw_video.display.line_width = 720;
        rawMediaFormat.u.raw_video.display.line_count = 576;
        rawMediaFormat.u.raw_video.last_active
                = rawMediaFormat.u.raw_video.display.line_count - 1;
        rawMediaFormat.u.raw_video.display.bytes_per_row
                = rawMediaFormat.u.raw_video.display.line_width * 4;
        rawMediaFormat.u.raw_video.field_rate = 0; // wildcard
        rawMediaFormat.u.raw_video.interlace = 1;
        rawMediaFormat.u.raw_video.first_active = 0;
        rawMediaFormat.u.raw_video.orientation = B_VIDEO_TOP_LEFT_RIGHT;
        rawMediaFormat.u.raw_video.pixel_width_aspect = 1;
        rawMediaFormat.u.raw_video.pixel_height_aspect = 1;
        rawMediaFormat.u.raw_video.display.pixel_offset = 0;
        rawMediaFormat.u.raw_video.display.line_offset = 0;
        rawMediaFormat.u.raw_video.display.flags = 0;

        return rawMediaFormat;
}


void
WriteBufferToImageFileAndRecycleIt(BBuffer* buffer)
{
        static BBitmap* image = NULL;

        if (image == NULL) {
                // Lazy initialization
                image = CreateBitmapUsingMediaFormat(CreateRawMediaFormat());
        }

        if (image == NULL) {
                // Failed to create the image, needed for converting the buffer
                buffer->Recycle();
                return;
        }

        memcpy(image->Bits(), buffer->Data(), image->BitsLength());
        buffer->Recycle();

        static int32 imageSavedCounter = 0;
        static const char* kImageFileNameTemplate = "./mpeg2TestImage%d.png";
        BString imageFileName;
        imageFileName.SetToFormat(kImageFileNameTemplate, imageSavedCounter);

        status_t savingBitmapStatus = SaveBitmapAtPathUsingFormat(image,
                &imageFileName, B_PNG_FORMAT);
        if (savingBitmapStatus >= B_OK)
                imageSavedCounter++;
}


BBitmap*
CreateBitmapUsingMediaFormat(media_format mediaFormat)
{
        const uint32 kNoFlags = 0;
        BBitmap* creatingBitmapFailed = NULL;

        float imageWidth = mediaFormat.u.raw_video.display.line_width;
        float imageHeight = mediaFormat.u.raw_video.display.line_count;
        BRect imageFrame(0, 0, imageWidth - 1, imageHeight - 1);
        color_space imageColorSpace = mediaFormat.u.raw_video.display.format;

        BBitmap* bitmap = NULL;

        bitmap = new BBitmap(imageFrame, kNoFlags, imageColorSpace);
        if (bitmap == NULL)
                return bitmap;

        if (bitmap->InitCheck() < B_OK) {
                delete bitmap;
                return creatingBitmapFailed;
        }

        if (bitmap->IsValid() == false) {
                delete bitmap;
                return creatingBitmapFailed;
        }

        return bitmap;
}


status_t
SaveBitmapAtPathUsingFormat(BBitmap* bitmap, BString* filePath,
        uint32 bitmapStorageFormat)
{
        BFile file(*filePath, B_CREATE_FILE | B_ERASE_FILE | B_WRITE_ONLY);
        status_t creatingFileStatus = file.InitCheck();
        if (creatingFileStatus < B_OK)
                return creatingFileStatus;

        BBitmapStream bitmapStream(bitmap);
        static BTranslatorRoster* translatorRoster = NULL;
        if (translatorRoster == NULL)
                translatorRoster = BTranslatorRoster::Default();

        status_t writingBitmapToFileStatus = translatorRoster->Translate(
                &bitmapStream, NULL, NULL, &file, bitmapStorageFormat,
                B_TRANSLATOR_BITMAP);
        bitmapStream.DetachBitmap(&bitmap);

        return writingBitmapToFileStatus;
}