UVCAndroid，安卓UVC相机通用开发库（支持多预览和多摄像头）

已于 2024-01-10 16:32:29 修改
阅读量2.6w 收藏 102
点赞数 35
分类专栏： android UVC 文章标签： uvc android 安卓
于 2022-04-19 08:46:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hanshiying007/article/details/124118486
版权
android 同时被 2 个专栏收录
15 篇文章 2 订阅
订阅专栏
UVC
1 篇文章 1 订阅
订阅专栏

文章目录

简介

UVCAndroid是一款用于安卓UVC相机的通用开发库。

GitHub源码地址：https://github.com/shiyinghan/UVCAndroid

主要功能

主要功能包括：
(1) 支持USB Camera设备检测，画面实时预览;
(2) 支持抓拍jpg格式图片，可设置图片压缩质量;
(3) 支持录制mp4格式视频，可屏蔽音频，可设置视频和音频的录制参数;
(4) 支持获取camera支持的分辨率，和分辨率切换;
(5) 支持预览自动识别各种相机的分辨率；
(6) 支持旋转摄像头90度、180度、270度；
(7) 支持调整对比度、亮度、色调、饱和度、白平衡等等一些相机控制参数；
(8) 支持多预览和多摄像头；
(9) 支持Android5.0+；

如何使用

1. 添加依赖到本地工程

第一步 添加mavenCentral仓库到工程gradle文件
Step 1. Add the mavenCentral repository to your build file
Add it in your root build.gradle at the end of repositories:

allprojects {
    repositories {
		...
		mavenCentral()
    }
}

第二步 添加依赖到app Module的gradle文件

dependencies {
    implementation 'com.herohan:UVCAndroid:1.0.5'
}

2. 获取权限

Request permissions

 	List<String> needPermissions = new ArrayList<>();
    needPermissions.add(Manifest.permission.CAMERA);
    needPermissions.add(Manifest.permission.WRITE_EXTERNAL_STORAGE);//拍照和录制视频时需要该权限
    //needPermissions.add(Manifest.permission.MANAGE_EXTERNAL_STORAGE); //Android 11 使用该权限替代 WRITE_EXTERNAL_STORAGE
    needPermissions.add(Manifest.permission.RECORD_AUDIO);//录制视频时需要音频时需要该权限

	//这里使用XXPermissions开源框架获取权限，你也可以使用系统原生的，或者其他开源框架获取权限
    XXPermissions.with(this)
            .permission(needPermissions)
            .request((permissions, all) -> {
                if(!all){
                    return;
                }
	
	//摄像头业务操作
           });

<application
	...
	android:requestLegacyExternalStorage="true"
	>

3. 初始化UVC业务类，设置UVC摄像头状态回调，设置TextureView或者SurfaceView的Surface监听回调

Initialize CameraHelper，set UVC Camera state callback

 private ICameraHelper mCameraHelper;
 private AspectRatioSurfaceView mCameraViewMain;
 private ICameraHelper.StateCallback mStateListener;

	//UVC摄像头状态回调
	mStateListener = new ICameraHelper.StateCallback() {
		//插入UVC设备
        @Override
        public void onAttach(UsbDevice device) {
        	//设置为当前设备（如果没有权限，会显示授权对话框）
            mCameraHelper.selectDevice(device);
        }

		//打开UVC设备成功（也就是已经获取到UVC设备的权限）
        @Override
        public void onDeviceOpen(UsbDevice device, boolean isFirstOpen) {
        	//打开UVC摄像头
            mCameraHelper.openCamera();
        }

		//打开摄像头成功
        @Override
        public void onCameraOpen(UsbDevice device) {
        	//开始预览
            mCameraHelper.startPreview();

			//获取预览使用的Size（包括帧格式、宽度、高度、FPS）
            Size size = mCameraHelper.getPreviewSize();
            if (size != null) {
                int width = size.width;
                int height = size.height;
                //需要自适应摄像头分辨率的话，设置新的宽高比
                mCameraViewMain.setAspectRatio(width, height);
            }

			//添加预览Surface
            mCameraHelper.addSurface(mCameraViewMain.getHolder().getSurface(), false);
        }

		//关闭摄像头成功
        @Override
        public void onCameraClose(UsbDevice device) {
            if (mCameraHelper != null) {
            	//移除预览Surface
                mCameraHelper.removeSurface(mCameraViewMain.getHolder().getSurface());
            }
        }

		//关闭UVC设备成功
        @Override
        public void onDeviceClose(UsbDevice device) {
        }

		//断开UVC设备
        @Override
        public void onDetach(UsbDevice device) {
        }

		//用户没有授予访问UVC设备的权限
        @Override
        public void onCancel(UsbDevice device) {
        }

    };
    
    //设置SurfaceView的Surface监听回调
    mCameraViewMain.getHolder().addCallback(new SurfaceHolder.Callback() {
    
    		//创建了新的Surface
            @Override
            public void surfaceCreated(@NonNull SurfaceHolder holder) {
                if (mCameraHelper != null) {
                	//添加预览Surface
                    mCameraHelper.addSurface(holder.getSurface(), false);
                }
            }
			
			//Surface发生了改变
            @Override
            public void surfaceChanged(@NonNull SurfaceHolder holder, int format, int width, int height) {
            }

			//销毁了原来的Surface
            @Override
            public void surfaceDestroyed(@NonNull SurfaceHolder holder) {
                if (mCameraHelper != null) {
                	//移除预览Surface
                    mCameraHelper.removeSurface(holder.getSurface());
                }
            }
        });
        
		mCameraHelper = new CameraHelper();
		//设置UVC摄像头状态回调
        mCameraHelper.setStateCallback(mStateListener);

