I managed to render Android camera preiview texture to GLSurfaceView now. However, only camera content or 3d model can be shown but BOTH. The following code results only showing the 3d model,
but what I want is the 3d model is shown on top of the camera preview.
@Override
  public synchronized void onDrawFrame(GL10 gl) {
    GLES20.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
    GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT);

    //render the camera texture
    if (updateTexture) {
      mSurfaceTexture.updateTexImage();
      mSurfaceTexture.getTransformMatrix(mTransformM);

      updateTexture = false;

      GLES20.glViewport(0, 0, mWidth, mHeight);

      mOffscreenShader.useProgram();

      int uTransformMLoc = mOffscreenShader.getHandle("uTransformM");
      int uOrientationMLoc = mOffscreenShader.getHandle("uOrientationM");
      int uRatioVLoc = mOffscreenShader.getHandle("ratios");

      GLES20.glUniformMatrix4fv(uTransformMLoc, 1, false, mTransformM, 0);
      GLES20.glUniformMatrix4fv(uOrientationMLoc, 1, false, mOrientationM, 0);
      GLES20.glUniform2fv(uRatioVLoc, 1, mRatio, 0);

      GLES20.glActiveTexture(GLES20.GL_TEXTURE0);
      GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, mCameraTexture.getTextureId());

      renderQuad(mOffscreenShader.getHandle("aPosition"));
    }

    //render 3d model
    frameBuffer.clear();
    world.renderScene(frameBuffer);
    world.draw(frameBuffer);
    frameBuffer.display();
  }


Sorry for my late reply. EgonOlsen, can you help take a look?
The full sample project: https://www.dropbox.com/s/bzgnmholz9z030i/CameraView1.zip?dl=0

Thanks for your help. I went through the thread you provided, it is really helpful. But I encounter the following error. It seems cant compile the vertex shader.
java.lang.RuntimeException: failed creating program
    at com.blogspot.geekonjava.dsmodel_ar.TextureRenderer.surfaceCreated(TextureRenderer.java:117)
    at com.blogspot.geekonjava.dsmodel_ar.MainActivity$MyRenderer.onSurfaceChanged(MainActivity.java:203)
    at android.opengl.GLSurfaceView$GLThread.guardedRun(GLSurfaceView.java:1511)
    at android.opengl.GLSurfaceView$GLThread.run(GLSurfaceView.java:1239)


Here is my code:

TextureRenderer
https://android.googlesource.com/platform/cts/+/master/tests/tests/media/src/android/media/cts/TextureRender.java


package com.blogspot.geekonjava.dsmodel_ar;

import android.app.Activity;
import android.graphics.PixelFormat;
import android.graphics.SurfaceTexture;
import android.opengl.GLES11Ext;
import android.opengl.GLES20;
import android.opengl.GLSurfaceView;
import android.opengl.GLU;
import android.os.Bundle;
import android.view.MotionEvent;

import com.example.dsmodel_ar.R;
import com.threed.jpct.Camera;
import com.threed.jpct.FrameBuffer;
import com.threed.jpct.Light;
import com.threed.jpct.Loader;
import com.threed.jpct.Logger;
import com.threed.jpct.Matrix;
import com.threed.jpct.Object3D;
import com.threed.jpct.SimpleVector;
import com.threed.jpct.Texture;
import com.threed.jpct.TextureManager;
import com.threed.jpct.World;
import com.threed.jpct.util.BitmapHelper;
import com.threed.jpct.util.MemoryHelper;

import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Field;

import javax.microedition.khronos.egl.EGLConfig;
import javax.microedition.khronos.opengles.GL10;

public class MainActivity extends Activity {

  // Used to handle pause and resume...
  private static MainActivity master = null;

  private GLSurfaceView mGLView;
  private MyRenderer renderer = null;
  private FrameBuffer fb = null;
  private World world = null;

  private float touchTurn = 0;
  private float touchTurnUp = 0;

  private float xpos = -1;
  private float ypos = -1;

  private Object3D model = null;
  private Light sun = null;

  private android.hardware.Camera mCamera;

  private SurfaceTexture surfaceTexture;
  private boolean frameAvailable = false;
  private Texture externalTexture;
  private TextureRenderer textureRenderer = new TextureRenderer();

  protected void onCreate(Bundle savedInstanceState) {
    Logger.log("onCreate");

    if (master != null) {
      copy(master);
    }

    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    mGLView = (GLSurfaceView) findViewById(R.id.surfaceView);
    mGLView.setEGLConfigChooser(8, 8, 8, 8, 16, 0);
    mGLView.getHolder().setFormat(PixelFormat.TRANSLUCENT);

    renderer = new MyRenderer();
    mGLView.setRenderer(renderer);

    this.externalTexture = new Texture(32, 32);
    TextureManager.getInstance().flush();
    TextureManager.getInstance().addTexture("video_texture", externalTexture);
  }

  @Override
  protected void onPause() {
    super.onPause();
    mGLView.onPause();
  }

