Android MediaRecorder录制摄像头视频流为MP4文件

最新推荐文章于 2023-12-14 19:38:47 发布
最新推荐文章于 2023-12-14 19:38:47 发布
阅读量553 收藏 2
点赞数
分类专栏： Android11 SystemUI 文章标签： android java android studio
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/oHeHui1/article/details/131138460
版权

使用 camera2接口，版本号为28 。

package com.example.camera01;

import android.Manifest;
import android.content.Context;
import android.content.pm.PackageManager;
import android.hardware.camera2.CameraAccessException;
import android.hardware.camera2.CameraCaptureSession;
import android.hardware.camera2.CameraCharacteristics;
import android.hardware.camera2.CameraDevice;
import android.hardware.camera2.CameraManager;
import android.hardware.camera2.CaptureRequest;
import android.hardware.camera2.params.OutputConfiguration;
import android.hardware.camera2.params.SessionConfiguration;
import android.hardware.camera2.params.StreamConfigurationMap;
import android.media.MediaRecorder;
import android.os.Bundle;
import android.os.Environment;
import android.os.Handler;
import android.os.HandlerThread;
import android.util.Log;
import android.util.Size;
import android.view.Surface;
import android.view.View;

import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;
import androidx.core.app.ActivityCompat;
import androidx.core.content.ContextCompat;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.Executor;

public class rtsp extends AppCompatActivity implements MediaRecorder.OnInfoListener, View.OnClickListener {

    private CameraManager mCameraManager;
    private static final int REQUEST_CAMERA_PERMISSION = 1;
    public static final String TAG = "LoginActivity";
    CameraDevice mCameraDevice;
    CameraCaptureSession mCaptureSession;