4. 释放UVC业务类（包含取消UVC摄像头状态回调，停止Camera预览，关闭Camera等操作）

Release CameraHelper(including canceling UVC Camera state callback, stopping Camera preview, etc.)

 mCameraHelper.release();

5. 图片抓拍

Image Capture

	//设置视图片抓拍全局参数（非必须，可以不设置，使用默认值）
	mCameraHelper.setImageCaptureConfig(
                mCameraHelper.getImageCaptureConfig().setCaptureMode(ImageCapture.CAPTURE_MODE_MAXIMIZE_QUALITY));
//        mCameraHelper.setImageCaptureConfig(
//                mCameraHelper.getImageCaptureConfig().setJpegCompressionQuality(90));

	//设置需要保存图片文件
 	File file = FileUtils.getCaptureFile(this, Environment.DIRECTORY_DCIM, ".jpg");
    ImageCapture.OutputFileOptions options =
             new ImageCapture.OutputFileOptions.Builder(file).build();

//                ContentValues contentValues = new ContentValues();
//                contentValues.put(MediaStore.MediaColumns.DISPLAY_NAME, "NEW_IMAGE");
//                contentValues.put(MediaStore.MediaColumns.MIME_TYPE, "image/jpeg");
//
//                ImageCapture.OutputFileOptions options = new ImageCapture.OutputFileOptions.Builder(
//                        getContentResolver(),
//                        MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
//                        contentValues).build();

//                ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
//                ImageCapture.OutputFileOptions options = new ImageCapture.OutputFileOptions.Builder(outputStream).build();

	//进行图片抓拍
    mCameraHelper.takePicture(options, new ImageCapture.OnImageCaptureCallback() {
    	//图片抓拍成功
       	@Override
        public void onImageSaved(@NonNull ImageCapture.OutputFileResults outputFileResults) {
            Toast.makeText(TakePictureActivity.this,
                    "save \"" + UriHelper.getPath(TakePictureActivity.this, outputFileResults.getSavedUri()) + "\"",
                    Toast.LENGTH_SHORT).show();
        }

		//图片抓拍出现错误
        @Override
        public void onError(int imageCaptureError, @NonNull String message, @Nullable Throwable cause) {
            Toast.makeText(TakePictureActivity.this, message, Toast.LENGTH_SHORT).show();
        }
    });

6. 录制视频

Video Capture

	//设置视频录制全局参数（非必须，可以不设置，使用默认值）
	mCameraHelper.setVideoCaptureConfig(
	    mCameraHelper.getVideoCaptureConfig()
	              .setAudioCaptureEnable(true) // true:有音频;false:没有音频(默认为true)
	              .setBitRate((int) (1024 * 1024 * 25 * 0.25))
	              .setVideoFrameRate(25)
	              .setIFrameInterval(1));

	//设置需要保存视频文件
	File file = FileUtils.getCaptureFile(this, Environment.DIRECTORY_MOVIES, ".mp4");
    VideoCapture.OutputFileOptions options =
            new VideoCapture.OutputFileOptions.Builder(file).build();

