เซสชันและคำขอบันทึกภาพของกล้อง

หมายเหตุ: หน้านี้อ้างอิงถึงแพ็กเกจ Camera2 เราขอแนะนำให้ใช้ CameraX เว้นแต่ว่าแอปของคุณต้องใช้ฟีเจอร์ระดับต่ำที่เฉพาะเจาะจงจาก Camera2 ทั้ง CameraX และ Camera2 รองรับ Android 5.0 (API ระดับ 21) ขึ้นไป

อุปกรณ์ที่ทำงานด้วยระบบ Android เครื่องเดียวอาจมีกล้องหลายตัว กล้องแต่ละตัวคือ CameraDevice และ CameraDevice สามารถแสดงผลสตรีมได้มากกว่า 1 รายการพร้อมกัน

เหตุผลหนึ่งที่ต้องทำเช่นนี้คือเพื่อให้สตรีมหนึ่ง ซึ่งเป็นเฟรมกล้องตามลำดับที่มาจาก CameraDevice ได้รับการเพิ่มประสิทธิภาพสำหรับงานที่เฉพาะเจาะจง เช่น การแสดงช่องมองภาพ ขณะที่สตรีมอื่นๆ อาจใช้เพื่อถ่ายภาพหรือบันทึกวิดีโอ สตรีมจะทำหน้าที่เป็นไปป์ไลน์คู่ขนานที่ประมวลผลเฟรมดิบที่มาจากกล้องทีละเฟรม ดังนี้

