WebM VP8 Codec SDK: simple_decoder.c

WebM VP8 Codec SDK

- Main Page
- Related Pages
- Modules
- Data Structures
- Files

simple_decoder.c

# Simple Decoder

This is an example of a simple decoder loop. It takes an input file containing the compressed data (in IVF format), passes it through the decoder, and writes the decompressed frames to disk. Other decoder examples build upon this one.

The details of the IVF format have been elided from this example for simplicity of presentation, as IVF files will not generally be used by your application. In general, an IVF file consists of a file header, followed by a variable number of frames. Each frame consists of a frame header followed by a variable length payload. The length of the payload is specified in the first four bytes of the frame header. The payload is the raw compressed data.

## Standard Includes

For decoders, you only have to include `vpx_decoder.h` and then any header files for the specific codecs you use. In this case, we’re using vp8. The `VPX_CODEC_DISABLE_COMPAT` macro can be defined to ensure strict compliance with the latest SDK by disabling some backwards compatibility features. Defining this macro is encouraged.

    #define VPX_CODEC_DISABLE_COMPAT 1
    #include "vpx/vpx_decoder.h"
    #include "vpx/vp9dx.h"
    #define interface (vpx_codec_vp8_dx())

## Initializing The Codec

The decoder is initialized by the following code. This is an example for the VP8 decoder, but the code is analogous for all algorithms. Replace `vpx_codec_vp8_dx()` with a pointer to the interface exposed by the algorithm you want to use. The `cfg` argument is left as NULL in this example, because we want the algorithm to determine the stream configuration (width/height) and allocate memory automatically. This parameter is generally only used if you need to preallocate memory, particularly in External Memory Allocation mode.

    /* Initialize codec */
    if(vpx_codec_dec_init(&codec, interface, NULL, flags))
        die_codec(&codec, "Failed to initialize decoder");

## Decoding A Frame

Once the frame has been read into memory, it is decoded using the `vpx_codec_decode` function. The call takes a pointer to the data (`frame`) and the length of the data (`frame_sz`). No application data is associated with the frame in this example, so the `user_priv` parameter is NULL. The `deadline` parameter is left at zero for this example. This parameter is generally only used when doing adaptive postprocessing.

    /* Decode the frame */
    if(vpx_codec_decode(&codec, frame, frame_sz, NULL, 0))
        die_codec(&codec, "Failed to decode frame");

