puwei/library-rtsp/src/main/java/org/easydarwin/video/EasyPlayerClient.java

package org.easydarwin.video;

import android.annotation.TargetApi;
import android.content.Context;
import android.media.AudioFormat;
import android.media.AudioManager;
import android.media.AudioTrack;
import android.media.MediaCodec;
import android.media.MediaCodecInfo;
import android.media.MediaCodecList;
import android.media.MediaFormat;
import android.os.Build;
import android.os.Bundle;
import android.os.Process;
import android.os.ResultReceiver;
import android.os.SystemClock;
import android.preference.PreferenceManager;
import android.text.TextUtils;
import android.util.Log;
import android.view.Surface;
import android.view.TextureView;

import org.easydarwin.audio.AudioCodec;
import org.easydarwin.audio.EasyAACMuxer;
import org.easydarwin.sw.JNIUtil;
import org.easydarwin.util.CodecSpecificDataUtil;
import org.easydarwin.util.TextureLifecycler;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.security.InvalidParameterException;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

import static android.media.AudioManager.AUDIOFOCUS_REQUEST_GRANTED;
import static android.media.MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420Flexible;
import static android.media.MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420PackedPlanar;
import static android.media.MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420Planar;
import static android.media.MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420PackedSemiPlanar;
import static android.media.MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420SemiPlanar;
import static android.media.MediaCodecInfo.CodecCapabilities.COLOR_TI_FormatYUV420PackedSemiPlanar;
import static org.easydarwin.util.CodecSpecificDataUtil.AUDIO_SPECIFIC_CONFIG_SAMPLING_RATE_TABLE;
import static org.easydarwin.video.Client.TRANSTYPE_TCP;
import static org.easydarwin.video.EasyMuxer2.VIDEO_TYPE_H264;
import static org.easydarwin.video.EasyMuxer2.VIDEO_TYPE_H265;

import androidx.lifecycle.Lifecycle;
import androidx.lifecycle.LifecycleObserver;
import androidx.lifecycle.LifecycleOwner;
import androidx.lifecycle.OnLifecycleEvent;

/**
 * Created by John on 2016/3/17.
 */
public class EasyPlayerClient implements Client.SourceCallBack {
    private static final long LEAST_FRAME_INTERVAL = 10000l;

    /* 视频编码 */
    public static final int EASY_SDK_VIDEO_CODEC_H264 = 0x1C;       /* H264 */
    public static final int EASY_SDK_VIDEO_CODEC_H265 = 0x48323635; /* H265 */
    public static final int EASY_SDK_VIDEO_CODEC_MJPEG = 0x08;      /* MJPEG */
    public static final int EASY_SDK_VIDEO_CODEC_MPEG4 = 0x0D;      /* MPEG4 */

    /* 音频编码 */
    public static final int EASY_SDK_AUDIO_CODEC_AAC = 0x15002;     /* AAC */
    public static final int EASY_SDK_AUDIO_CODEC_G711U = 0x10006;   /* G711 ulaw */
    public static final int EASY_SDK_AUDIO_CODEC_G711A = 0x10007;   /* G711 alaw */
    public static final int EASY_SDK_AUDIO_CODEC_G726 = 0x1100B;    /* G726 */

    /**
     * 表示视频显示出来了
     */
    public static final int RESULT_VIDEO_DISPLAYED = 01;

    /**
     * 表示视频的解码方式
     */
    public static final String KEY_VIDEO_DECODE_TYPE = "video-decode-type";

    /**
     * 表示视频的尺寸获取到了。具体尺寸见 EXTRA_VIDEO_WIDTH、EXTRA_VIDEO_HEIGHT
     */
    public static final int RESULT_VIDEO_SIZE = 02;

    public static final int RESULT_TIMEOUT = 03;

    public static final int RESULT_EVENT = 04;
    public static final int RESULT_UNSUPPORTED_VIDEO = 05;
    public static final int RESULT_UNSUPPORTED_AUDIO = 06;
    public static final int RESULT_RECORD_BEGIN = 7;
    public static final int RESULT_RECORD_END = 8;

    /**
     * 表示第一帧数据已经收到
     */
    public static final int RESULT_FRAME_RECVED = 9;

    private static final String TAG = EasyPlayerClient.class.getSimpleName();
    /**
     * 表示视频的宽度
     */
    public static final String EXTRA_VIDEO_WIDTH = "extra-video-width";
    /**
     * 表示视频的高度
     */
    public static final String EXTRA_VIDEO_HEIGHT = "extra-video-height";

    private static final int NAL_VPS = 32;
    private static final int NAL_SPS = 33;
    private static final int NAL_PPS = 34;

    private Surface mSurface;
    private final TextureLifecycler lifecycler;
    private volatile Thread mThread, mAudioThread;
    private final ResultReceiver mRR;
    private Client mClient;
    private boolean mAudioEnable = true;
    private volatile long mReceivedDataLength;
    private AudioTrack mAudioTrack;
    private String mRecordingPath;
    private EasyAACMuxer mObject;
    private EasyMuxer2 muxer2;
    private Client.MediaInfo mMediaInfo;
    private short mHeight = 0;
    short mWidth = 0;
    private ByteBuffer mCSD0;
    private ByteBuffer mCSD1;
    private final I420DataCallback i420callback;
    private boolean mMuxerWaitingKeyVideo;

    /**
     * -1 表示暂停中，0表示正常录像中，1表示恢复中。
     */
    private int mRecordingStatus;
    private long muxerPausedMillis = 0L;
    private long mMuxerCuttingMillis = 0L;

//    private RtmpClient mRTMPClient = new RtmpClient();

    public boolean isRecording() {
        return !TextUtils.isEmpty(mRecordingPath);
    }

    private static class FrameInfoQueue extends PriorityQueue<Client.FrameInfo> {
        public static final int CAPACITY = 500;
        public static final int INITIAL_CAPACITY = 300;

        public FrameInfoQueue() {
            super(INITIAL_CAPACITY, new Comparator<Client.FrameInfo>() {
                @Override
                public int compare(Client.FrameInfo frameInfo, Client.FrameInfo t1) {
                    return (int) (frameInfo.stamp - t1.stamp);
                }
            });
        }

        final ReentrantLock lock = new ReentrantLock();
        final Condition notFull = lock.newCondition();
        final Condition notVideo = lock.newCondition();
        final Condition notAudio = lock.newCondition();

        @Override
        public int size() {
            lock.lock();
            try {
                return super.size();
            } finally {
                lock.unlock();
            }
        }

        @Override
        public void clear() {
            lock.lock();
            try {
                int size = super.size();
                super.clear();
                int k = size;

                for (; k > 0 && lock.hasWaiters(notFull); k--) {
                    notFull.signal();
                }
            } finally {
                lock.unlock();
            }
        }

        public void put(Client.FrameInfo x) throws InterruptedException {
            lock.lockInterruptibly();

            try {
                int size;
                while ((size = super.size()) == CAPACITY) {
                    Log.v(TAG, "queue full:" + CAPACITY);
                    notFull.await();
                }

                offer(x);
//                Log.d(TAG, String.format("queue size : " + size));
                // 这里是乱序的。并非只有空的queue才丢到首位。因此不能做限制 if (size == 0)
                {

                    if (x.audio) {
                        notAudio.signal();
                    } else {
                        notVideo.signal();
                    }
                }
            } finally {
                lock.unlock();
            }
        }