    private MediaRecorder mMediaRecorder;
    private HandlerThread mHandlerThread;
    private Handler mHandler;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
    }

    @Override
    protected void onResume() {
        super.onResume();
        if (!checkCameraPermission())
            return;
        setContentView(R.layout.main);
        this.findViewById(R.id.stop).setOnClickListener(this);
        startStreaming(this);
    }

    @Override
    protected void onPause() {
        super.onPause();
        if (mCameraDevice != null) {
            mCameraDevice.close();
        }
    }

    private boolean checkCameraPermission() {
        int cameraPermission1 = ContextCompat.checkSelfPermission(this, Manifest.permission.CAMERA);
        int cameraPermission2 = ContextCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE);
        int cameraPermission3 = ContextCompat.checkSelfPermission(this, Manifest.permission.RECORD_AUDIO);
        int cameraPermission4 = ContextCompat.checkSelfPermission(this, Manifest.permission.INTERNET);

        if (cameraPermission1 != PackageManager.PERMISSION_GRANTED || cameraPermission2 != PackageManager.PERMISSION_GRANTED
                || cameraPermission3 != PackageManager.PERMISSION_GRANTED||  cameraPermission4 != PackageManager.PERMISSION_GRANTED) {
            ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.INTERNET,Manifest.permission.CAMERA, Manifest.permission.WRITE_EXTERNAL_STORAGE, Manifest.permission.RECORD_AUDIO}, REQUEST_CAMERA_PERMISSION);
            return false;
        }
        return true;
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        if (requestCode == REQUEST_CAMERA_PERMISSION) {
            if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                Log.e(TAG, "权限授予成功，可以进行拍照操作 PERMISSION_GRANTED");
                // 权限授予成功，可以进行拍照操作
            } else {
                Log.e(TAG, "权限授予失败，无法进行拍照操作");
                //
            }
        }
    }

    public void startStreaming(Context context) {
        try {
            // 创建 HandlerThread，用于在单独的线程上运行摄像头操作
            mHandlerThread = new HandlerThread("Camera2 Thread");
            mHandlerThread.start();
            mHandler = new Handler(mHandlerThread.getLooper());

            // 获取摄像头管理器
            mCameraManager = (CameraManager) context.getSystemService(Context.CAMERA_SERVICE);

            // 获取可以用于录制视频的摄像头列表
            String[] cameraIds = mCameraManager.getCameraIdList();
            for (String cameraId : cameraIds) {
                CameraCharacteristics characteristics = mCameraManager.getCameraCharacteristics(cameraId);
                Integer facing = characteristics.get(CameraCharacteristics.LENS_FACING);
                if (facing != null && facing == CameraCharacteristics.LENS_FACING_BACK) {
                    // 如果后置摄像头可用，使用它来录制视频
                    StreamConfigurationMap map = characteristics.get(
                            CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
                    Size[] sizes = map.getOutputSizes(MediaRecorder.class);

                    Log.e(TAG,"sizes"+sizes.length);
                    for(Size a: sizes){
                        Log.e(TAG,"a "+ a.toString());
                    }
                    Size size = sizes[3]; // 使用的输出尺寸 :   640  480

                    if (ActivityCompat.checkSelfPermission(this, Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
                        return;
                    }
                    mCameraManager.openCamera(cameraId, new CameraDevice.StateCallback() {
                        @Override
                        public void onOpened(@NonNull CameraDevice camera) {
                            try {
                                mCameraDevice = camera;
                                startRecording(camera, size);
                            } catch (CameraAccessException | IOException e) {
                                e.printStackTrace();
                            }
                        }

                        @Override
                        public void onDisconnected(@NonNull CameraDevice camera) {
                            stopStreaming();
                        }

                        @Override
                        public void onError(@NonNull CameraDevice camera, int error) {
                            stopStreaming();
                        }
                    }, mHandler);

                    break;
                }
            }
        } catch (CameraAccessException e) {
            e.printStackTrace();
        }
    }

    private void startRecording(CameraDevice camera, Size size) throws CameraAccessException, IOException {
        // 设置输出文件和其他 MediaRecorder 属性
        mMediaRecorder = new MediaRecorder();
        mMediaRecorder.setVideoSource(MediaRecorder.VideoSource.SURFACE);
        mMediaRecorder.setOutputFormat(MediaRecorder.OutputFormat.MPEG_4);
        mMediaRecorder.setVideoEncoder(MediaRecorder.VideoEncoder.H264);
        mMediaRecorder.setVideoSize(size.getWidth(), size.getHeight());
        mMediaRecorder.setVideoFrameRate(60);
        mMediaRecorder.setVideoEncodingBitRate(1024 * 1024);
        mMediaRecorder.setOnInfoListener(this);

        String a  = Environment.getExternalStorageDirectory().toString()+"/test1.mp4";
        Log.e(TAG, "setOutputFile : "+ a);
        mMediaRecorder.setOutputFile(new File(a));
        mMediaRecorder.prepare();

        // 创建 CaptureSession，将Surface作为输出目标
        Surface surface = mMediaRecorder.getSurface();

        try {
            List<OutputConfiguration> outputs = Arrays.asList(
                    new OutputConfiguration(surface));
            SessionConfiguration config = new SessionConfiguration(SessionConfiguration.SESSION_REGULAR,outputs,new Executor() {
                @Override
                public void execute(Runnable command) {
                    Log.e(TAG, "Executor execute ");
                    command.run();
                }
            } ,mCaptureSessionListener);
            camera.createCaptureSession(config);
        } catch (CameraAccessException ex) {
            Log.e(TAG, "Failed to create a capture session", ex);
        }
    }


    final CameraCaptureSession.StateCallback mCaptureSessionListener =
            new CameraCaptureSession.StateCallback() {
                @Override
                public void onConfigured(CameraCaptureSession session) {
                    Log.e(TAG, "Finished configuring camera outputs");
                    mCaptureSession = session;

                    if (mMediaRecorder.getSurface() != null) {
                        try {
                            // Build a request for preview footage
                            CaptureRequest.Builder requestBuilder =
                                    mCameraDevice.createCaptureRequest(mCameraDevice.TEMPLATE_RECORD);
                            requestBuilder.addTarget(mMediaRecorder.getSurface());
                            CaptureRequest previewRequest = requestBuilder.build();

                            // Start displaying preview images
                            try {
                                session.setRepeatingRequest(previewRequest, /*listener*/null,
                                        /*handler*/null);

                                mMediaRecorder.start();
                            } catch (CameraAccessException ex) {
                                Log.e(TAG, "Failed to make repeating preview request", ex);
                            }
                        } catch (CameraAccessException ex) {
                            Log.e(TAG, "Failed to build preview request", ex);
                        }
                    }
                    else {
                        Log.e(TAG, "Holder didn't exist when trying to formulate preview request");
                    }
                }

                @Override
                public void onClosed(CameraCaptureSession session) {
                    Log.e(TAG, "CameraCaptureSession onClosed");
                    mCaptureSession = null;
                }

                @Override
                public void onConfigureFailed(CameraCaptureSession session) {
                    Log.e(TAG, "Configuration error on device '" + mCameraDevice.getId());
                }};
    public void stopStreaming() {
        try {
            if (mMediaRecorder != null) {
                mMediaRecorder.stop();
                mMediaRecorder.release();
                mMediaRecorder = null;
            }
        } catch (Exception e) {
            Log.e(TAG, "stopStreaming: ", e);
        }
        mHandlerThread.quitSafely();
    }

    @Override
    public void onInfo(MediaRecorder mr, int what, int extra) {
        Log.e(TAG, "OnInfoListener: what: "+what);
    }

    @Override
    public void onClick(View v) {
        mMediaRecorder.stop();
        mCaptureSession.close();
    }
}
hehui0921
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JavaScript基于MediaRecorder录制mp4视频或webm视频并下载，JavaScript实现对video标签进行录制mp4视频或webm视频和下载
eguid音视频技术分享（JavaCV教程、FFmpeg教程、openCV图像处理教程、音视频教程）
04-17 2148
本章实现网页video标签录制mp4视频或webm视频并下载。视频录制这种计算密集型任务比较重，比较适合放在后台进行实现，本章适合前端任务不太重的短时间视频录制，长时间录制建议还是走后台录制并提供下载地址给网页前端即可。所以本章只适用于短时间的视频录制并下载，录制时间太长的视频会导致浏览器卡死、变慢等问题。前面已经实现了视频截图》的功能，需要对视频进行截图功能的可以参考。几个问题解答：需要注意的是video/mp4和video/mp4;
android调用摄像头录像的代码（录像并生成mp4文件）
to35998642的博客
07-29 2149
直接给代码吧，首先是MainActivity： import androidx.annotation.NonNull; import androidx.appcompat.app.AppCompatActivity; import androidx.core.app.ActivityCompat; import androidx.core.content.ContextCompat; import android.Manifest; import android.content.pm.PackageMan
Android MediaRecorder 录制视频 socket发送
07-07
android下实现用mediarecorder录制视频，保存在本地，并通过socket发送
从MediaRecord录像中读取H264参数
lgs7907
06-26 1229
mediarecorder（H264）的录制数据的开头就包含了SPS和pps参数，分析一下取出来即可，并且相同的设备、相同的配置获取的sps，pps都是相同的。
安卓中使用MediaRecorder对RTSP流进行录制。
程序猿么么的博客
05-24 1058
使用Android的MediaRecorder API可以轻松地录制RTSP视频流
MediaRecorder视频录制
02-10
在Android平台上，MediaRecorder是用于实现音视频录制的关键类。这个工具允许开发者创建高质量的多媒体文件，如视频或音频，而无需深入理解底层的编码和解码过程。本项目聚焦于"MediaRecorder视频录制"，特别关注的...
Android 获取手机摄像头视频数据
12-19
以上就是Android获取手机摄像头视频数据的基本步骤和注意事项。在实际开发中，还可以根据需求添加更多功能，比如添加滤镜、手势识别、防抖动等。通过不断实践和学习，你将能够构建出更强大的摄像头应用。
Android H264摄像头录制视频
08-18
在Android中，MediaRecorder可以设置为使用H264编码器来处理视频流。 3. **配置MediaRecorder**：在开始录制前，开发者需要对MediaRecorder进行一系列配置，如设置输出格式（通常是MP4或3GP），视频编码（H264），...
Android 摄像头视频录制例子
01-19
本文将深入探讨如何在Android中实现摄像头视频录制，并以"MediaCodech264"为例，讲解使用MediaCodec进行H.264编码的关键技术。 首先，Android提供了一个名为Camera的API，用于访问设备的摄像头硬件。从Android 3.0...
libstreaming源码分析二之MediaRecorder编码
echoaiya的专栏
06-03 5522
上一篇介绍了libstreaming的RTSP连接，连接成功后，即可将编码后的视频流打包发送。本文主要研究libstreaming的h264编码。   一、RTSP连接成功后，开始编码 在startStream()方法中，主要实现了两个功能：rtsp连接；连接成功后开始调用MeidaStream.start()，开始编码： Session.java：
RtspMediaRecorder:libstreaming 源码分析一之RTSP连接,]libstreaming源码分析二之MediaRecorder编码
05-18
RtspMediaRecorder libstreaming 源码分析一之RTSP连接,]libstreaming源码分析二之MediaRecorder编码
MediaRecorder录制MP4文件
小孟来码的博客
04-30 4392
前言 废话不多数直接看需要啥，有啥问题。代码粘出来就完事。 需要啥 1、需要一个SurfaceView看看自己录的什么熊样 2、存储文件的路径 3、MediaRecorder录制的工具 4、Camera调调角度，前后摄像头 都啥问题注意 1、视频的预览角度 有可能你的预览角度和播放角度都有问题，跟机型有关，也是因为机型的不同可能你们的选择角度还不一样呢，那怎么处理呢？好办法当然是去找算法，去自适应的调整。这里就简单告诉你咋用就完事了， 想要调整捕获的预览角度就要申请Camera对象进行参数调整， /**
使用MediaRecorder进行摄像头录制视频
qq_53077129的博客
02-16 554
MediaRecorder
MediaRecorder 介绍和使用，结合Camera2录制视频实例（含完整项目）
最新发布
阿飞的博客
12-14 3369
在中通过设定的宽高去修改view的宽高。@Override} else {} else {可以将相机的一些基础操作和实现都封装起来，并在CameraSurfaceView中完成相关操作。完整文件地址：// 封装相机的各种操作// 设置屏幕常亮@Override@Override// 将View的大小修改为和相机预览分辨率相同的比例@Override。
关于Android音视频，实现录屏并输出MP4文件
LingoA的博客
11-07 1682
一个视频从录制到生成MP4文件的过程和需要用到的工具类及作用
Camera2 实现预览、拍照和录制视频并保存本地
qq_45145993的博客
04-17 1632
基于Camera2实现预览、拍照录制视频
Android Camera2 —CameraManager API详解
星空物语
07-04 4044
在 API 级别 30 之前，当应用程序尝试打开多个不同 ID 的 {@link CameraDevice} 并且该设备不支持打开此类组合时，{@link #openCamera} 将失败并抛出 {@link CameraAccessException} 或一个 或多个已打开的 {@link CameraDevice} 将断开连接并接收 {@link android.hardware.camera2.CameraDevice.StateCallback#onDisconnected} 回调。
Camera2学习笔记
qq_45682662的博客
07-18 1856
实现思路这里只是简单的前后摄像头的切换，首先通过cameraManager.getCameraIdList()获取当前设备摄像头ID列表，然后遍历该列表，通过当前Camera的ID来判断当前摄像头是前置还是后置，如果是前置则查询到后置摄像头ID并将其赋值为当前Camera的ID，反之亦然，拿到要切换摄像头ID后就是去调用manager.openCamera方法打开指定ID的摄像头，再调用此方法之前要把当前摄像头关闭即调用closeCamera，再调用reopenCamera，主要实现代码如下。.......
RTSP 媒体协议流的录制方案及其覆盖策略详解
yinshipin007的博客
12-12 1137
在安防和监控领域，RTSP 媒体协议流有很广泛的使用。本文将介绍一种针对 RTSP 媒体流的录制方案及其相应的覆盖策略。据我所知，声网的实时录制功能支持三种模式，分别是云端录制、本地服务端录制和页面录制，今天我们介绍的录制方案和声网的云端录制类似。
Android Mediarecorder录制的时候录制声音
06-03
要在Android Mediarecorder中录制声音，需要设置音频源，并且确保录制权限已被授予。可以使用以下代码来设置音频源： ``` mediaRecorder.setAudioSource(MediaRecorder.AudioSource.MIC); ``` 在此例中，我们将音频源设置为麦克风。您可以将其替换为其他音频源，如MediaRecorder.AudioSource.CAMCORDER或MediaRecorder.AudioSource.VOICE_RECOGNITION，具体取决于您的需求。 请注意，录制音频还需要在AndroidManifest.xml文件中添加录制权限： ``` <uses-permission android:name="android.permission.RECORD_AUDIO"/> ``` 通过设置音频源和授予录制权限，您应该能够成功录制声音。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值