การแปลงรหัสในการพัฒนามือถือ — คืออะไร หลักการทำงาน และสถานการณ์การใช้งาน

การแปลงรหัสคืออะไร?

การแปลงรหัส คือกระบวนการแปลงไฟล์สื่อจากรูปแบบการบีบอัดหนึ่งไปยังอีกรูปแบบหนึ่งโดยการถอดรหัสสตรีมต้นทางอย่างสมบูรณ์เป็นรูปแบบ PCM กลางที่ไม่มีการบีบอัด แล้วจึงเข้ารหัสด้วยพารามิเตอร์ใหม่ หากไฟล์ต้นทางใช้โคเดก H.264 ที่อัตราบิต 10 Mbps และเอาต์พุตต้องการ H.265 ที่อัตราบิต 3 Mbps — นี่คือการแปลงรหัส

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

การแปลงรหัสใช้ในงานที่หลากหลาย: การปรับวิดีโอให้เข้ากับข้อจำกัดของแบนด์วิดท์ การแปลงเป็นรูปแบบที่รองรับการถอดรหัสฮาร์ดแวร์บนอุปกรณ์เป้าหมาย การสร้างหลายเวอร์ชันสำหรับสตรีมมิง HLS/DASH การแยกแทร็กเสียงเป็นไฟล์แยกต่างหาก บริการ OTT (Netflix, YouTube, Twitch) จะแปลงรหัสทุกไฟล์ที่อัปโหลดเป็นรูปแบบต่างๆ หลายสิบแบบด้วยอัตราบิต ความละเอียด และโคเดกที่แตกต่างกัน เพื่อให้สตรีมมิงแบบปรับเปลี่ยนได้แก่ผู้ใช้หลายล้านคน

การแปลงรหัสทำงานอย่างไร?

กระบวนการแปลงรหัสประกอบด้วยสามขั้นตอนหลัก: การถอดรหัส การประมวลผล และการเข้ารหัส แต่ละขั้นตอนสามารถดำเนินการบน CPU หรือบล็อก GPU/ฮาร์ดแวร์ ขึ้นอยู่กับความพร้อมใช้งานและประสิทธิภาพที่ต้องการ

ขั้นตอนของการแปลงรหัส

ขั้นตอนแรกคือการถอดรหัสสตรีมต้นทาง ไฟล์ต้นทางจะถูกอ่านจากคอนเทนเนอร์ (MP4, MOV, MKV) หลังจากนั้นแพ็กเก็ตวิดีโอที่ถูกบีบอัดจะถูกส่งไปยังตัวถอดรหัส การถอดรหัส สามารถใช้ฮาร์ดแวร์ (หากโคเดกรองรับ) หรือใช้ซอฟต์แวร์ผ่าน FFmpeg ผลลัพธ์ของการถอดรหัสคือเฟรมที่ไม่มีการบีบอัดในรูปแบบ YUV420 หรือ BGRA — นี่คือขั้นตอนที่การแปลงรหัสแตกต่างจากการทำ remultiplexing แบบง่าย

ขั้นตอนที่สองคือการกรองและประมวลผล เฟรมที่ถอดรหัสแล้วจะผ่านห่วงโซ่ของตัวกรอง: การปรับขนาดเป็นความละเอียดเป้าหมาย การเปลี่ยนอัตราเฟรม การแก้ไขสี การซ้อนทับข้อความหรือกราฟิก ห่วงโซ่ตัวกรอง FFmpeg ถูกสร้างเป็นกราฟที่ตัวกรองแต่ละตัวเป็นโมดูลประมวลผลแยกกัน ตัวอย่างเช่น ตัวกรอง scale=1280:720 เปลี่ยนความละเอียด fps=30 เปลี่ยนอัตราเฟรม และ yadif ทำการดีอินเทอร์เลซ การดำเนินการทั้งหมดจะดำเนินการกับเฟรมที่ไม่มีการบีบอัด ทำให้ขั้นตอนที่สองใช้ทรัพยากรมากที่สุด

ขั้นตอนที่สามคือการเข้ารหัสเป็นรูปแบบเป้าหมาย เฟรมที่ประมวลผลแล้วจะถูกป้อนเข้าสู่ตัวเข้ารหัส ซึ่งจะบีบอัดตามอัลกอริทึมของโคเดกเป้าหมาย ตัวเข้ารหัส สามารถใช้ฮาร์ดแวร์ (VideoToolbox บน iOS, MediaCodec บน Android) หรือซอฟต์แวร์ (libx264, libx265) พารามิเตอร์การเข้ารหัส: CRF (Constant Rate Factor) สำหรับคุณภาพคงที่ อัตราบิตสำหรับ CBR/VBR โปรไฟล์และระดับสำหรับความเข้ากันได้กับอุปกรณ์เป้าหมาย