การประมวลผลสตรีมแบบขนานที่ประมวลผลเฟรมดิบจากอุปกรณ์กล้องเป็นรูปแบบเอาต์พุตต่างๆ
รูปที่ 1 ภาพประกอบจาก Building a Universal Camera App (Google I/O '18)

การประมวลผลแบบขนานบ่งชี้ว่าอาจมีขีดจำกัดด้านประสิทธิภาพ ทั้งนี้ขึ้นอยู่กับพลังการประมวลผลที่พร้อมใช้งานจาก CPU, GPU หรือโปรเซสเซอร์อื่นๆ หากไปป์ไลน์ไม่สามารถตามเฟรมที่เข้ามาได้ทัน ก็จะเริ่มทิ้งเฟรมเหล่านั้น

ไปป์ไลน์แต่ละรายการมีรูปแบบเอาต์พุตของตัวเอง ข้อมูลดิบที่เข้ามาจะได้รับการแปลงเป็นรูปแบบเอาต์พุตที่เหมาะสมโดยอัตโนมัติด้วยตรรกะโดยนัยที่เชื่อมโยงกับแต่ละไปป์ไลน์ CameraDevice ที่ใช้ในตัวอย่างโค้ดของหน้านี้ไม่เฉพาะเจาะจง ดังนั้นคุณจึงต้องแจกแจงกล้องที่ใช้ได้ทั้งหมดก่อนดำเนินการต่อ

คุณสามารถใช้ CameraDevice เพื่อสร้าง CameraCaptureSession ซึ่งเจาะจงสำหรับ CameraDevice นั้น CameraDevice ต้องได้รับการกำหนดค่าเฟรมสำหรับเฟรมข้อมูลดิบแต่ละเฟรมโดยใช้ CameraCaptureSession การกำหนดค่าจะระบุแอตทริบิวต์ของกล้อง เช่น โฟกัสอัตโนมัติ รูรับแสง เอฟเฟกต์ และการเปิดรับแสง เนื่องจากข้อจำกัดด้านฮาร์ดแวร์ เซ็นเซอร์ตรวจจับผ่านกล้องจะมีการกำหนดค่าที่ใช้งานอยู่เพียงรายการเดียวเท่านั้นในช่วงเวลาหนึ่ง ซึ่งเรียกว่าการกำหนดค่าที่ใช้งานอยู่

อย่างไรก็ตาม Use Case ของสตรีมจะปรับปรุงและขยายวิธีการใช้ CameraDevice ก่อนหน้านี้เพื่อสตรีมเซสชันการจับภาพ ซึ่งช่วยให้คุณเพิ่มประสิทธิภาพสตรีมจากกล้องสำหรับ Use Case ที่เฉพาะเจาะจงได้ เช่น ช่วยยืดอายุการใช้งานแบตเตอรี่เมื่อเพิ่มประสิทธิภาพวิดีโอคอล

CameraCaptureSession อธิบายไปป์ไลน์ที่เป็นไปได้ทั้งหมดที่เชื่อมโยงกับ CameraDevice เมื่อสร้างเซสชันแล้ว คุณจะเพิ่มหรือนำไปป์ไลน์ออกไม่ได้ CameraCaptureSession จะเก็บคิวของ CaptureRequest ซึ่งจะกลายเป็นการกำหนดค่าที่ใช้งานอยู่

CaptureRequest จะเพิ่มการกำหนดค่าลงในคิวและเลือกไปป์ไลน์ที่ใช้ได้ 1 รายการ มากกว่า 1 รายการ หรือทั้งหมดเพื่อรับเฟรมจาก CameraDevice คุณสามารถส่งคำขอจับภาพได้หลายครั้งตลอดอายุของเซสชันการจับภาพ คำขอแต่ละรายการสามารถเปลี่ยนการกำหนดค่าที่ใช้งานอยู่และชุดไปป์ไลน์เอาต์พุตที่รับรูปภาพดิบได้

ใช้ Use Case ของสตรีมเพื่อประสิทธิภาพที่ดีขึ้น

กรณีการใช้งานสตรีมเป็นวิธีปรับปรุงประสิทธิภาพของเซสชันการจับภาพ Camera2 ซึ่งจะช่วยให้อุปกรณ์ฮาร์ดแวร์มีข้อมูลเพิ่มเติมในการปรับแต่งพารามิเตอร์ ซึ่งจะมอบประสบการณ์การใช้งานกล้องที่ดีขึ้นสำหรับงานที่เฉพาะเจาะจงของคุณ

ซึ่งจะช่วยให้อุปกรณ์กล้องเพิ่มประสิทธิภาพไปป์ไลน์ฮาร์ดแวร์และซอฟต์แวร์ของกล้องตามสถานการณ์ของผู้ใช้สำหรับแต่ละสตรีมได้ ดูข้อมูลเพิ่มเติมเกี่ยวกับกรณีการใช้งานสตรีมได้ที่ setStreamUseCase

กรณีการใช้งานสตรีมช่วยให้คุณระบุวิธีใช้สตรีมจากกล้องหนึ่งๆ ได้ละเอียดยิ่งขึ้น นอกเหนือจากการตั้งค่าเทมเพลตใน CameraDevice.createCaptureRequest() ซึ่งช่วยให้ฮาร์ดแวร์กล้องเพิ่มประสิทธิภาพพารามิเตอร์ต่างๆ เช่น การปรับแต่ง โหมดเซ็นเซอร์ หรือการตั้งค่าเซ็นเซอร์ตรวจจับผ่านกล้อง โดยพิจารณาจากข้อดีข้อเสียด้านคุณภาพหรือเวลาในการตอบสนองที่เหมาะกับ Use Case ที่เฉพาะเจาะจง

กรณีการใช้งานสตรีมมีดังนี้

  • DEFAULT: ครอบคลุมลักษณะการทำงานของแอปพลิเคชันที่มีอยู่ทั้งหมด ซึ่งเทียบเท่ากับการไม่ตั้งค่ากรณีการใช้งานสตรีมใดๆ

  • PREVIEW: แนะนำสำหรับช่องมองภาพหรือการวิเคราะห์รูปภาพในแอป

  • STILL_CAPTURE: เพิ่มประสิทธิภาพสำหรับการจับภาพความละเอียดสูงและคุณภาพสูง และไม่คาดว่าจะรักษาอัตราเฟรมที่เหมือนตัวอย่างไว้ได้

  • VIDEO_RECORD: เพิ่มประสิทธิภาพสำหรับการจับภาพวิดีโอคุณภาพสูง รวมถึงระบบกันภาพสั่นไหวคุณภาพสูง หากอุปกรณ์รองรับและแอปพลิเคชันเปิดใช้ ตัวเลือกนี้อาจสร้างเฟรมเอาต์พุตที่มีความล่าช้าอย่างมากจากแบบเรียลไทม์ เพื่อให้สามารถใช้ระบบป้องกันภาพสั่นไหวหรือการประมวลผลอื่นๆ ที่มีคุณภาพสูงสุด

  • VIDEO_CALL: แนะนำสำหรับการใช้กล้องเป็นเวลานานซึ่งอาจทำให้แบตเตอรี่หมดเร็ว

  • PREVIEW_VIDEO_STILL: แนะนำสำหรับแอปโซเชียลมีเดียหรือกรณีการใช้งานสตรีมเดียว ซึ่งเป็นสตรีมแบบอเนกประสงค์

  • VENDOR_START: ใช้สำหรับกรณีการใช้งานที่ OEM กำหนด

สร้าง CameraCaptureSession

หากต้องการสร้างเซสชันกล้อง ให้ระบุบัฟเฟอร์เอาต์พุตอย่างน้อย 1 รายการที่แอปสามารถเขียนเฟรมเอาต์พุตได้ บัฟเฟอร์แต่ละรายการแสดงถึงไปป์ไลน์ คุณต้องดำเนินการนี้ก่อนเริ่มใช้กล้อง เพื่อให้เฟรมเวิร์กสามารถกำหนดค่าไปป์ไลน์ภายในของอุปกรณ์และจัดสรรบัฟเฟอร์หน่วยความจำสำหรับการส่งเฟรมไปยังเป้าหมายเอาต์พุตที่จำเป็น

ข้อมูลโค้ดต่อไปนี้แสดงวิธีเตรียมเซสชันกล้องที่มีบัฟเฟอร์เอาต์พุต 2 รายการ โดยรายการหนึ่งเป็นของ SurfaceView และอีกรายการเป็นของ ImageReader การเพิ่ม Use Case ของสตรีม PREVIEW ไปยัง previewSurface และ Use Case ของสตรีม STILL_CAPTURE ไปยัง imReaderSurface ช่วยให้ฮาร์ดแวร์ของอุปกรณ์เพิ่มประสิทธิภาพสตรีมเหล่านี้ได้มากยิ่งขึ้น

// Retrieve the target surfaces, which might be coming from a number of places:
// 1. SurfaceView, if you want to display the image directly to the user
// 2. ImageReader, if you want to read each frame or perform frame-by-frame
// analysis
// 3. OpenGL Texture or TextureView, although discouraged for maintainability
// reasons
// 4. RenderScript.Allocation, if you want to do parallel processing
val surfaceView = findViewById<SurfaceView>(
    // ...
)
val imageReader = ImageReader.newInstance(
    // ...
)

// Remember to call this only *after* SurfaceHolder.Callback.surfaceCreated().
val previewSurface = surfaceView.holder.surface
val imReaderSurface = imageReader.surface
val targets = listOf(previewSurface, imReaderSurface)

// Create a capture session using the predefined targets; this also involves
// defining the session state callback to be notified of when the session is
// ready.
// Setup Stream Use Case while setting up your Output Configuration.
@RequiresApi(Build.VERSION_CODES.TIRAMISU)
fun configureSession(device: CameraDevice, targets: List<Surface>) {
    val configs = mutableListOf<OutputConfiguration>()
    val streamUseCase = CameraMetadata
        .SCALER_AVAILABLE_STREAM_USE_CASES_PREVIEW_VIDEO_STILL

    targets.forEach {
        val config = OutputConfiguration(it)
        config.streamUseCase = streamUseCase.toLong()
        configs.add(config)
    }
    // ...
    device.createCaptureSession(session)
}

ในตอนนี้ คุณยังไม่ได้กำหนดค่าที่ใช้งานอยู่ของกล้อง เมื่อกำหนดค่าเซสชันแล้ว คุณสามารถสร้างและส่งคำขอจับภาพเพื่อดำเนินการดังกล่าวได้

การเปลี่ยนรูปแบบที่ใช้กับอินพุตขณะที่เขียนลงในบัฟเฟอร์จะกำหนดโดยประเภทของเป้าหมายแต่ละรายการ ซึ่งต้องเป็น Surface เฟรมเวิร์ก Android รู้วิธีแปลงรูปภาพดิบในการกำหนดค่าที่ใช้งานอยู่เป็นรูปแบบที่เหมาะสมสำหรับเป้าหมายแต่ละรายการ การแปลงจะควบคุมโดยรูปแบบพิกเซลและขนาดของ Surface นั้นๆ

เฟรมเวิร์กจะพยายามทำงานอย่างเต็มที่ แต่การกำหนดค่า Surface บางชุดอาจใช้ไม่ได้ ซึ่งทำให้เกิดปัญหา เช่น ไม่มีการสร้างเซสชัน แสดงข้อผิดพลาดขณะรันไทม์เมื่อคุณส่งคำขอ หรือประสิทธิภาพลดลง เฟรมเวิร์กนี้รับประกันการผสมผสานที่เฉพาะเจาะจงของพารามิเตอร์อุปกรณ์ แพลตฟอร์ม และคำขอ ดูข้อมูลเพิ่มเติมได้ในเอกสารประกอบของ createCaptureSession()

CaptureRequests รายการเดียว

การกำหนดค่าที่ใช้สำหรับแต่ละเฟรมจะเข้ารหัสใน CaptureRequest ซึ่งจะส่งไปยังกล้อง หากต้องการสร้างคำขอจับภาพ คุณสามารถใช้เทมเพลตที่กำหนดไว้ล่วงหน้า หรือจะใช้ TEMPLATE_MANUAL เพื่อควบคุมอย่างเต็มรูปแบบก็ได้ เมื่อเลือกเทมเพลต คุณต้องระบุบัฟเฟอร์เอาต์พุตอย่างน้อย 1 รายการเพื่อใช้กับคำขอ คุณใช้ได้เฉพาะบัฟเฟอร์ที่กำหนดไว้แล้วในเซสชันการจับภาพที่คุณต้องการใช้

คำขอจับภาพใช้รูปแบบ Builder และเปิดโอกาสให้นักพัฒนาแอปตั้งค่าตัวเลือกต่างๆ มากมาย ซึ่งรวมถึงการเปิดรับแสงอัตโนมัติ โฟกัสอัตโนมัติ และรูรับแสงของเลนส์ ก่อนตั้งค่าช่อง ให้ตรวจสอบว่าตัวเลือกที่เฉพาะเจาะจงพร้อมใช้งานสำหรับอุปกรณ์โดยเรียกใช้ CameraCharacteristics.getAvailableCaptureRequestKeys() และตรวจสอบว่าค่าที่เลือกได้รับการรองรับโดยตรวจสอบลักษณะของกล้องที่เหมาะสม เช่น โหมดการรับแสงอัตโนมัติที่พร้อมใช้งาน

หากต้องการสร้างคำขอจับภาพสำหรับ SurfaceView โดยใช้เทมเพลตที่ออกแบบมาเพื่อแสดงตัวอย่างโดยไม่มีการแก้ไข ให้ใช้ CameraDevice.TEMPLATE_PREVIEW ดังนี้

val session: CameraCaptureSession = /* ... */ // from CameraCaptureSession.StateCallback
val captureRequest = session.device.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW)
captureRequest.addTarget(previewSurface)

