Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 9abe5676 authored by The Android Open Source Project's avatar The Android Open Source Project
Browse files

Merge commit 'remotes/goog/eclair' into eclair-release

parents b71e06e0 8073e420

include/ui/CameraParameters.h

+193 −1
Original line number Diff line number Diff line
@@ -69,11 +69,203 @@ public: 
    void dump() const;

    status_t dump(int fd, const Vector<String16>& args) const;



    // Parameter keys to communicate between camera application and driver.

    // The access (read/write, read only, or write only) is viewed from the

    // perspective of applications, not driver.



    // Preview frame size in pixels (width x height).

    // Example value: "480x320". Read/Write.

    static const char KEY_PREVIEW_SIZE[];

    // Supported preview frame sizes in pixels.

    // Example value: "800x600,480x320". Read only.

    static const char KEY_SUPPORTED_PREVIEW_SIZES[];

    // The image format for preview frames.

    // Example value: "yuv420sp" or PIXEL_FORMAT_XXX constants. Read/write.

    static const char KEY_PREVIEW_FORMAT[];

    // Supported image formats for preview frames.

    // Example value: "yuv420sp,yuv422i-yuyv". Read only.

    static const char KEY_SUPPORTED_PREVIEW_FORMATS[];

    // Number of preview frames per second.

    // Example value: "15". Read/write.

    static const char KEY_PREVIEW_FRAME_RATE[];

    // Supported number of preview frames per second.

    // Example value: "24,15,10". Read.

    static const char KEY_SUPPORTED_PREVIEW_FRAME_RATES[];

    // The dimensions for captured pictures in pixels (width x height).

    // Example value: "1024x768". Read/write.

    static const char KEY_PICTURE_SIZE[];

    // Supported dimensions for captured pictures in pixels.

    // Example value: "2048x1536,1024x768". Read only.

    static const char KEY_SUPPORTED_PICTURE_SIZES[];

    // The image format for captured pictures.

    // Example value: "jpeg" or PIXEL_FORMAT_XXX constants. Read/write.

    static const char KEY_PICTURE_FORMAT[];

    // Supported image formats for captured pictures.

    // Example value: "jpeg,rgb565". Read only.

    static const char KEY_SUPPORTED_PICTURE_FORMATS[];

    // The width (in pixels) of EXIF thumbnail in Jpeg picture.

    // Example value: "512". Read/write.

    static const char KEY_JPEG_THUMBNAIL_WIDTH[];

    // The height (in pixels) of EXIF thumbnail in Jpeg picture.

    // Example value: "384". Read/write.

    static const char KEY_JPEG_THUMBNAIL_HEIGHT[];

    // Supported EXIF thumbnail sizes (width x height).

    // Example value: "512x384,320x240". Read only.

    static const char KEY_SUPPORTED_THUMBNAIL_SIZES[];

    // The quality of the EXIF thumbnail in Jpeg picture. The range is 1 to 100,

    // with 100 being the best.

    // Example value: "90". Read/write.

    static const char KEY_JPEG_THUMBNAIL_QUALITY[];

    // Jpeg quality of captured picture. The range is 1 to 100, with 100 being

    // the best.

    // Example value: "90". Read/write.

    static const char KEY_JPEG_QUALITY[];

    // The orientation of the device in degrees. For example, suppose the

    // natural position of the device is landscape. If the user takes a picture

    // in landscape mode in 2048x1536 resolution, the rotation will be set to

    // "0". If the user rotates the phone 90 degrees clockwise, the rotation

    // should be set to "90".

    // The camera driver can set orientation in the EXIF header without rotating

    // the picture. Or the driver can rotate the picture and the EXIF thumbnail.

    // If the Jpeg picture is rotated, the orientation in the EXIF header should

    // be missing or 1 (row #0 is top and column #0 is left side). The driver

    // should not set default value for this parameter.

    // Example value: "0" or "90" or "180" or "270". Write only.

    static const char KEY_ROTATION[];

    // GPS latitude coordinate. This will be stored in JPEG EXIF header.

    // Example value: "25.032146". Write only.

    static const char KEY_GPS_LATITUDE[];

    // GPS longitude coordinate. This will be stored in JPEG EXIF header.

    // Example value: "121.564448". Write only.

    static const char KEY_GPS_LONGITUDE[];

    // GPS altitude. This will be stored in JPEG EXIF header.

    // Example value: "21.0". Write only.

    static const char KEY_GPS_ALTITUDE[];

    // GPS timestamp (UTC in seconds since January 1, 1970). This should be

    // stored in JPEG EXIF header.

    // Example value: "1251192757". Write only.

    static const char KEY_GPS_TIMESTAMP[];

    // Current white balance setting.

    // Example value: "auto" or WHITE_BALANCE_XXX constants. Read/write.

    static const char KEY_WHITE_BALANCE[];

    // Supported white balance settings.

    // Example value: "auto,incandescent,daylight". Read only.

    static const char KEY_SUPPORTED_WHITE_BALANCE[];

    // Current color effect setting.

    // Example value: "none" or EFFECT_XXX constants. Read/write.

    static const char KEY_EFFECT[];

    // Supported color effect settings.

    // Example value: "none,mono,sepia". Read only.

    static const char KEY_SUPPORTED_EFFECTS[];

    // Current antibanding setting.

    // Example value: "auto" or ANTIBANDING_XXX constants. Read/write.

    static const char KEY_ANTIBANDING[];

    // Supported antibanding settings.

    // Example value: "auto,50hz,60hz,off". Read only.

    static const char KEY_SUPPORTED_ANTIBANDING[];

    // Current scene mode.

    // Example value: "auto" or SCENE_MODE_XXX constants. Read/write.

    static const char KEY_SCENE_MODE[];

    // Supported scene mode settings.

    // Example value: "auto,night,fireworks". Read only.

    static const char KEY_SUPPORTED_SCENE_MODES[];

    // Current flash mode.

    // Example value: "auto" or FLASH_MODE_XXX constants. Read/write.

    static const char KEY_FLASH_MODE[];

    // Supported flash modes.

    // Example value: "auto,on,off". Read only.

    static const char KEY_SUPPORTED_FLASH_MODES[];

    // Current focus mode. If the camera does not support auto-focus, the value

    // should be FOCUS_MODE_FIXED. If the focus mode is not FOCUS_MODE_FIXED or

    // or FOCUS_MODE_INFINITY, applications should call

    // CameraHardwareInterface.autoFocus to start the focus.

    // Example value: "auto" or FOCUS_MODE_XXX constants. Read/write.

    static const char KEY_FOCUS_MODE[];

    // Supported focus modes.

    // Example value: "auto,macro,fixed". Read only.

    static const char KEY_SUPPORTED_FOCUS_MODES[];



        // Values for white balance settings.

    static const char WHITE_BALANCE_AUTO[];

    static const char WHITE_BALANCE_INCANDESCENT[];

    static const char WHITE_BALANCE_FLUORESCENT[];

    static const char WHITE_BALANCE_WARM_FLUORESCENT[];

    static const char WHITE_BALANCE_DAYLIGHT[];

    static const char WHITE_BALANCE_CLOUDY_DAYLIGHT[];

    static const char WHITE_BALANCE_TWILIGHT[];

    static const char WHITE_BALANCE_SHADE[];



    // Values for effect settings.

    static const char EFFECT_NONE[];

    static const char EFFECT_MONO[];

    static const char EFFECT_NEGATIVE[];

    static const char EFFECT_SOLARIZE[];

    static const char EFFECT_SEPIA[];

    static const char EFFECT_POSTERIZE[];

    static const char EFFECT_WHITEBOARD[];

    static const char EFFECT_BLACKBOARD[];

    static const char EFFECT_AQUA[];



    // Values for antibanding settings.

    static const char ANTIBANDING_AUTO[];

    static const char ANTIBANDING_50HZ[];

    static const char ANTIBANDING_60HZ[];

    static const char ANTIBANDING_OFF[];



    // Values for flash mode settings.

    // Flash will not be fired.

    static const char FLASH_MODE_OFF[];

    // Flash will be fired automatically when required. The timing is decided by

    // camera driver.

    static const char FLASH_MODE_AUTO[];

    // Flash will always be fired. The timing is decided by camera driver.

    static const char FLASH_MODE_ON[];

    // Flash will be fired in red-eye reduction mode.

    static const char FLASH_MODE_RED_EYE[];

    // Constant emission of light. This can be used for video recording.

    static const char FLASH_MODE_VIDEO_LIGHT[];



    // Values for scene mode settings.

    static const char SCENE_MODE_AUTO[];

    static const char SCENE_MODE_ACTION[];

    static const char SCENE_MODE_PORTRAIT[];

    static const char SCENE_MODE_LANDSCAPE[];

    static const char SCENE_MODE_NIGHT[];

    static const char SCENE_MODE_NIGHT_PORTRAIT[];

    static const char SCENE_MODE_THEATRE[];

    static const char SCENE_MODE_BEACH[];

    static const char SCENE_MODE_SNOW[];

    static const char SCENE_MODE_SUNSET[];

    static const char SCENE_MODE_STEADYPHOTO[];

    static const char SCENE_MODE_FIREWORKS[];

    static const char SCENE_MODE_SPORTS[];

    static const char SCENE_MODE_PARTY[];

    static const char SCENE_MODE_CANDLELIGHT[];



    // Formats for setPreviewFormat and setPictureFormat.

    static const char PIXEL_FORMAT_YUV422SP[];

    static const char PIXEL_FORMAT_YUV420SP[]; // NV21

    static const char PIXEL_FORMAT_YUV422I[]; // YUY2

    static const char PIXEL_FORMAT_RGB565[];

    static const char PIXEL_FORMAT_JPEG[];



    // Values for focus mode settings.

    // Auto-focus mode.

    static const char FOCUS_MODE_AUTO[];

    // Focus is set at infinity. Applications should not call

    // CameraHardwareInterface.autoFocus in this mode.

    static const char FOCUS_MODE_INFINITY[];

    static const char FOCUS_MODE_MACRO[];

    // Focus is fixed. The camera is always in this mode if the focus is not

    // adjustable. If the camera has auto-focus, this mode can fix the

    // focus, which is usually at hyperfocal distance. Applications should

    // not call CameraHardwareInterface.autoFocus in this mode.

    static const char FOCUS_MODE_FIXED[];