//        ContentValues contentValues = new ContentValues();
//        contentValues.put(MediaStore.MediaColumns.DISPLAY_NAME, "NEW_VIDEO");
//        contentValues.put(MediaStore.MediaColumns.MIME_TYPE, "video/mp4");
//
//        VideoCapture.OutputFileOptions options = new VideoCapture.OutputFileOptions.Builder(
//                getContentResolver(),
//                MediaStore.Video.Media.EXTERNAL_CONTENT_URI,
//                contentValues).build();

	//开始录制
    mCameraHelper.startRecording(options, new VideoCapture.OnVideoCaptureCallback() {
        @Override
        public void onStart() {
        }

		//视频录制成功
        @Override
        public void onVideoSaved(@NonNull VideoCapture.OutputFileResults outputFileResults) {
            Toast.makeText(
                    RecordVideoActivity.this,
                    "save \"" + UriHelper.getPath(RecordVideoActivity.this, outputFileResults.getSavedUri()) + "\"",
                    Toast.LENGTH_SHORT).show();
        }
		
		//视频录制出现错误
        @Override
        public void onError(int videoCaptureError, @NonNull String message, @Nullable Throwable cause) {
            Toast.makeText(RecordVideoActivity.this, message, Toast.LENGTH_LONG).show();
        }
    });

7. 改变摄像机预览参数（包括帧格式、宽度、高度、FPS）

Set camera preview parameters (including frame format, width, height, FPS)

	//停止相机预览
	mCameraHelper.stopPreview();
	//设置摄像机预览参数
	mCameraHelper.setPreviewSize(size);
	//开始相机预览
	mCameraHelper.startPreview();

	//需要自适应摄像头分辨率的话，设置新的宽高比
	mCameraViewMain.setAspectRatio(mPreviewWidth, mPreviewHeight);

Size里面的帧格式type只支持UVCCamera.UVC_VS_FRAME_UNCOMPRESSED（YUV格式）和UVCCamera.UVC_VS_FRAME_MJPEG（Mjpeg格式），使用的时候需要摄像头支持（摄像头可能支持YUV格式或者Mjpeg格式）。

8. 调整对比度、亮度、色调、饱和度、白平衡等等一些相机控制参数

Adjust contrast, brightness, hue, saturation, white balance, and other camera controls

//获取UVCControl对象，通过该对象调整相机控制参数
UVCControl control = mCameraHelper.getUVCControl();

