MediaExtractorAsync

MediaExtractorAsync.java

import java.io.FileDescriptor;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.util.Map;

import android.content.Context;
import android.media.MediaExtractor;
import android.media.MediaFormat;
import android.net.Uri;

public class MediaExtractorAsync {
    public static interface MediaExtractorCallback {
        boolean onFormatDetected(MediaFormat format, int idx, MediaExtractor extractor);

        void onDataExtracted(ByteBuffer buffer, MediaExtractor extractor);

        void onError(Throwable e);

        void onEnd();

        void onInterrupted();

    }

    private MediaExtractor extractor = new MediaExtractor();
    private Thread t;
    private MediaExtractorCallback callback;
    private int bufferCapacity = 1024 * 1024;

    public final void setDataSource(Context context, Uri uri, Map<String, String> headers) throws IOException {
        extractor.setDataSource(context, uri, headers);
    }

    public final void setDataSource(String path, Map<String, String> headers) throws IOException {
        extractor.setDataSource(path, headers);
    }

    public final void setDataSource(String path) throws IOException {
        extractor.setDataSource(path);
    }

    public final void setDataSource(FileDescriptor fd) throws IOException {
        extractor.setDataSource(fd);
    }

    public final void setDataSource(FileDescriptor fd, long offset, long length) throws IOException {
        extractor.setDataSource(fd, offset, length);
    }

    public final void release() {
        extractor.release();
    }

    public void seekTo(long timeUs, int mode) {
        extractor.seekTo(timeUs, mode);
    }

    public MediaExtractorCallback getCallback() {
        return callback;
    }

    public void setCallback(MediaExtractorCallback callback) {
        this.callback = callback;
    }

    public int getBufferCapacity() {
        return bufferCapacity;
    }

    public void setBufferCapacity(int bufferCapacity) {
        this.bufferCapacity = bufferCapacity;
    }

    public void start() {
        if (t != null)
            return;

        t = new Thread(new Runnable() {

            @Override
            public void run() {
                try {
                    for (int i = 0, len = extractor.getTrackCount(); i < len; i++) {
                        MediaFormat format = extractor.getTrackFormat(i);

                        if (callback.onFormatDetected(format, i, extractor)) {
                            extractor.selectTrack(i);
                        }
                    }

                    ByteBuffer buffer = ByteBuffer.allocate(bufferCapacity);

                    while (true) {
                        if (Thread.interrupted()) {
                            callback.onInterrupted();
                            break;
                        }

                        int readSampleData = extractor.readSampleData(buffer, 0);
                        if (readSampleData < 0)
                            break;

                        callback.onDataExtracted(buffer, extractor);

                        if (!extractor.advance()) {
                            break;
                        }
                    }

                    callback.onEnd();
                } catch (Throwable e) {
                    callback.onError(e);
                }
            }
        });
        t.start();
    }

    public void stop() {
        if (t == null)
            return;

        if (t.isAlive())
            t.interrupt();
    }
}

TestActivity.java

import java.io.IOException;
import java.nio.ByteBuffer;

import android.app.Activity;
import android.media.MediaExtractor;
import android.media.MediaFormat;
import android.os.Bundle;

import com.example.mediatest.MediaExtractorAsync.MediaExtractorCallback;

public class TestActivity extends Activity {
    private MediaExtractorCallback callback = new MediaExtractorCallback() {

        @Override
        public boolean onFormatDetected(MediaFormat format, int idx, MediaExtractor extractor) {
            // if you are interested in this track format, return true. -> extractor.selectTrack(i) is called.
            return true;
        }

        @Override
        public void onDataExtracted(ByteBuffer buffer, MediaExtractor extractor) {
            // process with buffer
        }

        @Override
        public void onError(Throwable e) {
            e.printStackTrace();
        }

        @Override
        public void onEnd() {
            // on end (or interrupted)
        }

        @Override
        public void onInterrupted() {
            // on interrupted
        }
    };
    private MediaExtractorAsync extractor = new MediaExtractorAsync();

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        try {
            extractor.setDataSource("http://kirinsan.org/kirinsan_hd.mp4");
            extractor.setCallback(callback);
            extractor.start();
        } catch (IOException e) {
            e.printStackTrace();
            finish();
        }
    }

    @Override
    protected void onDestroy() {
        extractor.stop();
        super.onDestroy();
    }
}