Android屏幕镜像一:屏幕采集 + MediaCodec编码

接下来实现一个简单的Android屏幕镜像功能,主要涉及到以下这些知识点:

  • 1、Android屏幕采集
  • 2、MediaCodec编解码
  • 3、Android音频数据采集
  • 4、AudioTack播放pcm
  • 5、tcpudp传输

一、屏幕采集

Android5.0及更高版本支持屏幕采集,屏幕采集需要用动态申请权限。

    public static final int REQUEST_CODE = 1000;
    private MediaProjectionManager mMediaProjectionManager;
    private MediaProjection mediaProjection;

    private void requestScreenCapture() {
        mMediaProjectionManager = (MediaProjectionManager) getSystemService(MEDIA_PROJECTION_SERVICE);
        Intent captureIntent = mMediaProjectionManager.createScreenCaptureIntent();
        startActivityForResult(captureIntent, REQUEST_CODE);
    }

    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        if (resultCode != RESULT_OK || requestCode != REQUEST_CODE)
            return;
        mediaProjection = mMediaProjectionManager.getMediaProjection(resultCode, data);
        if (mediaProjection == null) {
            return;
        }
        DisplayMetrics dm = getResources().getDisplayMetrics();
        mScreenCapture = new ScreenCapture(dm.widthPixels, dm.heightPixels, mediaProjection);
        mScreenCapture.setOnCaptureVideoCallback(mVideoCallback);
        mScreenCapture.startCapture();
    }

如上,获取截屏权限后,就可以开始截屏了。
通过MediaProjectioncreateVirtualDisplay方法可将截屏画面给到指定的surface中,这里我们截屏的画面不需要显示,而是需要将画面数据给到MediaCodec编码,所以这里需要通过MediaCodec生成一个surface用于接收截屏数据。

    public void initEncoder() {
        Log.i(TAG,"initEncoder");
        MediaFormat mediaFormat = MediaFormat.createVideoFormat(MediaFormat.MIMETYPE_VIDEO_AVC, width, height);
        // 设置视频输入颜色格式,这里选择使用Surface作为输入,可以忽略颜色格式的问题,并且不需要直接操作输入缓冲区。
        mediaFormat.setInteger(MediaFormat.KEY_COLOR_FORMAT, MediaCodecInfo.CodecCapabilities.COLOR_FormatSurface);
        // 码率
        mediaFormat.setInteger(MediaFormat.KEY_BIT_RATE, width * height);
        // 帧率
        mediaFormat.setInteger(MediaFormat.KEY_FRAME_RATE, 60);
        // I帧间隔
        mediaFormat.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, 5);
        try {
            mEncoder = MediaCodec.createEncoderByType(MediaFormat.MIMETYPE_VIDEO_AVC);
            mEncoder.configure(mediaFormat, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
            Surface surface = mEncoder.createInputSurface();
            mVirtualDisplay = mMediaProjection.createVirtualDisplay("-display", width, height, 1,
                    DisplayManager.VIRTUAL_DISPLAY_FLAG_PUBLIC, surface, null, null);
        } catch (Exception e) {
            Log.w(TAG, e);
            mEncoder = null;
        }
    }

二、获取编码数据

接下来调用MediaCodecstart方法,就可以获取编码数据

    public void startCapture() {
        if (isCapturing) {
            Log.w(TAG, "startCapture ignore 1");
            return;
        }

        initEncoder();
        if (mEncoder == null) {
            Log.w(TAG, "startCapture ignore 2");
            return;
        }
        Log.i(TAG, "startCapture");

        isCapturing = true;

        encodeAsync();
//        encodeSync();
//        encodeDeprecated();
    }

      /**
     * Android5.0之后异步获取
     */
    private void encodeAsync() {
        mCaptureThread = new Thread(new Runnable() {
            @Override
            public void run() {
                mEncoder.setCallback(new MediaCodec.Callback() {
                    @Override
                    public void onInputBufferAvailable(MediaCodec codec, int index) {
                        Log.i(TAG, "onInputBufferAvailable");
                    }

                    @Override
                    public void onOutputBufferAvailable(MediaCodec codec, int index, MediaCodec.BufferInfo info) {
                        //Log.i(TAG,"onOutputBufferAvailable");
                        ByteBuffer buffer = mEncoder.getOutputBuffer(index);
                        encodeFrame(buffer, info.size);
                        mEncoder.releaseOutputBuffer(index, false);
                    }

                    @Override
                    public void onError(MediaCodec codec, MediaCodec.CodecException e) {
                        Log.i(TAG, "onError");
                    }

                    @Override
                    public void onOutputFormatChanged(MediaCodec codec, MediaFormat format) {
                        Log.i(TAG, "onOutputFormatChanged");
                    }
                });
                mEncoder.start();
            }
        });
        mCaptureThread.start();
    }