เมื่อกำหนดคำขอการจับภาพแล้ว คุณจะส่งคำขอดังกล่าวไปยังเซสชันกล้องได้โดยทำดังนี้

val session: CameraCaptureSession = ...  // from CameraCaptureSession.StateCallback
val captureRequest: CaptureRequest.Builder = ...  // from CameraDevice.createCaptureRequest()

// The first null argument corresponds to the capture callback, which you
// provide if you want to retrieve frame metadata or keep track of failed capture
// requests that can indicate dropped frames; the second null argument
// corresponds to the Handler used by the asynchronous callback, which falls
// back to the current thread's looper if null.
session.capture(captureRequest.build(), null, null)

เมื่อเฟรมเอาต์พุตถูกใส่ลงในบัฟเฟอร์ที่เฉพาะเจาะจง ระบบจะทริกเกอร์การเรียกกลับการจับภาพ ในหลายกรณี ระบบจะเรียกใช้ Callback เพิ่มเติม เช่น ImageReader.OnImageAvailableListener เมื่อมีการประมวลผลเฟรมที่มี Callback ดังกล่าว เมื่อถึงจุดนี้ คุณจะดึงข้อมูลรูปภาพออกจากบัฟเฟอร์ที่ระบุได้

ทำซ้ำ CaptureRequests

