Pag-decode ng Software: ano ito, prinsipyo ng trabaho at mga sitwasyon ng paggamit

Ano ang software decoding?

Software decoding — isang paraan ng decompression ng media data kung saan ang lahat ng computational operations ay ginagawa sa universal cores ng CPU. Hindi tulad ng hardware decoding kung saan ang bawat codec ay may dedikadong physical block, ang software decoder ay ordinaryong code na nagpapatupad ng parehong algorithm sa pamamagitan ng processor instructions.

Ang mga software decoder ay isinusulat sa C/C++ gamit ang mga optimization para sa specific na CPU architecture: SIMD instructions ARM NEON para sa mobile devices, Intel SSE/AVX para sa desktop. Ang library na libavcodec mula sa FFmpeg ay naglalaman ng sampu-sampung libong linya ng na-optimize na assembler code para sa iba't ibang platform, na nagpapahintulot sa software decoding na makamit ang disenteng performance kahit para sa mabibigat na format tulad ng AV1 sa malalakas na CPU.

Ang pangunahing bentahe ng software decoding ay ang pagiging unibersal. Kung ang hardware decoder ay sumusuporta lamang ng 4–5 pangunahing format (H.264, H.265, VP9, AV1), ang FFmpeg ay maaaring mag-decode ng higit sa 200 codec: mula sa modernong AV1 at H.265 hanggang sa archival na Sorenson Spark, RealVideo at Motion JPEG. Ginagawa nitong kailangang-kailangan na tool ang software decoding para sa mga application na gumagana sa hindi karaniwang media data — halimbawa, professional video editor, video surveillance system, at specialized player.

Paano gumagana ang software decoding?

Ang software decoding ay umuulit ng parehong mga hakbang tulad ng hardware, ngunit sa universal CPU. Ang bawat hakbang ay ipinatutupad bilang mga function na sunod-sunod na tinatawag para sa bawat macroblock o frame. Ang pangunahing pagkakaiba ay flexibility: ang developer ay maaaring magbago ng pipeline, magdagdag ng mga filter at post-processing sa pagitan ng mga yugto ng decoding.

Arkitektura ng software decoder

Ang tipikal na software decoder ay binubuo ng mga module na nagpapatupad ng mga hiwalay na yugto ng algorithm. Ang entropy decoding module ay nagbabasa ng bit stream at nagre-reconstruct ng mga naka-quantize na DCT coefficient. Para sa H.264, ang modyul na ito ay nagpapatupad ng CABAC (Context-Adaptive Binary Arithmetic Coding) — isang kumplikadong algorithm na may conditional branching na mahirap i-accelerate ng hardware, ngunit sa CPU na may magandang branch predictor ay tumatakbo nang mahusay.

Ang inverse quantization module ay nagpaparami ng coefficients sa quantization step, at ang inverse DCT module ay nag-a-apply ng discrete cosine transform. Ang software implementation ng inverse DCT ay gumagamit ng mabilis na Chen algorithm o Loeffler algorithm, na nagbabawas ng bilang ng multiplication-accumulation operations mula 4096 hanggang 256 para sa 8x8 block. Ang SIMD instructions NEON (ARM) o SSE (x86) ay nagpapahintulot ng pagproseso ng 4–8 coefficients sa isang instruction, na nagbibigay ng 4–8 beses na acceleration kumpara sa scalar code.

Ang motion compensation module — ang pinaka-demanding sa memorya. Ito ay kumukuha ng mga lugar mula sa reference frames ayon sa motion vectors at nag-a-apply ng subpixel interpolation. Para sa H.265, ang interpolation accuracy ay umaabot sa 1/8 pixel, na nangangailangan ng filtering na may 8-tap FIR filter para sa luma at 4-tap para sa chroma. Ang software implementation ay napipilitang mag-load mula sa cache ng malalaking volume ng reference frame data, na ginagawang bottleneck ang motion compensation sa pag-decode ng mataas na resolution sa CPU.