        public Client.FrameInfo takeVideoFrame() throws InterruptedException {
            lock.lockInterruptibly();

            try {
                while (true) {
                    Client.FrameInfo x = peek();

                    if (x == null) {
                        notVideo.await();
                    } else {
                        if (!x.audio) {
                            remove();
                            notFull.signal();
                            notAudio.signal();
                            return x;
                        } else {
                            notVideo.await();
                        }
                    }
                }
            } finally {
                lock.unlock();
            }
        }

        public Client.FrameInfo takeVideoFrame(long ms) throws InterruptedException {
            lock.lockInterruptibly();

            try {
                while (true) {
                    Client.FrameInfo x = peek();
                    if (x == null) {
                        if (!notVideo.await(ms, TimeUnit.MILLISECONDS)) return null;
                    } else {
                        if (!x.audio) {
                            remove();
                            notFull.signal();
                            notAudio.signal();
                            return x;
                        } else {
                            notVideo.await();
                        }
                    }
                }
            } finally {
                lock.unlock();
            }
        }

        public Client.FrameInfo takeAudioFrame() throws InterruptedException {
            lock.lockInterruptibly();

            try {
                while (true) {
                    Client.FrameInfo x = peek();
                    if (x == null) {
                        notAudio.await();
                    } else {
                        if (x.audio) {
                            remove();
                            notFull.signal();
                            notVideo.signal();
                            return x;
                        } else {
                            notAudio.await();
                        }
                    }
                }
            } finally {
                lock.unlock();
            }
        }
    }

    private FrameInfoQueue mQueue = new FrameInfoQueue();

    private final Context mContext;

    /**
     * 最新的视频时间戳
     */
    private volatile long mNewestStample;
    private boolean mWaitingKeyFrame;
    private boolean mTimeout;
    private boolean mNotSupportedVideoCB, mNotSupportedAudioCB;

    /**
     * 创建SDK对象
     *
     * @param context 上下文对象
     * @param surface 显示视频用的surface
     */
    public EasyPlayerClient(Context context, Surface surface, ResultReceiver receiver) {
        this(context, surface, receiver, null);
    }

    /**
     * 创建SDK对象
     *
     * @param context 上下文对象
     * @param surface 显示视频用的surface
     */
    public EasyPlayerClient(Context context, Surface surface, ResultReceiver receiver, I420DataCallback callback) {
        mSurface = surface;
        mContext = context;
        mRR = receiver;
        i420callback = callback;
        lifecycler = null;
    }

    public EasyPlayerClient(Context context, final TextureView view, ResultReceiver receiver, I420DataCallback callback) {
        lifecycler = new TextureLifecycler(view);
        mContext = context;
        mRR = receiver;
        i420callback = callback;

        LifecycleObserver observer1 = new LifecycleObserver() {
            @OnLifecycleEvent(value = Lifecycle.Event.ON_DESTROY)
            public void destory() {
                stop();
                mSurface.release();
                mSurface = null;
            }

            @OnLifecycleEvent(value = Lifecycle.Event.ON_CREATE)
            private void create() {
                mSurface = new Surface(view.getSurfaceTexture());
            }
        };

        lifecycler.getLifecycle().addObserver(observer1);

        if (context instanceof LifecycleOwner) {
            LifecycleObserver observer = new LifecycleObserver() {
                @OnLifecycleEvent(value = Lifecycle.Event.ON_DESTROY)
                public void destory() {
                    stop();
                }

                @OnLifecycleEvent(value = Lifecycle.Event.ON_PAUSE)
                private void pause() {
                    EasyPlayerClient.this.pause();
                }

                @OnLifecycleEvent(value = Lifecycle.Event.ON_RESUME)
                private void resume() {
                    EasyPlayerClient.this.resume();
                }
            };

            ((LifecycleOwner) context).getLifecycle().addObserver(observer);
        }
    }

    /**
     * 启动播放
     *
     * @param url
     * @return
     */
    public void play(final String url) {
        if (lifecycler.getLifecycle().getCurrentState().isAtLeast(Lifecycle.State.CREATED)) {
            start(url, TRANSTYPE_TCP, 0, Client.EASY_SDK_VIDEO_FRAME_FLAG | Client.EASY_SDK_AUDIO_FRAME_FLAG, "", "", null);
        } else {
            lifecycler.getLifecycle().addObserver(new LifecycleObserver() {
                @OnLifecycleEvent(value = Lifecycle.Event.ON_CREATE)
                void create() {
                    start(url, TRANSTYPE_TCP, 0, Client.EASY_SDK_VIDEO_FRAME_FLAG | Client.EASY_SDK_AUDIO_FRAME_FLAG, "", "", null);
                }
            });
        }
    }

    /**
     * 启动播放
     *
     * @param url
     * @param type
     * @param sendOption
     * @param mediaType
     * @param user
     * @param pwd
     * @return
     */
    public int start(final String url, int type, int sendOption, int mediaType, String user, String pwd) {
        return start(url, type, sendOption, mediaType, user, pwd, null);
    }

    /**
     * 启动播放
     *
     * @param url
     * @param type
     * @param sendOption
     * @param mediaType
     * @param user
     * @param pwd
     * @return
     */
    public int start(final String url, int type, int sendOption, int mediaType, String user, String pwd, String recordPath) {
        if (url == null) {
            throw new NullPointerException("url is null");
        }
        if (type == 0)
            type = TRANSTYPE_TCP;
        mNewestStample = 0;
        mWaitingKeyFrame = PreferenceManager.getDefaultSharedPreferences(mContext).getBoolean("waiting_i_frame", true);
        mWidth = mHeight = 0;
        mQueue.clear();
        startCodec();
        startAudio();
        mTimeout = false;
        mNotSupportedVideoCB = mNotSupportedAudioCB = false;
        mReceivedDataLength = 0;
        mClient = new Client(mContext);
        int channel = mClient.registerCallback(this);
        mRecordingPath = recordPath;
        Log.i(TAG, String.format("playing url:\n%s\n", url));
        return mClient.openStream(channel, url, type, sendOption, mediaType, user, pwd);
    }

    public boolean isAudioEnable() {
        return mAudioEnable;
    }

    public void setAudioEnable(boolean enable) {
        mAudioEnable = enable;
        AudioTrack at = mAudioTrack;
        if (at != null) {
            Log.i(TAG, String.format("audio will be %s", enable ? "enabled" : "disabled"));
            synchronized (at) {
                if (!enable) {
                    at.pause();
                    at.flush();
                } else {
                    at.flush();
                    at.play();
                }
            }
        }
    }

    public static interface I420DataCallback {
        public void onI420Data(ByteBuffer buffer);
    }

    public void pause() {
        mQueue.clear();
        if (mClient != null) {
            mClient.pause();
        }
        mQueue.clear();
    }

    public void resume() {
        if (mClient != null) {
            mClient.resume();
        }
    }