คำขอกล้องเดียวทำได้ง่าย แต่สำหรับการแสดงตัวอย่างแบบสดหรือวิดีโอ คำขอเหล่านี้ไม่มีประโยชน์มากนัก ในกรณีนี้ คุณต้องได้รับสตรีมเฟรมอย่างต่อเนื่อง ไม่ใช่แค่เฟรมเดียว ข้อมูลโค้ดต่อไปนี้แสดงวิธีเพิ่มคำขอซ้ำลงในเซสชัน

val session: CameraCaptureSession = ... // from CameraCaptureSession.StateCallback
val captureRequest: CaptureRequest.Builder = ... // from CameraDevice.createCaptureRequest()

// This keeps sending the capture request as frequently as possible until
// the session is torn down or session.stopRepeating() is called.
session.setRepeatingRequest(captureRequest.build(), null, null)

คำขอจับภาพซ้ำจะทำให้อุปกรณ์กล้องจับภาพอย่างต่อเนื่องโดยใช้การตั้งค่าใน CaptureRequest ที่ระบุ นอกจากนี้ Camera2 API ยังช่วยให้ผู้ใช้จับภาพวิดีโอจากกล้องได้โดยการส่ง CaptureRequests ซ้ำๆ ดังที่เห็นในที่เก็บตัวอย่าง Camera2 นี้ใน GitHub นอกจากนี้ยังแสดงผลวิดีโอสโลว์โมชันได้ด้วยการจับภาพวิดีโอความเร็วสูง (สโลว์โมชัน) โดยใช้การถ่ายภาพต่อเนื่องซ้ำๆ CaptureRequests ดังที่แสดงในแอปตัวอย่างวิดีโอสโลว์โมชัน Camera2 บน GitHub