Mga katangian ng decoding sa mobile CPU

Ang modernong mobile processors, tulad ng Apple A17 o Qualcomm Snapdragon 8 Gen 2, ay may 6–8 cores na may sapat na performance para sa software decoding ng 1080p H.264 nang hindi lumalaktaw ng frames. Gayunpaman, para sa 4K na nilalaman, lalo na sa mga format na H.265 at AV1, ang software decoding sa CPU ay maaaring hindi makasabay: ang tipikal na load ng lahat ng cores ay umaabot sa 70–90%, na kritikal para sa multitasking. Ang malalaking cores (Apple Performance, Qualcomm Kryo Prime) ay nagbibigay ng ~4–5x performance kumpara sa maliliit na energy-efficient cores, ngunit kumokonsumo ng proporsyonal na mas maraming enerhiya.

Mga sikat na software decoder

Ang market ng software decoder ay kinakatawan ng ilang pangunahing library, bawat isa ay na-optimize para sa kanilang niche. Ang pagpili ng decoder ay depende sa mga kinakailangang format, platform, at mga paghihigpit sa lisensya.

FFmpeg / libavcodec

FFmpeg — ang de facto standard ng software decoding sa industriya. Ang library na libavcodec ay may kasamang mga decoder para sa lahat ng pangunahing at karamihan sa mga pambihirang codec, sumusuporta sa lahat ng container (MP4, MKV, AVI, MOV, WebM) at gumagana sa lahat ng platform. Ang FFmpeg ay lisensyado sa ilalim ng LGPL/GPL, na nangangailangan ng pagsasaalang-alang sa mga kondisyon ng lisensya sa komersyal na paggamit. Sa mga mobile device, ang FFmpeg ay ginagamit sa pamamagitan ng mga wrapper: ffmpeg-kit para sa iOS at Android, mobile-ffmpeg para sa React Native.

Dav1d — na-optimize na AV1 decoder

Dav1d — isang software AV1 decoder mula sa VideoLAN (mga gumawa ng VLC), na isinulat sa C na may SIMD optimization. Ang pangunahing gawain nito ay ang pinakamabilis na software decoding ng AV1 sa CPU nang walang hardware support. Ang Dav1d ay 30–50% mas mabilis kaysa sa reference decoder na libaom mula sa Alliance for Open Media dahil sa agresibong optimization: manual cache management, paggamit ng JIT compilation para sa post-processing filters, at vectorization ng critical functions.

Sa mga mobile device, ang dav1d ay maaaring mag-decode ng 1080p AV1 sa real-time sa flagship SoC (Apple A16+, Snapdragon 8 Gen 2+), ngunit para sa 4K ay nangangailangan ng malakas na CPU. Halimbawa, sa Apple M1, ang software dav1d ay umabot ng ~60 FPS para sa 4K AV1, at sa Snapdragon 8 Gen 2 — ~35 FPS. Para sa stable na 4K AV1 playback sa mga mobile device, inirerekomenda pa rin ang hardware support.

Paghahambing ng software at hardware decoding

Ang pagpili sa pagitan ng software at hardware decoding ay isang kompromiso sa pagitan ng compatibility at efficiency. Ang talahanayan sa ibaba ay nagpapakita ng detalyadong paghahambing ng mga pangunahing katangian.

Ang software decoding ay nagbibigay ng maximum flexibility: ang developer ay maaaring magbago ng algorithms, magdagdag ng custom filters, magpatupad ng sariling processing pipelines. Halimbawa, sa mga video editing application, ang bawat yugto ng decoding ay maaaring i-redirect sa GPU para sa color correction o paglalapat ng effects — ito ay posible lamang sa software control sa pag-decode.

