aom_codec.h

Go to the documentation of this file.

/*
 * Copyright (c) 2016, Alliance for Open Media. All rights reserved
 *
 * This source code is subject to the terms of the BSD 2 Clause License and
 * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
 * was not distributed with this source code in the LICENSE file, you can
 * obtain it at www.aomedia.org/license/software. If the Alliance for Open
 * Media Patent License 1.0 was not distributed with this source code in the
 * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
 */

#ifndef AOM_AOM_AOM_CODEC_H_
#define AOM_AOM_AOM_CODEC_H_

#ifdef __cplusplus
extern "C" {
#endif

#include "aom/aom_image.h"
#include "aom/aom_integer.h"

#ifndef AOM_DEPRECATED
#if defined(__GNUC__) && __GNUC__
#define AOM_DEPRECATED __attribute__((deprecated))
#elif defined(_MSC_VER)
#define AOM_DEPRECATED
#else
#define AOM_DEPRECATED
#endif
#endif /* AOM_DEPRECATED */

#ifndef AOM_DECLSPEC_DEPRECATED
#if defined(__GNUC__) && __GNUC__
#define AOM_DECLSPEC_DEPRECATED 
#elif defined(_MSC_VER)

#define AOM_DECLSPEC_DEPRECATED __declspec(deprecated)
#else
#define AOM_DECLSPEC_DEPRECATED 
#endif
#endif /* AOM_DECLSPEC_DEPRECATED */

#ifdef AOM_UNUSED
#elif defined(__GNUC__) || defined(__clang__)
#define AOM_UNUSED __attribute__((unused))
#else
#define AOM_UNUSED
#endif

#ifndef ATTRIBUTE_PACKED
#if defined(__GNUC__) && __GNUC__
#define ATTRIBUTE_PACKED __attribute__((packed))
#elif defined(_MSC_VER)
#define ATTRIBUTE_PACKED
#else
#define ATTRIBUTE_PACKED
#endif
#endif /* ATTRIBUTE_PACKED */

#define AOM_CODEC_ABI_VERSION (3 + AOM_IMAGE_ABI_VERSION) 
typedef enum {

  AOM_CODEC_OK,

  AOM_CODEC_ERROR,

  AOM_CODEC_MEM_ERROR,

  AOM_CODEC_ABI_MISMATCH,

  AOM_CODEC_INCAPABLE,

  AOM_CODEC_UNSUP_BITSTREAM,

  AOM_CODEC_UNSUP_FEATURE,

  AOM_CODEC_CORRUPT_FRAME,

  AOM_CODEC_INVALID_PARAM,

  AOM_CODEC_LIST_END

} aom_codec_err_t;

typedef long aom_codec_caps_t;
#define AOM_CODEC_CAP_DECODER 0x1 
#define AOM_CODEC_CAP_ENCODER 0x2 
typedef long aom_codec_flags_t;

typedef int64_t aom_codec_pts_t;

typedef const struct aom_codec_iface aom_codec_iface_t;

typedef struct aom_codec_priv aom_codec_priv_t;

typedef const void *aom_codec_iter_t;

typedef struct aom_codec_ctx {
  const char *name;             
  aom_codec_iface_t *iface;     
  aom_codec_err_t err;          
  const char *err_detail;       
  aom_codec_flags_t init_flags; 
  union {
    const struct aom_codec_dec_cfg *dec;
    const struct aom_codec_enc_cfg *enc;
    const void *raw;
  } config;               
  aom_codec_priv_t *priv; 
} aom_codec_ctx_t;

typedef enum aom_bit_depth {
  AOM_BITS_8 = 8,   
  AOM_BITS_10 = 10, 
  AOM_BITS_12 = 12, 
} aom_bit_depth_t;

typedef enum aom_superblock_size {
  AOM_SUPERBLOCK_SIZE_64X64,   
  AOM_SUPERBLOCK_SIZE_128X128, 
  AOM_SUPERBLOCK_SIZE_DYNAMIC  
} aom_superblock_size_t;

/*
 * Library Version Number Interface
 *
 * For example, see the following sample return values:
 *     aom_codec_version()           (1<<16 | 2<<8 | 3)
 *     aom_codec_version_str()       "v1.2.3-rc1-16-gec6a1ba"
 *     aom_codec_version_extra_str() "rc1-16-gec6a1ba"
 */

int aom_codec_version(void);

#define aom_codec_version_major() ((aom_codec_version() >> 16) & 0xff)

#define aom_codec_version_minor() ((aom_codec_version() >> 8) & 0xff)

#define aom_codec_version_patch() ((aom_codec_version() >> 0) & 0xff)

const char *aom_codec_version_str(void);

const char *aom_codec_version_extra_str(void);

const char *aom_codec_build_config(void);

const char *aom_codec_iface_name(aom_codec_iface_t *iface);

const char *aom_codec_err_to_string(aom_codec_err_t err);

const char *aom_codec_error(aom_codec_ctx_t *ctx);

const char *aom_codec_error_detail(aom_codec_ctx_t *ctx);

/* REQUIRED FUNCTIONS
 *
 * The following functions are required to be implemented for all codecs.
 * They represent the base case functionality expected of all codecs.
 */

aom_codec_err_t aom_codec_destroy(aom_codec_ctx_t *ctx);

aom_codec_caps_t aom_codec_get_caps(aom_codec_iface_t *iface);

aom_codec_err_t aom_codec_control_(aom_codec_ctx_t *ctx, int ctrl_id, ...);
#if defined(AOM_DISABLE_CTRL_TYPECHECKS) && AOM_DISABLE_CTRL_TYPECHECKS
#define aom_codec_control(ctx, id, data) aom_codec_control_(ctx, id, data)
#define AOM_CTRL_USE_TYPE(id, typ)
#define AOM_CTRL_USE_TYPE_DEPRECATED(id, typ)
#define AOM_CTRL_VOID(id, typ)

#else

#define aom_codec_control(ctx, id, data) \
  aom_codec_control_##id(ctx, id, data) 
#define AOM_CTRL_USE_TYPE(id, typ)                                           \
  static aom_codec_err_t aom_codec_control_##id(aom_codec_ctx_t *, int, typ) \
      AOM_UNUSED;                                                            \
                                                                             \
  static aom_codec_err_t aom_codec_control_##id(aom_codec_ctx_t *ctx,        \
                                                int ctrl_id, typ data) {     \
    return aom_codec_control_(ctx, ctrl_id, data);                           \
  } 