// แผนภาพไปป์ไลน์การแปลงรหัสบน FFmpeg
AVFormatContext *inputCtx, *outputCtx;
AVCodecContext *decoderCtx, *encoderCtx;
AVFrame *frame = av_frame_alloc();
AVPacket packet;

while (av_read_frame(inputCtx, &packet) >= 0) {
    // 1. ถอดรหัส
    avcodec_send_packet(decoderCtx, &packet);
    avcodec_receive_frame(decoderCtx, frame);
    
    // 2. กรอง (ปรับขนาด + เปลี่ยน fps)
    sws_scale(swsCtx, frame->data, frame->linesize,
              0, frame->height, scaledFrame->data,
              scaledFrame->linesize);
    
    // 3. เข้ารหัส
    avcodec_send_frame(encoderCtx, scaledFrame);
    avcodec_receive_packet(encoderCtx, &outPacket);
    av_interleaved_write_frame(outputCtx, &outPacket);
}

ไปป์ไลน์ข้างต้นแสดงให้เห็นวัฏจักรการแปลงรหัสแบบคลาสสิก ฟังก์ชัน av_read_frame อ่านแพ็กเก็ตที่บีบอัดจากไฟล์อินพุต avcodec_send_packet ถอดรหัสเป็นเฟรม sws_scale ดำเนินการปรับขนาด และ avcodec_send_frame เข้ารหัสเฟรมที่ประมวลผลแล้วเป็นรูปแบบเอาต์พุต วัฏจักรสามขั้นตอนนี้จะทำซ้ำสำหรับแต่ละเฟรมหรือกลุ่มของเฟรม (GOP) ขึ้นอยู่กับการตั้งค่าของตัวเข้ารหัส

การแปลงรหัส vs Transmuxing

ความแตกต่างระหว่างการแปลงรหัสและ Transmuxing เป็นหนึ่งในจุดที่สับสนมากที่สุดในวิศวกรรมสื่อ การทำความเข้าใจความแตกต่างนี้มีความสำคัญต่อการเลือกกลยุทธ์การประมวลผลสื่อที่ถูกต้อง

Transmuxing คือการบรรจุสตรีมที่บีบอัดใหม่ลงในคอนเทนเนอร์อื่นโดยไม่ต้องถอดรหัสและเข้ารหัสใหม่ หากวิดีโอถูกบีบอัดด้วยโคเดก H.265 ในคอนเทนเนอร์ MP4 อยู่แล้วและจำเป็นต้องใส่ในคอนเทนเนอร์ MOV หรือ MKV — Transmuxing เพียงคัดลอกแพ็กเก็ตบิตสตรีมจากคอนเทนเนอร์หนึ่งไปยังอีกคอนเทนเนอร์หนึ่ง คุณภาพไม่ได้รับผลกระทบ เวลาในการประมวลผลน้อยมากเนื่องจากไม่จำเป็นต้องถอดรหัสเฟรม FFmpeg ดำเนินการ Transmuxing ด้วยแฟล็ก -codec copy

การแปลงรหัส ในทางกลับกัน จะถอดรหัสและบีบอัดสตรีมสื่อใหม่ทั้งหมด ทุกครั้งที่วิดีโอผ่านการแปลงรหัส การสูญเสียรุ่น (generation loss) อาจเกิดขึ้น — คุณภาพลดลงเล็กน้อยเนื่องจากการบีบอัดแบบสูญเสียซ้ำแล้วซ้ำเล่า แม้ที่อัตราบิตเดียวกัน รุ่นที่สามของการแปลงรหัสมักจะแย่กว่ารุ่นแรก นี่คือเหตุผลที่ผู้เชี่ยวชาญแนะนำให้เก็บสำเนาหลักในรูปแบบที่ไม่มีการบีบอัดหรือบีบอัดน้อยที่สุด (ProRes, DNxHR) และแปลงรหัสเฉพาะเวอร์ชันสุดท้ายสำหรับการจัดส่ง

เครื่องมือสำหรับการแปลงรหัส

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

FFmpeg — เครื่องมืออเนกประสงค์

FFmpeg เป็นมาตรฐานโดยพฤตินัยสำหรับการแปลงรหัสบนทุกแพลตฟอร์ม บรรทัดคำสั่ง FFmpeg ช่วยให้สามารถดำเนินการแปลงได้แทบทุกประเภท: การเปลี่ยนโคเดก การปรับอัตราบิต การตัด การต่อ การใช้ตัวกรอง สำหรับแอปพลิเคชันมือถือ FFmpeg ถูกรวมผ่านไลบรารี libavformat, libavcodec และ libavfilter ตัวอย่างคำสั่งแปลงรหัสทั่วไป: ffmpeg -i input.mp4 -c:v libx265 -crf 23 -c:a aac -b:a 128k output.mp4