private:

    DefaultKeyedVector<String8,String8>    mMap;

};





}; // namespace android



#endif

libs/ui/CameraParameters.cpp

+118 −21
Original line number Diff line number Diff line
@@ -23,6 +23,103 @@ 
#include <ui/CameraParameters.h>



namespace android {

// Parameter keys to communicate between camera application and driver.

const char CameraParameters::KEY_PREVIEW_SIZE[] = "preview-size";

const char CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES[] = "preview-size-values";

const char CameraParameters::KEY_PREVIEW_FORMAT[] = "preview-format";

const char CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS[] = "preview-format-values";

const char CameraParameters::KEY_PREVIEW_FRAME_RATE[] = "preview-frame-rate";

const char CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES[] = "preview-frame-rate-values";

const char CameraParameters::KEY_PICTURE_SIZE[] = "picture-size";

const char CameraParameters::KEY_SUPPORTED_PICTURE_SIZES[] = "picture-size-values";

const char CameraParameters::KEY_PICTURE_FORMAT[] = "picture-format";

const char CameraParameters::KEY_SUPPORTED_PICTURE_FORMATS[] = "picture-format-values";

const char CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH[] = "jpeg-thumbnail-width";

const char CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT[] = "jpeg-thumbnail-height";

const char CameraParameters::KEY_SUPPORTED_THUMBNAIL_SIZES[] = "jpeg-thumbnail-size-values";

const char CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY[] = "jpeg-thumbnail-quality";

const char CameraParameters::KEY_JPEG_QUALITY[] = "jpeg-quality";

const char CameraParameters::KEY_ROTATION[] = "rotation";

const char CameraParameters::KEY_GPS_LATITUDE[] = "gps-latitude";

const char CameraParameters::KEY_GPS_LONGITUDE[] = "gps-longitude";

const char CameraParameters::KEY_GPS_ALTITUDE[] = "gps-altitude";

const char CameraParameters::KEY_GPS_TIMESTAMP[] = "gps-timestamp";

const char CameraParameters::KEY_WHITE_BALANCE[] = "whitebalance";

const char CameraParameters::KEY_SUPPORTED_WHITE_BALANCE[] = "whitebalance-values";

const char CameraParameters::KEY_EFFECT[] = "effect";

const char CameraParameters::KEY_SUPPORTED_EFFECTS[] = "effect-values";

const char CameraParameters::KEY_ANTIBANDING[] = "antibanding";

const char CameraParameters::KEY_SUPPORTED_ANTIBANDING[] = "antibanding-values";

const char CameraParameters::KEY_SCENE_MODE[] = "scene-mode";

const char CameraParameters::KEY_SUPPORTED_SCENE_MODES[] = "scene-mode-values";

const char CameraParameters::KEY_FLASH_MODE[] = "flash-mode";

const char CameraParameters::KEY_SUPPORTED_FLASH_MODES[] = "flash-mode-values";

const char CameraParameters::KEY_FOCUS_MODE[] = "focus-mode";

const char CameraParameters::KEY_SUPPORTED_FOCUS_MODES[] = "focus-mode-values";



// Values for white balance settings.

const char CameraParameters::WHITE_BALANCE_AUTO[] = "auto";

const char CameraParameters::WHITE_BALANCE_INCANDESCENT[] = "incandescent";

const char CameraParameters::WHITE_BALANCE_FLUORESCENT[] = "fluorescent";

const char CameraParameters::WHITE_BALANCE_WARM_FLUORESCENT[] = "warm-fluorescent";

const char CameraParameters::WHITE_BALANCE_DAYLIGHT[] = "daylight";

const char CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT[] = "cloudy-daylight";

const char CameraParameters::WHITE_BALANCE_TWILIGHT[] = "twilight";

const char CameraParameters::WHITE_BALANCE_SHADE[] = "shade";



// Values for effect settings.

const char CameraParameters::EFFECT_NONE[] = "none";

const char CameraParameters::EFFECT_MONO[] = "mono";

const char CameraParameters::EFFECT_NEGATIVE[] = "negative";

const char CameraParameters::EFFECT_SOLARIZE[] = "solarize";

const char CameraParameters::EFFECT_SEPIA[] = "sepia";

const char CameraParameters::EFFECT_POSTERIZE[] = "posterize";

const char CameraParameters::EFFECT_WHITEBOARD[] = "whiteboard";

const char CameraParameters::EFFECT_BLACKBOARD[] = "blackboard";

const char CameraParameters::EFFECT_AQUA[] = "aqua";



// Values for antibanding settings.

const char CameraParameters::ANTIBANDING_AUTO[] = "auto";

const char CameraParameters::ANTIBANDING_50HZ[] = "50hz";

const char CameraParameters::ANTIBANDING_60HZ[] = "60hz";

const char CameraParameters::ANTIBANDING_OFF[] = "off";



// Values for flash mode settings.

const char CameraParameters::FLASH_MODE_OFF[] = "off";

const char CameraParameters::FLASH_MODE_AUTO[] = "auto";

const char CameraParameters::FLASH_MODE_ON[] = "on";

const char CameraParameters::FLASH_MODE_RED_EYE[] = "red-eye";

const char CameraParameters::FLASH_MODE_VIDEO_LIGHT[] = "video-light";



// Values for scene mode settings.

const char CameraParameters::SCENE_MODE_AUTO[] = "auto";

const char CameraParameters::SCENE_MODE_ACTION[] = "action";

const char CameraParameters::SCENE_MODE_PORTRAIT[] = "portrait";

const char CameraParameters::SCENE_MODE_LANDSCAPE[] = "landscape";

const char CameraParameters::SCENE_MODE_NIGHT[] = "night";

const char CameraParameters::SCENE_MODE_NIGHT_PORTRAIT[] = "night-portrait";

const char CameraParameters::SCENE_MODE_THEATRE[] = "theatre";

const char CameraParameters::SCENE_MODE_BEACH[] = "beach";

const char CameraParameters::SCENE_MODE_SNOW[] = "snow";

const char CameraParameters::SCENE_MODE_SUNSET[] = "sunset";

const char CameraParameters::SCENE_MODE_STEADYPHOTO[] = "steadyphoto";

const char CameraParameters::SCENE_MODE_FIREWORKS[] = "fireworks";

const char CameraParameters::SCENE_MODE_SPORTS[] = "sports";

const char CameraParameters::SCENE_MODE_PARTY[] = "party";

const char CameraParameters::SCENE_MODE_CANDLELIGHT[] = "candlelight";



// Formats for setPreviewFormat and setPictureFormat.

const char CameraParameters::PIXEL_FORMAT_YUV422SP[] = "yuv422sp";

const char CameraParameters::PIXEL_FORMAT_YUV420SP[] = "yuv420sp";

const char CameraParameters::PIXEL_FORMAT_YUV422I[] = "yuv422i-yuyv";

const char CameraParameters::PIXEL_FORMAT_RGB565[] = "rgb565";

const char CameraParameters::PIXEL_FORMAT_JPEG[] = "jpeg";



// Values for focus mode settings.

const char CameraParameters::FOCUS_MODE_AUTO[] = "auto";

const char CameraParameters::FOCUS_MODE_INFINITY[] = "infinity";

const char CameraParameters::FOCUS_MODE_MACRO[] = "macro";

const char CameraParameters::FOCUS_MODE_FIXED[] = "fixed";



static const char* portrait = "portrait";

static const char* landscape = "landscape";
@@ -150,7 +247,7 @@ void CameraParameters::setPreviewSize(int width, int height) 
{

    char str[32];

    sprintf(str, "%dx%d", width, height);

    set("preview-size", str);

    set(KEY_PREVIEW_SIZE, str);

}



void CameraParameters::getPreviewSize(int *width, int *height) const
@@ -159,7 +256,7 @@ void CameraParameters::getPreviewSize(int *width, int *height) const 
    *height = -1;



