libEGL/Config.cpp

//
// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//

// Config.cpp: Implements the egl::Config class, describing the format, type
// and size for an egl::Surface. Implements EGLConfig and related functionality.
// [EGL 1.4] section 3.4 page 15.

#include "Config.h"

#include <algorithm>
#include <vector>

#include "debug.h"

using namespace std;

namespace egl
{
Config::Config(D3DDISPLAYMODE displayMode, EGLint minInterval, EGLint maxInterval, D3DFORMAT renderTargetFormat, D3DFORMAT depthStencilFormat, EGLint multiSample)
    : mDisplayMode(displayMode), mRenderTargetFormat(renderTargetFormat), mDepthStencilFormat(depthStencilFormat), mMultiSample(multiSample)
{
    set(displayMode, minInterval, maxInterval, renderTargetFormat, depthStencilFormat, multiSample);
}

void Config::setDefaults()
{
    mBufferSize = 0;
    mRedSize = 0;
    mGreenSize = 0;
    mBlueSize = 0;
    mLuminanceSize = 0;
    mAlphaSize = 0;
    mAlphaMaskSize = 0;
    mBindToTextureRGB = EGL_DONT_CARE;
    mBindToTextureRGBA = EGL_DONT_CARE;
    mColorBufferType = EGL_RGB_BUFFER;
    mConfigCaveat = EGL_DONT_CARE;
    mConfigID = EGL_DONT_CARE;
    mConformant = 0;
    mDepthSize = 0;
    mLevel = 0;
    mMatchNativePixmap = EGL_NONE;
    mMaxPBufferWidth = 0;
    mMaxPBufferHeight = 0;
    mMaxPBufferPixels = 0;
    mMaxSwapInterval = EGL_DONT_CARE;
    mMinSwapInterval = EGL_DONT_CARE;
    mNativeRenderable = EGL_DONT_CARE;
    mNativeVisualID = 0;
    mNativeVisualType = EGL_DONT_CARE;
    mRenderableType = EGL_OPENGL_ES_BIT;
    mSampleBuffers = 0;
    mSamples = 0;
    mStencilSize = 0;
    mSurfaceType = EGL_WINDOW_BIT;
    mTransparentType = EGL_NONE;
    mTransparentRedValue = EGL_DONT_CARE;
    mTransparentGreenValue = EGL_DONT_CARE;
    mTransparentBlueValue = EGL_DONT_CARE;
}

void Config::set(D3DDISPLAYMODE displayMode, EGLint minInterval, EGLint maxInterval, D3DFORMAT renderTargetFormat, D3DFORMAT depthStencilFormat, EGLint multiSample)
{
    switch (renderTargetFormat)
    {
      case D3DFMT_A1R5G5B5:
        mBufferSize = 16;
        mRedSize = 5;
        mGreenSize = 5;
        mBlueSize = 5;
        mAlphaSize = 1;
        break;
      case D3DFMT_A2R10G10B10:
        mBufferSize = 32;
        mRedSize = 10;
        mGreenSize = 10;
        mBlueSize = 10;
        mAlphaSize = 2;
        break;
      case D3DFMT_A8R8G8B8:
        mBufferSize = 32;
        mRedSize = 8;
        mGreenSize = 8;
        mBlueSize = 8;
        mAlphaSize = 8;
        break;
      case D3DFMT_R5G6B5:
        mBufferSize = 16;
        mRedSize = 5;
        mGreenSize = 6;
        mBlueSize = 5;
        mAlphaSize = 0;
        break;
      case D3DFMT_X1R5G5B5:
        mBufferSize = 16;
        mRedSize = 5;
        mGreenSize = 5;
        mBlueSize = 5;
        mAlphaSize = 0;
        break;
      case D3DFMT_X8R8G8B8:
        mBufferSize = 32;
        mRedSize = 8;
        mGreenSize = 8;
        mBlueSize = 8;
        mAlphaSize = 0;
        break;
      default:
        UNREACHABLE();   // Other formats should not be valid
    }

    mLuminanceSize = 0;
    mAlphaMaskSize = 0;
    mBindToTextureRGB = EGL_FALSE;
    mBindToTextureRGBA = EGL_FALSE;
    mColorBufferType = EGL_RGB_BUFFER;
    mConfigCaveat = (displayMode.Format == renderTargetFormat) ? EGL_NONE : EGL_SLOW_CONFIG;
    mConfigID = 0;
    mConformant = EGL_OPENGL_ES2_BIT;

    switch (depthStencilFormat)
    {
//      case D3DFMT_D16_LOCKABLE:
//        mDepthSize = 16;
//        mStencilSize = 0;
//        break;
      case D3DFMT_D32:
        mDepthSize = 32;
        mStencilSize = 0;
        break;
      case D3DFMT_D15S1:
        mDepthSize = 16;
        mStencilSize = 1;
        break;
      case D3DFMT_D24S8:
        mDepthSize = 24;
        mStencilSize = 8;
        break;
      case D3DFMT_D24X8:
        mDepthSize = 24;
        mStencilSize = 0;
        break;
      case D3DFMT_D24X4S4:
        mDepthSize = 24;
        mStencilSize = 4;
        break;
      case D3DFMT_D16:
        mDepthSize = 16;
        mStencilSize = 0;
        break;
//    case D3DFMT_D32F_LOCKABLE:
//        mDepthSize = 32;
//        mStencilSize = 0;
//        break;
//    case D3DFMT_D24FS8:
//        mDepthSize = 24;
//        mStencilSize = 8;
//        break;
      default:
        UNREACHABLE();
    }

    mLevel = 0;
    mMatchNativePixmap = EGL_NONE;
    mMaxPBufferWidth = 0;
    mMaxPBufferHeight = 0;
    mMaxPBufferPixels = 0;
    mMaxSwapInterval = maxInterval;
    mMinSwapInterval = minInterval;
    mNativeRenderable = EGL_FALSE;
    mNativeVisualID = 0;
    mNativeVisualType = 0;
    mRenderableType = EGL_OPENGL_ES2_BIT;
    mSampleBuffers = multiSample ? 1 : 0;
    mSamples = multiSample;
    mSurfaceType = EGL_PBUFFER_BIT | EGL_WINDOW_BIT | EGL_SWAP_BEHAVIOR_PRESERVED_BIT;
    mTransparentType = EGL_NONE;
    mTransparentRedValue = 0;
    mTransparentGreenValue = 0;
    mTransparentBlueValue = 0;
}

EGLConfig Config::getHandle() const
{
    return (EGLConfig)(size_t)mConfigID;
}

SortConfig::SortConfig(const EGLint *attribList)
    : mWantRed(false), mWantGreen(false), mWantBlue(false), mWantAlpha(false), mWantLuminance(false)
{
    scanForWantedComponents(attribList);
}

void SortConfig::scanForWantedComponents(const EGLint *attribList)
{
    // [EGL] section 3.4.1 page 24
    // Sorting rule #3: by larger total number of color bits, not considering
    // components that are 0 or don't-care.
    for (const EGLint *attr = attribList; attr[0] != EGL_NONE; attr += 2)
    {
        if (attr[1] != 0 && attr[1] != EGL_DONT_CARE)
        {
            switch (attr[0])
            {
              case EGL_RED_SIZE:       mWantRed = true; break;
              case EGL_GREEN_SIZE:     mWantGreen = true; break;
              case EGL_BLUE_SIZE:      mWantBlue = true; break;
              case EGL_ALPHA_SIZE:     mWantAlpha = true; break;
              case EGL_LUMINANCE_SIZE: mWantLuminance = true; break;
            }
        }
    }
}

EGLint SortConfig::wantedComponentsSize(const Config &config) const
{
    EGLint total = 0;

    if (mWantRed)       total += config.mRedSize;
    if (mWantGreen)     total += config.mGreenSize;
    if (mWantBlue)      total += config.mBlueSize;
    if (mWantAlpha)     total += config.mAlphaSize;
    if (mWantLuminance) total += config.mLuminanceSize;

    return total;
}

bool SortConfig::operator()(const Config *x, const Config *y) const
{
    return (*this)(*x, *y);
}

bool SortConfig::operator()(const Config &x, const Config &y) const
{
    #define SORT(attribute)                        \
        if (x.attribute != y.attribute)            \
        {                                          \
            return x.attribute < y.attribute;      \
        }

    META_ASSERT(EGL_NONE < EGL_SLOW_CONFIG && EGL_SLOW_CONFIG < EGL_NON_CONFORMANT_CONFIG);
    SORT(mConfigCaveat);

    META_ASSERT(EGL_RGB_BUFFER < EGL_LUMINANCE_BUFFER);
    SORT(mColorBufferType);

    // By larger total number of color bits, only considering those that are requested to be > 0.
    EGLint xComponentsSize = wantedComponentsSize(x);
    EGLint yComponentsSize = wantedComponentsSize(y);
    if (xComponentsSize != yComponentsSize)
    {
        return xComponentsSize > yComponentsSize;
    }

    SORT(mBufferSize);
    SORT(mSampleBuffers);
    SORT(mSamples);
    SORT(mDepthSize);
    SORT(mStencilSize);
    SORT(mAlphaMaskSize);
    SORT(mNativeVisualType);
    SORT(mConfigID);

    #undef SORT

    return false;
}

// We'd like to use SortConfig to also eliminate duplicate configs.
// This works as long as we never have two configs with different per-RGB-component layouts,
// but the same total.
// 5551 and 565 are different because R+G+B is different.
// 5551 and 555 are different because bufferSize is different.
const EGLint ConfigSet::mSortAttribs[] =
{
    EGL_RED_SIZE, 1,
    EGL_GREEN_SIZE, 1,
    EGL_BLUE_SIZE, 1,
    EGL_LUMINANCE_SIZE, 1,
    // BUT NOT ALPHA
    EGL_NONE
};

ConfigSet::ConfigSet()
    : mSet(SortConfig(mSortAttribs))
{
}

void ConfigSet::add(D3DDISPLAYMODE displayMode, EGLint minSwapInterval, EGLint maxSwapInterval, D3DFORMAT renderTargetFormat, D3DFORMAT depthStencilFormat, EGLint multiSample)
{
    Config config(displayMode, minSwapInterval, maxSwapInterval, renderTargetFormat, depthStencilFormat, multiSample);

    mSet.insert(config);
}

void ConfigSet::enumerate()
{
    EGLint index = 1;

    for (Iterator config = mSet.begin(); config != mSet.end(); config++)
    {
        config->mConfigID = index;
        index++;
    }
}

size_t ConfigSet::size() const
{
    return mSet.size();
}

bool ConfigSet::getConfigs(EGLConfig *configs, const EGLint *attribList, EGLint configSize, EGLint *numConfig)
{
    if (configs)
    {
        vector<const Config*> passed;
        passed.reserve(mSet.size());

        for (Iterator config = mSet.begin(); config != mSet.end(); config++)
        {
            bool match = true;
            const EGLint *attribute = attribList;

            while (attribute[0] != EGL_NONE)
            {
                switch (attribute[0])
                {
                  case EGL_BUFFER_SIZE:               match = config->mBufferSize >= attribute[1];                            break;
                  case EGL_ALPHA_SIZE:                match = config->mAlphaSize >= attribute[1];                            break;
                  case EGL_BLUE_SIZE:                 match = config->mBlueSize >= attribute[1];                            break;
                  case EGL_GREEN_SIZE:                match = config->mGreenSize >= attribute[1];                            break;
                  case EGL_RED_SIZE:                  match = config->mRedSize >= attribute[1];                            break;
                  case EGL_DEPTH_SIZE:                match = config->mDepthSize >= attribute[1];                            break;
                  case EGL_STENCIL_SIZE:              match = config->mStencilSize >= attribute[1];                        break;
                  case EGL_CONFIG_CAVEAT:             match = config->mConfigCaveat == attribute[1];                        break;
                  case EGL_CONFIG_ID:                 match = config->mConfigID == attribute[1];                            break;
                  case EGL_LEVEL:                     match = config->mLevel >= attribute[1];                                break;
                  case EGL_NATIVE_RENDERABLE:         match = config->mNativeRenderable == attribute[1];                    break;
                  case EGL_NATIVE_VISUAL_TYPE:        match = config->mNativeVisualType == attribute[1];                    break;
                  case EGL_SAMPLES:                   match = config->mSamples >= attribute[1];                            break;
                  case EGL_SAMPLE_BUFFERS:            match = config->mSampleBuffers >= attribute[1];                        break;
                  case EGL_SURFACE_TYPE:              match = (config->mSurfaceType & attribute[1]) == attribute[1];        break;
                  case EGL_TRANSPARENT_TYPE:          match = config->mTransparentType == attribute[1];                    break;
                  case EGL_TRANSPARENT_BLUE_VALUE:    match = config->mTransparentBlueValue == attribute[1];                break;
                  case EGL_TRANSPARENT_GREEN_VALUE:   match = config->mTransparentGreenValue == attribute[1];                break;
                  case EGL_TRANSPARENT_RED_VALUE:     match = config->mTransparentRedValue == attribute[1];                break;
                  case EGL_BIND_TO_TEXTURE_RGB:       match = config->mBindToTextureRGB == attribute[1];                    break;
                  case EGL_BIND_TO_TEXTURE_RGBA:      match = config->mBindToTextureRGBA == attribute[1];                    break;
                  case EGL_MIN_SWAP_INTERVAL:         match = config->mMinSwapInterval == attribute[1];                    break;
                  case EGL_MAX_SWAP_INTERVAL:         match = config->mMaxSwapInterval == attribute[1];                    break;
                  case EGL_LUMINANCE_SIZE:            match = config->mLuminanceSize >= attribute[1];                        break;
                  case EGL_ALPHA_MASK_SIZE:           match = config->mAlphaMaskSize >= attribute[1];                        break;
                  case EGL_COLOR_BUFFER_TYPE:         match = config->mColorBufferType == attribute[1];                    break;
                  case EGL_RENDERABLE_TYPE:           match = (config->mRenderableType & attribute[1]) == attribute[1];    break;
                  case EGL_MATCH_NATIVE_PIXMAP:       match = false; UNIMPLEMENTED();                                        break;
                  case EGL_CONFORMANT:                match = (config->mConformant & attribute[1]) == attribute[1];        break;
                  default:
                    return false;
                }

                if (!match)
                {
                    break;
                }

                attribute += 2;
            }

            if (match)
            {
                passed.push_back(&*config);
            }
        }

        sort(passed.begin(), passed.end(), SortConfig(attribList));

        EGLint index;
        for (index = 0; index < configSize && index < static_cast<EGLint>(passed.size()); index++)
        {
            configs[index] = passed[index]->getHandle();
        }

        *numConfig = index;
    }
    else
    {
        *numConfig = (EGLint)mSet.size();
    }

    return true;
}

const egl::Config *ConfigSet::get(EGLConfig configHandle)
{
    for (Iterator config = mSet.begin(); config != mSet.end(); config++)
    {
        if (config->getHandle() == configHandle)
        {
            return &(*config);
        }
    }

    return NULL;
}
}