API ของแพลตฟอร์ม

บน iOS การแปลงรหัสดำเนินการผ่าน AVAssetWriter และ AVAssetReader AVAssetReader ถอดรหัสไฟล์ต้นทางโดยการอ่านเฟรมที่ไม่มีการบีบอัด และ AVAssetWriter เข้ารหัสเป็นรูปแบบเป้าหมาย วิธีการนี้ใช้ตัวเข้ารหัสฮาร์ดแวร์ VideoToolbox โดยอัตโนมัติ ทำให้มั่นใจได้ถึงประสิทธิภาพสูงสุด บน Android ฟังก์ชันการทำงานที่คล้ายกันมีให้ใช้งานผ่าน MediaCodec ร่วมกับ MediaExtractor และ MediaMuxer — MediaExtractor แยกแพ็กเก็ตที่บีบอัด MediaCodec ถอดรหัสและเข้ารหัส MediaMuxer เขียนผลลัพธ์

บริการคลาวด์

สำหรับการแปลงรหัสฝั่งเซิร์ฟเวอร์ในสภาพแวดล้อมการผลิต จะใช้บริการคลาวด์: AWS Elemental MediaConvert, Azure Media Services, Google Transcoder API บริการเหล่านี้ปรับขนาดโดยอัตโนมัติภายใต้โหลด รองรับรูปแบบยอดนิยมทั้งหมด และสามารถแปลงรหัสไฟล์อินพุตเดียวเป็นรูปแบบเอาต์พุตหลายสิบแบบสำหรับสตรีมมิงแบบปรับเปลี่ยนได้ (HLS, DASH) สำหรับแอปพลิเคชันมือถือ การแปลงรหัสบนคลาวด์เป็นโซลูชันที่เหมาะสมที่สุดเนื่องจากไม่ทำให้อุปกรณ์ของผู้ใช้ทำงานหนักและช่วยให้สามารถเตรียมเนื้อหาแบบอะซิงโครนัสได้

ตัวอย่างโค้ดการแปลงรหัส

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

การแปลงรหัส H.264 เป็น H.265 บน iOS

import AVFoundation

func transcodeVideo(sourceURL: URL, destURL: URL) {
    let asset = AVAsset(url: sourceURL)
    let preset = AVAssetExportPresetHEVCHighestQuality
    
    AVAssetExportSession(asset: asset, presetName: preset)?
        .exportAsynchronously {
            switch assetExportSession?.status {
            case .completed:
                print("การแปลงรหัสเสร็จสมบูรณ์")
            case .failed:
                print("ข้อผิดพลาด: " + assetExportSession.error.localizedDescription)
            default:
                break
            }
        }
    
    // การแปลงรหัสด้วยตนเองด้วย AVAssetReader + AVAssetWriter
    let reader = try AVAssetReader(asset: asset)
    let writer = try AVAssetWriter(url: destURL,
        fileType: .mp4)
    
    let outputSettings: [String: Any] = [
        AVVideoCodecKey: AVVideoCodecType.hevc,
        AVVideoWidthKey: 1920,
        AVVideoHeightKey: 1080,
        AVVideoCompressionPropertiesKey: [
            AVVideoAverageBitRateKey: 4_000_000,
            AVVideoProfileLevelKey: AVVideoProfileLevelH265Main10
        ]
    ]
    
    let adaptor = AVAssetWriterInput(
        mediaType: .video,
        outputSettings: outputSettings
    )
    writer.add(adaptor)
}

ตัวอย่างแสดงสองวิธีการแปลงรหัสบน iOS AVAssetExportSession เป็นวิธีที่ง่ายด้วยค่าที่ตั้งไว้ล่วงหน้าด้านคุณภาพ (HEVCHighestQuality สำหรับ H.265) ไปป์ไลน์แบบแมนนวลผ่าน AVAssetReader + AVAssetWriter ให้การควบคุมพารามิเตอร์อย่างสมบูรณ์: อัตราบิต โปรไฟล์ ระดับ พารามิเตอร์ AVVideoProfileLevelH265Main10 เปิดใช้งานโปรไฟล์ HDR Main10 ด้วยความลึกสี 10 บิต ซึ่งสำคัญสำหรับเนื้อหา HDR สมัยใหม่

การแปลงรหัสบน Android ด้วย MediaCodec

class Transcoder(private val context: Context) {
    