Gayunpaman, ang presyo ng flexibility ay ang pagkonsumo ng kuryente. Para sa mga mobile device na may baterya na 3000–5000 mAh, ang tuloy-tuloy na software decoding ay nagbabawas ng oras ng panonood mula 10–15 oras (hardware) hanggang 2–4 oras. Ang pag-init ng CPU hanggang 45–50 degrees ay maaari ring magdulot ng throttling — pagbaba ng frequency ng processor para protektahan ito mula sa sobrang init, na humahantong sa paglaktaw ng frames at pagkasira ng karanasan ng user.

Mga halimbawa ng code ng software decoding

Tingnan natin ang praktikal na implementasyon ng software decoding sa parehong mobile platform. Sa iOS, ang software decoding ay ginagamit sa pamamagitan ng FFmpeg, sa Android — sa pamamagitan ng parehong library na may Java/Kotlin wrapper.

Software decoding gamit ang FFmpeg sa C

extern "C" {
    #include <libavcodec/avcodec.h>
    #include <libavformat/avformat.h>
    #include <libswscale/swscale.h>
}

class SoftwareDecoder {
    AVCodecContext* codecCtx;
    
public:
    bool init(const char* filename) {
        AVFormatContext* fmtCtx = nullptr;
        avformat_open_input(&fmtCtx, filename, nullptr, nullptr);
        avformat_find_stream_info(fmtCtx, nullptr);
        
        int videoStream = av_find_best_stream(
            fmtCtx, AVMEDIA_TYPE_VIDEO, -1, -1, nullptr, 0
        );
        
        AVCodec* decoder = avcodec_find_decoder(
            fmtCtx->streams[videoStream]->codecpar->codec_id
        );
        
        codecCtx = avcodec_alloc_context3(decoder);
        avcodec_parameters_to_context(codecCtx,
            fmtCtx->streams[videoStream]->codecpar);
        avcodec_open2(codecCtx, decoder, nullptr);
        return true;
    }
    
    AVFrame* decodePacket(AVPacket* packet) {
        avcodec_send_packet(codecCtx, packet);
        AVFrame* frame = av_frame_alloc();
        int ret = avcodec_receive_frame(codecCtx, frame);
        return (ret >= 0) ? frame : nullptr;
    }
};

Ang code ay nagpapakita ng minimal na FFmpeg pipeline para sa software decoding. avformat_open_input ay nagbubukas ng file at tinutukoy ang container format, ang avcodec_find_decoder ay awtomatikong nakakahanap ng angkop na decoder para sa anumang codec. Ang decodePacket method ay gumagamit ng bagong API (avcodec_send_packet / avcodec_receive_frame), na sumusuporta sa multi-threaded decoding kapag ang flag na AV_CODEC_FLAG_LOW_DELAY ay naka-enable para sa real-time applications.

Software decoding sa Kotlin gamit ang mobile-ffmpeg

class SoftwareDecoder(private val context: Context) {
    fun decodeVideo(inputPath: String, outputFolder: String) {
        val cmd = "-i $inputPath -vf fps=1 $outputFolder/frame_%04d.jpg"
        FFmpegExecutor(context).executeCommand(cmd) { rc ->
            Log.d("Decoder", "Natapos na may rc: $rc")
        }
    }
    
    fun getFrameCount(filePath: String): Int {
        val probe = MediaMetadataRetriever()
        probe.setDataSource(filePath)
        val duration = probe.extractMetadata(
            MediaMetadataRetriever.METADATA_KEY_DURATION
        )?.toIntOrNull() ?: 0
        val fps = probe.extractMetadata(
            MediaMetadataRetriever.METADATA_KEY_VIDEO_FRAME_COUNT
        )?.toIntOrNull() ?: 0
        probe.release()
        return fps
    }
}

Ang halimbawa sa Kotlin ay gumagamit ng FFmpegExecutor para kumuha ng isang frame bawat segundo mula sa video. Ang parameter na -vf fps=1 ay lumilikha ng filter na lumalaktaw sa 59 sa 60 frames, na nagbabawas ng CPU load. Ang ganitong approach ay kapaki-pakinabang para sa paggawa ng preview at placeholder sa mobile applications. Para sa real-time software decoding, inirerekomenda ang paggamit ng low-level API ng libavcodec nang direkta sa pamamagitan ng JNI.

