Помогите написать инициализацию OpenGL и проверить рендер

// OpenGL ES 2.0 & EGL
#include <GLES2/gl2.h>
#include <GLES2/gl2ext.h>
//#include <EGL/egl.h>

#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
#include <libswscale/swscale.h>

#include <jni.h>  
#include <string.h>  
#include <stdio.h>
#include <android/log.h>
#include <math.h>

//ffmpeg video variables
int initializedVideo = 0;
int initializedFrame = 0;
AVFormatContext *pFormatCtx = NULL;
int videoStream;
AVCodecContext *pCodecCtx = NULL;
AVCodec *pCodec = NULL;
AVFrame *pFrame = NULL;
AVPacket packet;
int frameFinished;

//ffmpeg video conversion variables
AVFrame *pFrameConverted = NULL;
uint8_t *bufferConverted = NULL;

//screen dimensions
int screenWidth = 0;
int screenHeight = 0;
int dPaddingX = 0, dPaddingY = 0;
//file
const char * szFileName;

// YUV to RGB Render
#define ANDROID_LOG

#ifdef ANDROID_LOG
#include <stdio.h>
#include <android/log.h>
#include <stdint.h>
#include <stdlib.h>

#undef WEBRTC_TRACE
#define WEBRTC_TRACE(a,b,c,...)  __android_log_print(ANDROID_LOG_DEBUG, "*YUV_RENDER*", __VA_ARGS__)
#endif

#define true 1
#define false 0

GLsizei _textureWidth;
GLsizei _textureHeight;
GLfloat _vertices[20];
int _id;
GLuint _program;
GLuint _textureIds[3]; // Texture id of Y,U and V texture.

typedef struct
{
    int Length;
    GLsizei Width;
    GLsizei Height;
    void * Buffer;
} VideoFrame;

VideoFrame frameToRender;

const char g_indices[] = {0, 3, 2, 0, 2, 1};

const char g_vertextShader[] = {
    "attribute vec4 aPosition;\n"
    "attribute vec2 aTextureCoord;\n"
    "varying vec2 vTextureCoord;\n"
    "void main() {\n"
    "  gl_Position = aPosition;\n"
    "  vTextureCoord = aTextureCoord;\n"
    "}\n"
};

// The fragment shader.
// Do YUV to RGB565 conversion.
const char g_fragmentShader[] = {
    "precision mediump float;\n"
    "uniform sampler2D Ytex;\n"
    "uniform sampler2D Utex,Vtex;\n"
    "varying vec2 vTextureCoord;\n"
    "void main(void) {\n"
    "  float nx,ny,r,g,b,y,u,v;\n"
    "  mediump vec4 txl,ux,vx;"
    "  nx=vTextureCoord[0];\n"
    "  ny=vTextureCoord[1];\n"
    "  y=texture2D(Ytex,vec2(nx,ny)).r;\n"
    "  u=texture2D(Utex,vec2(nx,ny)).r;\n"
    "  v=texture2D(Vtex,vec2(nx,ny)).r;\n"

    "  y=1.1643*(y-0.0625);\n"
    "  u=u-0.5;\n"
    "  v=v-0.5;\n"

    "  r=y+1.5958*v;\n"
    "  g=y-0.39173*u-0.81290*v;\n"
    "  b=y+2.017*u;\n"
    "  gl_FragColor=vec4(r,g,b,1.0);\n"
    "}\n"
};

void Java_ffvideolivewallpaper_frankandrobot_com_NativeCalls_VideoRenderOpenGles20(int32_t id)
{
    _id = id;
    _textureWidth = -1;
    _textureHeight = -1;
    frameToRender.Buffer = NULL;
    WEBRTC_TRACE(kTraceDebug, kTraceVideoRenderer, _id, "%s: id %d",
            __FUNCTION__, (int) _id);

    const GLfloat vertices[20] = {
        // X, Y, Z, U, V
        -1, -1, 0, 0, 1, // Bottom Left
        1, -1, 0, 1, 1, //Bottom Right
        1, 1, 0, 1, 0, //Top Right
        -1, 1, 0, 0, 0 //Top Left
    };

    memcpy(_vertices, vertices, sizeof (_vertices));
}

void printGLString(const char *name, GLenum s)
{
    // return a string describing the current GL connection
    const char *v = (const char *) glGetString(s);
    WEBRTC_TRACE(kTraceDebug, kTraceVideoRenderer, _id, "GL %s = %s\n", name, v);
}

