aom_encoder.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_ENCODER_H_
#define AOM_AOM_AOM_ENCODER_H_

#ifdef __cplusplus
extern "C" {
#endif

#include "aom/aom_codec.h"

#define AOM_ENCODER_ABI_VERSION \
  (7 + AOM_CODEC_ABI_VERSION) 
#define AOM_CODEC_CAP_PSNR 0x10000 
#define AOM_CODEC_CAP_HIGHBITDEPTH 0x40000

#define AOM_CODEC_USE_PSNR 0x10000 
#define AOM_CODEC_USE_HIGHBITDEPTH 0x40000 
typedef struct aom_fixed_buf {
  void *buf;       
  size_t sz;       
} aom_fixed_buf_t; 
typedef uint32_t aom_codec_frame_flags_t;
#define AOM_FRAME_IS_KEY 0x1 
#define AOM_FRAME_IS_DROPPABLE 0x2

#define AOM_FRAME_IS_INTRAONLY 0x10

#define AOM_FRAME_IS_SWITCH 0x20

#define AOM_FRAME_IS_ERROR_RESILIENT 0x40

#define AOM_FRAME_IS_DELAYED_RANDOM_ACCESS_POINT 0x80

typedef uint32_t aom_codec_er_flags_t;
#define AOM_ERROR_RESILIENT_DEFAULT 0x1

enum aom_codec_cx_pkt_kind {
  AOM_CODEC_CX_FRAME_PKT,    
  AOM_CODEC_STATS_PKT,       
  AOM_CODEC_FPMB_STATS_PKT,  
  AOM_CODEC_PSNR_PKT,        
  AOM_CODEC_CUSTOM_PKT = 256 
};

typedef struct aom_codec_cx_pkt {
  enum aom_codec_cx_pkt_kind kind; 
  union {
    struct {
      void *buf; 
      size_t sz; 
      aom_codec_pts_t pts;
      unsigned long duration;
      aom_codec_frame_flags_t flags; 
      int partition_id;
      size_t vis_frame_size;
    } frame;                            
    aom_fixed_buf_t twopass_stats;      
    aom_fixed_buf_t firstpass_mb_stats; 
    struct aom_psnr_pkt {
      unsigned int samples[4]; 
      uint64_t sse[4];         
      double psnr[4];          
    } psnr;                    
    aom_fixed_buf_t raw;       
    /* This packet size is fixed to allow codecs to extend this
     * interface without having to manage storage for raw packets,
     * i.e., if it's smaller than 128 bytes, you can store in the
     * packet list directly.
     */
    char pad[128 - sizeof(enum aom_codec_cx_pkt_kind)]; 
  } data;                                               
} aom_codec_cx_pkt_t; 
typedef struct aom_rational {
  int num;        
  int den;        
} aom_rational_t; 
enum aom_enc_pass {
  AOM_RC_ONE_PASS,   
  AOM_RC_FIRST_PASS, 
  AOM_RC_LAST_PASS   
};

enum aom_rc_mode {
  AOM_VBR, 
  AOM_CBR, 
  AOM_CQ,  
  AOM_Q,   
};

enum aom_kf_mode {
  AOM_KF_FIXED,       
  AOM_KF_AUTO,        
  AOM_KF_DISABLED = 0 
};

typedef enum {
  AOM_SUPERRES_NONE,
  AOM_SUPERRES_FIXED,
  AOM_SUPERRES_RANDOM,
  AOM_SUPERRES_QTHRESH,
  AOM_SUPERRES_AUTO,
} aom_superres_mode;

typedef struct cfg_options {
  unsigned int init_by_cfg_file;
  unsigned int super_block_size;
  unsigned int max_partition_size;
  unsigned int min_partition_size;
  unsigned int disable_ab_partition_type;
  unsigned int disable_rect_partition_type;
  unsigned int disable_1to4_partition_type;
  unsigned int disable_flip_idtx;
  unsigned int disable_cdef;
  unsigned int disable_lr;
  unsigned int disable_obmc;
  unsigned int disable_warp_motion;
  unsigned int disable_global_motion;
  unsigned int disable_dist_wtd_comp;
  unsigned int disable_diff_wtd_comp;
  unsigned int disable_inter_intra_comp;
  unsigned int disable_masked_comp;
  unsigned int disable_one_sided_comp;
  unsigned int disable_palette;
  unsigned int disable_intrabc;
  unsigned int disable_cfl;
  unsigned int disable_smooth_intra;
  unsigned int disable_filter_intra;
  unsigned int disable_dual_filter;
  unsigned int disable_intra_angle_delta;
  unsigned int disable_intra_edge_filter;
  unsigned int disable_tx_64x64;
  unsigned int disable_smooth_inter_intra;
  unsigned int disable_inter_inter_wedge;
  unsigned int disable_inter_intra_wedge;
  unsigned int disable_paeth_intra;
  unsigned int disable_trellis_quant;
  unsigned int disable_ref_frame_mv;
  unsigned int reduced_reference_set;
  unsigned int reduced_tx_type_set;
} cfg_options_t;

typedef long aom_enc_frame_flags_t;
#define AOM_EFLAG_FORCE_KF (1 << 0) 
typedef struct aom_codec_enc_cfg {
  /*
   * generic settings (g)
   */

  unsigned int g_usage;

  unsigned int g_threads;

  unsigned int g_profile; 
  unsigned int g_w;

  unsigned int g_h;

  unsigned int g_limit;

  unsigned int g_forced_max_frame_width;

  unsigned int g_forced_max_frame_height;

  aom_bit_depth_t g_bit_depth;

  unsigned int g_input_bit_depth;

  struct aom_rational g_timebase;

  aom_codec_er_flags_t g_error_resilient;

  enum aom_enc_pass g_pass;

  unsigned int g_lag_in_frames;

  /*
   * rate control settings (rc)
   */

  unsigned int rc_dropframe_thresh;

  unsigned int rc_resize_mode;

  unsigned int rc_resize_denominator;

  unsigned int rc_resize_kf_denominator;

  aom_superres_mode rc_superres_mode;

  unsigned int rc_superres_denominator;

  unsigned int rc_superres_kf_denominator;

  unsigned int rc_superres_qthresh;

  unsigned int rc_superres_kf_qthresh;

  enum aom_rc_mode rc_end_usage;

  aom_fixed_buf_t rc_twopass_stats_in;

  aom_fixed_buf_t rc_firstpass_mb_stats_in;

  unsigned int rc_target_bitrate;

  /*
   * quantizer settings
   */

  unsigned int rc_min_quantizer;

  unsigned int rc_max_quantizer;

  /*
   * bitrate tolerance
   */

  unsigned int rc_undershoot_pct;

  unsigned int rc_overshoot_pct;

  /*
   * decoder buffer model parameters
   */

  unsigned int rc_buf_sz;

  unsigned int rc_buf_initial_sz;

  unsigned int rc_buf_optimal_sz;

  /*
   * 2 pass rate control parameters
   */

  unsigned int rc_2pass_vbr_bias_pct;

  unsigned int rc_2pass_vbr_minsection_pct;

  unsigned int rc_2pass_vbr_maxsection_pct;

  /*
   * keyframing settings (kf)
   */

  int fwd_kf_enabled;

  enum aom_kf_mode kf_mode;

  unsigned int kf_min_dist;

  unsigned int kf_max_dist;

  unsigned int sframe_dist;

  unsigned int sframe_mode;

  unsigned int large_scale_tile;

  unsigned int monochrome;

  unsigned int full_still_picture_hdr;

  unsigned int save_as_annexb;

  int tile_width_count;

  int tile_height_count;

#define MAX_TILE_WIDTHS 64  // maximum tile width array length

  int tile_widths[MAX_TILE_WIDTHS];

#define MAX_TILE_HEIGHTS 64  // maximum tile height array length

  int tile_heights[MAX_TILE_HEIGHTS];

  unsigned int use_fixed_qp_offsets;

#define FIXED_QP_OFFSET_COUNT 5

  int fixed_qp_offsets[FIXED_QP_OFFSET_COUNT];

  cfg_options_t encoder_cfg;
} aom_codec_enc_cfg_t; 
aom_codec_err_t aom_codec_enc_init_ver(aom_codec_ctx_t *ctx,
                                       aom_codec_iface_t *iface,
                                       const aom_codec_enc_cfg_t *cfg,
                                       aom_codec_flags_t flags, int ver);

#define aom_codec_enc_init(ctx, iface, cfg, flags) \
  aom_codec_enc_init_ver(ctx, iface, cfg, flags, AOM_ENCODER_ABI_VERSION)

aom_codec_err_t aom_codec_enc_init_multi_ver(
    aom_codec_ctx_t *ctx, aom_codec_iface_t *iface, aom_codec_enc_cfg_t *cfg,
    int num_enc, aom_codec_flags_t flags, aom_rational_t *dsf, int ver);

#define aom_codec_enc_init_multi(ctx, iface, cfg, num_enc, flags, dsf) \
  aom_codec_enc_init_multi_ver(ctx, iface, cfg, num_enc, flags, dsf,   \
                               AOM_ENCODER_ABI_VERSION)

aom_codec_err_t aom_codec_enc_config_default(aom_codec_iface_t *iface,
                                             aom_codec_enc_cfg_t *cfg,
                                             unsigned int usage);

aom_codec_err_t aom_codec_enc_config_set(aom_codec_ctx_t *ctx,
                                         const aom_codec_enc_cfg_t *cfg);

aom_fixed_buf_t *aom_codec_get_global_headers(aom_codec_ctx_t *ctx);

#define AOM_USAGE_GOOD_QUALITY (0)

#define AOM_USAGE_REALTIME (1)

aom_codec_err_t aom_codec_encode(aom_codec_ctx_t *ctx, const aom_image_t *img,
                                 aom_codec_pts_t pts, unsigned long duration,
                                 aom_enc_frame_flags_t flags);

aom_codec_err_t aom_codec_set_cx_data_buf(aom_codec_ctx_t *ctx,
                                          const aom_fixed_buf_t *buf,
                                          unsigned int pad_before,
                                          unsigned int pad_after);

const aom_codec_cx_pkt_t *aom_codec_get_cx_data(aom_codec_ctx_t *ctx,
                                                aom_codec_iter_t *iter);

const aom_image_t *aom_codec_get_preview_frame(aom_codec_ctx_t *ctx);

#ifdef __cplusplus
}
#endif
#endif  // AOM_AOM_AOM_ENCODER_H_