由于是通过surface获取的编码数据,所以这里没有onInputBufferAvailable回调,只需监听onOutputBufferAvailable方法,就可以获得编码数据。Android5.0之后系统推荐使用这种通过异步获取编解码数据的方式,同时Android5.0之后系统也提供了同步获取编解码数据的方式。

    /**
     * Android5.0之后同步获取
     */
    private void encodeSync() {
        mCaptureThread = new Thread(new Runnable() {
            @Override
            public void run() {
                mEncoder.start();
                MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();
                while (isCapturing && mEncoder != null) {
                    try {
                        int index = mEncoder.dequeueOutputBuffer(bufferInfo, 0);
                        if (index >= 0) {
                            // Log.i(TAG, "dequeueOutputBuffer " + outId);
                            ByteBuffer buffer = mEncoder.getOutputBuffer(index);
                            encodeFrame(buffer, bufferInfo.size);
                            mEncoder.releaseOutputBuffer(index, false);
                        }
                    } catch (Exception e) {
                        Log.w(TAG, e);
                    }
                }
            }
        });
        mCaptureThread.start();
    }

Android5.0之前的同步获取方式已经标记废弃了。

    /**
     * Android5.0之前同步获取,已废弃
     */
    private void encodeDeprecated() {
        mCaptureThread = new Thread(new Runnable() {
            @Override
            public void run() {
                mEncoder.start();
                MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();
                while (isCapturing && mEncoder != null) {
                    try {

                        ByteBuffer[] buffers = mEncoder.getOutputBuffers();
                        int index = mEncoder.dequeueOutputBuffer(bufferInfo, 0);
                        if (index == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) {
                            Log.i(TAG, "captureDeprecated INFO_OUTPUT_FORMAT_CHANGED");
                        } else if (index >= 0) {
                            // Log.i(TAG, "dequeueOutputBuffer " + outId);
                            ByteBuffer buffer = buffers[index];
                            encodeFrame(buffer, bufferInfo.size);
                            mEncoder.releaseOutputBuffer(index, false);
                        }
                    } catch (Exception e) {
                        Log.w(TAG, e);
                    }
                }
            }
        });
        mCaptureThread.start();
    }

接下来可以在encodeFrame方法中处理h264数据

    private void encodeFrame(ByteBuffer buffer, int bufferSize) {
        final byte[] bytes = new byte[bufferSize];
        buffer.get(bytes);
        if (null != mVideoCallback) {
            mVideoCallback.onCaptureVideoCallback(bytes);
        }
    }

    private OnCaptureVideoCallback mVideoCallback;

    public void setOnCaptureVideoCallback(OnCaptureVideoCallback videoCallback) {
        mVideoCallback = videoCallback;
    }

    public interface OnCaptureVideoCallback {
        void onCaptureVideoCallback(byte[] bytes);
    }

这里将数据回调给调用者处理,调用者可以储存为文件,也可以直接通过socket发送到服务器处理。

三、关闭屏幕采集、释放编码器

结束屏幕录制的时候要及时释放这些系统资源

    public void stopCapture() {
        Log.i(TAG, "stopCapture");
        isCapturing = false;
        if (mVirtualDisplay != null) {
            mVirtualDisplay.release();
            mVirtualDisplay = null;
        }
        if (mMediaProjection != null) {
            mMediaProjection.stop();
            mMediaProjection = null;
        }
        if (mEncoder != null) {
            mEncoder.stop();
            mEncoder.release();
            mEncoder = null;
        }
    }

屏幕的采集编码暂到这里,接下来我们要在本机完成解码显示。

你可能感兴趣的:(Android屏幕镜像一:屏幕采集 + MediaCodec编码)