void checkGlError(const char* op)
{
#ifdef ANDROID_LOG
    //glGetError returns the value of the error flag
    for (GLint error = glGetError(); error; error = glGetError())
    {
        WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, "after %s() glError (0x%x)\n", op, error);
    }
#else
    return;
#endif
}

GLuint loadShader(GLenum shaderType, const char* pSource)
{
    //glCreateShader creates an empty shader object and returns a non-zero value by which it can be referenced
    GLuint shader = glCreateShader(shaderType);
    if (shader)
    {
        // glShaderSource sets the source code in shader to the source codein the
        // array of strings specified by string.
        glShaderSource(shader, 1, &pSource, NULL);
	// glCompileShader compiles the source code strings that have been stored
        // in the shader objectspecified by shader.
        glCompileShader(shader);
        GLint compiled = 0;
        // glGetShaderiv returns in params the value of a parameter for a specific shader object
        glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
        if (!compiled)
        {
            GLint infoLen = 0;
            glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLen);
            if (infoLen)
            {
                char* buf = (char*) malloc(infoLen);
                if (buf)
                {
                    glGetShaderInfoLog(shader, infoLen, NULL, buf);
                    WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id,
                            "%s: Could not compile shader %d: %s",
                            __FUNCTION__, shaderType, buf);
                    free(buf);
                }
                glDeleteShader(shader);
                shader = 0;
            }
        }
    }
    return shader;
}

GLuint createProgram(const char * pVertexSource, const char * pFragmentSource)
{
    GLuint vertexShader = loadShader(GL_VERTEX_SHADER, pVertexSource);
    if (!vertexShader)
    {
        return 0;
    }

    GLuint pixelShader = loadShader(GL_FRAGMENT_SHADER, pFragmentSource);
    if (!pixelShader)
    {
        return 0;
    }

    GLuint program = glCreateProgram();
    if (program)
    {
        glAttachShader(program, vertexShader);
        checkGlError("glAttachShader");
        glAttachShader(program, pixelShader);
        checkGlError("glAttachShader");
        glLinkProgram(program);
        GLint linkStatus = GL_FALSE;
        glGetProgramiv(program, GL_LINK_STATUS, &linkStatus);
        if (linkStatus != GL_TRUE)
        {
            GLint bufLength = 0;
            glGetProgramiv(program, GL_INFO_LOG_LENGTH, &bufLength);
            if (bufLength)
            {
                char* buf = (char*) malloc(bufLength);
                if (buf)
                {
                    glGetProgramInfoLog(program, bufLength, NULL, buf);
                    WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id,
                            "%s: Could not link program: %s",
                            __FUNCTION__, buf);
                    free(buf);
                }
            }
            glDeleteProgram(program);
            program = 0;
        }
    }
    return program;
}

int32_t Java_ffvideolivewallpaper_frankandrobot_com_NativeCalls_Setup(int32_t width, int32_t height)
{
    WEBRTC_TRACE(kTraceDebug, kTraceVideoRenderer, _id,
            "%s: width %d, height %d", __FUNCTION__, width, height);

    printGLString("Version", GL_VERSION);
    printGLString("Vendor", GL_VENDOR);
    printGLString("Renderer", GL_RENDERER);
    printGLString("Extensions", GL_EXTENSIONS);

    int maxTextureImageUnits[2];
    int maxTextureSize[2];
    glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, maxTextureImageUnits);
    glGetIntegerv(GL_MAX_TEXTURE_SIZE, maxTextureSize);

    WEBRTC_TRACE(kTraceDebug, kTraceVideoRenderer, _id,
            "%s: number of textures %d, size %d", __FUNCTION__,
            (int) maxTextureImageUnits[0], (int) maxTextureSize[0]);

    InitOpenGL();

    _program = createProgram(g_vertextShader, g_fragmentShader);
    if (!_program)
    {
        WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id,
                "%s: Could not create program", __FUNCTION__);
        return -1;
    }

    int positionHandle = glGetAttribLocation(_program, "aPosition");
    checkGlError("glGetAttribLocation aPosition");
    if (positionHandle == -1)
    {
        WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id,
                "%s: Could not get aPosition handle", __FUNCTION__);
        return -1;
    }
    int textureHandle = glGetAttribLocation(_program, "aTextureCoord");
    checkGlError("glGetAttribLocation aTextureCoord");
    if (textureHandle == -1)
    {
        WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id,
                "%s: Could not get aTextureCoord handle", __FUNCTION__);
        return -1;
    }

    // set the vertices array in the shader
    // _vertices contains 4 vertices with 5 coordinates. 3 for (xyz) for the vertices and 2 for the texture
    glVertexAttribPointer(positionHandle, 3, GL_FLOAT, false, 5
            * sizeof (GLfloat), _vertices);
    checkGlError("glVertexAttribPointer aPosition");

    glEnableVertexAttribArray(positionHandle);
    checkGlError("glEnableVertexAttribArray positionHandle");

    // set the texture coordinate array in the shader
    // _vertices contains 4 vertices with 5 coordinates. 3 for (xyz) for the vertices and 2 for the texture
    glVertexAttribPointer(textureHandle, 2, GL_FLOAT, false, 5
            * sizeof (GLfloat), &_vertices[3]);
    checkGlError("glVertexAttribPointer maTextureHandle");
    glEnableVertexAttribArray(textureHandle);
    checkGlError("glEnableVertexAttribArray textureHandle");

    glUseProgram(_program);
    int i = glGetUniformLocation(_program, "Ytex");
    checkGlError("glGetUniformLocation");
    glUniform1i(i, 0); /* Bind Ytex to texture unit 0 */
    checkGlError("glUniform1i Ytex");

    i = glGetUniformLocation(_program, "Utex");
    checkGlError("glGetUniformLocation Utex");
    glUniform1i(i, 1); /* Bind Utex to texture unit 1 */
    checkGlError("glUniform1i Utex");

    i = glGetUniformLocation(_program, "Vtex");
    checkGlError("glGetUniformLocation");
    glUniform1i(i, 2); /* Bind Vtex to texture unit 2 */
    checkGlError("glUniform1i Vtex");

    glViewport(0, 0, width, height);
    checkGlError("glViewport");
    return 0;
}