//根据监听器设置各种相机控制参数
private void setAllControlChangeListener(UVCControl controls) {
        // Brightness
        isbBrightness.setOnSeekChangeListener(
                (MyOnSeekChangeListener) seekParams -> controls.setBrightness(seekParams.progress));
        // Contrast
        isbContrast.setOnSeekChangeListener(
                (MyOnSeekChangeListener) seekParams -> controls.setContrast(seekParams.progress));
        // Contrast Auto
        cbContrastAuto.setOnCheckedChangeListener((buttonView, isChecked) -> {
            controls.setContrastAuto(isChecked);
        });
        // Hue
        isbHue.setOnSeekChangeListener(
                (MyOnSeekChangeListener) seekParams -> controls.setHue(seekParams.progress));
        // Hue Auto
        cbHueAuto.setOnCheckedChangeListener((buttonView, isChecked) -> {
            controls.setHueAuto(isChecked);
        });
        // Saturation
        isbSaturation.setOnSeekChangeListener(
                (MyOnSeekChangeListener) seekParams -> controls.setSaturation(seekParams.progress));
        // Sharpness
        isbSharpness.setOnSeekChangeListener(
                (MyOnSeekChangeListener) seekParams -> controls.setSharpness(seekParams.progress));
        // Gamma
        isbGamma.setOnSeekChangeListener(
                (MyOnSeekChangeListener) seekParams -> controls.setGamma(seekParams.progress));
        // White Balance
        isbWhiteBalance.setOnSeekChangeListener(
                (MyOnSeekChangeListener) seekParams -> controls.setWhiteBalance(seekParams.progress));
        // White Balance Auto
        cbWhiteBalanceAuto.setOnCheckedChangeListener((buttonView, isChecked) -> {
            controls.setWhiteBalanceAuto(isChecked);
        });
        // Backlight Compensation
        isbBacklightComp.setOnSeekChangeListener(
                (MyOnSeekChangeListener) seekParams -> controls.setBacklightComp(seekParams.progress));
        // Gain
        isbGain.setOnSeekChangeListener(
                (MyOnSeekChangeListener) seekParams -> controls.setGain(seekParams.progress));
        // Exposure Time
        isbExposureTime.setOnSeekChangeListener(
                (MyOnSeekChangeListener) seekParams -> controls.setExposureTimeAbsolute(seekParams.progress));
        // Exposure Time Auto
        cbExposureTimeAuto.setOnCheckedChangeListener((buttonView, isChecked) -> {
            controls.setExposureTimeAuto(isChecked);
        });
        // Iris
        isbIris.setOnSeekChangeListener(
                (MyOnSeekChangeListener) seekParams -> controls.setIrisAbsolute(seekParams.progress));
        // Focus
        isbFocus.setOnSeekChangeListener(
                (MyOnSeekChangeListener) seekParams -> controls.setFocusAbsolute(seekParams.progress));
        // Focus Auto
        cbFocusAuto.setOnCheckedChangeListener((buttonView, isChecked) -> {
            controls.setFocusAuto(isChecked);
        });
        // Zoom
        isbZoom.setOnSeekChangeListener(
                (MyOnSeekChangeListener) seekParams -> controls.setZoomAbsolute(seekParams.progress));
        // Pan
        isbPan.setOnSeekChangeListener(
                (MyOnSeekChangeListener) seekParams -> controls.setPanAbsolute(seekParams.progress));
        // Tilt
        isbTilt.setOnSeekChangeListener(
                (MyOnSeekChangeListener) seekParams -> controls.setTiltAbsolute(seekParams.progress));
        // Roll
        isbRoll.setOnSeekChangeListener(
                (MyOnSeekChangeListener) seekParams -> controls.setRollAbsolute(seekParams.progress));
        // Power Line Frequency
        rgPowerLineFrequency.setOnCheckedChangeListener((group, checkedId) -> {
            int value = 0;
            if (checkedId == R.id.rbPowerLineFrequencyDisable) {
                value = 0;
            } else if (checkedId == R.id.rbPowerLineFrequency50Hz) {
                value = 1;
            } else if (checkedId == R.id.rbPowerLineFrequency60Hz) {
                value = 2;
            } else if (checkedId == R.id.rbPowerLineFrequencyAuto) {
                value = 3;
            }
            controls.setPowerlineFrequency(value);
        });
    }

// 重置所有相机控制参数为初试值
private void resetAllControlParams(UVCControl control) {
        // Brightness
        control.resetBrightness();
        // Contrast
        control.resetContrast();
        // Contrast Auto
        control.resetContrastAuto();
        // Hue
        control.resetHue();
        // Hue Auto
        control.resetHueAuto();
        // Saturation
        control.resetSaturation();
        // Sharpness
        control.resetSharpness();
        // Gamma
        control.resetGamma();
        // White Balance
        control.resetWhiteBalance();
        // White Balance Auto
        control.resetWhiteBalanceAuto();
        // Backlight Compensation
        control.resetBacklightComp();
        // Gain
        control.resetGain();
        // Exposure Time
        control.resetExposureTimeAbsolute();
        // Auto-Exposure Mode
        control.resetAutoExposureMode();
        // Iris
        control.resetIrisAbsolute();
        // Focus
        control.resetFocusAbsolute();
        // Focus Auto
        control.resetFocusAuto();
        // Zoom
        control.resetZoomAbsolute();
        // Pan
        control.resetPanAbsolute();
        // Tilt
        control.resetTiltAbsolute();
        // Roll
        control.resetRollAbsolute();
        // Power Line Frequency
        control.resetPowerlineFrequency();
    }

9.旋转摄像头90度、180度、270度，设置摄像头预览镜像

Rotate the camera 90 degrees, 180 degrees, and 270 degrees , set the camera preview mirror

	//旋转摄像头
	private void rotateBy(int angle) {
        mPreviewRotation += angle;
        mPreviewRotation %= 360;
        if (mPreviewRotation < 0) {
            mPreviewRotation += 360;
        }

        if (mCameraHelper != null) {
            mCameraHelper.setPreviewConfig(
                    mCameraHelper.getPreviewConfig().setRotation(mPreviewRotation));
        }
    }

	//设置水平镜像显示
    private void flipHorizontally() {
        if (mCameraHelper != null) {
            mCameraHelper.setPreviewConfig(
                    mCameraHelper.getPreviewConfig().setMirror(MirrorMode.MIRROR_HORIZONTAL));
        }
    }

	//设置垂直镜像显示
    private void flipVertically() {
        if (mCameraHelper != null) {
            mCameraHelper.setPreviewConfig(
                    mCameraHelper.getPreviewConfig().setMirror(MirrorMode.MIRROR_VERTICAL));
        }
    }

