Question

I am working on streaming a video from web. Where I decode the video/audio stuff in native code and get the raw pixels for video

I create a bitmap in java code, with surfaceholder and canvas and update pixels for each bitmap from native code and then stream the bitmaps as video. My problem here is, the video crashes after a few seconds because of low memory.

I want to know whether there is anything that i need to make sure to not to crash app and use low memory.

Here is my code.

public CanvasThread(SurfaceHolder surfaceHolder, Panel panel) {
    _surfaceHolder = surfaceHolder;
    _panel = panel;     }
public void setRunning(boolean run) {
    _run = run;    }

@Override
public void run() {
    Canvas c;
    while (_run) {
        c = null;
        try {
            c = _surfaceHolder.lockCanvas(null);
            synchronized (_surfaceHolder) {
                _panel.onDraw(c);
            }
        } finally {
                if (c != null) {
                _surfaceHolder.unlockCanvasAndPost(c);
            }
       }    

  public class Panel extends SurfaceView implements SurfaceHolder.Callback{
    private CanvasThread canvasthread;
    private static Bitmap mBitmap;
    private static boolean ii=false;
       public Panel(Context context, AttributeSet attrs) {
        super(context, attrs); 
        getHolder().addCallback(this);
        canvasthread = new CanvasThread(getHolder(), this);
        setFocusable(true);
       mBitmap=Bitmap.createBitmap(480, 320, Bitmap.Config.RGB_565);//bitmap created in constructor
    }

     public Panel(Context context) {
           super(context);
            getHolder().addCallback(this);
            canvasthread = new CanvasThread(getHolder(), this);
            setFocusable(true);
        }

     private static native void renderbitmap(Bitmap bitmap); //native function
    @Override
    public void onDraw(Canvas canvas) {

        renderbitmap(mBitmap); //Update pixels from native code
        canvas.drawBitmap(mBitmap, 0,0,null);//draw on canvas
}

    @Override
    public void surfaceChanged(SurfaceHolder holder, int format, int width,int height) {        }
    @Override
    public void surfaceCreated(SurfaceHolder holder) {
        canvasthread.setRunning(true);
        canvasthread.start();       }
    @Override
    public void surfaceDestroyed(SurfaceHolder holder) {
        boolean retry = true;
        canvasthread.setRunning(false);
        while (retry) {
            try {
                canvasthread.join();
                retry = false;
            } catch (InterruptedException e) {              }
    }

Answer 1

You might check out Richard Quirk’s glbuffer. I’m using it in a video player app.

In general you want to hold on to the video packets you’re receiving and only decode them right before they are needed for display. It should be easy to integrate your code with glbuffer and bypass any Bitmap allocation in Java code.

There would be one decoded frame at any given time present in the native code and in GL texture memory and several encoded packets that you’re keeping around for buffering.