/*
 * SetCoordinates
 * Sets the coordinates where the stream shall be rendered. Values must be between 0 and 1.
 */
int Java_ffvideolivewallpaper_frankandrobot_com_NativeCalls_SetCoordinates(int32_t zOrder, const float left, const float top, const float right, const float bottom)
{
    if ((top > 1 || top < 0) || (right > 1 || right < 0) || (bottom > 1
            || bottom < 0) || (left > 1 || left < 0))
    {
        WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id,
                "%s: Wrong coordinates", __FUNCTION__);
        return -1;
    }

    // Bottom Left
    _vertices[0] = (left * 2) - 1;
    _vertices[1] = -1 * (2 * bottom) + 1;
    _vertices[2] = zOrder;

    //Bottom Right
    _vertices[5] = (right * 2) - 1;
    _vertices[6] = -1 * (2 * bottom) + 1;
    _vertices[7] = zOrder;

    //Top Right
    _vertices[10] = (right * 2) - 1;
    _vertices[11] = -1 * (2 * top) + 1;
    _vertices[12] = zOrder;

    //Top Left
    _vertices[15] = (left * 2) - 1;
    _vertices[16] = -1 * (2 * top) + 1;
    _vertices[17] = zOrder;

    return 0;
}
[\code]

void InitOpenGL()
{
    // src/modules/audio_processing/main/test/android/apmtest/jni/main.c
    glClearColor(1.0f, 0.0f, 0.0f, 1.0f);
    glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
    glEnable(GL_TEXTURE_2D);
    glDisable(GL_DEPTH_TEST);
}

void SetupTextures(const VideoFrame frameToRender)
{
    WEBRTC_TRACE(kTraceDebug, kTraceVideoRenderer, _id,
            "%s: width %d, height %d length %u", __FUNCTION__,
            frameToRender.Width, frameToRender.Height,
            frameToRender.Length);

    const GLsizei width = frameToRender.Width;
    const GLsizei height = frameToRender.Height;

    glGenTextures(3, _textureIds); //Generate  the Y, U and V texture
    GLuint currentTextureId = _textureIds[0]; // Y
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, currentTextureId);

    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

    glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, width, height, 0,
            GL_LUMINANCE, GL_UNSIGNED_BYTE,
            (const GLvoid*) frameToRender.Buffer);

    currentTextureId = _textureIds[1]; // U
    glActiveTexture(GL_TEXTURE1);
    glBindTexture(GL_TEXTURE_2D, currentTextureId);

    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

    const uint8_t * uComponent = frameToRender.Buffer + width * height;
    glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, width / 2, height / 2, 0,
            GL_LUMINANCE, GL_UNSIGNED_BYTE, (const GLvoid*) uComponent);

    currentTextureId = _textureIds[2]; // V
    glActiveTexture(GL_TEXTURE2);
    glBindTexture(GL_TEXTURE_2D, currentTextureId);

    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

    const uint8_t* vComponent = uComponent + (width * height) / 4;
    glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, width / 2, height / 2, 0,
            GL_LUMINANCE, GL_UNSIGNED_BYTE, (const GLvoid*) vComponent);

    checkGlError("SetupTextures");
    // Texture Size
    _textureWidth = width;
    _textureHeight = height;
}

