title: How do I use native C libraries in Android Studio
body: <p>I created a problem some years back based on <a href="https://ikaruga2.wordpress.com/2011/06/15/video-live-wallpaper-part-1/" rel="noreferrer">https://ikaruga2.wordpress.com/2011/06/15/video-live-wallpaper-part-1/</a>.  My project was built in the version of Eclipse provided directly by Google at the time and worked fine with a copy of the compiled ffmpeg libraries created with my app name.</p>
  
  <p>Now I'm trying to create a new app based on my old app.  As Google no longer supports Eclipse I downloaded Android Studio and imported my project.  With a few tweaks, I was able to successfully compile the old version of the project.  So I modified the name, copied a new set of ".so" files into app\src\main\jniLibs\armeabi (where I assumed they should go) and tried running the application on my phone again with absolutely no other changes.</p>
  
  <p>The NDK throws no errors.  Gradle compiles the file without errors and installs it on my phone.  The app appears in my live wallpapers list and I can click it to bring up the preview.  But instead of a video appearing I receive and error and logCat reports:</p>
  
  <pre><code>02-26 21:50:31.164  18757-18757/? E/AndroidRuntime﹕ FATAL EXCEPTION: main
  java.lang.ExceptionInInitializerError
          at com.nightscapecreations.anim3free.VideoLiveWallpaper.onSharedPreferenceChanged(VideoLiveWallpaper.java:165)
          at com.nightscapecreations.anim3free.VideoLiveWallpaper.onCreate(VideoLiveWallpaper.java:81)
          at android.app.ActivityThread.handleCreateService(ActivityThread.java:2273)
          at android.app.ActivityThread.access$1600(ActivityThread.java:127)
          at android.app.ActivityThread$H.handleMessage(ActivityThread.java:1212)
          at android.os.Handler.dispatchMessage(Handler.java:99)
          at android.os.Looper.loop(Looper.java:137)
          at android.app.ActivityThread.main(ActivityThread.java:4441)
          at java.lang.reflect.Method.invokeNative(Native Method)
          at java.lang.reflect.Method.invoke(Method.java:511)
          at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:823)
          at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:590)
          at dalvik.system.NativeStart.main(Native Method)
   Caused by: java.lang.UnsatisfiedLinkError: Cannot load library: link_image[1936]:   144 could not load needed library '/data/data/com.nightscapecreations.anim1free/lib/libavutil.so' for 'libavcore.so' (load_library[1091]: Library '/data/data/com.nightscapecreations.anim1free/lib/libavutil.so' not found)
          at java.lang.Runtime.loadLibrary(Runtime.java:370)
          at java.lang.System.loadLibrary(System.java:535)
          at com.nightscapecreations.anim3free.NativeCalls.&lt;clinit&gt;(NativeCalls.java:64)
          at com.nightscapecreations.anim3free.VideoLiveWallpaper.onSharedPreferenceChanged(VideoLiveWallpaper.java:165)
          at com.nightscapecreations.anim3free.VideoLiveWallpaper.onCreate(VideoLiveWallpaper.java:81)
          at android.app.ActivityThread.handleCreateService(ActivityThread.java:2273)
          at android.app.ActivityThread.access$1600(ActivityThread.java:127)
          at android.app.ActivityThread$H.handleMessage(ActivityThread.java:1212)
          at android.os.Handler.dispatchMessage(Handler.java:99)
          at android.os.Looper.loop(Looper.java:137)
          at android.app.ActivityThread.main(ActivityThread.java:4441)
          at java.lang.reflect.Method.invokeNative(Native Method)
          at java.lang.reflect.Method.invoke(Method.java:511)
  </code></pre>
  
  <p>I'm a novice Android/Java/C++ developer and am not sure what this error means, but Google leads me to believe that my new libraries are not being found.  In my Eclipse project I had this set of libraries in "libs\armeabi", and another copy of them in a more complicated folder structure at "jni\ffmpeg-android\build\ffmpeg\armeabi\lib".  Android Studio appears to have kept everything the same, other than renaming "libs" to "jniLibs", but I'm hitting a brick wall with this error and am unsure how to proceed.</p>
  
  <p>How can I compile this new app with the new name using Android Studio?</p>
  
  <p>In case it helps here is my Android.mk file:</p>
  
  <pre><code>    LOCAL_PATH := $(call my-dir)
  
      include $(CLEAR_VARS)
      MY_LIB_PATH := ffmpeg-android/build/ffmpeg/armeabi/lib
      LOCAL_MODULE := bambuser-libavcore
      LOCAL_SRC_FILES := $(MY_LIB_PATH)/libavcore.so
      include $(PREBUILT_SHARED_LIBRARY)
  
      include $(CLEAR_VARS)
      LOCAL_MODULE := bambuser-libavformat
      LOCAL_SRC_FILES := $(MY_LIB_PATH)/libavformat.so
      include $(PREBUILT_SHARED_LIBRARY)
  
      include $(CLEAR_VARS)
      LOCAL_MODULE := bambuser-libavcodec
      LOCAL_SRC_FILES := $(MY_LIB_PATH)/libavcodec.so
      include $(PREBUILT_SHARED_LIBRARY)
  
      include $(CLEAR_VARS)
      LOCAL_MODULE := bambuser-libavfilter
      LOCAL_SRC_FILES := $(MY_LIB_PATH)/libavfilter.so
      include $(PREBUILT_SHARED_LIBRARY)
  
      include $(CLEAR_VARS)
      LOCAL_MODULE := bambuser-libavutil
      LOCAL_SRC_FILES := $(MY_LIB_PATH)/libavutil.so
      include $(PREBUILT_SHARED_LIBRARY)
  
      include $(CLEAR_VARS)
      LOCAL_MODULE := bambuser-libswscale
      LOCAL_SRC_FILES := $(MY_LIB_PATH)/libswscale.so
      include $(PREBUILT_SHARED_LIBRARY)
  
      #local_PATH := $(call my-dir)
  
      include $(CLEAR_VARS)
  
      LOCAL_CFLAGS := -DANDROID_NDK \
                      -DDISABLE_IMPORTGL
  
      LOCAL_MODULE    := video
      LOCAL_SRC_FILES := video.c
  
      LOCAL_C_INCLUDES := \
          $(LOCAL_PATH)/include \
          $(LOCAL_PATH)/ffmpeg-android/ffmpeg \
          $(LOCAL_PATH)/freetype/include/freetype2 \
          $(LOCAL_PATH)/freetype/include \
          $(LOCAL_PATH)/ftgl/src \
          $(LOCAL_PATH)/ftgl
      LOCAL_LDLIBS := -L$(NDK_PLATFORMS_ROOT)/$(TARGET_PLATFORM)/arch-arm/usr/lib -L$(LOCAL_PATH) -L$(LOCAL_PATH)/ffmpeg-android/build/ffmpeg/armeabi/lib/ -lGLESv1_CM -ldl -lavformat -lavcodec -lavfilter -lavutil -lswscale -llog -lz -lm
  
      include $(BUILD_SHARED_LIBRARY)
  </code></pre>
  
  <p>And here is my NativeCalls.java:</p>
  
  <pre><code>    package com.nightscapecreations.anim3free;
  
      public class NativeCalls {
          //ffmpeg
          public static native void initVideo();
          public static native void loadVideo(String fileName); //
          public static native void prepareStorageFrame();
          public static native void getFrame(); //
          public static native void freeConversionStorage();
          public static native void closeVideo();//
          public static native void freeVideo();//
          //opengl
          public static native void initPreOpenGL(); //
          public static native void initOpenGL(); //
          public static native void drawFrame(); //
          public static native void closeOpenGL(); //
          public static native void closePostOpenGL();//
          //wallpaper
          public static native void updateVideoPosition();
          public static native void setSpanVideo(boolean b);
          //getters
          public static native int getVideoHeight();
          public static native int getVideoWidth();
          //setters
          public static native void setWallVideoDimensions(int w,int h);
          public static native void setWallDimensions(int w,int h);
          public static native void setScreenPadding(int w,int h);
          public static native void setVideoMargins(int w,int h);
          public static native void setDrawDimensions(int drawWidth,int drawHeight);
          public static native void setOffsets(int x,int y);
          public static native void setSteps(int xs,int ys);
          public static native void setScreenDimensions(int w, int h);
          public static native void setTextureDimensions(int tx,
                                 int ty );
          public static native void setOrientation(boolean b);
          public static native void setPreviewMode(boolean b);
          public static native void setTonality(int t);
          public static native void toggleGetFrame(boolean b);
          //fps
          public static native void setLoopVideo(boolean b);
  
          static {
          System.loadLibrary("avcore");
          System.loadLibrary("avformat");
          System.loadLibrary("avcodec");
          //System.loadLibrary("avdevice");
          System.loadLibrary("avfilter");
          System.loadLibrary("avutil");
          System.loadLibrary("swscale");
          System.loadLibrary("video");
          }
  
      }
  </code></pre>
  
  <p><strong>EDIT</strong></p>
  
  <p>This is the first part of my video.c file:</p>
  
  <pre><code>    #include &lt;GLES/gl.h&gt;
      #include &lt;GLES/glext.h&gt;
  
      #include &lt;GLES2/gl2.h&gt;
      #include &lt;GLES2/gl2ext.h&gt;
  
      #include &lt;stdlib.h&gt;
      #include &lt;time.h&gt;
  
      #include &lt;libavcodec/avcodec.h&gt;
      #include &lt;libavformat/avformat.h&gt;
      #include &lt;libswscale/swscale.h&gt;
  
      #include &lt;jni.h&gt;  
      #include &lt;string.h&gt;  
      #include &lt;stdio.h&gt;
      #include &lt;android/log.h&gt;
  
      //#include &lt;FTGL/ftgl.h&gt;
  
      //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;
      float           aspect_ratio;
  
      //ffmpeg video conversion variables
      AVFrame         *pFrameConverted=NULL;
      int             numBytes;
      uint8_t         *bufferConverted=NULL;
  
      //opengl
      int textureFormat=PIX_FMT_RGBA; // PIX_FMT_RGBA   PIX_FMT_RGB24
      int GL_colorFormat=GL_RGBA; // Must match the colorspace specified for textureFormat
      int textureWidth=256;
      int textureHeight=256;
      int nTextureHeight=-256;
      int textureL=0, textureR=0, textureW=0;
      int frameTonality;
  
      //GLuint textureConverted=0;
      GLuint texturesConverted[2] = { 0,1 };
      GLuint dummyTex = 2;
      static int len=0;
  
  
      static const char* BWVertexSrc =
               "attribute vec4 InVertex;\n"
               "attribute vec2 InTexCoord0;\n"
               "attribute vec2 InTexCoord1;\n"
               "uniform mat4 ProjectionModelviewMatrix;\n"
               "varying vec2 TexCoord0;\n"
               "varying vec2 TexCoord1;\n"
  
               "void main()\n"
               "{\n"
               "  gl_Position = ProjectionModelviewMatrix * InVertex;\n"
               "  TexCoord0 = InTexCoord0;\n"
               "  TexCoord1 = InTexCoord1;\n"
               "}\n";
      static const char* BWFragmentSrc  =
  
               "#version 110\n"
               "uniform sampler2D Texture0;\n"
               "uniform sampler2D Texture1;\n"
  
               "varying vec2 TexCoord0;\n"
               "varying vec2 TexCoord1;\n"
  
               "void main()\n"
               "{\n"
              "   vec3 color = texture2D(m_Texture, texCoord).rgb;\n"
              "   float gray = (color.r + color.g + color.b) / 3.0;\n"
              "   vec3 grayscale = vec3(gray);\n"
  
              "   gl_FragColor = vec4(grayscale, 1.0);\n"
               "}";
      static GLuint shaderProgram;
  
  
      //// Create a pixmap font from a TrueType file.
      //FTGLPixmapFont font("/home/user/Arial.ttf");
      //// Set the font size and render a small text.
      //font.FaceSize(72);
      //font.Render("Hello World!");
  
      //screen dimensions
      int screenWidth = 50;
      int screenHeight= 50;
      int screenL=0, screenR=0, screenW=0;
      int dPaddingX=0,dPaddingY=0;
      int drawWidth=50,drawHeight=50;
  
      //wallpaper
      int wallWidth = 50;
      int wallHeight = 50;
      int xOffSet, yOffSet;
      int xStep, yStep;
      jboolean spanVideo = JNI_TRUE;
  
      //video dimensions
      int wallVideoWidth = 0;
      int wallVideoHeight = 0;
      int marginX, marginY;
      jboolean isScreenPortrait = JNI_TRUE;
      jboolean isPreview = JNI_TRUE;
      jboolean loopVideo = JNI_TRUE;
      jboolean isGetFrame = JNI_TRUE;
  
      //file
      const char * szFileName;
  
      #define max( a, b ) ( ((a) &gt; (b)) ? (a) : (b) )
      #define min( a, b ) ( ((a) &lt; (b)) ? (a) : (b) )
  
      //test variables
      #define RGBA8(r, g, b)  (((r) &lt;&lt; (24)) | ((g) &lt;&lt; (16)) | ((b) &lt;&lt; (8)) | 255)
      int sPixelsInited=JNI_FALSE;
      uint32_t *s_pixels=NULL;
  
      int s_pixels_size() { 
        return (sizeof(uint32_t) * textureWidth * textureHeight * 5); 
      }
  
      void render_pixels1(uint32_t *pixels, uint32_t c) {
          int x, y;
          /* fill in a square of 5 x 5 at s_x, s_y */
          for (y = 0; y &lt; textureHeight; y++) {
              for (x = 0; x &lt; textureWidth; x++) {
                  int idx = x + y * textureWidth;
                  pixels[idx++] = RGBA8(255, 255, 0);
              }
          }
      }
  
      void render_pixels2(uint32_t *pixels, uint32_t c) {
          int x, y;
          /* fill in a square of 5 x 5 at s_x, s_y */
          for (y = 0; y &lt; textureHeight; y++) {
              for (x = 0; x &lt; textureWidth; x++) {
                  int idx = x + y * textureWidth;
                  pixels[idx++] = RGBA8(0, 0, 255);
              }
          }
      }
  
      void Java_com_nightscapecreations_anim3free_NativeCalls_initVideo (JNIEnv * env, jobject this) {
          initializedVideo = 0;
          initializedFrame = 0;
      }
  
      /* list of things that get loaded: */
      /* buffer */
      /* pFrameConverted */
      /* pFrame */
      /* pCodecCtx */
      /* pFormatCtx */
      void Java_com_nightscapecreations_anim3free_NativeCalls_loadVideo (JNIEnv * env, jobject this, jstring fileName)  {
          jboolean isCopy;
          szFileName = (*env)-&gt;GetStringUTFChars(env, fileName, &amp;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(&amp;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)&lt;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&lt;pFormatCtx-&gt;nb_streams; i++)
              if(pFormatCtx-&gt;streams[i]-&gt;codec-&gt;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-&gt;streams[videoStream]-&gt;codec;
          // Find the decoder for the video stream
          pCodec=avcodec_find_decoder(pCodecCtx-&gt;codec_id);
          if(pCodec==NULL) {
              __android_log_print(ANDROID_LOG_DEBUG, "video.c", "NDK: Unsupported codec");
              return;
          }
          // Open codec
          if(avcodec_open(pCodecCtx, pCodec)&lt;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");
      }
  
      //for this to work, you need to set the scaled video dimensions first
      void Java_com_nightscapecreations_anim3free_NativeCalls_prepareStorageFrame (JNIEnv * env, jobject this)  {
          // Allocate an AVFrame structure
          pFrameConverted=avcodec_alloc_frame();
          // Determine required buffer size and allocate buffer
          numBytes=avpicture_get_size(textureFormat, textureWidth, textureHeight);
          bufferConverted=(uint8_t *)av_malloc(numBytes*sizeof(uint8_t));
          if ( pFrameConverted == NULL || bufferConverted == NULL )
              __android_log_print(ANDROID_LOG_DEBUG, "prepareStorage&gt;&gt;&gt;&gt;", "Out of memory");
          // Assign appropriate parts of buffer to image planes in pFrameRGB
          // Note that pFrameRGB is an AVFrame, but AVFrame is a superset
          // of AVPicture
          avpicture_fill((AVPicture *)pFrameConverted, bufferConverted, textureFormat, textureWidth, textureHeight);
          __android_log_print(ANDROID_LOG_DEBUG, "prepareStorage&gt;&gt;&gt;&gt;", "Created frame");
          __android_log_print(ANDROID_LOG_DEBUG, "prepareStorage&gt;&gt;&gt;&gt;", "texture dimensions: %dx%d", textureWidth, textureHeight);
          initializedFrame = 1;
      }
  
      jint Java_com_nightscapecreations_anim3free_NativeCalls_getVideoWidth (JNIEnv * env, jobject this)  {
          return pCodecCtx-&gt;width;
      }
  
      jint Java_com_nightscapecreations_anim3free_NativeCalls_getVideoHeight (JNIEnv * env, jobject this)  {
          return pCodecCtx-&gt;height;
      }
  
      void Java_com_nightscapecreations_anim3free_NativeCalls_getFrame (JNIEnv * env, jobject this)  {
          // keep reading packets until we hit the end or find a video packet
          while(av_read_frame(pFormatCtx, &amp;packet)&gt;=0) {
              static struct SwsContext *img_convert_ctx;
              // 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, &amp;frameFinished, packet.data, packet.size);
                  // Did we get a video frame?
                  if(frameFinished) {
                      if(img_convert_ctx == NULL) {
                          /* get/set the scaling context */
                          int w = pCodecCtx-&gt;width;
                          int h = pCodecCtx-&gt;height;
                          img_convert_ctx = sws_getContext(w, h, pCodecCtx-&gt;pix_fmt, textureWidth,textureHeight, textureFormat, SWS_FAST_BILINEAR, NULL, NULL, NULL);
                          if(img_convert_ctx == NULL) {
                              return;
                          }
                      }
                      /* if img convert null */
                      /* finally scale the image */
                      /* __android_log_print(ANDROID_LOG_DEBUG,  */
                      /*          "video.c",  */
                      /*          "getFrame: Try to scale the image" */
                      /*          ); */
  
                      //pFrameConverted = pFrame;
                      sws_scale(img_convert_ctx, pFrame-&gt;data, pFrame-&gt;linesize, 0, pCodecCtx-&gt;height, pFrameConverted-&gt;data, pFrameConverted-&gt;linesize);
                      //av_picture_crop(pFrameConverted-&gt;data, pFrame-&gt;data, 1, pCodecCtx-&gt;height, pCodecCtx-&gt;width);
                      //av_picture_crop();
                      //avfilter_vf_crop();
  
                      /* do something with pFrameConverted */
                      /* ... see drawFrame() */
                      /* We found a video frame, did something with it, now free up
                         packet and return */
                      av_free_packet(&amp;packet);
      //              __android_log_print(ANDROID_LOG_INFO, "Droid Debug", "pFrame.age: %d", pFrame-&gt;age);
      //              __android_log_print(ANDROID_LOG_INFO, "Droid Debug", "pFrame.buffer_hints: %d", pFrame-&gt;buffer_hints);
      //              __android_log_print(ANDROID_LOG_INFO, "Droid Debug", "pFrame.display_picture_number: %d", pFrame-&gt;display_picture_number);
      //              __android_log_print(ANDROID_LOG_INFO, "Droid Debug", "pFrame.hwaccel_picture_private: %d", pFrame-&gt;hwaccel_picture_private);
      //              __android_log_print(ANDROID_LOG_INFO, "Droid Debug", "pFrame.key_frame: %d", pFrame-&gt;key_frame);
      //              __android_log_print(ANDROID_LOG_INFO, "Droid Debug", "pFrame.palette_has_changed: %d", pFrame-&gt;palette_has_changed);
      //              __android_log_print(ANDROID_LOG_INFO, "Droid Debug", "pFrame.pict_type: %d", pFrame-&gt;pict_type);
      //              __android_log_print(ANDROID_LOG_INFO, "Droid Debug", "pFrame.qscale_type: %d", pFrame-&gt;qscale_type);
      //              __android_log_print(ANDROID_LOG_INFO, "Droid Debug", "pFrameConverted.age: %d", pFrameConverted-&gt;age);
      //              __android_log_print(ANDROID_LOG_INFO, "Droid Debug", "pFrameConverted.buffer_hints: %d", pFrameConverted-&gt;buffer_hints);
      //              __android_log_print(ANDROID_LOG_INFO, "Droid Debug", "pFrameConverted.display_picture_number: %d", pFrameConverted-&gt;display_picture_number);
      //              __android_log_print(ANDROID_LOG_INFO, "Droid Debug", "pFrameConverted.hwaccel_picture_private: %d", pFrameConverted-&gt;hwaccel_picture_private);
      //              __android_log_print(ANDROID_LOG_INFO, "Droid Debug", "pFrameConverted.key_frame: %d", pFrameConverted-&gt;key_frame);
      //              __android_log_print(ANDROID_LOG_INFO, "Droid Debug", "pFrameConverted.palette_has_changed: %d", pFrameConverted-&gt;palette_has_changed);
      //              __android_log_print(ANDROID_LOG_INFO, "Droid Debug", "pFrameConverted.pict_type: %d", pFrameConverted-&gt;pict_type);
      //              __android_log_print(ANDROID_LOG_INFO, "Droid Debug", "pFrameConverted.qscale_type: %d", pFrameConverted-&gt;qscale_type);
                      return;
                  } /* if frame finished */
              } /* if packet video stream */
              // Free the packet that was allocated by av_read_frame
              av_free_packet(&amp;packet);
          } /* while */
          //reload video when you get to the end
          av_seek_frame(pFormatCtx,videoStream,0,AVSEEK_FLAG_ANY);
      }
  
      void Java_com_nightscapecreations_anim3free_NativeCalls_setLoopVideo (JNIEnv * env, jobject this, jboolean b) {
          loopVideo = b;
      }
  
      void Java_com_nightscapecreations_anim3free_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&gt;&gt;&gt;&gt;", "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&gt;&gt;&gt;&gt;", "Freed video structures");
          }
      }
  
      void Java_com_nightscapecreations_anim3free_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&gt;&gt;&gt;&gt;", "Freed video structures");
              initializedVideo = 0;
          }
      }
  
      void Java_com_nightscapecreations_anim3free_NativeCalls_freeConversionStorage (JNIEnv * env, jobject this) {
          if ( initializedFrame == 1 ) {
              // Free the converted image
              av_free(bufferConverted);
              av_freep(pFrameConverted);
              initializedFrame = 0;
          }
      }
  
      /*--- END OF VIDEO ----*/
  
      /* disable these capabilities. */
      static GLuint s_disable_options[] = {
          GL_FOG,
          GL_LIGHTING,
          GL_CULL_FACE,
          GL_ALPHA_TEST,
          GL_BLEND,
          GL_COLOR_LOGIC_OP,
          GL_DITHER,
          GL_STENCIL_TEST,
          GL_DEPTH_TEST,
          GL_COLOR_MATERIAL,
          0
      };
  
      // For stuff that opengl needs to work with,
      // like the bitmap containing the texture
      void Java_com_nightscapecreations_anim3free_NativeCalls_initPreOpenGL (JNIEnv * env, jobject this)  {
  
      }
      ...
  </code></pre>