Software decoding ng AV1 gamit ang dav1d

#include <dav1d/dav1d.h>

int decode_av1_frame(const uint8_t* data, size_t size) {
    Dav1dContext* ctx = nullptr;
    Dav1dSettings settings = { 0 };
    dav1d_default_settings(&settings);
    settings.n_threads = 4;
    dav1d_open(&ctx, &settings);
    
    Dav1dData dav1d_data = { 0 };
    dav1d_data_wrap(&dav1d_data, data, size, nullptr, nullptr);
    
    Dav1dPicture pic = { 0 };
    if (dav1d_send_data(ctx, &dav1d_data) == 0) {
        dav1d_get_picture(ctx, &pic);
    }
    
    dav1d_close(&ctx);
    return pic.p.w;
}

Ang Dav1d ay nagbibigay ng minimalistang API: dav1d_open ay lumilikha ng decoder context na may tinukoy na bilang ng threads, ang dav1d_send_data ay tumatanggap ng compressed bit stream, ang dav1d_get_picture ay nagbabalik ng na-decode na frame sa YUV420 format. Para sa mga mobile device, ang optimal na bilang ng threads (n_threads) ay ang bilang ng productive CPU cores minus isa, upang mag-iwan ng resource para sa UI thread. Sinusuportahan din ng Dav1d ang Dav1dPicAllocator para sa memory management at pag-iwas sa mga hindi kinakailangang pag-kopya kapag naglilipat ng frame sa GPU.

Mga sitwasyon ng paggamit ng software decoding

Sa kabila ng mas mataas na pagkonsumo ng kuryente, ang software decoding ay kailangang-kailangan sa mga sitwasyon kung saan ang hardware decoding ay hindi makapagbigay ng kinakailangang functionality. Ang pag-unawa sa mga sitwasyong ito ay tumutulong sa developer na gumawa ng mga architectural na desisyon.

Mga pambihirang at lumang format

Ang mga hardware decoder ay sumusuporta lamang ng modernong format. Kung ang application ay gumagana sa archival recordings, video surveillance (MJPEG, H.263), professional codec (ProRes, DNxHD, CineForm) o content mula sa third-party sources — ang software decoding sa pamamagitan ng FFmpeg ang tanging opsyon. Ang ProRes ay nade-decode nang software sa lahat ng device maliban sa Apple A13+ chips na may hardware support. Para sa H.263, walang hardware support sa anumang modernong SoC — software decoding lamang.

Custom na post-processing

Ang software decoding ay nagbibigay ng ganap na access sa bawat yugto ng frame processing. Ito ay kritikal para sa mga application na nangangailangan ng paglalapat ng mga filter (blur, noise reduction, sharpening) nang direkta sa na-decode na data bago i-output. Ang FFmpeg filters ay nagpapahintulot sa pagbuo ng mga kumplikadong chain: decoding -> color correction -> scaling -> subtitle overlay -> encoding — lahat sa loob ng isang library nang walang data transfer sa pagitan ng iba't ibang API.

Fallback kapag walang hardware support

Ang inirerekomendang architecture para sa media player ay hybrid: hardware decoding bilang pangunahing, software bilang fallback. Bago mag-play, sinusuri ng application ang availability ng hardware decoder para sa partikular na codec. Kung hindi matagpuan ang decoder — magsisimula ang software decoding sa pamamagitan ng FFmpeg. Ang ganitong strategy ay nagsisiguro ng maximum compatibility nang walang pagkawala ng performance para sa mga pangunahing format. Ang pagsusuri ng availability ay dapat gawin sa bawat pagtakbo, dahil ang hardware support ay maaaring mag-iba kahit sa mga device ng parehong modelo dahil sa iba't ibang revision ng SoC.