void UpdateTextures(const VideoFrame frameToRender)
{
    __android_log_print(ANDROID_LOG_DEBUG, "*YUV_Render*", "NDK: UpdateTextures...");
    const GLsizei width = frameToRender.Width;
    const GLsizei height = frameToRender.Height;
    // Y
    GLuint currentTextureId = _textureIds[0];
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, currentTextureId);
    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height, GL_LUMINANCE,
            GL_UNSIGNED_BYTE, (const GLvoid*) frameToRender.Buffer);

    // U
    currentTextureId = _textureIds[1];
    glActiveTexture(GL_TEXTURE1);
    glBindTexture(GL_TEXTURE_2D, currentTextureId);
    const uint8_t* uComponent = frameToRender.Buffer + width * height;
    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width / 2, height / 2,
            GL_LUMINANCE, GL_UNSIGNED_BYTE, (const GLvoid*) uComponent);
    // V
    currentTextureId = _textureIds[2];
    glActiveTexture(GL_TEXTURE2);
    glBindTexture(GL_TEXTURE_2D, currentTextureId);
    const uint8_t* vComponent = uComponent + (width * height) / 4;
    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width / 2, height / 2,
            GL_LUMINANCE, GL_UNSIGNED_BYTE, (const GLvoid*) vComponent);

    checkGlError("UpdateTextures");
}

int32_t Render(const VideoFrame frameToRender)
{
    /*
    if (frameToRender.Length == 0)
    {
        return -1;
    }
     */
    WEBRTC_TRACE(kTraceDebug, kTraceVideoRenderer, _id, "%s: id %d",
            __FUNCTION__, _id);

    glUseProgram(_program);
    checkGlError("glUseProgram");

    if (_textureWidth != frameToRender.Width || _textureHeight
            != frameToRender.Height)
    {
        SetupTextures(frameToRender);
    } else
    {
        UpdateTextures(frameToRender);
    }

    glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, g_indices);
    checkGlError("glDrawArrays");

    return 0;
}
// END YUV RENDER

void Java_ffvideolivewallpaper_frankandrobot_com_NativeCalls_drawFrame
(JNIEnv * env, jobject this)
{
    Render(frameToRender);
}

void Java_ffvideolivewallpaper_frankandrobot_com_NativeCalls_initVideo
(JNIEnv * env, jobject this)
{
    initializedVideo = 0;
    initializedFrame = 0;
}

void Java_ffvideolivewallpaper_frankandrobot_com_NativeCalls_loadVideo
(JNIEnv * env, jobject this, jstring fileName)
{
    jboolean isCopy;
    szFileName = (*env)->GetStringUTFChars(env, fileName, &isCopy);
    //debug
    __android_log_print(ANDROID_LOG_DEBUG, "NDK: ", "NDK:LC: [%s]", szFileName);
    // Register all formats and codecs
    av_register_all();
    // Open video file
    if (av_open_input_file(&pFormatCtx, szFileName, NULL, 0, NULL) != 0)
    {
        __android_log_print(ANDROID_LOG_DEBUG, "video.c", "NDK: Couldn't open file");
        return;
    }
    __android_log_print(ANDROID_LOG_DEBUG, "video.c", "NDK: Succesfully loaded file");
    // Retrieve stream information */
    if (av_find_stream_info(pFormatCtx) < 0)
    {
        __android_log_print(ANDROID_LOG_DEBUG, "video.c", "NDK: Couldn't find stream information");
        return;
    }
    __android_log_print(ANDROID_LOG_DEBUG, "video.c", "NDK: Found stream info");
    // Find the first video stream
    videoStream = -1;
    int i;
    for (i = 0; i < pFormatCtx->nb_streams; i++)
        if (pFormatCtx->streams[i]->codec->codec_type == CODEC_TYPE_VIDEO)
        {
            videoStream = i;
            break;
        }
    if (videoStream == -1)
    {
        __android_log_print(ANDROID_LOG_DEBUG, "video.c", "NDK: Didn't find a video stream");
        return;
    }
    __android_log_print(ANDROID_LOG_DEBUG, "video.c", "NDK: Found video stream");
    // Get a pointer to the codec contetx for the video stream
    pCodecCtx = pFormatCtx->streams[videoStream]->codec;
    // Find the decoder for the video stream
    pCodec = avcodec_find_decoder(pCodecCtx->codec_id);
    if (pCodec == NULL)
    {
        __android_log_print(ANDROID_LOG_DEBUG, "video.c", "NDK: Unsupported codec");
        return;
    }
    // Open codec
    if (avcodec_open(pCodecCtx, pCodec) < 0)
    {
        __android_log_print(ANDROID_LOG_DEBUG, "video.c", "NDK: Could not open codec");
        return;
    }
    // Allocate video frame (decoded pre-conversion frame)
    pFrame = avcodec_alloc_frame();
    // keep track of initialization
    initializedVideo = 1;
    __android_log_print(ANDROID_LOG_DEBUG, "video.c", "NDK: Finished loading video");
}

