วิธีการ

การจับภาพความเร็วสูงและวิดีโอสโลว์โมชันด้วย CameraX 1.5

ใช้เวลาอ่าน 6 นาที
ดูโปรไฟล์ของ Charles Munger
Leo Huang วิศวกรซอฟต์แวร์

การจับภาพการเคลื่อนไหวที่รวดเร็วได้อย่างชัดเจนเป็นฟีเจอร์สำคัญสำหรับแอปกล้องสมัยใหม่ ซึ่งทำได้โดยใช้การจับภาพความเร็วสูง ซึ่งเป็นกระบวนการรับเฟรมที่อัตราต่างๆ เช่น 120 หรือ 240 FPS การจับภาพความละเอียดสูงนี้สามารถใช้เพื่อวัตถุประสงค์ที่แตกต่างกัน 2 ประการ ได้แก่ การสร้างวิดีโอที่มีอัตราเฟรมสูงเพื่อการวิเคราะห์แบบทีละเฟรมอย่างละเอียด หรือการสร้างวิดีโอสโลว์โมชันที่การเคลื่อนไหวจะปรากฏบนหน้าจออย่างน่าตื่นตาตื่นใจ

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


หลักการเบื้องหลังสโลว์โมชัน

หลักการพื้นฐานของสโลว์โมชันคือการจับภาพวิดีโอที่อัตราเฟรมสูงกว่าที่เล่นมาก ตัวอย่างเช่น หากคุณบันทึกเหตุการณ์ 1 วินาทีที่ 120 เฟรมต่อวินาที (FPS) แล้วเล่นวิดีโอที่บันทึกไว้นั้นที่ 30 FPS ตามมาตรฐาน วิดีโอจะใช้เวลาเล่น 4 วินาที การ "ยืด" เวลาออกไปนี้เองที่สร้างเอฟเฟกต์สโลว์โมชันที่น่าทึ่ง ซึ่งช่วยให้คุณเห็นรายละเอียดที่เร็วเกินกว่าจะมองเห็นได้ด้วยตาเปล่า

เพื่อให้วิดีโอเอาต์พุตสุดท้ายราบรื่นและลื่นไหล โดยปกติแล้วควรแสดงผลที่อัตราเฟรมอย่างน้อย 30 FPS ซึ่งหมายความว่าหากต้องการสร้างวิดีโอสโลว์โมชัน 4 เท่า อัตราเฟรมที่จับภาพต้นฉบับต้องมีอย่างน้อย 120 FPS (จับภาพ 120 FPS ÷ 4 = เล่น 30 FPS)

เมื่อจับภาพฟุตเทจที่มีอัตราเฟรมสูงแล้ว คุณจะสร้างผลลัพธ์ที่ต้องการได้ 2 วิธีหลักๆ ดังนี้

  • สโลว์โมชันที่จัดการโดยโปรแกรมเล่น (วิดีโอที่มีอัตราเฟรมสูง): ระบบจะบันทึกการบันทึกความเร็วสูง (เช่น 120 FPS) เป็นไฟล์วิดีโอที่มีอัตราเฟรมสูงโดยตรง จากนั้นวิดีโอเพลเยอร์จะรับผิดชอบในการลดความเร็วในการเล่น ซึ่งช่วยให้ผู้ใช้สลับระหว่างการเล่นแบบปกติและแบบสโลว์โมชันได้อย่างยืดหยุ่น
  • สโลว์โมชันที่พร้อมเล่น (วิดีโอที่เข้ารหัสใหม่): สตรีมวิดีโอความเร็วสูงจะได้รับการประมวลผลและเข้ารหัสใหม่เป็นไฟล์ที่มีอัตราเฟรมมาตรฐาน (เช่น 30 FPS) ระบบจะ "ฝัง" เอฟเฟกต์สโลว์โมชันโดยการปรับการประทับเวลาของเฟรม วิดีโอที่ได้จะเล่นแบบสโลว์โมชันในวิดีโอเพลเยอร์มาตรฐานโดยไม่ต้องมีการจัดการพิเศษ แม้ว่าวิดีโอจะเล่นแบบสโลว์โมชันโดยค่าเริ่มต้น แต่วิดีโอเพลเยอร์ยังคงมีตัวควบคุมความเร็วในการเล่นที่ช่วยให้ผู้ใช้เพิ่มความเร็วและดูวิดีโอที่ความเร็วเดิมได้