    /**
     * 终止播放
     */
    public void stop() {
        Thread t = mThread;
        mThread = null;
        if (t != null) {
            t.interrupt();
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        t = mAudioThread;
        mAudioThread = null;
        if (t != null) {
            t.interrupt();
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        stopRecord();

        mQueue.clear();
        if (mClient != null) {
            mClient.unrigisterCallback(this);
            mClient.closeStream();
            try {
                mClient.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        mQueue.clear();
        mClient = null;
        mNewestStample = 0;
    }

    public long receivedDataLength() {
        return mReceivedDataLength;
    }

    private void startAudio() {
        mAudioThread = new Thread("AUDIO_CONSUMER") {

            @TargetApi(Build.VERSION_CODES.JELLY_BEAN)
            @Override
            public void run() {
                {
                    Process.setThreadPriority(Process.THREAD_PRIORITY_AUDIO);
                    Client.FrameInfo frameInfo;
                    long handle = 0;
                    final AudioManager am = (AudioManager) mContext.getSystemService(Context.AUDIO_SERVICE);
                    AudioManager.OnAudioFocusChangeListener l = new AudioManager.OnAudioFocusChangeListener() {
                        @Override
                        public void onAudioFocusChange(int focusChange) {
                            if (focusChange == AudioManager.AUDIOFOCUS_GAIN) {
                                AudioTrack audioTrack = mAudioTrack;
                                if (audioTrack != null) {
                                    audioTrack.setStereoVolume(1.0f, 1.0f);
                                    if (audioTrack.getPlayState() == AudioTrack.PLAYSTATE_PAUSED) {
                                        audioTrack.flush();
                                        audioTrack.play();
                                    }
                                }
                            } else if (focusChange == AudioManager.AUDIOFOCUS_LOSS) {
                                AudioTrack audioTrack = mAudioTrack;
                                if (audioTrack != null) {
                                    if (audioTrack.getPlayState() == AudioTrack.PLAYSTATE_PLAYING) {
                                        audioTrack.pause();
                                    }
                                }
                            } else if (focusChange == AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK) {
                                AudioTrack audioTrack = mAudioTrack;
                                if (audioTrack != null) {
                                    audioTrack.setStereoVolume(0.5f, 0.5f);
                                }
                            }
                        }
                    };
                    try {
                        int requestCode = am.requestAudioFocus(l, AudioManager.STREAM_MUSIC, AudioManager.AUDIOFOCUS_GAIN);
                        if (requestCode != AUDIOFOCUS_REQUEST_GRANTED) {
                            return;
                        }
                        do {
                            frameInfo = mQueue.takeAudioFrame();
                            if (mMediaInfo != null) break;
                        } while (true);
                        final Thread t = Thread.currentThread();

                        if (mAudioTrack == null) {
                            int sampleRateInHz = (int) (mMediaInfo.sample * 1.001);
                            int channelConfig = mMediaInfo.channel == 1 ? AudioFormat.CHANNEL_OUT_MONO : AudioFormat.CHANNEL_OUT_STEREO;
                            int audioFormat = AudioFormat.ENCODING_PCM_16BIT;
                            int bfSize = AudioTrack.getMinBufferSize(mMediaInfo.sample, channelConfig, audioFormat) * 8;
                            mAudioTrack = new AudioTrack(AudioManager.STREAM_MUSIC, sampleRateInHz, channelConfig, audioFormat, bfSize, AudioTrack.MODE_STREAM);
                        }
                        mAudioTrack.play();
                        handle = AudioCodec.create(frameInfo.codec, frameInfo.sample_rate, frameInfo.channels, frameInfo.bits_per_sample);

                        Log.w(TAG, String.format("POST VIDEO_DISPLAYED IN AUDIO THREAD!!!"));
                        ResultReceiver rr = mRR;
                        if (rr != null) rr.send(RESULT_VIDEO_DISPLAYED, null);

                        // 半秒钟的数据缓存
                        byte[] mBufferReuse = new byte[16000];
                        int[] outLen = new int[1];
                        while (mAudioThread != null) {
                            if (frameInfo == null) {
                                frameInfo = mQueue.takeAudioFrame();
                            }
                            if (frameInfo.codec == EASY_SDK_AUDIO_CODEC_AAC && false) {
                                pumpAACSample(frameInfo);
                            }
                            outLen[0] = mBufferReuse.length;
                            long ms = SystemClock.currentThreadTimeMillis();
                            int nRet = AudioCodec.decode(handle, frameInfo.buffer, 0, frameInfo.length, mBufferReuse, outLen);
                            if (nRet == 0) {
//                                if (frameInfo.codec != EASY_SDK_AUDIO_CODEC_AAC )
                                {
//                                    save2path(mBufferReuse, 0, outLen[0],"/sdcard/111.pcm", true);
                                    pumpPCMSample(mBufferReuse, outLen[0], frameInfo.stamp);
                                }
                                if (mAudioEnable)
                                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                                        mAudioTrack.write(mBufferReuse, 0, outLen[0], AudioTrack.WRITE_NON_BLOCKING);
                                    } else {
                                        mAudioTrack.write(mBufferReuse, 0, outLen[0]);
                                    }

                            }
                            frameInfo = null;
                        }
                    } catch (Exception ex) {
                        ex.printStackTrace();
                    } finally {
                        am.abandonAudioFocus(l);
                        if (handle != 0) {
                            AudioCodec.close(handle);
                        }
                        AudioTrack track = mAudioTrack;
                        if (track != null) {
                            synchronized (track) {
                                mAudioTrack = null;
                                track.release();
                            }
                        }
                    }
                }
            }
        };

        mAudioThread.start();
    }

    private static void save2path(byte[] buffer, int offset, int length, String path, boolean append) {
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream(path, append);
            fos.write(buffer, offset, length);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    private static int getXPS(byte[] data, int offset, int length, byte[] dataOut, int[] outLen, int type) {
        int i;
        int pos0;
        int pos1;
        pos0 = -1;
        length = Math.min(length, data.length);
        for (i = offset; i < length - 4; i++) {
            if ((0 == data[i]) && (0 == data[i + 1]) && (1 == data[i + 2]) && (type == (0x0F & data[i + 3]))) {
                pos0 = i;
                break;
            }
        }
        if (-1 == pos0) {
            return -1;
        }
        if (pos0 > 0 && data[pos0 - 1] == 0) { // 0 0 0 1
            pos0 = pos0 - 1;
        }
        pos1 = -1;
        for (i = pos0 + 4; i < length - 4; i++) {
            if ((0 == data[i]) && (0 == data[i + 1]) && (1 == data[i + 2])) {
                pos1 = i;
                break;
            }
        }
        if (-1 == pos1 || pos1 == 0) {
            return -2;
        }
        if (data[pos1 - 1] == 0) {
            pos1 -= 1;
        }
        if (pos1 - pos0 > outLen[0]) {
            return -3; // 输入缓冲区太小
        }
        dataOut[0] = 0;
        System.arraycopy(data, pos0, dataOut, 0, pos1 - pos0);
        // memcpy(pXPS+1, pES+pos0, pos1-pos0);
        // *pMaxXPSLen = pos1-pos0+1;
        outLen[0] = pos1 - pos0;
        return pos1;
    }

    private static byte[] getvps_sps_pps(byte[] data, int offset, int length) {
        int i = 0;
        int vps = -1, sps = -1, pps = -1;
        length = Math.min(length, data.length);
        do {
            if (vps == -1) {
                for (i = offset; i < length - 4; i++) {
                    if ((0x00 == data[i]) && (0x00 == data[i + 1]) && (0x01 == data[i + 2])) {
                        byte nal_spec = data[i + 3];
                        int nal_type = (nal_spec >> 1) & 0x03f;
                        if (nal_type == NAL_VPS) {
                            // vps found.
                            if (data[i - 1] == 0x00) {  // start with 00 00 00 01
                                vps = i - 1;
                            } else {                      // start with 00 00 01
                                vps = i;
                            }
                            break;
                        }
                    }
                }
            }
            if (sps == -1) {
                for (i = vps; i < length - 4; i++) {
                    if ((0x00 == data[i]) && (0x00 == data[i + 1]) && (0x01 == data[i + 2])) {
                        byte nal_spec = data[i + 3];
                        int nal_type = (nal_spec >> 1) & 0x03f;
                        if (nal_type == NAL_SPS) {
                            // vps found.
                            if (data[i - 1] == 0x00) {  // start with 00 00 00 01
                                sps = i - 1;
                            } else {                      // start with 00 00 01
                                sps = i;
                            }
                            break;
                        }
                    }
                }
            }
            if (pps == -1) {
                for (i = sps; i < length - 4; i++) {
                    if ((0x00 == data[i]) && (0x00 == data[i + 1]) && (0x01 == data[i + 2])) {
                        byte nal_spec = data[i + 3];
                        int nal_type = (nal_spec >> 1) & 0x03f;
                        if (nal_type == NAL_PPS) {
                            // vps found.
                            if (data[i - 1] == 0x00) {  // start with 00 00 00 01
                                pps = i - 1;
                            } else {                    // start with 00 00 01
                                pps = i;
                            }
                            break;
                        }
                    }
                }
            }
        } while (vps == -1 || sps == -1 || pps == -1);
        if (vps == -1 || sps == -1 || pps == -1) {// 没有获取成功。
            return null;
        }
        // 计算csd buffer的长度。即从vps的开始到pps的结束的一段数据
        int begin = vps;
        int end = -1;
        for (i = pps + 4; i < length - 4; i++) {
            if ((0x00 == data[i]) && (0x00 == data[i + 1]) && (0x01 == data[i + 2])) {
                if (data[i - 1] == 0x00) {  // start with 00 00 00 01
                    end = i - 1;
                } else {                    // start with 00 00 01
                    end = i;
                }
                break;
            }
        }
        if (end == -1 || end < begin) {
            return null;
        }
        // 拷贝并返回
        byte[] buf = new byte[end - begin];
        System.arraycopy(data, begin, buf, 0, buf.length);
        return buf;
    }

    private static boolean codecMatch(String mimeType, MediaCodecInfo codecInfo) {
        String[] types = codecInfo.getSupportedTypes();
        for (String type : types) {
            if (type.equalsIgnoreCase(mimeType)) {
                return true;
            }
        }
        return false;
    }

    private static String codecName() {
        ArrayList<String> array = new ArrayList<>();
        int numCodecs = MediaCodecList.getCodecCount();
        for (int i1 = 0; i1 < numCodecs; i1++) {
            MediaCodecInfo codecInfo = MediaCodecList.getCodecInfoAt(i1);
            if (codecInfo.isEncoder()) {
                continue;
            }

            if (codecMatch("video/avc", codecInfo)) {
                String name = codecInfo.getName();
                Log.d("DECODER", String.format("decoder:%s", name));
                array.add(name);
            }
        }
//        if (array.remove("OMX.qcom.video.decoder.avc")) {
//            array.add("OMX.qcom.video.decoder.avc");
//        }
//        if (array.remove("OMX.amlogic.avc.decoder.awesome")) {
//            array.add("OMX.amlogic.avc.decoder.awesome");
//        }
        if (array.isEmpty()) {
            return "";
        }
        return array.get(0);
    }

    private static MediaCodecInfo selectCodec(String mimeType) {
        int numCodecs = MediaCodecList.getCodecCount();
        for (int i = 0; i < numCodecs; i++) {
            MediaCodecInfo codecInfo = MediaCodecList.getCodecInfoAt(i);

            if (codecInfo.isEncoder()) {
                continue;
            }

            String[] types = codecInfo.getSupportedTypes();
            for (int j = 0; j < types.length; j++) {
                if (types[j].equalsIgnoreCase(mimeType)) {
                    return codecInfo;
                }
            }
        }
        return null;
    }

    private void startCodec() {
        mThread = new Thread("VIDEO_CONSUMER") {

            @TargetApi(Build.VERSION_CODES.JELLY_BEAN)
            @Override
            public void run() {
                Process.setThreadPriority(Process.THREAD_PRIORITY_AUDIO);
                MediaCodec mCodec = null;
                int mColorFormat = 0;
                VideoCodec.VideoDecoderLite mDecoder = null, displayer = null;

                try {
                    boolean pushBlankBuffersOnStop = true;

                    int index = 0;
                    // previous
                    long previousStampUs = 0l;
                    long lastFrameStampUs = 0l;
                    long differ = 0;
                    int realWidth = mWidth;
                    int realHeight = mHeight;
                    int sliceHeight = realHeight;

                    int frameWidth = 0;
                    int frameHeight = 0;
//
//                    long decodeBegin = 0;
//                    long current = 0;

                    MediaCodec.BufferInfo info = new MediaCodec.BufferInfo();

                    Client.FrameInfo initFrameInfo = null;
                    Client.FrameInfo frameInfo = null;

                    while (mThread != null) {
                        if (mCodec == null && mDecoder == null) {
                            if (frameInfo == null) {
                                frameInfo = mQueue.takeVideoFrame();
                            }

                            initFrameInfo = frameInfo;

                            try {
                                if (PreferenceManager.getDefaultSharedPreferences(mContext).getBoolean("use-sw-codec", false)) {
                                    throw new IllegalStateException("user set sw codec");
                                }

                                final String mime = frameInfo.codec == EASY_SDK_VIDEO_CODEC_H264 ? "video/avc" : "video/hevc";
                                MediaFormat format = MediaFormat.createVideoFormat(mime, mWidth, mHeight);
                                format.setInteger(MediaFormat.KEY_MAX_INPUT_SIZE, 0);
                                format.setInteger(MediaFormat.KEY_PUSH_BLANK_BUFFERS_ON_STOP, pushBlankBuffersOnStop ? 1 : 0);
                                // 指定解码后的帧格式
                                format.setInteger(MediaFormat.KEY_COLOR_FORMAT, COLOR_FormatYUV420Flexible);

                                if (mCSD0 != null) {
                                    format.setByteBuffer("csd-0", mCSD0);
                                } else {
                                    throw new InvalidParameterException("csd-0 is invalid.");
                                }

                                if (mCSD1 != null) {
                                    format.setByteBuffer("csd-1", mCSD1);
                                } else {
                                    if (frameInfo.codec == EASY_SDK_VIDEO_CODEC_H264)
                                        throw new InvalidParameterException("csd-1 is invalid.");
                                }

                                MediaCodecInfo ci = selectCodec(mime);
                                mColorFormat = CodecSpecificDataUtil.selectColorFormat(ci, mime);

                                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
                                    MediaCodecInfo.CodecCapabilities capabilities = ci.getCapabilitiesForType(mime);
                                    MediaCodecInfo.VideoCapabilities videoCapabilities = capabilities.getVideoCapabilities();
                                    boolean supported = videoCapabilities.isSizeSupported(mWidth, mHeight);
                                    Log.i(TAG, "media codec " + ci.getName() + (supported ? "support" : "not support") + mWidth + "*" + mHeight);
                                    if (!supported) {
                                        boolean b1 = videoCapabilities.getSupportedWidths().contains(mWidth + 0);
                                        boolean b2 = videoCapabilities.getSupportedHeights().contains(mHeight + 0);
                                        supported |= b1 && b2;
                                        if (supported) {
                                            Log.w(TAG, ".......................................................................");
                                        } else {
                                            throw new IllegalStateException("media codec " + ci.getName() + (supported ? "support" : "not support") + mWidth + "*" + mHeight);
                                        }
                                    }
                                }
                                Log.i(TAG, String.format("config codec:%s", format));

                                MediaCodec codec = MediaCodec.createByCodecName(ci.getName());
                                codec.configure(format, mSurface, null, 0);
                                codec.setVideoScalingMode(MediaCodec.VIDEO_SCALING_MODE_SCALE_TO_FIT);
                                codec.start();

                                mCodec = codec;
//                                if (i420callback != null) {
//                                    final VideoCodec.VideoDecoderLite decoder = new VideoCodec.VideoDecoderLite();
//                                    decoder.create(mSurface, frameInfo.codec == EASY_SDK_VIDEO_CODEC_H264);
//                                    displayer = decoder;
//                                }
                            } catch (Throwable e) {
                                if (mCodec != null) {
                                    mCodec.release();
                                }
                                mCodec = null;

                                if (displayer != null) {
                                    displayer.close();
                                    Log.i(TAG, "AAAA 958 displayer.close()");
                                }

                                displayer = null;

                                Log.e(TAG, String.format("init codec error due to %s", e.getMessage()));
                                e.printStackTrace();

                                final VideoCodec.VideoDecoderLite decoder = new VideoCodec.VideoDecoderLite();
                                decoder.create(mSurface, frameInfo.codec == EASY_SDK_VIDEO_CODEC_H264);
                                mDecoder = decoder;
                            }

//                            previewTickUs = mTexture.getTimestamp();
//                            differ = previewTickUs - frameInfo.stamp;
//                            index = mCodec.dequeueInputBuffer(0);
//                            if (index >= 0) {
//                                ByteBuffer buffer = mCodec.getInputBuffers()[index];
//                                buffer.clear();
//                                mCSD0.clear();
//                                mCSD1.clear();
//                                buffer.put(mCSD0.array(), 0, mCSD0.remaining());
//                                buffer.put(mCSD1.array(), 0, mCSD1.remaining());
//                                mCodec.queueInputBuffer(index, 0, buffer.position(), 0, MediaCodec.BUFFER_FLAG_CODEC_CONFIG);
//                            }
                        } else {
                            frameInfo = mQueue.takeVideoFrame(5);
                        }

                        if (frameInfo != null) {
                            Log.d(TAG, "video " + frameInfo.stamp + " take[" + (frameInfo.stamp - lastFrameStampUs) + "]");
                            if (frameHeight != 0 && frameWidth != 0) {
                                if (frameInfo.width != 0 && frameInfo.height != 0) {
                                    if (frameInfo.width != frameWidth || frameInfo.height != frameHeight) {
                                        frameHeight = frameInfo.height;
                                        frameWidth = frameInfo.width;
                                        stopRecord();
                                        if (mCodec != null) {
                                            mCodec.release();
                                            mCodec = null;
                                            continue;
                                        }
                                    }
                                }
                            }
                            frameHeight = frameInfo.height;
                            frameWidth = frameInfo.width;
                            pumpVideoSample(frameInfo);
                            lastFrameStampUs = frameInfo.stamp;
                        }

                        do {
                            if (mDecoder != null) {
                                if (frameInfo != null) {
                                    long decodeBegin = SystemClock.elapsedRealtime();
                                    int[] size = new int[2];

//                                    mDecoder.decodeFrame(frameInfo, size);
                                    ByteBuffer buf = mDecoder.decodeFrameYUV(frameInfo, size);

                                    if (i420callback != null && buf != null) {
                                        i420callback.onI420Data(buf);
                                    }

                                    if (buf != null) {
                                        mDecoder.releaseBuffer(buf);
                                        Log.i(TAG, "AAAA 1022 releaseBuffer ");
                                    }

                                    long decodeSpend = SystemClock.elapsedRealtime() - decodeBegin;

                                    boolean firstFrame = previousStampUs == 0l;
                                    if (firstFrame) {
                                        Log.i(TAG, String.format("POST VIDEO_DISPLAYED!!!"));
                                        ResultReceiver rr = mRR;
                                        if (rr != null) {
                                            Bundle data = new Bundle();
                                            data.putInt(KEY_VIDEO_DECODE_TYPE, 0);
                                            rr.send(RESULT_VIDEO_DISPLAYED, data);
                                        }
                                    }

                                    //Log.d(TAG, String.format("timestamp=%d diff=%d",current, current - previousStampUs ));

                                    if (previousStampUs != 0l) {
                                        long sleepTime = frameInfo.stamp - previousStampUs - decodeSpend * 1000;
                                        if (sleepTime > 100000) {
                                            Log.w(TAG, "sleep time.too long:" + sleepTime);
                                            sleepTime = 100000;
                                        }
                                        if (sleepTime > 0) {
                                            sleepTime %= 100000;
                                            long cache = mNewestStample - frameInfo.stamp;
                                            sleepTime = fixSleepTime(sleepTime, cache, 50000);
                                            if (sleepTime > 0) {
                                                Thread.sleep(sleepTime / 1000);
                                            }
                                            Log.d(TAG, "cache:" + cache);
                                        }
                                    }
                                    previousStampUs = frameInfo.stamp;
                                }
                            } else {
                                try {
                                    do {
                                        if (frameInfo != null) {
                                            byte[] pBuf = frameInfo.buffer;
                                            index = mCodec.dequeueInputBuffer(10);
                                            if (false)
                                                throw new IllegalStateException("fake state");
                                            if (index >= 0) {
                                                ByteBuffer buffer = mCodec.getInputBuffers()[index];
                                                buffer.clear();
                                                if (pBuf.length > buffer.remaining()) {
                                                    mCodec.queueInputBuffer(index, 0, 0, frameInfo.stamp, 0);
                                                } else {
                                                    buffer.put(pBuf, frameInfo.offset, frameInfo.length);
                                                    mCodec.queueInputBuffer(index, 0, buffer.position(), frameInfo.stamp + differ, 0);
                                                }
                                                frameInfo = null;
                                            }
                                        }
                                        index = mCodec.dequeueOutputBuffer(info, 10); //
                                        switch (index) {
                                            case MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED:
                                                Log.i(TAG, "INFO_OUTPUT_BUFFERS_CHANGED");
                                                break;
                                            case MediaCodec.INFO_OUTPUT_FORMAT_CHANGED:
                                                MediaFormat mf = mCodec.getOutputFormat();
                                                Log.i(TAG, "INFO_OUTPUT_FORMAT_CHANGED ：" + mf);

                                                int width = mf.getInteger(MediaFormat.KEY_WIDTH);
                                                if (mf.containsKey("crop-left") && mf.containsKey("crop-right")) {
                                                    width = mf.getInteger("crop-right") + 1 - mf.getInteger("crop-left");
                                                }

                                                int height = mf.getInteger(MediaFormat.KEY_HEIGHT);
                                                if (mf.containsKey("crop-top") && mf.containsKey("crop-bottom")) {
                                                    height = mf.getInteger("crop-bottom") + 1 - mf.getInteger("crop-top");
                                                }

                                                realWidth = width;
                                                realHeight = height;

                                                if (mf.containsKey(MediaFormat.KEY_SLICE_HEIGHT)) {
                                                    sliceHeight = mf.getInteger(MediaFormat.KEY_SLICE_HEIGHT);
                                                } else {
                                                    sliceHeight = realHeight;
                                                }
                                                break;
                                            case MediaCodec.INFO_TRY_AGAIN_LATER:
                                                // 输出为空
                                                break;
                                            default:
                                                // 输出队列不为空
                                                // -1表示为第一帧数据
                                                long newSleepUs = -1;
                                                boolean firstTime = previousStampUs == 0l;
                                                if (!firstTime) {
                                                    long sleepUs = (info.presentationTimeUs - previousStampUs);
                                                    if (sleepUs > 100000) {
                                                        // 时间戳异常，可能服务器丢帧了。
                                                        Log.w(TAG, "sleep time.too long:" + sleepUs);
                                                        sleepUs = 100000;
                                                    } else if (sleepUs < 0) {
                                                        Log.w(TAG, "sleep time.too short:" + sleepUs);
                                                        sleepUs = 0;
                                                    }

                                                    {
                                                        long cache = mNewestStample - lastFrameStampUs;
                                                        newSleepUs = fixSleepTime(sleepUs, cache, 100000);
                                                        // Log.d(TAG, String.format("sleepUs:%d,newSleepUs:%d,Cache:%d", sleepUs, newSleepUs, cache));
                                                    }
                                                }

                                                //previousStampUs = info.presentationTimeUs;
                                                ByteBuffer outputBuffer;
                                                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
                                                    outputBuffer = mCodec.getOutputBuffer(index);
                                                } else {
                                                    outputBuffer = mCodec.getOutputBuffers()[index];
                                                }

                                                if (i420callback != null && outputBuffer != null) {
//                                                    if (sliceHeight != realHeight) {
//                                                        ByteBuffer tmp = ByteBuffer.allocateDirect(realWidth * realHeight * 3 / 2);
//                                                        outputBuffer.clear();
//                                                        outputBuffer.limit(realWidth * realHeight);
//                                                        tmp.put(outputBuffer);
//
//                                                        outputBuffer.clear();
//                                                        outputBuffer.position(realWidth * sliceHeight);
//                                                        outputBuffer.limit((realWidth * sliceHeight + realWidth * realHeight / 4));
//                                                        tmp.put(outputBuffer);
//
//                                                        outputBuffer.clear();
//                                                        outputBuffer.position(realWidth * sliceHeight + realWidth * realHeight / 4);
//                                                        outputBuffer.limit((realWidth * sliceHeight + realWidth * realHeight / 4 + realWidth * realHeight / 4));
//                                                        tmp.put(outputBuffer);
//
//                                                        tmp.clear();
//                                                        outputBuffer = tmp;
//                                                    }

                                                    if (mColorFormat == COLOR_FormatYUV420SemiPlanar
                                                            || mColorFormat == COLOR_FormatYUV420PackedSemiPlanar
                                                            || mColorFormat == COLOR_TI_FormatYUV420PackedSemiPlanar) {

//                                                        byte[] in = new byte[realWidth * realHeight * 3 / 2];
//                                                        outputBuffer.clear();
//                                                        outputBuffer.get(in);
//
//                                                        // yuvuv_to_yuv
//                                                        JNIUtil.yuvConvert(in, realWidth, realHeight, 4);
////                                                        // 旋转90或180或270度
////                                                        yuvRotate(in, 0, realWidth, realHeight, 90);
//
//                                                        ByteBuffer tmp = ByteBuffer.allocateDirect(realWidth * realHeight * 3 / 2);
//                                                        tmp.clear();
//                                                        tmp.put(in);

                                                        i420callback.onI420Data(null);

//                                                        // 旋转90或270度，则宽高需要互换
//                                                        displayer.decoder_decodeBuffer(tmp, realWidth, realHeight);
                                                    }
                                                }

                                                //previewStampUs = info.presentationTimeUs;
                                                if (false && Build.VERSION.SDK_INT >= 21) {
                                                    Log.d(TAG, String.format("releaseoutputbuffer:%d,stampUs:%d", index, previousStampUs));
                                                    mCodec.releaseOutputBuffer(index, previousStampUs);
                                                } else {
                                                    if (newSleepUs < 0) {
                                                        newSleepUs = 0;
                                                    }
//                                            Log.d(TAG,String.format("sleep:%d", newSleepUs/1000));
                                                    Thread.sleep(newSleepUs / 1000);
                                                    mCodec.releaseOutputBuffer(index, true);
                                                }

                                                if (firstTime) {
                                                    Log.i(TAG, String.format("POST VIDEO_DISPLAYED!!!"));
                                                    ResultReceiver rr = mRR;
                                                    if (rr != null) {
                                                        Bundle data = new Bundle();
                                                        data.putInt(KEY_VIDEO_DECODE_TYPE, 1);
                                                        rr.send(RESULT_VIDEO_DISPLAYED, data);
                                                    }
                                                }
                                                previousStampUs = info.presentationTimeUs;
                                        }

                                    }
                                    while (frameInfo != null || index < MediaCodec.INFO_TRY_AGAIN_LATER);
                                } catch (IllegalStateException ex) {
                                    // mediacodec error...

                                    ex.printStackTrace();

                                    Log.e(TAG, String.format("init codec error due to %s", ex.getMessage()));

                                    if (mCodec != null)
                                        mCodec.release();
                                    mCodec = null;

                                    if (displayer != null) {
                                        displayer.close();
                                        Log.i(TAG, "AAAA 1217 displayer.close()");
                                    }
                                    displayer = null;

                                    final VideoCodec.VideoDecoderLite decoder = new VideoCodec.VideoDecoderLite();
                                    decoder.create(mSurface, initFrameInfo.codec == EASY_SDK_VIDEO_CODEC_H264);
                                    mDecoder = decoder;
                                    continue;
                                }

                            }
                            break;
                        } while (true);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    if (mCodec != null) {
//                        mCodec.stop();
                        mCodec.release();
                    }

                    if (mDecoder != null) {
                        mDecoder.close();
                        Log.i(TAG, "AAAA 1238 mDecoder.close();");
                    }

                    if (displayer != null) {
                        displayer.close();
                        Log.i(TAG, "AAAA 1243 displayer.close();");
                    }
                }
            }
        };

        mThread.start();
    }

    private static final long fixSleepTime(long sleepTimeUs, long totalTimestampDifferUs, long delayUs) {
        if (totalTimestampDifferUs < 0l) {
            Log.w(TAG, String.format("totalTimestampDifferUs is:%d, this should not be happen.", totalTimestampDifferUs));
            totalTimestampDifferUs = 0;
        }

        double dValue = ((double) (delayUs - totalTimestampDifferUs)) / 1000000d;
        double radio = Math.exp(dValue);
        double r = sleepTimeUs * radio + 0.5f;
        Log.i(TAG, String.format("%d,%d,%d->%d", sleepTimeUs, totalTimestampDifferUs, delayUs, (int) r));
        return (long) r;
    }

    @TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR2)
    public synchronized void startRecord(String path) {
        if (mMediaInfo == null || mWidth == 0 || mHeight == 0 || mCSD0 == null)
            return;

        mRecordingPath = path;
        EasyMuxer2 muxer2 = new EasyMuxer2();
        mMuxerCuttingMillis = 0l;
        mRecordingStatus = 0;
        muxerPausedMillis = 0;
        ByteBuffer csd1 = this.mCSD1;
        if (csd1 == null) csd1 = ByteBuffer.allocate(0);
        byte[] extra = new byte[mCSD0.capacity() + csd1.capacity()];
        mCSD0.clear();
        csd1.clear();
        mCSD0.get(extra, 0, mCSD0.capacity());
        csd1.get(extra, mCSD0.capacity(), csd1.capacity());

        int r = muxer2.create(path, mMediaInfo.videoCodec == EASY_SDK_VIDEO_CODEC_H265 ? VIDEO_TYPE_H265 : VIDEO_TYPE_H264, mWidth, mHeight, extra, mMediaInfo.sample, mMediaInfo.channel);
        if (r != 0) {
            Log.w(TAG, "create muxer2:" + r);
            return;
        }

        mMuxerWaitingKeyVideo = true;
        this.muxer2 = muxer2;

        ResultReceiver rr = mRR;
        if (rr != null) {
            rr.send(RESULT_RECORD_BEGIN, null);
        }
    }

    public synchronized void pauseRecord() {
        if (mRecordingStatus != -1) {
            mRecordingStatus = -1;
            muxerPausedMillis = SystemClock.elapsedRealtime();
        }
    }

    public synchronized void resumeRecord() {
        if (mRecordingStatus == -1) {
            mMuxerWaitingKeyVideo = true;
            mRecordingStatus = 1;
        }
    }

    private static int getSampleIndex(int sample) {
        for (int i = 0; i < AUDIO_SPECIFIC_CONFIG_SAMPLING_RATE_TABLE.length; i++) {
            if (sample == AUDIO_SPECIFIC_CONFIG_SAMPLING_RATE_TABLE[i]) {
                return i;
            }
        }
        return -1;
    }

    private void pumpAACSample(Client.FrameInfo frameInfo) {
        EasyMuxer muxer = mObject;
        if (muxer == null) return;
        MediaCodec.BufferInfo bi = new MediaCodec.BufferInfo();
        bi.offset = frameInfo.offset;
        bi.size = frameInfo.length;
        ByteBuffer buffer = ByteBuffer.wrap(frameInfo.buffer, bi.offset, bi.size);
        bi.presentationTimeUs = frameInfo.stamp;

        try {
            if (!frameInfo.audio) {
                throw new IllegalArgumentException("frame should be audio!");
            }
            if (frameInfo.codec != EASY_SDK_AUDIO_CODEC_AAC) {
                throw new IllegalArgumentException("audio codec should be aac!");
            }
            bi.offset += 7;
            bi.size -= 7;
            muxer.pumpStream(buffer, bi, false);
        } catch (IllegalStateException ex) {
            ex.printStackTrace();
        }
    }

    private synchronized void pumpPCMSample(byte[] pcm, int length, long stampUS) {
        EasyMuxer2 muxer2 = this.muxer2;
        if (muxer2 == null)
            return;

        if (mRecordingStatus < 0)
            return;

        if (mMuxerWaitingKeyVideo) {
            Log.i(TAG, "writeFrame ignore due to no key frame!");
            return;
        }

        long timeStampMillis = stampUS / 1000;
        timeStampMillis -= mMuxerCuttingMillis;
        timeStampMillis = Math.max(0, timeStampMillis);
        int r = muxer2.writeFrame(EasyMuxer2.AVMEDIA_TYPE_AUDIO, pcm, 0, length, timeStampMillis);
        Log.i(TAG, "writeFrame audio ret:" + r);
    }


    private synchronized void pumpVideoSample(Client.FrameInfo frameInfo) {
        EasyMuxer2 muxer2 = this.muxer2;
        if (muxer2 == null) return;
        if (mRecordingStatus < 0) return;
        if (mMuxerWaitingKeyVideo) {
            if (frameInfo.type == 1) {
                mMuxerWaitingKeyVideo = false;
                if (mRecordingStatus == 1) {
                    mMuxerCuttingMillis += SystemClock.elapsedRealtime() - muxerPausedMillis;
                    mRecordingStatus = 0;
                }
            }
        }
        if (mMuxerWaitingKeyVideo) {
            Log.i(TAG, "writeFrame ignore due to no key frame!");
            return;
        }
        if (frameInfo.type == 1) {
//            frameInfo.offset = 60;
//            frameInfo.length -= 60;
        }
        long timeStampMillis = frameInfo.stamp / 1000;
        timeStampMillis -= mMuxerCuttingMillis;
        timeStampMillis = Math.max(0, timeStampMillis);
        int r = muxer2.writeFrame(EasyMuxer2.AVMEDIA_TYPE_VIDEO, frameInfo.buffer, frameInfo.offset, frameInfo.length, timeStampMillis);
        Log.i(TAG, "writeFrame video ret:" + r);
    }


    public synchronized void stopRecord() {
        mRecordingPath = null;
        mMuxerCuttingMillis = 0l;
        mRecordingStatus = 0;
        muxerPausedMillis = 0;
        EasyMuxer2 muxer2 = this.muxer2;
        if (muxer2 == null) return;
        this.muxer2 = null;
        muxer2.close();
        mObject = null;
        ResultReceiver rr = mRR;
        if (rr != null) {
            rr.send(RESULT_RECORD_END, null);
        }
    }

    @TargetApi(Build.VERSION_CODES.JELLY_BEAN)
    @Override
    public void onSourceCallBack(int _channelId, int _channelPtr, int _frameType, Client.FrameInfo frameInfo) {
//        long begin = SystemClock.elapsedRealtime();
        try {
            onRTSPSourceCallBack1(_channelId, _channelPtr, _frameType, frameInfo);
        } catch (Throwable e) {
            e.printStackTrace();
        } finally {
//            Log.d(TAG, String.format("onRTSPSourceCallBack %d", SystemClock.elapsedRealtime() - begin));
        }
    }

    public void onRTSPSourceCallBack1(int _channelId, int _channelPtr, int _frameType, Client.FrameInfo frameInfo) {
        Thread.currentThread().setName("PRODUCER_THREAD");
        if (frameInfo != null) {
            mReceivedDataLength += frameInfo.length;
        }
        if (_frameType == Client.EASY_SDK_VIDEO_FRAME_FLAG) {
            //Log.d(TAG,String.format("receive video frame"));
            if (frameInfo.codec != EASY_SDK_VIDEO_CODEC_H264 && frameInfo.codec != EASY_SDK_VIDEO_CODEC_H265) {
                ResultReceiver rr = mRR;
                if (!mNotSupportedVideoCB && rr != null) {
                    mNotSupportedVideoCB = true;
                    rr.send(RESULT_UNSUPPORTED_VIDEO, null);
                }
                return;
            }
//            save2path(frameInfo.buffer, 0, frameInfo.length, "/sdcard/264.h264", true);
            if (frameInfo.width == 0 || frameInfo.height == 0) {
                return;
            }

            if (frameInfo.length >= 4) {
                if (frameInfo.buffer[0] == 0 && frameInfo.buffer[1] == 0 && frameInfo.buffer[2] == 0 && frameInfo.buffer[3] == 1) {
                    if (frameInfo.length >= 8) {
                        if (frameInfo.buffer[4] == 0 && frameInfo.buffer[5] == 0 && frameInfo.buffer[6] == 0 && frameInfo.buffer[7] == 1) {
                            frameInfo.offset += 4;
                            frameInfo.length -= 4;
                        }
                    }
                }
            }

//            int offset = frameInfo.offset;
//            byte nal_unit_type = (byte) (frameInfo.buffer[offset + 4] & (byte) 0x1F);
//            if (nal_unit_type == 7 || nal_unit_type == 5) {
//                Log.i(TAG,String.format("recv I frame"));
//            }

            if (frameInfo.type == 1) {
                Log.i(TAG, String.format("recv I frame"));
            }

//            boolean firstFrame = mNewestStample == 0;
            mNewestStample = frameInfo.stamp;
            frameInfo.audio = false;
            if (mWaitingKeyFrame) {

                ResultReceiver rr = mRR;
                Bundle bundle = new Bundle();
                bundle.putInt(EXTRA_VIDEO_WIDTH, frameInfo.width);
                bundle.putInt(EXTRA_VIDEO_HEIGHT, frameInfo.height);
                mWidth = frameInfo.width;
                mHeight = frameInfo.height;
                Log.i(TAG, String.format("RESULT_VIDEO_SIZE:%d*%d", frameInfo.width, frameInfo.height));
                if (rr != null) rr.send(RESULT_VIDEO_SIZE, bundle);


                Log.i(TAG, String.format("width:%d,height:%d", mWidth, mHeight));

                if (frameInfo.codec == EASY_SDK_VIDEO_CODEC_H264) {
                    byte[] dataOut = new byte[128];
                    int[] outLen = new int[]{128};
                    int result = getXPS(frameInfo.buffer, 0, 256, dataOut, outLen, 7);
                    if (result >= 0) {
                        ByteBuffer csd0 = ByteBuffer.allocate(outLen[0]);
                        csd0.put(dataOut, 0, outLen[0]);
                        csd0.clear();
                        mCSD0 = csd0;
                        Log.i(TAG, String.format("CSD-0 searched"));
                    }
                    outLen[0] = 128;
                    result = getXPS(frameInfo.buffer, 0, 256, dataOut, outLen, 8);
                    if (result >= 0) {
                        ByteBuffer csd1 = ByteBuffer.allocate(outLen[0]);
                        csd1.put(dataOut, 0, outLen[0]);
                        csd1.clear();
                        mCSD1 = csd1;
                        Log.i(TAG, String.format("CSD-1 searched"));
                    }
                    if (false) {
                        int off = (result - frameInfo.offset);
                        frameInfo.offset += off;
                        frameInfo.length -= off;
                    }
                } else {
                    byte[] spsPps = getvps_sps_pps(frameInfo.buffer, 0, 256);
                    if (spsPps != null) {
                        mCSD0 = ByteBuffer.wrap(spsPps);
                    }
                }

                if (frameInfo.type != 1) {
                    Log.w(TAG, String.format("discard p frame."));
                    return;
                }
                mWaitingKeyFrame = false;
                synchronized (this) {
                    if (!TextUtils.isEmpty(mRecordingPath) && mObject == null) {
                        startRecord(mRecordingPath);
                    }
                }
            } else {
                int width = frameInfo.width;
                int height = frameInfo.height;
                if (width != 0 && height != 0)
                    if (width != mWidth || height != mHeight) {
                        // resolution change...
                        ResultReceiver rr = mRR;
                        Bundle bundle = new Bundle();
                        bundle.putInt(EXTRA_VIDEO_WIDTH, frameInfo.width);
                        bundle.putInt(EXTRA_VIDEO_HEIGHT, frameInfo.height);
                        mWidth = frameInfo.width;
                        mHeight = frameInfo.height;
                        Log.i(TAG, String.format("RESULT_VIDEO_SIZE:%d*%d", frameInfo.width, frameInfo.height));
                        if (rr != null) rr.send(RESULT_VIDEO_SIZE, bundle);
                    }
            }
//            Log.d(TAG, String.format("queue size :%d", mQueue.size()));
            try {
                mQueue.put(frameInfo);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } else if (_frameType == Client.EASY_SDK_AUDIO_FRAME_FLAG) {
            mNewestStample = frameInfo.stamp;
            frameInfo.audio = true;
            if (true) {
                if (frameInfo.codec != EASY_SDK_AUDIO_CODEC_AAC &&
                        frameInfo.codec != EASY_SDK_AUDIO_CODEC_G711A &&
                        frameInfo.codec != EASY_SDK_AUDIO_CODEC_G711U &&
                        frameInfo.codec != EASY_SDK_AUDIO_CODEC_G726) {
                    ResultReceiver rr = mRR;
                    if (!mNotSupportedAudioCB && rr != null) {
                        mNotSupportedAudioCB = true;
                        if (rr != null) {
                            rr.send(RESULT_UNSUPPORTED_AUDIO, null);
                        }
                    }
                    return;
                }

            }
            Log.d(TAG, String.format("queue size :%d", mQueue.size()));
            try {
                mQueue.put(frameInfo);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } else if (_frameType == 0) {
            // time out...
            if (!mTimeout) {
                mTimeout = true;

                ResultReceiver rr = mRR;
                if (rr != null) rr.send(RESULT_TIMEOUT, null);
            }
        } else if (_frameType == Client.EASY_SDK_EVENT_FRAME_FLAG) {
            ResultReceiver rr = mRR;
            Bundle resultData = new Bundle();
            resultData.putString("event-msg", new String(frameInfo.buffer));
            if (rr != null) rr.send(RESULT_EVENT, null);
        }
    }

    @Override
    public void onMediaInfoCallBack(int _channelId, Client.MediaInfo mi) {
        mMediaInfo = mi;
        Log.i(TAG, String.format("MediaInfo fetchd\n%s", mi));
    }

    @Override
    public void onEvent(int channel, int err, int info) {
        ResultReceiver rr = mRR;
        Bundle resultData = new Bundle();
        /*
            int state = 0;
        int err = EasyRTSP_GetErrCode(fRTSPHandle);
		// EasyRTSPClient开始进行连接，建立EasyRTSPClient连接线程
		if (NULL == _pBuf && NULL == _frameInfo)
		{
			LOGD("Recv Event: Connecting...");
			state = 1;
		}

		// EasyPlayerClient RTSPClient连接错误，错误码通过EasyRTSP_GetErrCode()接口获取，比如404
		else if (NULL != _frameInfo && _frameInfo->codec == EASY_SDK_EVENT_CODEC_ERROR)
		{
			LOGD("Recv Event: Error:%d ...\n", err);
			state = 2;
		}

		// EasyRTSPClient连接线程退出，此时上层应该停止相关调用，复位连接按钮等状态
		else if (NULL != _frameInfo && _frameInfo->codec == EASY_SDK_EVENT_CODEC_EXIT)
		{
			LOGD("Recv Event: Exit,Error:%d ...", err);
			state = 3;
		}

        * */
        switch (info) {
            case 1:
                resultData.putString("event-msg", "连接中...");
                break;
            case 2:
                resultData.putInt("errorcode", err);
                resultData.putString("event-msg", String.format("错误：%d", err));
                break;
            case 3:
                resultData.putInt("errorcode", err);
                resultData.putString("event-msg", String.format("线程退出。%d", err));
                break;
        }
        if (rr != null) rr.send(RESULT_EVENT, resultData);
    }

    /**
     * 旋转YUV格式数据
     *
     * @param src    YUV数据
     * @param format 0，420P；1，420SP
     * @param width  宽度
     * @param height 高度
     * @param degree 旋转度数
     */
    private static void yuvRotate(byte[] src, int format, int width, int height, int degree) {
        int offset = 0;
        if (format == 0) {
            JNIUtil.rotateMatrix(src, offset, width, height, degree);
            offset += (width * height);
            JNIUtil.rotateMatrix(src, offset, width / 2, height / 2, degree);
            offset += width * height / 4;
            JNIUtil.rotateMatrix(src, offset, width / 2, height / 2, degree);
        } else if (format == 1) {
            JNIUtil.rotateMatrix(src, offset, width, height, degree);
            offset += width * height;
            JNIUtil.rotateShortMatrix(src, offset, width / 2, height / 2, degree);
        }
    }
}