#define AOM_CTRL_USE_TYPE_DEPRECATED(id, typ)                            \
  AOM_DECLSPEC_DEPRECATED static aom_codec_err_t aom_codec_control_##id( \
      aom_codec_ctx_t *, int, typ) AOM_DEPRECATED AOM_UNUSED;            \
                                                                         \
  AOM_DECLSPEC_DEPRECATED static aom_codec_err_t aom_codec_control_##id( \
      aom_codec_ctx_t *ctx, int ctrl_id, typ data) {                     \
    return aom_codec_control_(ctx, ctrl_id, data);                       \
  } 
#define AOM_CTRL_VOID(id)                                               \
  static aom_codec_err_t aom_codec_control_##id(aom_codec_ctx_t *, int) \
      AOM_UNUSED;                                                       \
                                                                        \
  static aom_codec_err_t aom_codec_control_##id(aom_codec_ctx_t *ctx,   \
                                                int ctrl_id) {          \
    return aom_codec_control_(ctx, ctrl_id);                            \
  } 
#endif

typedef enum ATTRIBUTE_PACKED {
  OBU_SEQUENCE_HEADER = 1,
  OBU_TEMPORAL_DELIMITER = 2,
  OBU_FRAME_HEADER = 3,
  OBU_TILE_GROUP = 4,
  OBU_METADATA = 5,
  OBU_FRAME = 6,
  OBU_REDUNDANT_FRAME_HEADER = 7,
  OBU_TILE_LIST = 8,
  OBU_PADDING = 15,
} OBU_TYPE;

typedef enum {
  OBU_METADATA_TYPE_AOM_RESERVED_0 = 0,
  OBU_METADATA_TYPE_HDR_CLL = 1,
  OBU_METADATA_TYPE_HDR_MDCV = 2,
  OBU_METADATA_TYPE_SCALABILITY = 3,
  OBU_METADATA_TYPE_ITUT_T35 = 4,
  OBU_METADATA_TYPE_TIMECODE = 5,
} OBU_METADATA_TYPE;

const char *aom_obu_type_to_string(OBU_TYPE type);

#ifdef __cplusplus
}
#endif
#endif  // AOM_AOM_AOM_CODEC_H_