CameraX API ช่วยลดความซับซ้อนของกระบวนการนี้ด้วยการมอบวิธีแบบรวมศูนย์ในการเลือกแนวทางที่ต้องการ ดังที่แสดงด้านล่าง


API วิดีโอความเร็วสูงใหม่

โซลูชัน CameraX ใหม่สร้างขึ้นจากองค์ประกอบหลัก 2 อย่าง ได้แก่

  • Recorder#getHighSpeedVideoCapabilities(CameraInfo): วิธีนี้ช่วยให้คุณตรวจสอบได้ว่ากล้องสามารถบันทึกด้วยความเร็วสูงได้หรือไม่ และหากได้ จะรองรับความละเอียด (ออบเจ็กต์ Quality) ใดบ้าง
  • HighSpeedVideoSessionConfig: นี่คือออบเจ็กต์การกำหนดค่าพิเศษที่จัดกลุ่ม Use Case VideoCapture และ Preview ของคุณ โดยบอกให้ CameraX สร้างเซสชันกล้องความเร็วสูงแบบรวม โปรดทราบว่าแม้สตรีม VideoCapture จะทำงานที่อัตราเฟรมสูงที่กำหนดค่าไว้ แต่โดยปกติแล้วระบบกล้องจะจำกัดสตรีม Preview ไว้ที่อัตรามาตรฐานอย่างน้อย 30 FPS เพื่อให้แสดงผลบนหน้าจอได้อย่างราบรื่น

เริ่มต้นใช้งาน

ก่อนเริ่มต้น โปรดตรวจสอบว่าคุณได้เพิ่มทรัพยากร Dependency ของ CameraX ที่จำเป็นลงในไฟล์ build.gradle.kts ของแอปแล้ว คุณจะต้องมีอาร์ติแฟกต์ camera-video พร้อมกับไลบรารี CameraX หลัก

// build.gradle.kts (Module: app)

dependencies {

    val camerax_version = "1.5.1"


    implementation("androidx.camera:camera-core:$camerax_version")

    implementation("androidx.camera:camera-camera2:$camerax_version")

    implementation("androidx.camera:camera-lifecycle:$camerax_version")

    implementation("androidx.camera:camera-video:$camerax_version")

    implementation("androidx.camera:camera-view:$camerax_version")

}

หมายเหตุเกี่ยวกับ API เวอร์ชันทดลอง

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

@kotlin.OptIn(ExperimentalSessionConfig::class, ExperimentalHighSpeedVideo::class)

การใช้งาน

การติดตั้งใช้งานสำหรับทั้ง 2 ผลลัพธ์จะเริ่มต้นด้วยขั้นตอนการตั้งค่าเดียวกัน การเลือกระหว่างการสร้างวิดีโอที่มีอัตราเฟรมสูงหรือวิดีโอสโลว์โมชันขึ้นอยู่กับการตั้งค่าเดียว

1. ตั้งค่าการจับภาพความเร็วสูง

ก่อนอื่น ไม่ว่าเป้าหมายของคุณคืออะไร คุณต้องรับ ProcessCameraProvider ตรวจสอบความสามารถของอุปกรณ์ และสร้าง Use Case

บล็อกโค้ดต่อไปนี้แสดงขั้นตอนการตั้งค่าทั้งหมดภายในฟังก์ชันระงับ คุณสามารถเรียกใช้ฟังก์ชันนี้จากขอบเขต Coroutine เช่น lifecycleScope.launch

// Add the OptIn annotation at the top of your function or class

