/*
 * Copyright (C) 2016 Intel Corporation. All Rights Reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sub license, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice (including the
 * next paragraph) shall be included in all copies or substantial portions
 * of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
 * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

#include "test_va_api_fixture.h"

namespace VAAPI
{

// Testing VABufferType in groups that will be associated with VAProfile and
// VAEntrypoint. vaCreateBuffer doesn't require these itself but its input
// parameter do care about them.

typedef ::testing::WithParamInterface<std::tuple<VAProfile, VAEntrypoint,
        VABufferType, size_t>> CreateBufferParamInterface;

class VAAPICreateBuffer
    : public VAAPIFixture
    , public CreateBufferParamInterface
{
public:
    VAAPICreateBuffer()
        : profile(::testing::get<0>(GetParam()))
        , entrypoint(::testing::get<1>(GetParam()))
        , bufferType(::testing::get<2>(GetParam()))
        , bufferSize(::testing::get<3>(GetParam()))
    { }

protected:
    const VAProfile& profile;
    const VAEntrypoint& entrypoint;
    const VABufferType& bufferType;
    const size_t bufferSize;

    virtual void SetUp()
    {
        VAAPIFixture::SetUp();
        doInitialize();
        ASSERT_FALSE(HasFailure());
    }

    virtual void TearDown()
    {
        doTerminate();
        VAAPIFixture::TearDown();
    }
};

typedef std::tuple<Profiles, size_t> BufferSpec;
typedef std::vector<BufferSpec> BufferSpecs;
typedef std::map<VABufferType, BufferSpecs> BufferSpecsMap;

using std::make_tuple;

static const BufferSpecsMap decodeBufferSpecs = {
    {
        VAPictureParameterBufferType, {
            make_tuple(g_vaMPEG2Profiles, sizeof(VAPictureParameterBufferMPEG2)),
            make_tuple(g_vaMPEG4Profiles, sizeof(VAPictureParameterBufferMPEG4)),
            make_tuple(g_vaH264Profiles, sizeof(VAPictureParameterBufferH264)),
            make_tuple(g_vaVC1Profiles, sizeof(VAPictureParameterBufferVC1)),
            make_tuple(g_vaJPEGProfiles,
                       sizeof(VAPictureParameterBufferJPEGBaseline)),
            make_tuple(g_vaVP8Profiles, sizeof(VAPictureParameterBufferVP8)),
            make_tuple(g_vaHEVCProfiles, sizeof(VAPictureParameterBufferHEVC)),
            make_tuple(g_vaVP9Profiles, sizeof(VADecPictureParameterBufferVP9)),
        }
    },
    {
        VAIQMatrixBufferType, {
            make_tuple(g_vaMPEG2Profiles, sizeof(VAIQMatrixBufferMPEG2)),
            make_tuple(g_vaMPEG4Profiles, sizeof(VAIQMatrixBufferMPEG4)),
            make_tuple(g_vaH264Profiles, sizeof(VAIQMatrixBufferH264)),
            make_tuple(g_vaJPEGProfiles, sizeof(VAIQMatrixBufferJPEGBaseline)),
            make_tuple(g_vaVP8Profiles, sizeof(VAIQMatrixBufferVP8)),
            make_tuple(g_vaHEVCProfiles, sizeof(VAIQMatrixBufferHEVC)),
        }
    },
    {
        VASliceParameterBufferType, {
            make_tuple(g_vaMPEG2Profiles, sizeof(VASliceParameterBufferMPEG2)),
            make_tuple(g_vaMPEG4Profiles, sizeof(VASliceParameterBufferMPEG4)),
            make_tuple(g_vaH264Profiles, sizeof(VASliceParameterBufferH264)),
            make_tuple(g_vaVC1Profiles, sizeof(VASliceParameterBufferVC1)),
            make_tuple(g_vaJPEGProfiles,
                       sizeof(VASliceParameterBufferJPEGBaseline)),
            make_tuple(g_vaVP8Profiles, sizeof(VASliceParameterBufferVP8)),
            make_tuple(g_vaHEVCProfiles, sizeof(VASliceParameterBufferHEVC)),
            make_tuple(g_vaVP9Profiles, sizeof(VASliceParameterBufferVP9)),
        }
    },
    {
        VAMacroblockParameterBufferType, {
            make_tuple(g_vaMPEG2Profiles, sizeof(VAMacroblockParameterBufferMPEG2)),
        }
    },
    {
        VAQMatrixBufferType, {
            make_tuple(g_vaJPEGProfiles, sizeof(VAQMatrixBufferJPEG)),
            make_tuple(g_vaVP8Profiles, sizeof(VAQMatrixBufferVP8)),
            make_tuple(g_vaHEVCProfiles, sizeof(VAQMatrixBufferHEVC)),
        }
    },
    {
        VAHuffmanTableBufferType, {
            make_tuple(g_vaJPEGProfiles, sizeof(VAHuffmanTableBufferJPEGBaseline)),
        }
    },
    {
        VAProbabilityBufferType, {
            make_tuple(g_vaVP8Profiles, sizeof(VAProbabilityDataBufferVP8)),
        }
    },
};

static const BufferSpecsMap encodeBufferSpecs = {
    {
        VAEncSequenceParameterBufferType, {
            make_tuple(g_vaMPEG2Profiles,
                       sizeof(VAEncSequenceParameterBufferMPEG2)),
            make_tuple(g_vaMPEG4Profiles,
                       sizeof(VAEncSequenceParameterBufferMPEG4)),
            make_tuple(g_vaH263Profiles, sizeof(VAEncSequenceParameterBufferH263)),
            make_tuple(g_vaH264Profiles, sizeof(VAEncSequenceParameterBufferH264)),
            make_tuple(g_vaVP8Profiles, sizeof(VAEncSequenceParameterBufferVP8)),
            make_tuple(g_vaHEVCProfiles, sizeof(VAEncSequenceParameterBufferHEVC)),
            make_tuple(g_vaVP9Profiles, sizeof(VAEncSequenceParameterBufferVP9)),
        }
    },
    {
        VAEncPictureParameterBufferType, {
            make_tuple(g_vaMPEG2Profiles, sizeof(VAEncPictureParameterBufferMPEG2)),
            make_tuple(g_vaMPEG4Profiles, sizeof(VAEncPictureParameterBufferMPEG4)),
            make_tuple(g_vaH263Profiles, sizeof(VAEncPictureParameterBufferH263)),
            make_tuple(g_vaH264Profiles, sizeof(VAEncPictureParameterBufferH264)),
            make_tuple(g_vaJPEGProfiles, sizeof(VAEncPictureParameterBufferJPEG)),
            make_tuple(g_vaVP8Profiles, sizeof(VAEncPictureParameterBufferVP8)),
            make_tuple(g_vaHEVCProfiles, sizeof(VAEncPictureParameterBufferHEVC)),
            make_tuple(g_vaVP9Profiles, sizeof(VAEncPictureParameterBufferVP9)),
        }
    },
    {
        VAEncSliceParameterBufferType, {
            make_tuple(g_vaMPEG2Profiles, sizeof(VAEncSliceParameterBufferMPEG2)),
            make_tuple(g_vaH264Profiles, sizeof(VAEncSliceParameterBufferH264)),
            make_tuple(g_vaJPEGProfiles, sizeof(VAEncSliceParameterBufferJPEG)),
            make_tuple(g_vaHEVCProfiles, sizeof(VAEncSliceParameterBufferHEVC)),
        }
    },
    {
        VAEncPackedHeaderParameterBufferType, {
            make_tuple(g_vaProfiles, sizeof(VAEncPackedHeaderParameterBuffer)),
        }
    },
    {
        VAEncMiscParameterBufferType, {
            make_tuple(g_vaProfiles, sizeof(VAEncMiscParameterBuffer)),
        }
    },
};

static const BufferSpecsMap vppBufferSpecs = {
    {
        VAProcPipelineParameterBufferType, {
            make_tuple(g_vaNoneProfiles, sizeof(VAProcPipelineParameterBuffer)),
        }
    },
    {
        VAProcFilterParameterBufferType, {
            make_tuple(g_vaNoneProfiles, sizeof(VAProcFilterParameterBuffer)),
            make_tuple(g_vaNoneProfiles,
                       sizeof(VAProcFilterParameterBufferDeinterlacing)),
            make_tuple(g_vaNoneProfiles,
                       sizeof(VAProcFilterParameterBufferColorBalance)),
            make_tuple(g_vaNoneProfiles,
                       sizeof(VAProcFilterParameterBufferTotalColorCorrection)),
        }
    },
};

TEST_P(VAAPICreateBuffer, CreateBufferWithOutData)
{
    // vaCreateBuffer uses a VAContextID as an input.  This VAContextID requires
    // a VAConfigID to be created.  VAConfigID requires VAProfile and
    // VAEntrypoint to be given.  As such, to test vaCreateBuffer these are
    // the minimum requirements.  There's no need to create surfaces or attach
    // them to a VAConfigID.

    if (!isSupported(profile, entrypoint)) {
        skipTest(profile, entrypoint);
        return;
    }

    // profile and entrypoint are supported
    createConfig(profile, entrypoint);

    // vaCreateContext input requires resolution, since this test
    // doesn't create surfaces, passing min resolution should provide
    // the desired result.
    Resolution minRes, maxRes;
    getMinMaxSurfaceResolution(minRes, maxRes);
    doCreateContext(minRes);

    createBuffer(bufferType, bufferSize);
    destroyBuffer();

    doDestroyContext();
    destroyConfig();
}

std::vector<CreateBufferParamInterface::ParamType> generateInput()
{
    std::vector<CreateBufferParamInterface::ParamType> inputs;

    const auto addBufferSpecs = [&](
    const BufferSpecsMap & bsm, const Entrypoints & entrypoints) {
        for (const auto& specs : bsm) {
            const auto& bufferType = std::get<0>(specs);
            for (const auto& spec : std::get<1>(specs)) {
                const auto& bufferSize = std::get<1>(spec);
                for (const auto& profile : std::get<0>(spec)) {
                    for (const auto& entrypoint : entrypoints) {
                        inputs.push_back(
                            make_tuple(
                                profile, entrypoint, bufferType, bufferSize));
                    }
                }
            }
        }
    };

    addBufferSpecs(decodeBufferSpecs, {VAEntrypointVLD,});
    addBufferSpecs(encodeBufferSpecs, {VAEntrypointEncSlice,
                                       VAEntrypointEncSliceLP, VAEntrypointEncPicture,
                                      });
    addBufferSpecs(vppBufferSpecs, {VAEntrypointVideoProc,});

    return inputs;
}

INSTANTIATE_TEST_SUITE_P(
    CreateBuffer, VAAPICreateBuffer,
    ::testing::ValuesIn(generateInput()));

} // namespace VAAPI