10.设置多个预览

Set multiple previews

mCameraHelper.addSurface(svCameraViewMain.getHolder().getSurface(), false);
mCameraHelper.addSurface(svCameraViewSecond.getHolder().getSurface(), false);
mCameraHelper.addSurface(svCameraViewThird.getHolder().getSurface(), false);
mCameraHelper.addSurface(svCameraViewFourth.getHolder().getSurface(), false);

11.设置多个摄像头(USB2.0受带宽所限，有可能无法同时连接多个摄像头)

Setting multiple Cameras

	private ICameraHelper mCameraHelperLeft;
    private ICameraHelper mCameraHelperRight;

    private AspectRatioSurfaceView svCameraViewLeft;
    private AspectRatioSurfaceView svCameraViewRight;

	private UsbDevice mUsbDeviceLeft;
    private UsbDevice mUsbDeviceRight;

	private final ICameraHelper.StateCallback mStateListenerLeft = new ICameraHelper.StateCallback() {
		@Override
        public void onAttach(UsbDevice device) {
            synchronized (mSync) {
                if (mUsbDeviceLeft == null && !device.equals(mUsbDeviceRight)) {
                    selectDeviceLeft(device);
                }
            }
        }
        @Override
        public void onDeviceOpen(UsbDevice device, boolean isFirstOpen) {
            if (device.equals(mUsbDeviceLeft)) {
                UVCParam param = new UVCParam();
                param.setQuirks(UVCCamera.UVC_QUIRK_FIX_BANDWIDTH);
                mCameraHelperLeft.openCamera(param);
            }
        }
        @Override
        public void onCameraOpen(UsbDevice device) {
            if (device.equals(mUsbDeviceLeft)) {
                mCameraHelperLeft.startPreview();

                Size size = mCameraHelperLeft.getPreviewSize();
                if (size != null) {
                    int width = size.width;
                    int height = size.height;
                    //auto aspect ratio
                    svCameraViewLeft.setAspectRatio(width, height);
                }

                mCameraHelperLeft.addSurface(svCameraViewLeft.getHolder().getSurface(), false);

                mIsCameraLeftConnected = true;
            }
        }

        @Override
        public void onCameraClose(UsbDevice device) {
            if (device.equals(mUsbDeviceLeft)) {
                if (mCameraHelperLeft != null) {
                   mCameraHelperLeft.removeSurface(svCameraViewLeft.getHolder().getSurface());
                }

                mIsCameraLeftConnected = false;
            }
        }

        @Override
        public void onDeviceClose(UsbDevice device) {
        }

        @Override
        public void onDetach(UsbDevice device) {
            if (device.equals(mUsbDeviceLeft)) {
                mUsbDeviceLeft = null;
            }
        }

        @Override
        public void onCancel(UsbDevice device) {
            if (device.equals(mUsbDeviceLeft)) {
                mUsbDeviceLeft = null;
            }
        }
	};
	private final ICameraHelper.StateCallback mStateListenerRight = new ICameraHelper.StateCallback() {
		@Override
        public void onAttach(UsbDevice device) {
            synchronized (mSync) {
                if (mUsbDeviceRight == null && !device.equals(mUsbDeviceLeft)) {
                    selectDeviceRight(device);
                }
            }
        }

        @Override
        public void onDeviceOpen(UsbDevice device, boolean isFirstOpen) {
            if (device.equals(mUsbDeviceRight)) {
                UVCParam param = new UVCParam();
                param.setQuirks(UVCCamera.UVC_QUIRK_FIX_BANDWIDTH);
                mCameraHelperRight.openCamera(param);
            }
        }

        @Override
        public void onCameraOpen(UsbDevice device) {
            if (device.equals(mUsbDeviceRight)) {
                mCameraHelperRight.startPreview();

                Size size = mCameraHelperRight.getPreviewSize();
                if (size != null) {
                    int width = size.width;
                    int height = size.height;
                    //auto aspect ratio
                    svCameraViewRight.setAspectRatio(width, height);
                }

                mCameraHelperRight.addSurface(svCameraViewRight.getHolder().getSurface(), false);

                mIsCameraRightConnected = true;
            }
        }

        @Override
        public void onCameraClose(UsbDevice device) {
            if (device.equals(mUsbDeviceRight)) {
                if (mCameraHelperRight != null) {
                    mCameraHelperRight.removeSurface(svCameraViewRight.getHolder().getSurface());
                }

                mIsCameraRightConnected = false;
            }
        }

        @Override
        public void onDeviceClose(UsbDevice device) {
        }

        @Override
        public void onDetach(UsbDevice device) {
            if (device.equals(mUsbDeviceRight)) {
                mUsbDeviceRight = null;
            }
        }

        @Override
        public void onCancel(UsbDevice device) {
            if (device.equals(mUsbDeviceRight)) {
                mUsbDeviceRight = null;
            }
        }
	};

	svCameraViewLeft.getHolder().addCallback(new SurfaceHolder.Callback() {
            @Override
            public void surfaceCreated(@NonNull SurfaceHolder holder) {
                if (mCameraHelperLeft != null) {
                    mCameraHelperLeft.addSurface(holder.getSurface(), false);
                }
            }

            @Override
            public void surfaceChanged(@NonNull SurfaceHolder holder, int format, int width, int height) {

            }

            @Override
            public void surfaceDestroyed(@NonNull SurfaceHolder holder) {
                if (mCameraHelperLeft != null) {
                    mCameraHelperLeft.removeSurface(holder.getSurface());
                }
            }
        });
	svCameraViewRight.setAspectRatio(DEFAULT_WIDTH, DEFAULT_HEIGHT);

        svCameraViewRight.getHolder().addCallback(new SurfaceHolder.Callback() {
            @Override
            public void surfaceCreated(@NonNull SurfaceHolder holder) {
                if (mCameraHelperRight != null) {
                    mCameraHelperRight.addSurface(holder.getSurface(), false);
                }
            }

            @Override
            public void surfaceChanged(@NonNull SurfaceHolder holder, int format, int width, int height) {

            }

            @Override
            public void surfaceDestroyed(@NonNull SurfaceHolder holder) {
                if (mCameraHelperRight != null) {
                    mCameraHelperRight.removeSurface(holder.getSurface());
                }
            }
        });

	mCameraHelperLeft = new CameraHelper();
	mCameraHelperLeft.setStateCallback(mStateListenerLeft);
	mCameraHelperRight = new CameraHelper();
	mCameraHelperRight.setStateCallback(mStateListenerRight);