@kotlin.OptIn(ExperimentalSessionConfig::class, ExperimentalHighSpeedVideo::class)

private suspend fun setupCamera() {

    // Asynchronously get the CameraProvider

    val cameraProvider = ProcessCameraProvider.awaitInstance(this)



    // -- CHECK CAPABILITIES --

    val cameraInfo = cameraProvider.getCameraInfo(CameraSelector.DEFAULT_BACK_CAMERA)

    val videoCapabilities = Recorder.getHighSpeedVideoCapabilities(cameraInfo)

    if (videoCapabilities == null) {

        // This camera device does not support high-speed video.

        return

    }




    // -- CREATE USE CASES --

    val preview = Preview.Builder().build()    


    // You can create a Recorder with default settings.

    // CameraX will automatically select a suitable quality.

    val recorder = Recorder.Builder().build()


    // Alternatively, to use a specific resolution, you can configure the
    // Recorder with a QualitySelector. This is useful if your app has
    // specific resolution requirements or you want to offer user
    // preferences. 

    // To use a specific quality, you can uncomment the following lines.

    // Get the list of qualities supported for high-speed video. 

    // val supportedQualities = videoCapabilities.getSupportedQualities(DynamicRange.SDR)

    // Build the Recorder using the quality from the supported list.

    // val recorderWithQuality = Recorder.Builder()

    //     .setQualitySelector(QualitySelector.from(supportedQualities.first()))

    //     .build()



    // Create the VideoCapture use case, using either recorder or recorderWithQuality

    val videoCapture = VideoCapture.withOutput(recorder)

    // Now you are ready to configure the session for your desired output...

}

2. การเลือกเอาต์พุต

ตอนนี้คุณต้องตัดสินใจว่าจะสร้างวิดีโอประเภทใด โค้ดนี้จะทำงานภายในฟังก์ชัน setupCamera() suspend ที่แสดงด้านบน

ตัวเลือก ก: สร้างวิดีโอที่มีอัตราเฟรมสูง

เลือกตัวเลือกนี้หากต้องการให้ไฟล์สุดท้ายมีอัตราเฟรมสูง (เช่น วิดีโอ 120 FPS)

// Create a builder for the high-speed session

val sessionConfigBuilder = HighSpeedVideoSessionConfig.Builder(videoCapture)

    .setPreview(preview)


// Query and apply a supported frame rate. Common supported frame rates include 120 and 240 fps.

val supportedFrameRateRanges =

    cameraInfo.getSupportedFrameRateRanges(sessionConfigBuilder.build())


sessionConfigBuilder.setFrameRateRange(supportedFrameRateRanges.first())

ตัวเลือก ข: สร้างวิดีโอสโลว์โมชันที่พร้อมเล่น

เลือกตัวเลือกนี้หากต้องการวิดีโอที่เล่นแบบสโลว์โมชันโดยอัตโนมัติในวิดีโอเพลเยอร์มาตรฐาน

// Create a builder for the high-speed session

val sessionConfigBuilder = HighSpeedVideoSessionConfig.Builder(videoCapture)

    .setPreview(preview)



// This is the key: enable automatic slow-motion!

sessionConfigBuilder.setSlowMotionEnabled(true)



// Query and apply a supported frame rate. Common supported frame rates include 120, 240, and 480 fps.

val supportedFrameRateRanges =

   cameraInfo.getSupportedFrameRateRanges(sessionConfigBuilder.build())

sessionConfigBuilder.setFrameRateRange(supportedFrameRateRanges.first())

แฟล็กเดียวนี้เป็นกุญแจสำคัญในการสร้างวิดีโอสโลว์โมชันที่พร้อมเล่น เมื่อ setSlowMotionEnabled เป็นจริง CameraX จะประมวลผลสตรีมความเร็วสูงและบันทึกเป็นไฟล์วิดีโอ 30 FPS มาตรฐาน ความเร็วของภาพสโลว์โมชันจะกำหนดโดยอัตราส่วนของอัตราเฟรมที่จับภาพต่ออัตราการเล่นมาตรฐานนี้