  @Override
  protected void onResume() {
    super.onResume();
    mGLView.onResume();
  }

  @Override
  protected void onStop() {
    super.onStop();
  }

  private void copy(Object src) {
    try {
      Logger.log("Copying data from master Activity!");
      Field[] fs = src.getClass().getDeclaredFields();
      for (Field f : fs) {
        f.setAccessible(true);
        f.set(this, f.get(src));
      }
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
  }

  public boolean onTouchEvent(MotionEvent me) {

    if (me.getAction() == MotionEvent.ACTION_DOWN) {
      xpos = me.getX();
      ypos = me.getY();
      return true;
    }

    if (me.getAction() == MotionEvent.ACTION_UP) {
      xpos = -1;
      ypos = -1;
      touchTurn = 0;
      touchTurnUp = 0;
      return true;
    }

    if (me.getAction() == MotionEvent.ACTION_MOVE) {
      float xd = me.getX() - xpos;
      float yd = me.getY() - ypos;

      xpos = me.getX();
      ypos = me.getY();

      touchTurn = xd / -100f;
      touchTurnUp = yd / -100f;
      return true;
    }

    try {
      Thread.sleep(15);
    } catch (Exception e) {
      // No need for this...
    }

    return super.onTouchEvent(me);
  }

  class MyRenderer implements GLSurfaceView.Renderer {

    private long time = System.currentTimeMillis();

    public MyRenderer() {
    }

    public void onSurfaceChanged(GL10 gl, int w, int h) {
      if (fb != null) {
        fb.dispose();
      }
      fb = new FrameBuffer(gl, w, h);

      if (master == null) {

        world = new World();
        world.setAmbientLight(20, 20, 20);

        sun = new Light(world);
        sun.setIntensity(250, 250, 250);

        Texture texture = new Texture(BitmapHelper.rescale(BitmapHelper.convert(getResources().getDrawable(R.drawable.monster)), 512, 512));
        TextureManager.getInstance().addTexture("texture", texture);

        model = loadModel(R.raw.monster, 1);
        model.setTexture("texture");
        model.build();

        world.addObject(model);

        Camera cam = world.getCamera();
        cam.moveCamera(Camera.CAMERA_MOVEOUT, 50);
        cam.lookAt(model.getTransformedCenter());

        SimpleVector sv = new SimpleVector();
        sv.set(model.getTransformedCenter());
        sv.y -= 100;
        sv.z -= 100;
        sun.setPosition(sv);
        MemoryHelper.compact();

        if (master == null) {
          Logger.log("Saving master Activity!");
          master = MainActivity.this;
        }
      }


      if (surfaceTexture != null) {
        surfaceTexture.release();
      }

      textureRenderer.surfaceCreated();
      surfaceTexture = new SurfaceTexture(textureRenderer.getTextureId());
      externalTexture.setExternalId(textureRenderer.getTextureId(), GLES11Ext.GL_TEXTURE_EXTERNAL_OES);
      surfaceTexture.setOnFrameAvailableListener(new SurfaceTexture.OnFrameAvailableListener() {
        @Override
        public void onFrameAvailable(SurfaceTexture surfaceTexture) {
          synchronized (MainActivity.this) {
            frameAvailable = true;
          }
        }
      });

      MemoryHelper.compact();


      mCamera = android.hardware.Camera.open();
      try {
        mCamera.setPreviewTexture(surfaceTexture);
        mCamera.startPreview();
      } catch (IOException ioe) {
        // Something bad happened
      }
    }

    public void onSurfaceCreated(GL10 gl, EGLConfig config) {
    }

    public void onDrawFrame(GL10 gl) {
      if (touchTurn != 0) {
        model.rotateY(touchTurn);
        touchTurn = 0;
      }

      if (touchTurnUp != 0) {
        model.rotateX(touchTurnUp);
        touchTurnUp = 0;
      }

      fb.clear();
      world.renderScene(fb);
      world.draw(fb);
      fb.display();

      synchronized (this) {
        if (frameAvailable) {
          int error = GLES20.glGetError();
          if (error != 0) {
            System.out.println("gl error before updateTexImage" + error + ": " + GLU.gluErrorString(error));
          }
          surfaceTexture.updateTexImage();
          frameAvailable = false;
        }
      }
    }

    private Object3D loadModel(int filename, float scale) {
      InputStream stream = getResources().openRawResource(filename);
      Object3D[] model = Loader.load3DS(stream, scale);
      Object3D o3d = new Object3D(0);
      Object3D temp = null;
      for (int i = 0; i < model.length; i++) {
        temp = model[i];
        System.out.println("model:" + temp.getName());
        temp.setCenter(SimpleVector.ORIGIN);
        temp.rotateX((float) (-.5 * Math.PI));
        temp.rotateMesh();
        temp.setRotationMatrix(new Matrix());
        o3d = Object3D.mergeObjects(o3d, temp);
        o3d.build();
      }
      return o3d;
    }
  }
}