    // Get the current string, if it doesn't exist, leave the -1x-1

    const char *p = get("preview-size");

    const char *p = get(KEY_PREVIEW_SIZE);

    if (p == 0)

        return;
@@ -172,17 +269,17 @@ void CameraParameters::getPreviewSize(int *width, int *height) const 


void CameraParameters::setPreviewFrameRate(int fps)

{

    set("preview-frame-rate", fps);

    set(KEY_PREVIEW_FRAME_RATE, fps);

}



int CameraParameters::getPreviewFrameRate() const

{

    return getInt("preview-frame-rate");

    return getInt(KEY_PREVIEW_FRAME_RATE);

}



void CameraParameters::setPreviewFormat(const char *format)

{

    set("preview-format", format);

    set(KEY_PREVIEW_FORMAT, format);

}



int CameraParameters::getOrientation() const
@@ -196,22 +293,22 @@ int CameraParameters::getOrientation() const 
void CameraParameters::setOrientation(int orientation)

{

    if (orientation == CAMERA_ORIENTATION_PORTRAIT) {

        set("preview-format", portrait);

        set("orientation", portrait);

    } else {

        set("preview-format", landscape);

        set("orientation", landscape);

    }

}



const char *CameraParameters::getPreviewFormat() const

{

    return get("preview-format");

    return get(KEY_PREVIEW_FORMAT);

}



void CameraParameters::setPictureSize(int width, int height)

{

    char str[32];

    sprintf(str, "%dx%d", width, height);

    set("picture-size", str);

    set(KEY_PICTURE_SIZE, str);

}



void CameraParameters::getPictureSize(int *width, int *height) const
@@ -220,7 +317,7 @@ void CameraParameters::getPictureSize(int *width, int *height) const 
    *height = -1;