เช่น

  • การบันทึกที่ 120 FPS จะสร้างวิดีโอที่เล่นด้วยความเร็ว 1/4 เท่า (120 ÷ 30 = 4)
  • การบันทึกที่ 240 FPS จะสร้างวิดีโอที่เล่นด้วยความเร็ว 1/8 เท่า (240 ÷ 30 = 8)

สรุปข้อมูลทั้งหมด: การบันทึกวิดีโอ

เมื่อกำหนดค่า HighSpeedVideoSessionConfig และเชื่อมโยงกับวงจรแล้ว ขั้นตอนสุดท้ายคือการเริ่มบันทึก กระบวนการเตรียมตัวเลือกเอาต์พุต การเริ่มบันทึก และการจัดการเหตุการณ์วิดีโอจะเหมือนกับการจับภาพวิดีโอมาตรฐาน

โพสต์นี้จะเน้นที่การกำหนดค่าความเร็วสูง ดังนั้นเราจะไม่พูดถึงกระบวนการบันทึกโดยละเอียด ดูคำแนะนำที่ครอบคลุมเกี่ยวกับทุกอย่างตั้งแต่การเตรียมออบเจ็กต์ FileOutputOptions หรือ MediaStoreOutputOptions ไปจนถึงการจัดการ Callback ของ VideoRecordEvent ได้ที่เอกสารประกอบของ VideoCapture

// Bind the session config to the lifecycle

cameraProvider.bindToLifecycle(

    this as LifecycleOwner,

    CameraSelector.DEFAULT_BACK_CAMERA,

    sessionConfigBuilder.build() // Bind the config object from Option A or B

)



// Start the recording using the VideoCapture use case

val recording = videoCapture.output

    .prepareRecording(context, outputOptions) // See docs for creating outputOptions

    .start(ContextCompat.getMainExecutor(context)) { recordEvent ->

        // Handle recording events (e.g., Start, Pause, Finalize)

    }

การรองรับวิดีโอสโลว์โมชันของ Google Photos

เมื่อเปิดใช้ setSlowMotionEnabled(true) ใน CameraX ไฟล์วิดีโอที่ได้จะได้รับการออกแบบให้จดจำได้ทันทีและเล่นเป็นสโลว์โมชันในวิดีโอเพลเยอร์และแอปแกลเลอรีมาตรฐาน โดยเฉพาะอย่างยิ่ง Google Photos มีฟังก์ชันการทำงานที่ปรับปรุงใหม่สำหรับวิดีโอสโลว์โมชันเหล่านี้เมื่ออัตราเฟรมที่จับภาพคือ 120, 240, 360, 480 หรือ 960 FPS

  • การจดจำ UI ที่แตกต่างกันในภาพปก: ในคลังภาพ Google Photos คุณสามารถระบุวิดีโอสโลว์โมชันได้ด้วยองค์ประกอบ UI ที่เฉพาะเจาะจง ซึ่งทำให้วิดีโอสโลว์โมชันแตกต่างจากวิดีโอปกติ
normal.png
slowmotion.png
ภาพปกวิดีโอปกติภาพปกวิดีโอแบบสโลว์โมชัน
  • ส่วนความเร็วที่ปรับได้ระหว่างการเล่น: เมื่อเล่นวิดีโอสโลว์โมชัน Google Photos จะมีตัวควบคุมเพื่อปรับส่วนของวิดีโอที่เล่นด้วยความเร็วต่ำและส่วนที่เล่นด้วยความเร็วปกติ ซึ่งช่วยให้ผู้ใช้ควบคุมการสร้างสรรค์ได้ จากนั้น คุณจะส่งออกวิดีโอที่แก้ไขแล้วเป็นไฟล์วิดีโอใหม่ได้โดยใช้ปุ่มแชร์ ซึ่งจะคงส่วนที่เป็นสโลว์โมชันที่คุณกำหนดไว้