jint Java_ffvideolivewallpaper_frankandrobot_com_NativeCalls_getVideoWidth
(JNIEnv * env, jobject this)
{
    return pCodecCtx->width;
}

jint Java_ffvideolivewallpaper_frankandrobot_com_NativeCalls_getVideoHeight
(JNIEnv * env, jobject this)
{
    return pCodecCtx->height;
}

void Java_ffvideolivewallpaper_frankandrobot_com_NativeCalls_getFrame
(JNIEnv * env, jobject this)
{
    // keep reading packets until we hit the end or find a video packet
    while (av_read_frame(pFormatCtx, &packet) >= 0)
    {
        // Is this a packet from the video stream?
        if (packet.stream_index == videoStream)
        {
            // Decode video frame
            __android_log_print(ANDROID_LOG_DEBUG,
                    "video.c", "getFrame: Try to decode frame");
            avcodec_decode_video(pCodecCtx, pFrame,
                    &frameFinished, packet.data, packet.size);
            // Did we get a video frame?
            if (frameFinished)
            {
                frameToRender.Width = pCodecCtx->width;
                frameToRender.Height = pCodecCtx->height;

                if (frameToRender.Buffer == NULL)
                {
                    __android_log_print(ANDROID_LOG_DEBUG,
                            "video.c", "getFrame: allocate memory for Buffer");
                    frameToRender.Buffer = malloc((int) (frameToRender.Width * frameToRender.Height * 2));
                }
                __android_log_print(ANDROID_LOG_DEBUG,
                        "video.c", "getFrame: memcpy pFrame to Buffer...");
                memcpy(frameToRender.Buffer, pFrame->data, (int) (frameToRender.Width * 2));

                frameToRender.Length = frameToRender.Width * frameToRender.Height * 2;

                av_free_packet(&packet);
                return;
            } /* if frame finished */
        } /* if packet video stream */
        // Free the packet that was allocated by av_read_frame
        av_free_packet(&packet);
    } /* while */
    //reload video when you get to the end
    av_seek_frame(pFormatCtx, videoStream, 0, AVSEEK_FLAG_ANY);
}

void Java_ffvideolivewallpaper_frankandrobot_com_NativeCalls_closeVideo
(JNIEnv * env, jobject this)
{
    if (initializedFrame == 1)
    {
        // Free the converted image
        av_free(bufferConverted);
        av_free(pFrameConverted);
        initializedFrame = 0;
        __android_log_print(ANDROID_LOG_DEBUG, "closeVideo>>>>", "Freed converted image");
    }
    if (initializedVideo == 1)
    {
        /* // Free the YUV frame */
        av_free(pFrame);
        /* // Close the codec */
        avcodec_close(pCodecCtx);
        // Close the video file
        av_close_input_file(pFormatCtx);
        initializedVideo = 0;
        __android_log_print(ANDROID_LOG_DEBUG, "closeVideo>>>>", "Freed video structures");
    }
}

void Java_ffvideolivewallpaper_frankandrobot_com_NativeCalls_freeVideo
(JNIEnv * env, jobject this)
{
    if (initializedVideo == 1)
    {
        /* // Free the YUV frame */
        av_free(pFrame);
        /* // Close the codec */
        avcodec_close(pCodecCtx);
        // Close the video file
        av_close_input_file(pFormatCtx);
        __android_log_print(ANDROID_LOG_DEBUG, "closeVideo>>>>", "Freed video structures");
        initializedVideo = 0;
    }
}

/*--- END OF VIDEO ----*/
void Java_ffvideolivewallpaper_frankandrobot_com_NativeCalls_setScreenPadding
(JNIEnv *env, jobject this, jint w, jint h)
{
    dPaddingX = w;
    dPaddingY = h;
}