美文网首页
Android屏幕镜像一:屏幕采集 + MediaCodec编码

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

作者: DON_1007 | 来源:发表于2019-12-07 16:22 被阅读0次

    接下来实现一个简单的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编码

          本文链接:https://www.haomeiwen.com/subject/cbilgctx.html