libs/rs/rsElement.cpp

/*
 * Copyright (C) 2009 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "rsContext.h"

#include <GLES/gl.h>

using namespace android;
using namespace android::renderscript;


Element::Element(Context *rsc) : ObjectBase(rsc)
{
    mType = RS_TYPE_FLOAT;
    mIsNormalized = false;
    mKind = RS_KIND_USER;
    mBits = 0;
    mAllocFile = __FILE__;
    mAllocLine = __LINE__;
    mFields = NULL;
    mFieldCount = 0;
}


Element::~Element()
{
    clear();
}

void Element::clear()
{
    delete [] mFields;
    mFields = NULL;
    mFieldCount = 0;
}
/*
void Element::setComponent(uint32_t idx, Component *c)
{
    rsAssert(!mComponents[idx].get());
    rsAssert(idx < mComponentCount);
    mComponents[idx].set(c);

// Fixme: This should probably not be here
    c->incUserRef();
}
*/

size_t Element::getSizeBits() const
{
    if (!mFieldCount) {
        return mBits;
    }

    size_t total = 0;
    for (size_t ct=0; ct < mFieldCount; ct++) {
        total += mFields[ct].e->mBits;
    }
    return total;
}

size_t Element::getFieldOffsetBits(uint32_t componentNumber) const
{
    size_t offset = 0;
    for (uint32_t ct = 0; ct < componentNumber; ct++) {
        offset += mFields[ct].e->mBits;
    }
    return offset;
}

uint32_t Element::getGLType() const
{
    int bits[4];

    if (!mFieldCount) {
        switch (mType) {
        case RS_TYPE_FLOAT:
            if (mBits == 32) {
                return GL_FLOAT;
            }
            return 0;
        case RS_TYPE_SIGNED:
            switch (mBits) {
            case 8:
                return GL_BYTE;
            case 16:
                return GL_SHORT;
            //case 32:
                //return GL_INT;
            }
            return 0;
        case RS_TYPE_UNSIGNED:
            switch (mBits) {
            case 8:
                return GL_UNSIGNED_BYTE;
            case 16:
                return GL_UNSIGNED_SHORT;
            //case 32:
                //return GL_UNSIGNED_INT;
            }
            return 0;
        }
    }

    if (mFieldCount > 4) {
        return 0;
    }

    for (uint32_t ct=0; ct < mFieldCount; ct++) {
        bits[ct] = mFields[ct].e->mBits;
        if (mFields[ct].e->mFieldCount) {
            return 0;
        }
        if (mFields[ct].e->mType != RS_TYPE_UNSIGNED) {
            return 0;
        }
        if (!mFields[ct].e->mIsNormalized) {
            return 0;
        }
    }

    switch(mFieldCount) {
    case 1:
        if (bits[0] == 8) {
            return GL_UNSIGNED_BYTE;
        }
        return 0;
    case 2:
        if ((bits[0] == 8) &&
            (bits[1] == 8)) {
            return GL_UNSIGNED_BYTE;
        }
        return 0;
    case 3:
        if ((bits[0] == 8) &&
            (bits[1] == 8) &&
            (bits[2] == 8)) {
            return GL_UNSIGNED_BYTE;
        }
        if ((bits[0] == 5) &&
            (bits[1] == 6) &&
            (bits[2] == 5)) {
            return GL_UNSIGNED_SHORT_5_6_5;
        }
        return 0;
    case 4:
        if ((bits[0] == 8) &&
            (bits[1] == 8) &&
            (bits[2] == 8) &&
            (bits[3] == 8)) {
            return GL_UNSIGNED_BYTE;
        }
        if ((bits[0] == 4) &&
            (bits[1] == 4) &&
            (bits[2] == 4) &&
            (bits[3] == 4)) {
            return GL_UNSIGNED_SHORT_4_4_4_4;
        }
        if ((bits[0] == 5) &&
            (bits[1] == 5) &&
            (bits[2] == 5) &&
            (bits[3] == 1)) {
            return GL_UNSIGNED_SHORT_5_5_5_1;
        }
    }
    return 0;
}

