android camera预览格式转换,Android驱动修改camera preview和video 的format

对于Android Camera预览格式转换，可以通过修改Camera的参数来实现。具体步骤如下：

1. 获取当前的Camera对象，通过Camera.open()方法获取
2. 获取当前的Camera参数，通过Camera.getParameters()方法获取
3. 设置Camera参数中的预览格式，通过Camera.Parameters.setPreviewFormat()方法设置
4. 将修改后的Camera参数通过Camera.setParameters()方法设置到Camera对象中
5. 开启Camera预览，通过Camera.startPreview()方法开启

对于Android驱动修改Camera Preview和Video的format，需要修改驱动代码，比较复杂。需要先了解Android Camera的架构和驱动的实现方式。具体步骤如下：

1. 下载并编译Android源代码
2. 找到Camera驱动的实现代码，一般在kernel/drivers/media/platform/msm/camera_v2/
3. 修改驱动代码中的Camera预览和视频格式，一般在V4L2框架中实现
4. 重新编译内核并刷入设备

需要注意的是，在修改驱动代码时，需要仔细阅读代码并进行测试，以确保修改后的代码可以正常工作。同时，修改驱动代码需要具备一定的驱动开发经验和技能。

相关问题

android camera 录制15秒视频

你可以使用Android的Camera2 API来录制15秒的视频。以下是一个简单的示例代码，可以帮助你开始录制视频：

1. 在你的AndroidManifest.xml文件中添加以下权限：

<uses-permission android:name="android.permission.CAMERA" />
<uses-permission android:name="android.permission.RECORD_AUDIO" />
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />

2. 在你的布局文件中添加一个SurfaceView元素用于预览视频：

<SurfaceView
    android:id="@+id/surfaceView"
    android:layout_width="match_parent"
    android:layout_height="match_parent" />

3. 在你的Activity或Fragment中，获取SurfaceView并设置它的回调：

private SurfaceView surfaceView;
private SurfaceHolder surfaceHolder;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    surfaceView = findViewById(R.id.surfaceView);
    surfaceHolder = surfaceView.getHolder();
    surfaceHolder.addCallback(surfaceHolderCallback);
}

private SurfaceHolder.Callback surfaceHolderCallback = new SurfaceHolder.Callback() {
    @Override
    public void surfaceCreated(SurfaceHolder holder) {
        // 初始化Camera
        initializeCamera();
    }

    @Override
    public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
        // 当SurfaceView尺寸发生变化时，更新Camera参数
        updateCameraParameters();
    }

    @Override
    public void surfaceDestroyed(SurfaceHolder holder) {
        // 释放Camera资源
        releaseCamera();
    }
};

4. 初始化Camera并设置参数：

private CameraDevice camera;
private CameraCaptureSession captureSession;
private CaptureRequest.Builder previewRequestBuilder;
private Size previewSize;

private void initializeCamera() {
    CameraManager cameraManager = (CameraManager) getSystemService(Context.CAMERA_SERVICE);
    try {
        // 获取后置摄像头
        String cameraId = cameraManager.getCameraIdList()[0];
        CameraCharacteristics characteristics = cameraManager.getCameraCharacteristics(cameraId);
        StreamConfigurationMap map = characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
        previewSize = map.getOutputSizes(SurfaceTexture.class)[0];

        // 打开Camera
        if (ActivityCompat.checkSelfPermission(this, Manifest.permission.CAMERA) == PackageManager.PERMISSION_GRANTED) {
            cameraManager.openCamera(cameraId, cameraStateCallback, null);
        }
    } catch (CameraAccessException e) {
        e.printStackTrace();
    }
}

private CameraDevice.StateCallback cameraStateCallback = new CameraDevice.StateCallback() {
    @Override
    public void onOpened(CameraDevice camera) {
        MainActivity.this.camera = camera;
        // 开始预览
        startPreview();
    }

    @Override
    public void onDisconnected(CameraDevice camera) {
        camera.close();
        MainActivity.this.camera = null;
    }

    @Override
    public void onError(CameraDevice camera, int error) {
        camera.close();
        MainActivity.this.camera = null;
    }
};