    fun transcodeToHevc(inputUri: Uri, outputFile: File) {
        val extractor = MediaExtractor()
        extractor.setDataSource(context, inputUri, null)
        
        val trackFormat = extractor.getTrackFormat(videoTrackIndex)
        val mime = trackFormat.getString(MediaFormat.KEY_MIME)
        
        val decoder = MediaCodec.createDecoderByType(mime!!)
        val encoder = MediaCodec.createEncoderByType(MediaFormat.MIMETYPE_VIDEO_HEVC)
        
        val outputFormat = MediaFormat.createVideoFormat(
            MediaFormat.MIMETYPE_VIDEO_HEVC, 1920, 1080
        ).apply {
            setInteger(MediaFormat.KEY_BIT_RATE, 4_000_000)
            setInteger(MediaFormat.KEY_FRAME_RATE, 30)
            setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, 2)
        }
        
        encoder.configure(outputFormat, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE)
        encoder.start()
    }
}

โค้ด Android สร้างไปป์ไลน์ของ MediaExtractor — ตัวถอดรหัส MediaCodec — ตัวเข้ารหัส MediaCodec — MediaMuxer MediaExtractor กำหนดประเภทโคเดกจากไฟล์อินพุตและเลือกตัวถอดรหัสที่เกี่ยวข้อง ตัวเข้ารหัสถูกกำหนดค่าสำหรับ H.265 (HEVC) ด้วยอัตราบิต 4 Mbps และช่วงเวลาของคีย์เฟรม 2 วินาที ซึ่งเหมาะสมที่สุดสำหรับการสตรีมมิง สำคัญ: ตัวเข้ารหัส MediaCodec ทำงานแบบซิงโครนัส ดังนั้นสำหรับการแปลงรหัสแบบเรียลไทม์ ต้องใช้ลูปที่มีการจัดการประทับเวลา PTS ที่ถูกต้องสำหรับแต่ละเฟรม

การปรับแต่งการแปลงรหัสสำหรับอุปกรณ์มือถือ

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

การใช้การเข้ารหัสฮาร์ดแวร์

ปัจจัยด้านประสิทธิภาพที่สำคัญคือตัวเข้ารหัสฮาร์ดแวร์ บน iOS VideoToolbox ให้การเข้ารหัสฮาร์ดแวร์ H.264 และ H.265 ที่ความเร็วสูงกว่าซอฟต์แวร์ libx264 5–10 เท่า บน Android MediaCodec ใช้ส่วนประกอบ OMX ของฮาร์ดแวร์หากมี การเปิดใช้งานการเข้ารหัสฮาร์ดแวร์ช่วยลดเวลาในการแปลงรหัสวิดีโอความยาว 10 นาทีจาก 30–40 นาที (ซอฟต์แวร์) เหลือ 3–5 นาที (ฮาร์ดแวร์) บนอุปกรณ์เรือธง

การเลือกพารามิเตอร์คุณภาพ

สำหรับการแปลงรหัสบนมือถือ ความสมดุลระหว่างคุณภาพ ขนาด และเวลาในการประมวลผลเป็นสิ่งสำคัญ สำหรับ H.265 บนอุปกรณ์มือถือ อัตราบิต 4–8 Mbps แนะนำสำหรับวิดีโอ 1080p ที่ 30 FPS โหมด CRF (Constant Rate Factor) ใน libx265 ช่วยให้ตั้งค่าคุณภาพได้โดยตรง โดยที่ 23–28 ให้คุณภาพภาพที่ดีด้วยขนาดไฟล์ที่พอเหมาะ สำหรับตัวเข้ารหัสฮาร์ดแวร์ ให้ใช้โหมด CBR ด้วยอัตราบิตเป้าหมายเนื่องจาก CRF ไม่รองรับในฮาร์ดแวร์

การจัดการความร้อน

การแปลงรหัสอย่างต่อเนื่องบนอุปกรณ์มือถือทำให้เกิดความร้อนสูง หลังจาก 5–7 นาทีของการเข้ารหัสวิดีโอ 4K อย่างเข้มข้น อุณหภูมิของโปรเซสเซอร์อาจสูงถึง 50–55 องศา หลังจากนั้นการลดความเร็วจะเริ่มทำงาน วิธีแก้ไข คือการแปลงรหัสแบบหยุดพักหรือลดอัตราเฟรมเป็น 30 FPS หากแอปพลิเคชันต้องการการแปลงรหัสเป็นชุด (เช่น โปรแกรมตัดต่อวิดีโอ) ควรประมวลผลเป็นชุดละ 2–3 นาทีโดยมีช่วงพักให้เย็นลง สำหรับสถานการณ์การผลิต ควรย้ายการแปลงรหัสไปยังฝั่งเซิร์ฟเวอร์และใช้บริการคลาวด์