uint32_t Element::getGLFormat() const
{
    if (!mFieldCount) {
        if (mKind == RS_KIND_ALPHA) {
            return GL_ALPHA;
        }
        if (mKind == RS_KIND_LUMINANCE) {
            return GL_LUMINANCE;
        }
    }

    switch(mFieldCount) {
    case 2:
        if ((mFields[0].e->mKind == RS_KIND_LUMINANCE) &&
            (mFields[1].e->mKind == RS_KIND_ALPHA)) {
            return GL_LUMINANCE_ALPHA;
        }
        break;
    case 3:
        if ((mFields[0].e->mKind == RS_KIND_RED) &&
            (mFields[1].e->mKind == RS_KIND_GREEN) &&
            (mFields[2].e->mKind == RS_KIND_BLUE)) {
            return GL_RGB;
        }
        break;
    case 4:
        if ((mFields[0].e->mKind == RS_KIND_RED) &&
            (mFields[1].e->mKind == RS_KIND_GREEN) &&
            (mFields[2].e->mKind == RS_KIND_BLUE) &&
            (mFields[3].e->mKind == RS_KIND_ALPHA)) {
            return GL_RGBA;
        }
        break;
    }
    return 0;
}

const char * Element::getCType() const
{
    switch(mType) {
    case RS_TYPE_FLOAT:
        return "float";
    case RS_TYPE_SIGNED:
    case RS_TYPE_UNSIGNED:
        switch(mBits) {
        case 32:
            return "int";
        case 16:
            return "short";
        case 8:
            return "char";
        }
        break;
    }
    return NULL;
}

void Element::dumpLOGV(const char *prefix) const
{
    ObjectBase::dumpLOGV(prefix);
    LOGV("%s   Element: components %i,  size %i", prefix, mFieldCount, mBits);
    for (uint32_t ct = 0; ct < mFieldCount; ct++) {
        char buf[1024];
        sprintf(buf, "%s component %i: ", prefix, ct);
        //mComponents[ct]->dumpLOGV(buf);
    }
}

Element * Element::create(Context *rsc, RsDataKind dk, RsDataType dt,
                          bool isNorm, size_t bits)
{
    Element *e = new Element(rsc);
    e->mKind = dk;
    e->mType = dt;
    e->mIsNormalized = isNorm;
    e->mBits = bits;
    return e;
}

Element * Element::create(Context *rsc, Element **ein, const char **nin,
                          const size_t * lengths, size_t count)
{
    Element *e = new Element(rsc);
    e->mFields = new ElementField_t [count];
    e->mFieldCount = count;

    for (size_t ct=0; ct < count; ct++) {
        e->mFields[ct].e.set(ein[ct]);
        e->mFields[ct].name.setTo(nin[ct], lengths[ct]);
    }

    return e;
}


ElementState::ElementState()
{
}

ElementState::~ElementState()
{
}


/////////////////////////////////////////
//

namespace android {
namespace renderscript {

void rsi_ElementBegin(Context *rsc)
{
    ElementState * sec = &rsc->mStateElement;

    sec->mBuildList.clear();
    sec->mNames.clear();
}

void rsi_ElementAdd(Context *rsc, RsDataKind dk, RsDataType dt, bool isNormalized, size_t bits, const char *name)
{
    ElementState * sec = &rsc->mStateElement;

    rsAssert(bits > 0);

    Element *c = Element::create(rsc, dk, dt, isNormalized, bits);
    sec->mBuildList.add(c);
    if (name)
        sec->mNames.add(String8(name));
    else
        sec->mNames.add(String8(""));
}

RsElement rsi_ElementCreate(Context *rsc)
{
    ElementState * sec = &rsc->mStateElement;

    size_t count = sec->mBuildList.size();
    rsAssert(count > 0);

    if (count == 1) {
        Element *se = sec->mBuildList[0];
        se->incUserRef();
        sec->mBuildList.clear();
        sec->mNames.clear();
        return se;
    }

    Element ** tmpElements = (Element **)calloc(count, sizeof(Element *));
    const char ** tmpNames = (const char **)calloc(count, sizeof(char *));
    size_t * tmpLengths = (size_t *)calloc(count, sizeof(size_t));


    for (size_t ct = 0; ct < count; ct++) {
        tmpElements[ct] = sec->mBuildList[ct];
        tmpNames[ct] = sec->mNames[ct].string();
        tmpLengths[ct] = sec->mNames[ct].length();
    }
    Element *se = Element::create(rsc, tmpElements, tmpNames, tmpLengths, count);

    sec->mBuildList.clear();
    sec->mNames.clear();
    se->incUserRef();
    free(tmpElements);
    free(tmpNames);
    free(tmpLengths);
    return se;
}


}
}