private void startPreview() {
    try {
        SurfaceTexture texture = surfaceHolder.getSurfaceTexture();
        texture.setDefaultBufferSize(previewSize.getWidth(), previewSize.getHeight());
        Surface surface = new Surface(texture);

        previewRequestBuilder = camera.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
        previewRequestBuilder.addTarget(surface);

        List<Surface> surfaces = new ArrayList<>();
        surfaces.add(surface);

        camera.createCaptureSession(surfaces, captureSessionStateCallback, null);
    } catch (CameraAccessException e) {
        e.printStackTrace();
    }
}

private CameraCaptureSession.StateCallback captureSessionStateCallback = new CameraCaptureSession.StateCallback() {
    @Override
    public void onConfigured(CameraCaptureSession session) {
        captureSession = session;

        try {
            previewRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
            previewRequestBuilder.set(CaptureRequest.CONTROL_AE_MODE, CaptureRequest.CONTROL_AE_MODE_ON_AUTO_FLASH);

            CaptureRequest previewRequest = previewRequestBuilder.build();
            captureSession.setRepeatingRequest(previewRequest, null, null);
        } catch (CameraAccessException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void onConfigureFailed(CameraCaptureSession session) {
        session.close();
        captureSession = null;
    }
};

private void updateCameraParameters() {
    if (camera == null) {
        return;
    }

    try {
        // 获取最佳预览尺寸
        CameraCharacteristics characteristics = camera.getCameraCharacteristics(camera.getId());
        StreamConfigurationMap map = characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
        Size[] supportedSizes = map.getOutputSizes(SurfaceTexture.class);
        Size optimalSize = getOptimalPreviewSize(supportedSizes, surfaceView.getWidth(), surfaceView.getHeight());

        // 更新预览尺寸
        if (!previewSize.equals(optimalSize)) {
            previewSize = optimalSize;
            updatePreview();
        }
    } catch (CameraAccessException e) {
        e.printStackTrace();
    }
}

private void updatePreview() {
    if (camera == null) {
        return;
    }

    try {
        // 停止当前预览
        captureSession.stopRepeating();
        captureSession.abortCaptures();

        // 更新预览大小
        SurfaceTexture texture = surfaceHolder.getSurfaceTexture();
        texture.setDefaultBufferSize(previewSize.getWidth(), previewSize.getHeight());

        // 创建新的预览请求
        Surface surface = new Surface(texture);
        previewRequestBuilder = camera.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
        previewRequestBuilder.addTarget(surface);

        List<Surface> surfaces = new ArrayList<>();
        surfaces.add(surface);

        camera.createCaptureSession(surfaces, captureSessionStateCallback, null);
    } catch (CameraAccessException e) {
        e.printStackTrace();
    }
}

private Size getOptimalPreviewSize(Size[] sizes, int width, int height) {
    final double ASPECT_TOLERANCE = 0.1;
    double targetRatio = (double) height / width;

    if (sizes == null) {
        return null;
    }

    Size optimalSize = null;
    double minDiff = Double.MAX_VALUE;

    int targetHeight = height;

    for (Size size : sizes) {
        double ratio = (double) size.getWidth() / size.getHeight();
        if (Math.abs(ratio - targetRatio) > ASPECT_TOLERANCE) {
            continue;
        }

        if (Math.abs(size.getHeight() - targetHeight) < minDiff) {
            optimalSize = size;
            minDiff = Math.abs(size.getHeight() - targetHeight);
        }
    }

    if (optimalSize == null) {
        minDiff = Double.MAX_VALUE;
        for (Size size : sizes) {
            if (Math.abs(size.getHeight() - targetHeight) < minDiff) {
                optimalSize = size;
                minDiff = Math.abs(size.getHeight() - targetHeight);
            }
        }
    }

    return optimalSize;
}

5. 在你的Activity或Fragment中实现录制视频的逻辑：

private MediaRecorder mediaRecorder;
private File outputFile;

private void startRecording() {
    try {
        // 创建输出文件
        outputFile = new File(getExternalFilesDir(null), "video.mp4");

        // 创建MediaRecorder
        mediaRecorder = new MediaRecorder();
        mediaRecorder.setVideoSource(MediaRecorder.VideoSource.SURFACE);
        mediaRecorder.setAudioSource(MediaRecorder.AudioSource.MIC);
        mediaRecorder.setOutputFormat(MediaRecorder.OutputFormat.MPEG_4);
        mediaRecorder.setVideoEncoder(MediaRecorder.VideoEncoder.H264);
        mediaRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.AAC);
        mediaRecorder.setVideoSize(previewSize.getWidth(), previewSize.getHeight());
        mediaRecorder.setVideoFrameRate(30);
        mediaRecorder.setOutputFile(outputFile.getAbsolutePath());

        // 配置MediaRecorder
        mediaRecorder.prepare();
        mediaRecorder.start();

        // 录制15秒后停止
        new Handler().postDelayed(new Runnable() {
            @Override
            public void run() {
                stopRecording();
            }
        }, 15000);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

private void stopRecording() {
    if (mediaRecorder != null) {
        mediaRecorder.stop();
        mediaRecorder.release();
        mediaRecorder = null;

        // 停止预览
        if (camera != null) {
            captureSession.close();
            captureSession = null;
            camera.close();
            camera = null;
        }

        // 播放录制的视频
        Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(outputFile.getAbsolutePath()));
        intent.setDataAndType(Uri.parse(outputFile.getAbsolutePath()), "video/*");
        startActivity(intent);
    }
}

6. 最后，在你的Activity或Fragment中添加一个按钮来启动录制：

public void onRecordButtonClicked(View view) {
    startRecording();
}

Android使用camera2扫码并打开闪光灯代码

下面是一个使用 camera2 API 实现扫码并打开闪光灯的示例代码：

public class ScanActivity extends AppCompatActivity implements SurfaceHolder.Callback {

    private static final String TAG = "ScanActivity";
    private static final int REQUEST_CAMERA_PERMISSION = 1;

    private CameraManager mCameraManager;
    private CameraDevice mCameraDevice;
    private SurfaceView mSurfaceView;
    private ImageReader mImageReader;
    private CaptureRequest.Builder mPreviewRequestBuilder;
    private CaptureRequest mPreviewRequest;
    private HandlerThread mBackgroundThread;
    private Handler mBackgroundHandler;
    private boolean mFlashSupported;
    private boolean mFlashEnabled;
    private Semaphore mCameraOpenCloseLock = new Semaphore(1);

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_scan);

        mSurfaceView = findViewById(R.id.surface_view);
        mSurfaceView.getHolder().addCallback(this);
    }

    @Override
    protected void onResume() {
        super.onResume();
        startBackgroundThread();
        if (mSurfaceView.isAvailable()) {
            openCamera(mSurfaceView.getWidth(), mSurfaceView.getHeight());
        } else {
            mSurfaceView.getHolder().addCallback(this);
        }
    }

    @Override
    protected void onPause() {
        closeCamera();
        stopBackgroundThread();
        super.onPause();
    }

    private void startBackgroundThread() {
        mBackgroundThread = new HandlerThread(TAG);
        mBackgroundThread.start();
        mBackgroundHandler = new Handler(mBackgroundThread.getLooper());
    }

    private void stopBackgroundThread() {
        mBackgroundThread.quitSafely();
        try {
            mBackgroundThread.join();
            mBackgroundThread = null;
            mBackgroundHandler = null;
        } catch (InterruptedException e) {
            Log.e(TAG, "stopBackgroundThread: ", e);
        }
    }

    @Override
    public void surfaceCreated(SurfaceHolder holder) {

    }

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

    }

    @Override
    public void surfaceDestroyed(SurfaceHolder holder) {

    }

    private void openCamera(int width, int height) {
        if (ActivityCompat.checkSelfPermission(this, Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
            ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.CAMERA}, REQUEST_CAMERA_PERMISSION);
            return;
        }
        mCameraManager = (CameraManager) getSystemService(Context.CAMERA_SERVICE);
        try {
            if (!mCameraOpenCloseLock.tryAcquire(2500, TimeUnit.MILLISECONDS)) {
                throw new RuntimeException("Time out waiting to lock camera opening.");
            }
            String cameraId = mCameraManager.getCameraIdList()[0];
            CameraCharacteristics characteristics = mCameraManager.getCameraCharacteristics(cameraId);
            StreamConfigurationMap map = characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
            mImageReader = ImageReader.newInstance(width, height, ImageFormat.YUV_420_888, 2);
            mImageReader.setOnImageAvailableListener(mOnImageAvailableListener, mBackgroundHandler);
            if (map == null) {
                throw new RuntimeException("Cannot get available preview/video sizes");
            }
            Size largest = Collections.max(Arrays.asList(map.getOutputSizes(ImageFormat.YUV_420_888)), new CompareSizesByArea());
            configureTransform(width, height);
            mCameraManager.openCamera(cameraId, mStateCallback, mBackgroundHandler);
        } catch (CameraAccessException e) {
            Log.e(TAG, "openCamera: ", e);
        } catch (InterruptedException e) {
            throw new RuntimeException("Interrupted while trying to lock camera opening.", e);
        }
    }

    private void closeCamera() {
        try {
            mCameraOpenCloseLock.acquire();
            if (null != mCameraDevice) {
                mCameraDevice.close();
                mCameraDevice = null;
            }
            if (null != mImageReader) {
                mImageReader.close();
                mImageReader = null;
            }
        } catch (InterruptedException e) {
            throw new RuntimeException("Interrupted while trying to lock camera closing.", e);
        } finally {
            mCameraOpenCloseLock.release();
        }
    }

    private void configureTransform(int viewWidth, int viewHeight) {
        if (null == mSurfaceView || null == mPreviewRequestBuilder) {
            return;
        }
        int rotation = getWindowManager().getDefaultDisplay().getRotation();
        Matrix matrix = new Matrix();
        RectF viewRect = new RectF(0, 0, viewWidth, viewHeight);
        RectF bufferRect = new RectF(0, 0, mImageReader.getHeight(), mImageReader.getWidth());
        float centerX = viewRect.centerX();
        float centerY = viewRect.centerY();
        if (Surface.ROTATION_90 == rotation || Surface.ROTATION_270 == rotation) {
            bufferRect.offset(centerX - bufferRect.centerX(), centerY - bufferRect.centerY());
            matrix.setRectToRect(viewRect, bufferRect, Matrix.ScaleToFit.FILL);
            float scale = Math.max((float) viewHeight / mImageReader.getHeight(), (float) viewWidth / mImageReader.getWidth());
            matrix.postScale(scale, scale, centerX, centerY);
            matrix.postRotate(90 * (rotation - 2), centerX, centerY);
        } else if (Surface.ROTATION_180 == rotation) {
            matrix.postRotate(180, centerX, centerY);
        }
        mSurfaceView.setTransform(matrix);
    }

    private void createCameraPreviewSession() {
        try {
            Surface surface = mSurfaceView.getHolder().getSurface();
            mPreviewRequestBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
            mPreviewRequestBuilder.addTarget(surface);
            mPreviewRequestBuilder.addTarget(mImageReader.getSurface());
            mCameraDevice.createCaptureSession(Arrays.asList(surface, mImageReader.getSurface()), new CameraCaptureSession.StateCallback() {

                @Override
                public void onConfigured(@NonNull CameraCaptureSession cameraCaptureSession) {
                    if (null == mCameraDevice) {
                        return;
                    }
                    try {
                        mPreviewRequest = mPreviewRequestBuilder.build();
                        cameraCaptureSession.setRepeatingRequest(mPreviewRequest, null, mBackgroundHandler);
                    } catch (CameraAccessException e) {
                        Log.e(TAG, "onConfigured: ", e);
                    }
                }

                @Override
                public void onConfigureFailed(@NonNull CameraCaptureSession cameraCaptureSession) {
                    Log.e(TAG, "onConfigureFailed: ");
                }
            }, null);
        } catch (CameraAccessException e) {
            Log.e(TAG, "createCameraPreviewSession: ", e);
        }
    }

    private final CameraDevice.StateCallback mStateCallback = new CameraDevice.StateCallback() {

        @Override
        public void onOpened(@NonNull CameraDevice cameraDevice) {
            mCameraOpenCloseLock.release();
            mCameraDevice = cameraDevice;
            createCameraPreviewSession();
        }

        @Override
        public void onDisconnected(@NonNull CameraDevice cameraDevice) {
            mCameraOpenCloseLock.release();
            cameraDevice.close();
            mCameraDevice = null;
        }

        @Override
        public void onError(@NonNull CameraDevice cameraDevice, int error) {
            mCameraOpenCloseLock.release();
            cameraDevice.close();
            mCameraDevice = null;
            finish();
        }
    };

    private final ImageReader.OnImageAvailableListener mOnImageAvailableListener = new ImageReader.OnImageAvailableListener() {

        @Override
        public void onImageAvailable(ImageReader reader) {
            Image image = reader.acquireLatestImage();
            if (image == null) {
                return;
            }
            ByteBuffer buffer = image.getPlanes()[0].getBuffer();
            byte[] data = new byte[buffer.remaining()];
            buffer.get(data);
            int width = image.getWidth();
            int height = image.getHeight();
            int format = image.getFormat();
            int stride = image.getPlanes()[0].getRowStride();
            boolean success = false;
            if (format == ImageFormat.YUV_420_888) {
                PlanarYUVLuminanceSource source = new PlanarYUVLuminanceSource(data, width, height, stride, 0, 0, width, height, false);
                BinaryBitmap bitmap = new BinaryBitmap(new HybridBinarizer(source));
                MultiFormatReader reader = new MultiFormatReader();
                try {
                    Result result = reader.decode(bitmap);
                    String text = result.getText();
                    success = true;
                    Log.d(TAG, "onImageAvailable: text = " + text);
                } catch (NotFoundException e) {
                    Log.e(TAG, "onImageAvailable: ", e);
                }
            }
            image.close();
            if (success) {
                runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        Toast.makeText(ScanActivity.this, "扫描成功", Toast.LENGTH_SHORT).show();
                    }
                });
            }
        }
    };

    private static class CompareSizesByArea implements Comparator<Size> {

        @Override
        public int compare(Size lhs, Size rhs) {
            return Long.signum((long) lhs.getWidth() * lhs.getHeight() - (long) rhs.getWidth() * rhs.getHeight());
        }
    }

    private void toggleFlash() {
        if (mCameraDevice == null || !mFlashSupported) {
            return;
        }
        try {
            mFlashEnabled = !mFlashEnabled;
            mPreviewRequestBuilder.set(CaptureRequest.FLASH_MODE, mFlashEnabled ? CaptureRequest.FLASH_MODE_TORCH : CaptureRequest.FLASH_MODE_OFF);
            mCameraDevice.createCaptureSession(Arrays.asList(mSurfaceView.getHolder().getSurface(), mImageReader.getSurface()), new CameraCaptureSession.StateCallback() {

                @Override
                public void onConfigured(@NonNull CameraCaptureSession cameraCaptureSession) {
                    try {
                        cameraCaptureSession.setRepeatingRequest(mPreviewRequestBuilder.build(), null, mBackgroundHandler);
                    } catch (CameraAccessException e) {
                        Log.e(TAG, "onConfigured: ", e);
                    }
                }

                @Override
                public void onConfigureFailed(@NonNull CameraCaptureSession cameraCaptureSession) {
                    Log.e(TAG, "onConfigureFailed: ");
                }
            }, null);
        } catch (CameraAccessException e) {
            Log.e(TAG, "toggleFlash: ", e);
        }
    }

    @Override
    public boolean onKeyDown(int keyCode, KeyEvent event) {
        if (keyCode == KeyEvent.KEYCODE_VOLUME_DOWN || keyCode == KeyEvent.KEYCODE_VOLUME_UP) {
            toggleFlash();
            return true;
        }
        return super.onKeyDown(keyCode, event);
    }
}

在该示例中，我们使用 ImageReader 获取相机预览数据，并使用 ZXing 库进行识别。同时，我们还实现了打开闪光灯的功能，可以使用音量键触发。需要注意的是，在使用打开闪光灯的功能时，需要先检查相机设备是否支持闪光灯。