    // Get the current string, if it doesn't exist, leave the -1x-1

    const char *p = get("picture-size");

    const char *p = get(KEY_PICTURE_SIZE);

    if (p == 0)

        return;
@@ -233,12 +330,12 @@ void CameraParameters::getPictureSize(int *width, int *height) const 


void CameraParameters::setPictureFormat(const char *format)

{

    set("picture-format", format);

    set(KEY_PICTURE_FORMAT, format);

}



const char *CameraParameters::getPictureFormat() const

{

    return get("picture-format");

    return get(KEY_PICTURE_FORMAT);

}



void CameraParameters::dump() const

opengl/libs/Android.mk

+4 −0
Original line number Diff line number Diff line
@@ -32,6 +32,10 @@ ifeq ($(TARGET_BOARD_PLATFORM),msm7k) 
LOCAL_CFLAGS += -DADRENO130=1

endif



ifeq ($(TARGET_BOARD_PLATFORM),qsd8k)

LOCAL_CFLAGS += -DADRENO130=1

endif



include $(BUILD_SHARED_LIBRARY)

installed_libEGL := $(LOCAL_INSTALLED_MODULE)

opengl/tests/gl2_basic/gl2_basic.cpp

+36 −55
Original line number Diff line number Diff line
@@ -44,17 +44,6 @@ static void printGLString(const char *name, GLenum s) { 
    fprintf(stderr, "GL %s = %s\n", name, v);

}



static const char* eglErrorToString[] = {

        "EGL_SUCCESS", // 0x3000 12288

        "EGL_NOT_INITIALIZED",

        "EGL_BAD_ACCESS", // 0x3002 12290

        "EGL_BAD_ALLOC", "EGL_BAD_ATTRIBUTE",

        "EGL_BAD_CONFIG",

        "EGL_BAD_CONTEXT", // 0x3006 12294

        "EGL_BAD_CURRENT_SURFACE", "EGL_BAD_DISPLAY", "EGL_BAD_MATCH",

        "EGL_BAD_NATIVE_PIXMAP", "EGL_BAD_NATIVE_WINDOW", "EGL_BAD_PARAMETER", // 0x300c 12300

        "EGL_BAD_SURFACE" };



static void checkEglError(const char* op, EGLBoolean returnVal = EGL_TRUE) {

    if (returnVal != EGL_TRUE) {

        fprintf(stderr, "%s() returned %d\n", op, returnVal);
@@ -62,11 +51,7 @@ static void checkEglError(const char* op, EGLBoolean returnVal = EGL_TRUE) { 


    for (EGLint error = eglGetError(); error != EGL_SUCCESS; error

            = eglGetError()) {

        const char* errorString = "unknown";

        if (error >= EGL_SUCCESS && error <= EGL_BAD_SURFACE) {

            errorString = eglErrorToString[error - EGL_SUCCESS];

        }

        fprintf(stderr, "after %s() eglError %s (0x%x)\n", op, errorString,

        fprintf(stderr, "after %s() eglError %s (0x%x)\n", op, EGLUtils::strerror(error),

                error);

    }

}
@@ -190,22 +175,33 @@ void renderFrame() { 
    checkGlError("glDrawArrays");

}



#if 0



void PrintEGLConfig(EGLDisplay dpy, EGLConfig config) {

	int attrib[] = {EGL_RED_SIZE, EGL_GREEN_SIZE, EGL_BLUE_SIZE, EGL_ALPHA_SIZE,

			EGL_DEPTH_SIZE, EGL_SURFACE_TYPE, EGL_RENDERABLE_TYPE

	};

	for(size_t i = 0; i < sizeof(attrib)/sizeof(attrib[0]); i++) {

        int value = 0;

        int a = attrib[i];

        if (eglGetConfigAttrib(dpy, config, a, &value)) {

            printf(" 0x%04x: %d", a, value);

        }

	}

	printf("\n");

}



#endif



int main(int argc, char** argv) {

    EGLBoolean returnValue;

    EGLConfig configs[2];

    EGLint config_count;

    EGLConfig myConfig = {0};



    EGLint context_attribs[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE };

    EGLint s_configAttribs[] = { EGL_BUFFER_SIZE, EGL_DONT_CARE, EGL_RED_SIZE,

            5, EGL_GREEN_SIZE, 6, EGL_BLUE_SIZE, 5, EGL_DEPTH_SIZE, 8,

            EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, EGL_NONE };



    EGLint s_configAttribs2[] =

    {

            EGL_DEPTH_SIZE,     16,

            EGL_NONE

    };



    EGLint s_configAttribs[] = {

            EGL_SURFACE_TYPE, EGL_PBUFFER_BIT|EGL_WINDOW_BIT,

            EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,

            EGL_NONE };

    EGLint majorVersion;

    EGLint minorVersion;

    EGLContext context;
@@ -214,9 +210,6 @@ int main(int argc, char** argv) { 


    EGLDisplay dpy;



    EGLNativeWindowType window = 0;

    window = android_createDisplaySurface();



    checkEglError("<init>");

    dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);

    checkEglError("eglGetDisplay");
@@ -233,43 +226,31 @@ int main(int argc, char** argv) { 
        return 0;

    }



    returnValue = eglGetConfigs(dpy, configs, 2, &config_count);

    checkEglError("eglGetConfigs", returnValue);

    fprintf(stderr, "Config count: %d\n", config_count);

    for (int i = 0; i < config_count; i++) {

        fprintf(stderr, "%d: 0x%08x\n", i, (unsigned int) configs[i]);

    }



#if 0

    EGLConfig config;

    EGLUtils::selectConfigForNativeWindow(dpy, s_configAttribs, window, &config);

    checkEglError("EGLUtils::selectConfigForNativeWindow");

#else

    int chooseConfigResult = eglChooseConfig(dpy, s_configAttribs2, configs, 2,

            &config_count);

    checkEglError("eglChooseConfig", chooseConfigResult);

    if (chooseConfigResult != EGL_TRUE) {

        printf("eglChooseConfig failed\n");

    EGLNativeWindowType window = android_createDisplaySurface();

    returnValue = EGLUtils::selectConfigForNativeWindow(dpy, s_configAttribs, window, &myConfig);

    if (returnValue) {

    	printf("EGLUtils::selectConfigForNativeWindow() returned %d", returnValue);

    	return 0;

    }

#endif



    surface = eglCreateWindowSurface(dpy, configs[0], window, NULL);

    surface = eglCreateWindowSurface(dpy, myConfig, window, NULL);

    checkEglError("eglCreateWindowSurface");

    if (surface == EGL_NO_SURFACE) {

        printf("gelCreateWindowSurface failed.\n");

        return 0;

    }

    EGLint gl2_0Attribs[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE };



    context = eglCreateContext(dpy, configs[0], EGL_NO_CONTEXT, context_attribs);

    context = eglCreateContext(dpy, myConfig, EGL_NO_CONTEXT, context_attribs);

    checkEglError("eglCreateContext");

    if (context == EGL_NO_CONTEXT) {

        printf("eglCreateContext failed\n");

        return 0;

    }

    eglMakeCurrent(dpy, surface, surface, context);

    checkEglError("eglMakeCurrent");

    returnValue = eglMakeCurrent(dpy, surface, surface, context);

    checkEglError("eglMakeCurrent", returnValue);

    if (returnValue != EGL_TRUE) {

        return 0;

    }

    eglQuerySurface(dpy, surface, EGL_WIDTH, &w);

    checkEglError("eglQuerySurface");

    eglQuerySurface(dpy, surface, EGL_HEIGHT, &h);

opengl/tests/gl2_jni/Android.mk

+0 −2
Original line number Diff line number Diff line
@@ -44,8 +44,6 @@ LOCAL_SHARED_LIBRARIES := \ 


LOCAL_MODULE := libgl2jni



LOCAL_ARM_MODE := arm



LOCAL_PRELINK_MODULE := false



include $(BUILD_SHARED_LIBRARY)