Codecs may produce a variable number of output frames for every call to `vpx_codec_decode`. These frames are retrieved by the `vpx_codec_get_frame` iterator function. The iterator variable `iter` is initialized to NULL each time `vpx_codec_decode` is called. `vpx_codec_get_frame` is called in a loop, returning a pointer to a decoded image or NULL to indicate the end of list.

    while((img = vpx_codec_get_frame(&codec, &iter))) {

## Processing The Decoded Data

In this example, we simply write the encoded data to disk. It is important to honor the image’s `stride` values.

    for(plane=0; plane < 3; plane++) {
        unsigned char *buf =img->planes[plane];

        for(y=0; y < (plane ? (img->d_h + 1) >> 1 : img->d_h); y++) {
            (void) fwrite(buf, 1, (plane ? (img->d_w + 1) >> 1 : img->d_w),
                          outfile);
            buf += img->stride[plane];
        }
    }

## Cleanup

The `vpx_codec_destroy` call frees any memory allocated by the codec.

    if(vpx_codec_destroy(&codec))
        die_codec(&codec, "Failed to destroy codec");

## Error Handling

This example does not special case any error return codes. If there was an error, a descriptive message is printed and the program exits. With few exeptions, vpx_codec functions return an enumerated error status, with the value `0` indicating success.

    static void die_codec(vpx_codec_ctx_t *ctx, const char *s) {
        const char *detail = vpx_codec_error_detail(ctx);

        printf("%s: %s\n", s, vpx_codec_error(ctx));
        if(detail)
            printf("    %s\n",detail);
        exit(EXIT_FAILURE);
    }

# Putting It All Together

    /*
        Copyright (c) 2010 The WebM project authors. All Rights Reserved.

        Use of this source code is governed by a BSD-style license
        that can be found in the LICENSE file in the root of the source
        tree. An additional intellectual property rights grant can be found
        in the file PATENTS.  All contributing project authors may
        be found in the AUTHORS file in the root of the source tree.
     */

    /*
       This is an example of a simple decoder loop. It takes an input file
       containing the compressed data (in IVF format), passes it through the
       decoder, and writes the decompressed frames to disk. Other decoder
       examples build upon this one.

       The details of the IVF format have been elided from this example for
       simplicity of presentation, as IVF files will not generally be used by
       your application. In general, an IVF file consists of a file header,
       followed by a variable number of frames. Each frame consists of a frame
       header followed by a variable length payload. The length of the payload
       is specified in the first four bytes of the frame header. The payload is
       the raw compressed data.
     */
    #include <stdarg.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #define VPX_CODEC_DISABLE_COMPAT 1
    #include "./vpx_config.h"
    #include "vpx/vp8dx.h"
    #include "vpx/vpx_decoder.h"
    #define interface (vpx_codec_vp8_dx())

    #define IVF_FILE_HDR_SZ  (32)
    #define IVF_FRAME_HDR_SZ (12)

    static unsigned int mem_get_le32(const unsigned char *mem) {
        return (mem[3] << 24)|(mem[2] << 16)|(mem[1] << 8)|(mem[0]);
    }

    static void die(const char *fmt, ...) {
        va_list ap;

        va_start(ap, fmt);
        vprintf(fmt, ap);
        if(fmt[strlen(fmt)-1] != '\n')
            printf("\n");
        exit(EXIT_FAILURE);
    }

    static void die_codec(vpx_codec_ctx_t *ctx, const char *s) {                  //
        const char *detail = vpx_codec_error_detail(ctx);                         //
                                                                                  //
        printf("%s: %s\n", s, vpx_codec_error(ctx));                              //
        if(detail)                                                                //
            printf("    %s\n",detail);                                            //
        exit(EXIT_FAILURE);                                                       //
    }                                                                             //

    int main(int argc, char **argv) {
        FILE            *infile, *outfile;
        vpx_codec_ctx_t  codec;
        int              flags = 0, frame_cnt = 0;
        unsigned char    file_hdr[IVF_FILE_HDR_SZ];
        unsigned char    frame_hdr[IVF_FRAME_HDR_SZ];
        unsigned char    frame[256*1024];
        vpx_codec_err_t  res;

        (void)res;
        /* Open files */
        if(argc!=3)
            die("Usage: %s <infile> <outfile>\n", argv[0]);
        if(!(infile = fopen(argv[1], "rb")))
            die("Failed to open %s for reading", argv[1]);
        if(!(outfile = fopen(argv[2], "wb")))
            die("Failed to open %s for writing", argv[2]);

        /* Read file header */
        if(!(fread(file_hdr, 1, IVF_FILE_HDR_SZ, infile) == IVF_FILE_HDR_SZ
             && file_hdr[0]=='D' && file_hdr[1]=='K' && file_hdr[2]=='I'
             && file_hdr[3]=='F'))
            die("%s is not an IVF file.", argv[1]);

        printf("Using %s\n",vpx_codec_iface_name(interface));
        /* Initialize codec */                                                    //
        if(vpx_codec_dec_init(&codec, interface, NULL, flags))                    //
            die_codec(&codec, "Failed to initialize decoder");                    //

        /* Read each frame */
        while(fread(frame_hdr, 1, IVF_FRAME_HDR_SZ, infile) == IVF_FRAME_HDR_SZ) {
            int               frame_sz = mem_get_le32(frame_hdr);
            vpx_codec_iter_t  iter = NULL;
            vpx_image_t      *img;

            frame_cnt++;
            if(frame_sz > sizeof(frame))
                die("Frame %d data too big for example code buffer", frame_sz);
            if(fread(frame, 1, frame_sz, infile) != frame_sz)
                die("Frame %d failed to read complete frame", frame_cnt);

            /* Decode the frame */                                                //
            if(vpx_codec_decode(&codec, frame, frame_sz, NULL, 0))                //
                die_codec(&codec, "Failed to decode frame");                      //

            /* Write decoded data to disk */
            while((img = vpx_codec_get_frame(&codec, &iter))) {                   //
                unsigned int plane, y;

                for(plane=0; plane < 3; plane++) {                                //
                    unsigned char *buf =img->planes[plane];                       //
                                                                                  //
                    for(y=0; y < (plane ? (img->d_h + 1) >> 1 : img->d_h); y++) { //
                        (void) fwrite(buf, 1, (plane ? (img->d_w + 1) >> 1 : img->d_w),//
                                      outfile);                                   //
                        buf += img->stride[plane];                                //
                    }                                                             //
                }                                                                 //
            }
        }
        printf("Processed %d frames.\n",frame_cnt);
        if(vpx_codec_destroy(&codec))                                             //
            die_codec(&codec, "Failed to destroy codec");                         //

        fclose(outfile);
        fclose(infile);
        return EXIT_SUCCESS;
    }