Interleave CaptureRequests

หากต้องการส่งคำขอจับภาพครั้งที่ 2 ขณะที่คำขอจับภาพซ้ำทำงานอยู่ เช่น เพื่อแสดงช่องมองภาพและให้ผู้ใช้ถ่ายภาพ คุณไม่จำเป็นต้องหยุดคำขอจับภาพซ้ำที่กำลังดำเนินอยู่ แต่คุณจะส่งคำขอจับภาพแบบไม่ทำซ้ำแทนในขณะที่คำขอแบบทำซ้ำยังคงทำงานอยู่

บัฟเฟอร์เอาต์พุตที่ใช้จะต้องได้รับการกำหนดค่าเป็นส่วนหนึ่งของเซสชันกล้องเมื่อสร้างเซสชันเป็นครั้งแรก คำขอที่ทำซ้ำจะมีลำดับความสำคัญต่ำกว่าคำขอแบบเฟรมเดียวหรือแบบต่อเนื่อง ซึ่งช่วยให้ตัวอย่างต่อไปนี้ทำงานได้

val session: CameraCaptureSession = /* ... */ // from CameraCaptureSession.StateCallback

// Create the repeating request and dispatch it.
val repeatingRequest = session.device.createCaptureRequest(
    CameraDevice.TEMPLATE_PREVIEW
)
repeatingRequest.addTarget(previewSurface)
session.setRepeatingRequest(repeatingRequest.build(), null, null)

// Some time later...

// Create the single request and dispatch it.
// NOTE: This can disrupt the ongoing repeating request momentarily.
val singleRequest = session.device.createCaptureRequest(
    CameraDevice.TEMPLATE_STILL_CAPTURE
)
singleRequest.addTarget(imReaderSurface)
session.capture(singleRequest.build(), null, null)

อย่างไรก็ตาม วิธีนี้มีข้อเสียคือคุณจะไม่ทราบแน่ชัดว่าคำขอเดียวเกิดขึ้นเมื่อใด ในภาพต่อไปนี้ หาก A เป็นคำขอจับภาพซ้ำและ B เป็นคำขอจับภาพเฟรมเดียว เซสชันจะประมวลผลคิวคำขอดังนี้

คิวคำขอการจับภาพซ้ำที่ทำงานอยู่ถูกขัดจังหวะด้วยคำขอการจับภาพรายการเดียว
รูปที่ 2 ภาพคิวคำขอสำหรับเซสชันกล้องที่กำลังดำเนินอยู่

ไม่มีการรับประกันเวลาในการตอบสนองระหว่างคำขอที่เกิดซ้ำครั้งสุดท้ายจาก A ก่อนที่คำขอ B จะเปิดใช้งานและครั้งถัดไปที่มีการใช้ A อีกครั้ง คุณจึงอาจพบเฟรมที่ข้ามไป คุณสามารถดำเนินการบางอย่างเพื่อบรรเทาปัญหานี้ได้ ดังนี้

  • เพิ่มเป้าหมายเอาต์พุตจากคำขอ A ไปยังคำขอ B ด้วยวิธีนี้ เมื่อเฟรมของ B พร้อมใช้งาน ระบบจะคัดลอกเฟรมดังกล่าวไปยังเป้าหมายเอาต์พุตของ A ตัวอย่างเช่น การดำเนินการนี้จำเป็นเมื่อถ่ายภาพรวมของวิดีโอเพื่อรักษาอัตราเฟรมให้คงที่ ในโค้ดก่อนหน้า คุณเพิ่ม singleRequest.addTarget(previewSurface) ก่อนสร้างคำขอ

  • ใช้เทมเพลตหลายแบบร่วมกันซึ่งออกแบบมาเพื่อใช้กับสถานการณ์นี้โดยเฉพาะ เช่น การหน่วงเวลาชัตเตอร์เป็นศูนย์