其他API

方法说明
getDeviceList()获取当前检测到的所有UVC设备
getSupportedFormatList（）获取当前摄像头支持的Format列表
getSupportedSizeList（）获取当前摄像头支持的Size列表
getPreviewSize（）获取当前摄像头正在使用的预览Size
setButtonCallback（）设置按钮事件回调
setFrameCallback（）设置实时预览图像数据回调（请在StateCallback的onDeviceOpen或者onCameraOpen回调函数里面调用，使用方法可以参考demo里面的SetFrameCallbackActivity），支持格式 UVCCamera.PIXEL_FORMAT_YUV；PIXEL_FORMAT_NV12；PIXEL_FORMAT_NV21；PIXEL_FORMAT_RGB565；PIXEL_FORMAT_RGBX等格式
openCamera(Size size）用指定格式打开当前摄像头
closeCamera(）关闭当前摄像头
isRecording(）是否正在录像
isCameraOpened(）是否已经打开当前摄像头

下载演示APK

Download demo APK
在这里插入图片描述
app-debug.apk

在这里插入图片描述
demo-debug.apk

参考

saki4510t/UVCCamera

kanseei
关注
  • 35
    点赞
  • 踩
  • 102
    收藏
    觉得还不错? 一键收藏
  • 122
    评论
专栏目录
USBCamera多摄像头同时预览打开
04-28
支持USB摄像头的android代码，UVC协议谁信那个头，USBCamera多摄像头同时预览打开。 可以复用里面的代码进行更多的摄像头打开，只要带宽足够，可以打开多个。 测试环境： macOS Catalina 版本10.15.7 Android Studio Arctic Fox | 2020.3.1 Patch 4 Gradle版本 distributionUrl=https\://services.gradle.org/distributions/gradle-6.7.1-all.zip 目前问题提点： 多摄像头同时拍照路径会复用 多摄像头同时录像未适配 修复问题： 退出时候资源销毁问题
AndroidUVCCamera:Android外接UVC相机库，致力于使用最简单的API、最清晰的代码逻辑实现预览和拍照功能
05-11
AndroidUVCCamera 最近在做一个外接USB相机的项目，github上搜了下，有很多开源的库，这些库底层基本用的都是同一套东西，但上层业务比较繁琐，使用起来很不方便，并且也不太符合项目的业务需求，所以重新封装了一下，本库只需几个简单的API即可完成预览、拍照功能，无需关注复杂的USB插拔处理逻辑。文档地址： 最好用的Android UVC Camera库 1.添加依赖 Step 1. Add the JitPack repository to your build file.Add it in your root build.gradle at the end of repositories: allprojects { repositories { ... maven { url 'https://jitpack.io' } } } Step 2. A
探索LLSimpleCamera：一款轻量级的Android相机库
最新发布
gitblog_00052的博客
03-26 362
探索LLSimpleCamera：一款轻量级的Android相机库 项目地址:https://gitcode.com/omergul123/LLSimpleCamera LLSimpleCamera 是一个由Omer Gul开发的开源项目，旨在为Android开发者提供一个简单易用、功能齐全的相机API。这个库的目标是简化在Android应用中集成自定义相机功能的过程，减少代码复杂性，并提高用户体...
Android-UVC-Camera
04-04
Android-UVC-相机 仍在开发中... 连结至Play商店： ： 这是一个Android Studio项目。 它从您的Android设备连接到USB摄像头。 （需要OTG电缆或OTG集线器）（适用于Micro Usb和C型USB设备） 该项目旨在从所有Android设备（在4.0.4 Ice Cream Sandwich以上）（也包括Mediathek Devices）上执行同步视频流。 该应用程序通过可变的，不同的输入值连接到USB摄像头，以创建摄像头驱动程序。 在大多数情况下，您不需要设置自己的摄像头驱动程序，因为其他应用程序可能会自动为您执行此操作，但是对于某些Android设备，它可能有助于观看USB摄像头中的视频。 添加了LibUsb支持：LibUsb提高了标准USB设备驱动程序的性能。 （某些OTG电缆不起作用->我会发现这是一个外部供电的，更多端口USB
Android相机调用-libusbCamera【外接摄像头】【USB摄像头】 【多摄像头预览】
花花的笔记
02-23 1931
有的自定义系统，对于自己外接的USB摄像头，android原生的camera和camera2都无法打开，CameraX也用不了。这时候就要用libusbCamera，这个库可以打开摄像头，还可以多摄像头同时预览。本文主要是同时打开3个USB摄像头的项目记录，详细的接口介绍请参见原博客。
这可能是介绍 Android UvcCamera 最详细的文章了
农村打工仔的博客
09-11 4129
设备外接 usb 摄像头，进行基本的预览、拍照、录像。相信有些同学在工作中有遇到类似的需求。 usb 摄像头在 Android 设备上，应用的确很广泛，我之前公司做的是车载产品，众所周知，现在汽车上是安装了越来越多的摄像头，通过摄像头采集的实时信息，能协助我们进行更加安全的驾驶。而这些摄像头，除了比较常见的 mipi 摄像头，很多也开始用的 usb 摄像头。 除了车载产品，类似安防、医疗等各方面，和监控、视频相关的很多领域，也都会用到 usb 摄像头。 uvc camera？有 camer
Android Uvc 摄像头驱动
04-26
AndroidUSBCamera是基于[saki4510t/UVCCamera](https://github.com/saki4510t/UVCCamera)开发的，USB Camera（UVC设备）项目和视频数据采集的使用高度封装，可以帮助开发者通过一些简单的 API 轻松使用 USB 相机设备。使用AndroidUSBCamera，您可以简单的检测并连接USB Camera，还可以实现拍照、录制mp4、切换分辨率、获取h.264/aac/src.yuv(nv21)码流和设置相机对比度或亮度，支持480P、720P、1080P及更高等。支持覆盖和录制设备的麦克风。 支持安卓5.0,6.0,7.0,8.0,9.0,10.0
[转]这可能是介绍Android UvcCamera最详细的文章了
空名先生
06-22 4336
一、什么是UVC?UVC全称为USB Video Class，直接翻译过来的意思就是：USB视频类，它是一种专门为USB视频捕获设备定义的协议标准。这个标准是Microsoft与另外几家设备厂商联合推出的为USB视频捕获设备定义的协议标准，已经成为USB org标准之一。现在的主流操作系统，都已提供UVC设备驱动，因此符合UVC规格的硬件设备在不需要安装任何的驱动程序下即可在主机中正常使用。是的，目前Android系统已经支持uvc设备。
Android Camera开发入门（4）：USB/UVC Camera的使用
挨T工作室的博客
08-31 3612
UVC，全称为USB Video Class，是一种专门为USB视频捕获设备定义的协议标准。它是由Microsoft与其他设备厂商联合推出的，并已成为USB组织的标准之一。
Android 预览基于UVC协议的摄像头并截图或录屏
邵旺运的博客
05-29 1214
Android 预览基于UVC协议的摄像头并截图或录屏
Android 外接基于UVC协议的摄像头并实现预览
邵旺运的博客
05-23 3483
本文主要展示具体的实现，并不研究UVC协议以及底层实现，只展示Android外界usb摄像头的预览功能的流程。Android 平台支持使用即插即用的 USB 摄像头（即网络摄像头），但前提是这些摄像头采用标准的。UVC协议：USB Video Class，USB视频类，是一种为USB视频捕获设备定义的协议标准。1.项目中集成libuvccamera模块（代码可从github下载，或者是文末demo中附带）
android设备连接usb摄像头开源库UVCCamera
09-23
Android 手机、大屏设备、板子等连接usb摄像头开源库UVCCamera
Android UVC驱动外接摄像头
09-03
Android UVC驱动外接摄像头 https://blog.csdn.net/qq_31939617/article/details/82348796
Android 外接基于UVC协议的摄像头并实现预览 demo
05-23
Android 外接基于UVC协议的摄像头并实现预览 demo
Android 同时打开多路摄像头
12-29
Android 同时打开多路USB摄像头，采用UVC驱动。目前demo内是最多打开六路
Android 10 无法获取USB设备权限异常问题
hanshiying007的博客
12-13 7343
问题 在小米和VIVO的Android 10的版本上面，利用如下代码无法获取USB设备的权限： private static final String ACTION_USB_PERMISSION = "com.android.example.USB_PERMISSION"; private final BroadcastReceiver usbReceiver = new BroadcastReceiver() { public void onReceive
NDK的多线程编程＜pthread.h＞库的使用问题
hanshiying007的博客
12-10 3791
问题 在项目中使用一个开源库，里面有原生的C++代码，其中有不少并发操作，使用了<pthread.h>库保证线程安全。 其中线程同步是使用互斥锁来实现的，正常的流程情况是： 初始化锁 – pthread_mutex_init 加锁 – pthread_mutex_lock、pthread_mutex_trylock 解锁 – pthread_mutex_unlock 销毁锁 – pthread_mutex_destroy 但是因为逻辑比较复杂，导致偶尔会出现执行异常，出现了销毁锁之后又进行加
错误: Cannot fit requested classes in a single dex file
hanshiying007的博客
07-01 3763
出现原因： 主要原因是你的项目貌似有点大，已经超过65k个方法。一个dex已经装不下了，需要个多个dex，也就是multidex ，因为Android系统定义总方法数是一个short int，short int 最大值为65536 解决方法 gradle文件的defaultConfig默认配置里面增加： multiDexEnabled true 在dependencies中添加： impleme...
android uvc摄像头预览
12-20
Android UVC摄像头预览是指利用Android系统支持的USB视频类（UVC）摄像头进行实时视频预览和录制。通过USB接口连接UVC摄像头，手机或平板电脑便能够利用相应的应用程序进行摄像头预览。 在进行Android UVC摄像头预览时，首先需要确保设备的操作系统支持UVC摄像头，并且连接的UVC摄像头也是相应的兼容设备。然后，用户可以下载和安装特定的UVC摄像头预览应用程序，打开应用程序后便可以实时查看摄像头拍摄的画面。 通过UVC摄像头预览应用程序，用户可以进行多种操作，例如调整摄像头的曝光、对焦、白平衡等参数，实现更加精准的拍摄效果。同时，用户还可以进行实时录制视频、拍摄照片，或者与其他设备进行实时视频通话。 值得一提的是，UVC摄像头预览不仅适用于普通的消费者用户，还可以在各种专业领域中得到应用，例如医疗影像、工业检测、安防监控等领域。通过将UVC摄像头与Android设备结合使用，可以为用户提供更加便捷、灵活的摄像头预览和录制功能，满足各种实时视频需求。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 122
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值