normal2.png
slowmotion2.png
การเล่นวิดีโอปกติการเล่นวิดีโอสโลว์โมชัน
พร้อมการควบคุม
การแก้ไข

หมายเหตุเกี่ยวกับการรองรับอุปกรณ์

API ความเร็วสูงของ CameraX อาศัยระบบ CamcorderProfile ของ Android ที่สำคัญเพื่อกำหนดความละเอียดและอัตราเฟรมความเร็วสูงที่อุปกรณ์รองรับ CamcorderProfile ได้รับการตรวจสอบโดยชุดเครื่องมือทดสอบความเข้ากันได้ (CTS) ของ Android ซึ่งหมายความว่าคุณมั่นใจได้ในความสามารถในการบันทึกวิดีโอที่รายงานของอุปกรณ์

ซึ่งหมายความว่าความสามารถของอุปกรณ์ในการบันทึกวิดีโอสโลว์โมชันด้วยแอปกล้องในตัวไม่ได้เป็นการรับประกันว่า API ความเร็วสูงของ CameraX จะทำงานได้ ความคลาดเคลื่อนนี้เกิดขึ้นเนื่องจากผู้ผลิตอุปกรณ์มีหน้าที่ป้อนข้อมูล CamcorderProfile ในเฟิร์มแวร์ของอุปกรณ์ และบางครั้งโปรไฟล์ความเร็วสูงที่จำเป็น เช่น CamcorderProfile.QUALITY_HIGH_SPEED_1080P และ CamcorderProfile.QUALITY_HIGH_SPEED_720P ก็ไม่ได้รวมอยู่ด้วย เมื่อไม่มีโปรไฟล์เหล่านี้ Recorder.getHighSpeedVideoCapabilities() จะแสดงผลเป็น null

ดังนั้น คุณจึงควรใช้ Recorder.getHighSpeedVideoCapabilities() เพื่อตรวจสอบฟีเจอร์ที่รองรับแบบเป็นโปรแกรมเสมอ เนื่องจากเป็นวิธีที่น่าเชื่อถือที่สุดในการรับประกันประสบการณ์ที่สอดคล้องกันในอุปกรณ์ต่างๆ หากคุณพยายามเชื่อมโยง HighSpeedVideoSessionConfig ในอุปกรณ์ที่ Recorder.getHighSpeedVideoCapabilities() แสดงผลเป็น Null การดำเนินการจะล้มเหลวพร้อมกับ IllegalArgumentException คุณสามารถยืนยันการรองรับในอุปกรณ์ Google Pixel เนื่องจากอุปกรณ์เหล่านี้มีโปรไฟล์ความเร็วสูงเหล่านี้อย่างสม่ำเสมอ นอกจากนี้ อุปกรณ์ต่างๆ จากผู้ผลิตรายอื่น เช่น Motorola Edge 30, OPPO Find N2 Flip และ Sony Xperia 1 V ก็รองรับความสามารถด้านวิดีโอความเร็วสูงด้วยเช่นกัน


บทสรุป

CameraX High-Speed Video API มีทั้งประสิทธิภาพและความยืดหยุ่น ไม่ว่าคุณจะต้องการฟุตเทจที่มีอัตราเฟรมสูงอย่างแท้จริงสำหรับการวิเคราะห์ทางเทคนิค หรือต้องการเพิ่มเอฟเฟกต์สโลว์โมชันแบบภาพยนตร์ลงในแอป HighSpeedVideoSessionConfig ก็มีโซลูชันที่เรียบง่ายและครบวงจร การทำความเข้าใจบทบาทของแฟล็ก setSlowMotionEnabled จะช่วยให้คุณรองรับทั้ง 2 กรณีการใช้งานได้อย่างง่ายดาย และช่วยให้ผู้ใช้ควบคุมครีเอทีฟโฆษณาได้มากขึ้น

เขียนโดย
อ่านต่อ