vpx/: apply clang-format

Change-Id: I95922a64568bf289863c1564212b6be5beec36df

16 files changed, 2119 insertions, 2362 deletions

diff --git a/vpx/internal/vpx_codec_internal.h b/vpx/internal/vpx_codec_internal.h
index 7380fcc7e..522e5c168 100644
--- a/vpx/internal/vpx_codec_internal.h
+++ b/vpx/internal/vpx_codec_internal.h
@@ -8,7 +8,6 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
-
 /*!\file
  * \brief Describes the decoder algorithm interface for algorithm
  *        implementations.
@@ -61,7 +60,7 @@ extern "C" {
  */
 #define VPX_CODEC_INTERNAL_ABI_VERSION (5) /**<\hideinitializer*/
 
-typedef struct vpx_codec_alg_priv  vpx_codec_alg_priv_t;
+typedef struct vpx_codec_alg_priv vpx_codec_alg_priv_t;
 typedef struct vpx_codec_priv_enc_mr_cfg vpx_codec_priv_enc_mr_cfg_t;
 
 /*!\brief init function pointer prototype
@@ -77,8 +76,8 @@ typedef struct vpx_codec_priv_enc_mr_cfg vpx_codec_priv_enc_mr_cfg_t;
  * \retval #VPX_CODEC_MEM_ERROR
  *     Memory operation failed.
  */
-typedef vpx_codec_err_t (*vpx_codec_init_fn_t)(vpx_codec_ctx_t *ctx,
-                                               vpx_codec_priv_enc_mr_cfg_t *data);
+typedef vpx_codec_err_t (*vpx_codec_init_fn_t)(
+    vpx_codec_ctx_t *ctx, vpx_codec_priv_enc_mr_cfg_t *data);
 
 /*!\brief destroy function pointer prototype
  *
@@ -112,8 +111,8 @@ typedef vpx_codec_err_t (*vpx_codec_destroy_fn_t)(vpx_codec_alg_priv_t *ctx);
  * \retval #VPX_CODEC_OK
  *     Bitstream is parsable and stream information updated
  */
-typedef vpx_codec_err_t (*vpx_codec_peek_si_fn_t)(const uint8_t         *data,
-                                                  unsigned int           data_sz,
+typedef vpx_codec_err_t (*vpx_codec_peek_si_fn_t)(const uint8_t *data,
+                                                  unsigned int data_sz,
                                                   vpx_codec_stream_info_t *si);
 
 /*!\brief Return information about the current stream.
@@ -129,7 +128,7 @@ typedef vpx_codec_err_t (*vpx_codec_peek_si_fn_t)(const uint8_t         *data,
  * \retval #VPX_CODEC_OK
  *     Bitstream is parsable and stream information updated
  */
-typedef vpx_codec_err_t (*vpx_codec_get_si_fn_t)(vpx_codec_alg_priv_t    *ctx,
+typedef vpx_codec_err_t (*vpx_codec_get_si_fn_t)(vpx_codec_alg_priv_t *ctx,
                                                  vpx_codec_stream_info_t *si);
 
 /*!\brief control function pointer prototype
@@ -193,11 +192,11 @@ typedef const struct vpx_codec_ctrl_fn_map {
  *         see the descriptions of the other error codes in ::vpx_codec_err_t
  *         for recoverability capabilities.
  */
-typedef vpx_codec_err_t (*vpx_codec_decode_fn_t)(vpx_codec_alg_priv_t  *ctx,
-                                                 const uint8_t         *data,
-                                                 unsigned int     data_sz,
-                                                 void        *user_priv,
-                                                 long         deadline);
+typedef vpx_codec_err_t (*vpx_codec_decode_fn_t)(vpx_codec_alg_priv_t *ctx,
+                                                 const uint8_t *data,
+                                                 unsigned int data_sz,
+                                                 void *user_priv,
+                                                 long deadline);
 
 /*!\brief Decoded frames iterator
  *
@@ -206,7 +205,8 @@ typedef vpx_codec_err_t (*vpx_codec_decode_fn_t)(vpx_codec_alg_priv_t  *ctx,
  * complete when this function returns NULL.
  *
  * The list of available frames becomes valid upon completion of the
- * vpx_codec_decode call, and remains valid until the next call to vpx_codec_decode.
+ * vpx_codec_decode call, and remains valid until the next call to
+ * vpx_codec_decode.
  *
  * \param[in]     ctx      Pointer to this instance's context
  * \param[in out] iter     Iterator storage, initialized to NULL
@@ -215,7 +215,7 @@ typedef vpx_codec_err_t (*vpx_codec_decode_fn_t)(vpx_codec_alg_priv_t  *ctx,
  *         produced will always be in PTS (presentation time stamp) order.
  */
 typedef vpx_image_t *(*vpx_codec_get_frame_fn_t)(vpx_codec_alg_priv_t *ctx,
-                                                 vpx_codec_iter_t     *iter);
+                                                 vpx_codec_iter_t *iter);
 
 /*!\brief Pass in external frame buffers for the decoder to use.
  *
@@ -244,32 +244,28 @@ typedef vpx_image_t *(*vpx_codec_get_frame_fn_t)(vpx_codec_alg_priv_t *ctx,
  * buffers.
  */
 typedef vpx_codec_err_t (*vpx_codec_set_fb_fn_t)(
-    vpx_codec_alg_priv_t *ctx,
-    vpx_get_frame_buffer_cb_fn_t cb_get,
+    vpx_codec_alg_priv_t *ctx, vpx_get_frame_buffer_cb_fn_t cb_get,
     vpx_release_frame_buffer_cb_fn_t cb_release, void *cb_priv);
 
+typedef vpx_codec_err_t (*vpx_codec_encode_fn_t)(vpx_codec_alg_priv_t *ctx,
+                                                 const vpx_image_t *img,
+                                                 vpx_codec_pts_t pts,
+                                                 unsigned long duration,
+                                                 vpx_enc_frame_flags_t flags,
+                                                 unsigned long deadline);
+typedef const vpx_codec_cx_pkt_t *(*vpx_codec_get_cx_data_fn_t)(
+    vpx_codec_alg_priv_t *ctx, vpx_codec_iter_t *iter);
 
-typedef vpx_codec_err_t (*vpx_codec_encode_fn_t)(vpx_codec_alg_priv_t  *ctx,
-                                                 const vpx_image_t     *img,
-                                                 vpx_codec_pts_t        pts,
-                                                 unsigned long          duration,
-                                                 vpx_enc_frame_flags_t  flags,
-                                                 unsigned long          deadline);
-typedef const vpx_codec_cx_pkt_t *(*vpx_codec_get_cx_data_fn_t)(vpx_codec_alg_priv_t *ctx,
-                                                                vpx_codec_iter_t     *iter);
-
-typedef vpx_codec_err_t
-(*vpx_codec_enc_config_set_fn_t)(vpx_codec_alg_priv_t       *ctx,
-                                 const vpx_codec_enc_cfg_t  *cfg);
-typedef vpx_fixed_buf_t *
-(*vpx_codec_get_global_headers_fn_t)(vpx_codec_alg_priv_t   *ctx);
+typedef vpx_codec_err_t (*vpx_codec_enc_config_set_fn_t)(
+    vpx_codec_alg_priv_t *ctx, const vpx_codec_enc_cfg_t *cfg);
+typedef vpx_fixed_buf_t *(*vpx_codec_get_global_headers_fn_t)(
+    vpx_codec_alg_priv_t *ctx);
 
-typedef vpx_image_t *
-(*vpx_codec_get_preview_frame_fn_t)(vpx_codec_alg_priv_t   *ctx);
+typedef vpx_image_t *(*vpx_codec_get_preview_frame_fn_t)(
+    vpx_codec_alg_priv_t *ctx);
 
-typedef vpx_codec_err_t
-(*vpx_codec_enc_mr_get_mem_loc_fn_t)(const vpx_codec_enc_cfg_t     *cfg,
-                                     void **mem_loc);
+typedef vpx_codec_err_t (*vpx_codec_enc_mr_get_mem_loc_fn_t)(
+    const vpx_codec_enc_cfg_t *cfg, void **mem_loc);
 
 /*!\brief usage configuration mapping
  *
@@ -282,7 +278,7 @@ typedef vpx_codec_err_t
  *
  */
 typedef const struct vpx_codec_enc_cfg_map {
-  int                 usage;
+  int usage;
   vpx_codec_enc_cfg_t cfg;
 } vpx_codec_enc_cfg_map_t;
 
@@ -291,41 +287,47 @@ typedef const struct vpx_codec_enc_cfg_map {
  * All decoders \ref MUST expose a variable of this type.
  */
 struct vpx_codec_iface {
-  const char               *name;        /**< Identification String  */
-  int                       abi_version; /**< Implemented ABI version */
-  vpx_codec_caps_t          caps;    /**< Decoder capabilities */
-  vpx_codec_init_fn_t       init;    /**< \copydoc ::vpx_codec_init_fn_t */
-  vpx_codec_destroy_fn_t    destroy;     /**< \copydoc ::vpx_codec_destroy_fn_t */
-  vpx_codec_ctrl_fn_map_t  *ctrl_maps;   /**< \copydoc ::vpx_codec_ctrl_fn_map_t */
+  const char *name;                   /**< Identification String  */
+  int abi_version;                    /**< Implemented ABI version */
+  vpx_codec_caps_t caps;              /**< Decoder capabilities */
+  vpx_codec_init_fn_t init;           /**< \copydoc ::vpx_codec_init_fn_t */
+  vpx_codec_destroy_fn_t destroy;     /**< \copydoc ::vpx_codec_destroy_fn_t */
+  vpx_codec_ctrl_fn_map_t *ctrl_maps; /**< \copydoc ::vpx_codec_ctrl_fn_map_t */
   struct vpx_codec_dec_iface {
-    vpx_codec_peek_si_fn_t    peek_si;     /**< \copydoc ::vpx_codec_peek_si_fn_t */
-    vpx_codec_get_si_fn_t     get_si;      /**< \copydoc ::vpx_codec_get_si_fn_t */
-    vpx_codec_decode_fn_t     decode;      /**< \copydoc ::vpx_codec_decode_fn_t */
-    vpx_codec_get_frame_fn_t  get_frame;   /**< \copydoc ::vpx_codec_get_frame_fn_t */
-    vpx_codec_set_fb_fn_t     set_fb_fn;   /**< \copydoc ::vpx_codec_set_fb_fn_t */
+    vpx_codec_peek_si_fn_t peek_si; /**< \copydoc ::vpx_codec_peek_si_fn_t */
+    vpx_codec_get_si_fn_t get_si;   /**< \copydoc ::vpx_codec_get_si_fn_t */
+    vpx_codec_decode_fn_t decode;   /**< \copydoc ::vpx_codec_decode_fn_t */
+    vpx_codec_get_frame_fn_t
+        get_frame;                   /**< \copydoc ::vpx_codec_get_frame_fn_t */
+    vpx_codec_set_fb_fn_t set_fb_fn; /**< \copydoc ::vpx_codec_set_fb_fn_t */
   } dec;
   struct vpx_codec_enc_iface {
-    int                                cfg_map_count;
-    vpx_codec_enc_cfg_map_t           *cfg_maps;      /**< \copydoc ::vpx_codec_enc_cfg_map_t */
-    vpx_codec_encode_fn_t              encode;        /**< \copydoc ::vpx_codec_encode_fn_t */
-    vpx_codec_get_cx_data_fn_t         get_cx_data;   /**< \copydoc ::vpx_codec_get_cx_data_fn_t */
-    vpx_codec_enc_config_set_fn_t      cfg_set;       /**< \copydoc ::vpx_codec_enc_config_set_fn_t */
-    vpx_codec_get_global_headers_fn_t  get_glob_hdrs; /**< \copydoc ::vpx_codec_get_global_headers_fn_t */
-    vpx_codec_get_preview_frame_fn_t   get_preview;   /**< \copydoc ::vpx_codec_get_preview_frame_fn_t */
-    vpx_codec_enc_mr_get_mem_loc_fn_t  mr_get_mem_loc;   /**< \copydoc ::vpx_codec_enc_mr_get_mem_loc_fn_t */
+    int cfg_map_count;
+    vpx_codec_enc_cfg_map_t
+        *cfg_maps;                /**< \copydoc ::vpx_codec_enc_cfg_map_t */
+    vpx_codec_encode_fn_t encode; /**< \copydoc ::vpx_codec_encode_fn_t */
+    vpx_codec_get_cx_data_fn_t
+        get_cx_data; /**< \copydoc ::vpx_codec_get_cx_data_fn_t */
+    vpx_codec_enc_config_set_fn_t
+        cfg_set; /**< \copydoc ::vpx_codec_enc_config_set_fn_t */
+    vpx_codec_get_global_headers_fn_t
+        get_glob_hdrs; /**< \copydoc ::vpx_codec_get_global_headers_fn_t */
+    vpx_codec_get_preview_frame_fn_t
+        get_preview; /**< \copydoc ::vpx_codec_get_preview_frame_fn_t */
+    vpx_codec_enc_mr_get_mem_loc_fn_t
+        mr_get_mem_loc; /**< \copydoc ::vpx_codec_enc_mr_get_mem_loc_fn_t */
   } enc;
 };
 
 /*!\brief Callback function pointer / user data pair storage */
 typedef struct vpx_codec_priv_cb_pair {
   union {
-    vpx_codec_put_frame_cb_fn_t    put_frame;
-    vpx_codec_put_slice_cb_fn_t    put_slice;
+    vpx_codec_put_frame_cb_fn_t put_frame;
+    vpx_codec_put_slice_cb_fn_t put_slice;
   } u;
-  void                            *user_priv;
+  void *user_priv;
 } vpx_codec_priv_cb_pair_t;
 
-
 /*!\brief Instance private storage
  *
  * This structure is allocated by the algorithm's init function. It can be
@@ -335,39 +337,38 @@ typedef struct vpx_codec_priv_cb_pair {
  * and the pointer cast to the proper type.
  */
 struct vpx_codec_priv {
-  const char                     *err_detail;
-  vpx_codec_flags_t               init_flags;
+  const char *err_detail;
+  vpx_codec_flags_t init_flags;
   struct {
-    vpx_codec_priv_cb_pair_t    put_frame_cb;
-    vpx_codec_priv_cb_pair_t    put_slice_cb;
+    vpx_codec_priv_cb_pair_t put_frame_cb;
+    vpx_codec_priv_cb_pair_t put_slice_cb;
   } dec;
   struct {
-    vpx_fixed_buf_t             cx_data_dst_buf;
-    unsigned int                cx_data_pad_before;
-    unsigned int                cx_data_pad_after;
-    vpx_codec_cx_pkt_t          cx_data_pkt;
-    unsigned int                total_encoders;
+    vpx_fixed_buf_t cx_data_dst_buf;
+    unsigned int cx_data_pad_before;
+    unsigned int cx_data_pad_after;
+    vpx_codec_cx_pkt_t cx_data_pkt;
+    unsigned int total_encoders;
   } enc;
 };
 
 /*
  * Multi-resolution encoding internal configuration
  */
-struct vpx_codec_priv_enc_mr_cfg
-{
-    unsigned int           mr_total_resolutions;
-    unsigned int           mr_encoder_id;
-    struct vpx_rational    mr_down_sampling_factor;
-    void*                  mr_low_res_mode_info;
+struct vpx_codec_priv_enc_mr_cfg {
+  unsigned int mr_total_resolutions;
+  unsigned int mr_encoder_id;
+  struct vpx_rational mr_down_sampling_factor;
+  void *mr_low_res_mode_info;
 };
 
 #undef VPX_CTRL_USE_TYPE
 #define VPX_CTRL_USE_TYPE(id, typ) \
-  static VPX_INLINE typ id##__value(va_list args) {return va_arg(args, typ);}
+  static VPX_INLINE typ id##__value(va_list args) { return va_arg(args, typ); }
 
 #undef VPX_CTRL_USE_TYPE_DEPRECATED
 #define VPX_CTRL_USE_TYPE_DEPRECATED(id, typ) \
-  static VPX_INLINE typ id##__value(va_list args) {return va_arg(args, typ);}
+  static VPX_INLINE typ id##__value(va_list args) { return va_arg(args, typ); }
 
 #define CAST(id, arg) id##__value(arg)
 
@@ -380,10 +381,9 @@ struct vpx_codec_priv_enc_mr_cfg
  * the same name as the struct, less the _algo suffix. The CODEC_INTERFACE
  * macro is provided to define this getter function automatically.
  */
-#define CODEC_INTERFACE(id)\
-  vpx_codec_iface_t* id(void) { return &id##_algo; }\
-  vpx_codec_iface_t  id##_algo
-
+#define CODEC_INTERFACE(id)                          \
+  vpx_codec_iface_t *id(void) { return &id##_algo; } \
+  vpx_codec_iface_t id##_algo
 
 /* Internal Utility Functions
  *
@@ -391,38 +391,39 @@ struct vpx_codec_priv_enc_mr_cfg
  * utilities for manipulating vpx_codec_* data structures.
  */
 struct vpx_codec_pkt_list {
-  unsigned int            cnt;
-  unsigned int            max;
+  unsigned int cnt;
+  unsigned int max;
   struct vpx_codec_cx_pkt pkts[1];
 };
 
-#define vpx_codec_pkt_list_decl(n)\
-  union {struct vpx_codec_pkt_list head;\
-    struct {struct vpx_codec_pkt_list head;\
-      struct vpx_codec_cx_pkt    pkts[n];} alloc;}
-
-#define vpx_codec_pkt_list_init(m)\
-  (m)->alloc.head.cnt = 0,\
-                        (m)->alloc.head.max = sizeof((m)->alloc.pkts) / sizeof((m)->alloc.pkts[0])
+#define vpx_codec_pkt_list_decl(n)     \
+  union {                              \
+    struct vpx_codec_pkt_list head;    \
+    struct {                           \
+      struct vpx_codec_pkt_list head;  \
+      struct vpx_codec_cx_pkt pkts[n]; \
+    } alloc;                           \
+  }
 
-int
-vpx_codec_pkt_list_add(struct vpx_codec_pkt_list *,
-                       const struct vpx_codec_cx_pkt *);
+#define vpx_codec_pkt_list_init(m) \
+  (m)->alloc.head.cnt = 0,         \
+  (m)->alloc.head.max = sizeof((m)->alloc.pkts) / sizeof((m)->alloc.pkts[0])
 
-const vpx_codec_cx_pkt_t *
-vpx_codec_pkt_list_get(struct vpx_codec_pkt_list *list,
-                       vpx_codec_iter_t           *iter);
+int vpx_codec_pkt_list_add(struct vpx_codec_pkt_list *,
+                           const struct vpx_codec_cx_pkt *);
 
+const vpx_codec_cx_pkt_t *vpx_codec_pkt_list_get(
+    struct vpx_codec_pkt_list *list, vpx_codec_iter_t *iter);
 
 #include <stdio.h>
 #include <setjmp.h>
 
 struct vpx_internal_error_info {
-  vpx_codec_err_t  error_code;
-  int              has_detail;
-  char             detail[80];
-  int              setjmp;
-  jmp_buf          jmp;
+  vpx_codec_err_t error_code;
+  int has_detail;
+  char detail[80];
+  int setjmp;
+  jmp_buf jmp;
 };
 
 #define CLANG_ANALYZER_NORETURN
@@ -434,8 +435,7 @@ struct vpx_internal_error_info {
 #endif
 
 void vpx_internal_error(struct vpx_internal_error_info *info,
-                        vpx_codec_err_t                 error,
-                        const char                     *fmt,
+                        vpx_codec_err_t error, const char *fmt,
                         ...) CLANG_ANALYZER_NORETURN;
 
 #ifdef __cplusplus
diff --git a/vpx/src/svc_encodeframe.c b/vpx/src/svc_encodeframe.c
index ef9b3528a..427f30f36 100644
--- a/vpx/src/svc_encodeframe.c
+++ b/vpx/src/svc_encodeframe.c
@@ -33,8 +33,8 @@
 #ifndef MINGW_HAS_SECURE_API
 // proto from /usr/x86_64-w64-mingw32/include/sec_api/string_s.h
 _CRTIMP char *__cdecl strtok_s(char *str, const char *delim, char **context);
-#endif  /* MINGW_HAS_SECURE_API */
-#endif  /* __MINGW32__ */
+#endif /* MINGW_HAS_SECURE_API */
+#endif /* __MINGW32__ */
 
 #ifdef _MSC_VER
 #define strdup _strdup
@@ -47,13 +47,11 @@ _CRTIMP char *__cdecl strtok_s(char *str, const char *delim, char **context);
 
 #define MAX_QUANTIZER 63
 
-static const int DEFAULT_SCALE_FACTORS_NUM[VPX_SS_MAX_LAYERS] = {
-  4, 5, 7, 11, 16
-};
+static const int DEFAULT_SCALE_FACTORS_NUM[VPX_SS_MAX_LAYERS] = { 4, 5, 7, 11,
+                                                                  16 };
 
-static const int DEFAULT_SCALE_FACTORS_DEN[VPX_SS_MAX_LAYERS] = {
-  16, 16, 16, 16, 16
-};
+static const int DEFAULT_SCALE_FACTORS_DEN[VPX_SS_MAX_LAYERS] = { 16, 16, 16,
+                                                                  16, 16 };
 
 typedef enum {
   QUANTIZER = 0,
@@ -63,20 +61,17 @@ typedef enum {
   ALL_OPTION_TYPES
 } LAYER_OPTION_TYPE;
 
-static const int option_max_values[ALL_OPTION_TYPES] = {
-  63, INT_MAX, INT_MAX, 1
-};
+static const int option_max_values[ALL_OPTION_TYPES] = { 63, INT_MAX, INT_MAX,
+                                                         1 };
 
-static const int option_min_values[ALL_OPTION_TYPES] = {
-  0, 0, 1, 0
-};
+static const int option_min_values[ALL_OPTION_TYPES] = { 0, 0, 1, 0 };
 
 // One encoded frame
 typedef struct FrameData {
-  void                     *buf;    // compressed data buffer
-  size_t                    size;  // length of compressed data
-  vpx_codec_frame_flags_t   flags;    /**< flags for this frame */
-  struct FrameData         *next;
+  void *buf;                     // compressed data buffer
+  size_t size;                   // length of compressed data
+  vpx_codec_frame_flags_t flags; /**< flags for this frame */
+  struct FrameData *next;
 } FrameData;
 
 static SvcInternal_t *get_svc_internal(SvcContext *svc_ctx) {
@@ -91,8 +86,7 @@ static SvcInternal_t *get_svc_internal(SvcContext *svc_ctx) {
   return (SvcInternal_t *)svc_ctx->internal;
 }
 
-static const SvcInternal_t *get_const_svc_internal(
-    const SvcContext *svc_ctx) {
+static const SvcInternal_t *get_const_svc_internal(const SvcContext *svc_ctx) {
   if (svc_ctx == NULL) return NULL;
   return (const SvcInternal_t *)svc_ctx->internal;
 }
@@ -102,8 +96,8 @@ static void svc_log_reset(SvcContext *svc_ctx) {
   si->message_buffer[0] = '\0';
 }
 
-static int svc_log(SvcContext *svc_ctx, SVC_LOG_LEVEL level,
-                   const char *fmt, ...) {
+static int svc_log(SvcContext *svc_ctx, SVC_LOG_LEVEL level, const char *fmt,
+                   ...) {
   char buf[512];
   int retval = 0;
   va_list ap;
@@ -130,14 +124,11 @@ static int svc_log(SvcContext *svc_ctx, SVC_LOG_LEVEL level,
   return retval;
 }
 
-static vpx_codec_err_t extract_option(LAYER_OPTION_TYPE type,
-                                      char *input,
-                                      int *value0,
-                                      int *value1) {
+static vpx_codec_err_t extract_option(LAYER_OPTION_TYPE type, char *input,
+                                      int *value0, int *value1) {
   if (type == SCALE_FACTOR) {
     *value0 = strtol(input, &input, 10);
-    if (*input++ != '/')
-      return VPX_CODEC_INVALID_PARAM;
+    if (*input++ != '/') return VPX_CODEC_INVALID_PARAM;
     *value1 = strtol(input, &input, 10);
 
     if (*value0 < option_min_values[SCALE_FACTOR] ||
@@ -148,8 +139,7 @@ static vpx_codec_err_t extract_option(LAYER_OPTION_TYPE type,
       return VPX_CODEC_INVALID_PARAM;
   } else {
     *value0 = atoi(input);
-    if (*value0 < option_min_values[type] ||
-        *value0 > option_max_values[type])
+    if (*value0 < option_min_values[type] || *value0 > option_max_values[type])
       return VPX_CODEC_INVALID_PARAM;
   }
   return VPX_CODEC_OK;
@@ -176,8 +166,7 @@ static vpx_codec_err_t parse_layer_options_from_string(SvcContext *svc_ctx,
   for (i = 0; i < svc_ctx->spatial_layers; ++i) {
     if (token != NULL) {
       res = extract_option(type, token, option0 + i, option1 + i);
-      if (res != VPX_CODEC_OK)
-        break;
+      if (res != VPX_CODEC_OK) break;
       token = strtok_r(NULL, delim, &save_ptr);
     } else {
       break;
@@ -186,7 +175,8 @@ static vpx_codec_err_t parse_layer_options_from_string(SvcContext *svc_ctx,
   if (res == VPX_CODEC_OK && i != svc_ctx->spatial_layers) {
     svc_log(svc_ctx, SVC_LOG_ERROR,
             "svc: layer params type: %d    %d values required, "
-            "but only %d specified\n", type, svc_ctx->spatial_layers, i);
+            "but only %d specified\n",
+            type, svc_ctx->spatial_layers, i);
     res = VPX_CODEC_INVALID_PARAM;
   }
   free(input_string);
@@ -233,14 +223,14 @@ static vpx_codec_err_t parse_options(SvcContext *svc_ctx, const char *options) {
                                             si->svc_params.scaling_factor_den);
       if (res != VPX_CODEC_OK) break;
     } else if (strcmp("max-quantizers", option_name) == 0) {
-      res = parse_layer_options_from_string(svc_ctx, QUANTIZER, option_value,
-                                            si->svc_params.max_quantizers,
-                                            NULL);
+      res =
+          parse_layer_options_from_string(svc_ctx, QUANTIZER, option_value,
+                                          si->svc_params.max_quantizers, NULL);
       if (res != VPX_CODEC_OK) break;
     } else if (strcmp("min-quantizers", option_name) == 0) {
-      res = parse_layer_options_from_string(svc_ctx, QUANTIZER, option_value,
-                                            si->svc_params.min_quantizers,
-                                            NULL);
+      res =
+          parse_layer_options_from_string(svc_ctx, QUANTIZER, option_value,
+                                          si->svc_params.min_quantizers, NULL);
       if (res != VPX_CODEC_OK) break;
     } else if (strcmp("auto-alt-refs", option_name) == 0) {
       res = parse_layer_options_from_string(svc_ctx, AUTO_ALT_REF, option_value,
@@ -287,8 +277,7 @@ static vpx_codec_err_t parse_options(SvcContext *svc_ctx, const char *options) {
   return res;
 }
 
-vpx_codec_err_t vpx_svc_set_options(SvcContext *svc_ctx,
-                                    const char *options) {
+vpx_codec_err_t vpx_svc_set_options(SvcContext *svc_ctx, const char *options) {
   SvcInternal_t *const si = get_svc_internal(svc_ctx);
   if (svc_ctx == NULL || options == NULL || si == NULL) {
     return VPX_CODEC_INVALID_PARAM;
@@ -308,34 +297,34 @@ void assign_layer_bitrates(const SvcContext *svc_ctx,
     if (si->bitrates[0] != 0) {
       enc_cfg->rc_target_bitrate = 0;
       for (sl = 0; sl < svc_ctx->spatial_layers; ++sl) {
-        enc_cfg->ss_target_bitrate[sl*svc_ctx->temporal_layers] = 0;
+        enc_cfg->ss_target_bitrate[sl * svc_ctx->temporal_layers] = 0;
         for (tl = 0; tl < svc_ctx->temporal_layers; ++tl) {
-          enc_cfg->ss_target_bitrate[sl*svc_ctx->temporal_layers]
-              += (unsigned int)si->bitrates[sl * svc_ctx->temporal_layers + tl];
-          enc_cfg->layer_target_bitrate[sl*svc_ctx->temporal_layers + tl]
-              = si->bitrates[sl * svc_ctx->temporal_layers + tl];
+          enc_cfg->ss_target_bitrate[sl * svc_ctx->temporal_layers] +=
+              (unsigned int)si->bitrates[sl * svc_ctx->temporal_layers + tl];
+          enc_cfg->layer_target_bitrate[sl * svc_ctx->temporal_layers + tl] =
+              si->bitrates[sl * svc_ctx->temporal_layers + tl];
         }
       }
     } else {
       float total = 0;
-      float alloc_ratio[VPX_MAX_LAYERS] = {0};
+      float alloc_ratio[VPX_MAX_LAYERS] = { 0 };
 
       for (sl = 0; sl < svc_ctx->spatial_layers; ++sl) {
         if (si->svc_params.scaling_factor_den[sl] > 0) {
-          alloc_ratio[sl] = (float)( pow(2, sl) );
+          alloc_ratio[sl] = (float)(pow(2, sl));
           total += alloc_ratio[sl];
         }
       }
 
       for (sl = 0; sl < svc_ctx->spatial_layers; ++sl) {
         enc_cfg->ss_target_bitrate[sl] = spatial_layer_target =
-            (unsigned int)(enc_cfg->rc_target_bitrate *
-                alloc_ratio[sl] / total);
+            (unsigned int)(enc_cfg->rc_target_bitrate * alloc_ratio[sl] /
+                           total);
         if (svc_ctx->temporal_layering_mode == 3) {
           enc_cfg->layer_target_bitrate[sl * svc_ctx->temporal_layers] =
-              (spatial_layer_target*6)/10;  // 60%
+              (spatial_layer_target * 6) / 10;  // 60%
           enc_cfg->layer_target_bitrate[sl * svc_ctx->temporal_layers + 1] =
-              (spatial_layer_target*8)/10;  // 80%
+              (spatial_layer_target * 8) / 10;  // 80%
           enc_cfg->layer_target_bitrate[sl * svc_ctx->temporal_layers + 2] =
               spatial_layer_target;
         } else if (svc_ctx->temporal_layering_mode == 2 ||
@@ -359,7 +348,7 @@ void assign_layer_bitrates(const SvcContext *svc_ctx,
       }
     } else {
       float total = 0;
-      float alloc_ratio[VPX_MAX_LAYERS] = {0};
+      float alloc_ratio[VPX_MAX_LAYERS] = { 0 };
 
       for (i = 0; i < svc_ctx->spatial_layers; ++i) {
         if (si->svc_params.scaling_factor_den[i] > 0) {
@@ -372,8 +361,9 @@ void assign_layer_bitrates(const SvcContext *svc_ctx,
       }
       for (i = 0; i < VPX_SS_MAX_LAYERS; ++i) {
         if (total > 0) {
-          enc_cfg->layer_target_bitrate[i] = (unsigned int)
-              (enc_cfg->rc_target_bitrate * alloc_ratio[i] / total);
+          enc_cfg->layer_target_bitrate[i] =
+              (unsigned int)(enc_cfg->rc_target_bitrate * alloc_ratio[i] /
+                             total);
         }
       }
     }
@@ -384,7 +374,7 @@ vpx_codec_err_t vpx_svc_init(SvcContext *svc_ctx, vpx_codec_ctx_t *codec_ctx,
                              vpx_codec_iface_t *iface,
                              vpx_codec_enc_cfg_t *enc_cfg) {
   vpx_codec_err_t res;
-  int i, sl , tl;
+  int i, sl, tl;
   SvcInternal_t *const si = get_svc_internal(svc_ctx);
   if (svc_ctx == NULL || codec_ctx == NULL || iface == NULL ||
       enc_cfg == NULL) {
@@ -434,23 +424,21 @@ vpx_codec_err_t vpx_svc_init(SvcContext *svc_ctx, vpx_codec_ctx_t *codec_ctx,
   res = parse_options(svc_ctx, si->options);
   if (res != VPX_CODEC_OK) return res;
 
-  if (svc_ctx->spatial_layers < 1)
-    svc_ctx->spatial_layers = 1;
+  if (svc_ctx->spatial_layers < 1) svc_ctx->spatial_layers = 1;
   if (svc_ctx->spatial_layers > VPX_SS_MAX_LAYERS)
     svc_ctx->spatial_layers = VPX_SS_MAX_LAYERS;
 
-  if (svc_ctx->temporal_layers < 1)
-    svc_ctx->temporal_layers = 1;
+  if (svc_ctx->temporal_layers < 1) svc_ctx->temporal_layers = 1;
   if (svc_ctx->temporal_layers > VPX_TS_MAX_LAYERS)
     svc_ctx->temporal_layers = VPX_TS_MAX_LAYERS;
 
   if (svc_ctx->temporal_layers * svc_ctx->spatial_layers > VPX_MAX_LAYERS) {
-      svc_log(svc_ctx, SVC_LOG_ERROR,
-          "spatial layers * temporal layers exceeds the maximum number of "
-          "allowed layers of %d\n",
-          svc_ctx->spatial_layers * svc_ctx->temporal_layers,
-          (int) VPX_MAX_LAYERS);
-      return VPX_CODEC_INVALID_PARAM;
+    svc_log(svc_ctx, SVC_LOG_ERROR,
+            "spatial layers * temporal layers exceeds the maximum number of "
+            "allowed layers of %d\n",
+            svc_ctx->spatial_layers * svc_ctx->temporal_layers,
+            (int)VPX_MAX_LAYERS);
+    return VPX_CODEC_INVALID_PARAM;
   }
   assign_layer_bitrates(svc_ctx, enc_cfg);
 
@@ -462,14 +450,13 @@ vpx_codec_err_t vpx_svc_init(SvcContext *svc_ctx, vpx_codec_ctx_t *codec_ctx,
   if (svc_ctx->temporal_layers > 1) {
     int i;
     for (i = 0; i < svc_ctx->temporal_layers; ++i) {
-      enc_cfg->ts_target_bitrate[i] = enc_cfg->rc_target_bitrate /
-                                      svc_ctx->temporal_layers;
+      enc_cfg->ts_target_bitrate[i] =
+          enc_cfg->rc_target_bitrate / svc_ctx->temporal_layers;
       enc_cfg->ts_rate_decimator[i] = 1 << (svc_ctx->temporal_layers - 1 - i);
     }
   }
 
-  if (svc_ctx->threads)
-    enc_cfg->g_threads = svc_ctx->threads;
+  if (svc_ctx->threads) enc_cfg->g_threads = svc_ctx->threads;
 
   // Modify encoder configuration
   enc_cfg->ss_number_layers = svc_ctx->spatial_layers;
@@ -507,10 +494,8 @@ vpx_codec_err_t vpx_svc_init(SvcContext *svc_ctx, vpx_codec_ctx_t *codec_ctx,
  * Encode a frame into multiple layers
  * Create a superframe containing the individual layers
  */
-vpx_codec_err_t vpx_svc_encode(SvcContext *svc_ctx,
-                               vpx_codec_ctx_t *codec_ctx,
-                               struct vpx_image *rawimg,
-                               vpx_codec_pts_t pts,
+vpx_codec_err_t vpx_svc_encode(SvcContext *svc_ctx, vpx_codec_ctx_t *codec_ctx,
+                               struct vpx_image *rawimg, vpx_codec_pts_t pts,
                                int64_t duration, int deadline) {
   vpx_codec_err_t res;
   vpx_codec_iter_t iter;
@@ -522,8 +507,8 @@ vpx_codec_err_t vpx_svc_encode(SvcContext *svc_ctx,
 
   svc_log_reset(svc_ctx);
 
-  res = vpx_codec_encode(codec_ctx, rawimg, pts, (uint32_t)duration, 0,
-                         deadline);
+  res =
+      vpx_codec_encode(codec_ctx, rawimg, pts, (uint32_t)duration, 0, deadline);
   if (res != VPX_CODEC_OK) {
     return res;
   }
@@ -540,23 +525,20 @@ vpx_codec_err_t vpx_svc_encode(SvcContext *svc_ctx,
           svc_log(svc_ctx, SVC_LOG_DEBUG,
                   "SVC frame: %d, layer: %d, PSNR(Total/Y/U/V): "
                   "%2.3f  %2.3f  %2.3f  %2.3f \n",
-                  si->psnr_pkt_received, i,
-                  cx_pkt->data.layer_psnr[i].psnr[0],
+                  si->psnr_pkt_received, i, cx_pkt->data.layer_psnr[i].psnr[0],
                   cx_pkt->data.layer_psnr[i].psnr[1],
                   cx_pkt->data.layer_psnr[i].psnr[2],
                   cx_pkt->data.layer_psnr[i].psnr[3]);
           svc_log(svc_ctx, SVC_LOG_DEBUG,
                   "SVC frame: %d, layer: %d, SSE(Total/Y/U/V): "
                   "%2.3f  %2.3f  %2.3f  %2.3f \n",
-                  si->psnr_pkt_received, i,
-                  cx_pkt->data.layer_psnr[i].sse[0],
+                  si->psnr_pkt_received, i, cx_pkt->data.layer_psnr[i].sse[0],
                   cx_pkt->data.layer_psnr[i].sse[1],
                   cx_pkt->data.layer_psnr[i].sse[2],
                   cx_pkt->data.layer_psnr[i].sse[3]);
 
           for (j = 0; j < COMPONENTS; ++j) {
-            si->psnr_sum[i][j] +=
-                cx_pkt->data.layer_psnr[i].psnr[j];
+            si->psnr_sum[i][j] += cx_pkt->data.layer_psnr[i].psnr[j];
             si->sse_sum[i][j] += cx_pkt->data.layer_psnr[i].sse[j];
           }
         }
@@ -571,30 +553,25 @@ vpx_codec_err_t vpx_svc_encode(SvcContext *svc_ctx,
       }
 #endif
 #endif
-      case VPX_CODEC_PSNR_PKT:
-      {
+      case VPX_CODEC_PSNR_PKT: {
 #if VPX_ENCODER_ABI_VERSION > (5 + VPX_CODEC_ABI_VERSION)
         int j;
         svc_log(svc_ctx, SVC_LOG_DEBUG,
                 "frame: %d, layer: %d, PSNR(Total/Y/U/V): "
                 "%2.3f  %2.3f  %2.3f  %2.3f \n",
-                si->psnr_pkt_received, 0,
-                cx_pkt->data.layer_psnr[0].psnr[0],
+                si->psnr_pkt_received, 0, cx_pkt->data.layer_psnr[0].psnr[0],
                 cx_pkt->data.layer_psnr[0].psnr[1],
                 cx_pkt->data.layer_psnr[0].psnr[2],
                 cx_pkt->data.layer_psnr[0].psnr[3]);
         for (j = 0; j < COMPONENTS; ++j) {
-          si->psnr_sum[0][j] +=
-              cx_pkt->data.layer_psnr[0].psnr[j];
+          si->psnr_sum[0][j] += cx_pkt->data.layer_psnr[0].psnr[j];
           si->sse_sum[0][j] += cx_pkt->data.layer_psnr[0].sse[j];
         }
 #endif
       }
-      ++si->psnr_pkt_received;
-      break;
-      default: {
+        ++si->psnr_pkt_received;
         break;
-      }
+      default: { break; }
     }
   }
 
@@ -632,7 +609,6 @@ const char *vpx_svc_dump_statistics(SvcContext *svc_ctx) {
 
   svc_log(svc_ctx, SVC_LOG_INFO, "\n");
   for (i = 0; i < svc_ctx->spatial_layers; ++i) {
-
     svc_log(svc_ctx, SVC_LOG_INFO,
             "Layer %d Average PSNR=[%2.3f, %2.3f, %2.3f, %2.3f], Bytes=[%u]\n",
             i, (double)si->psnr_sum[i][0] / number_of_frames,
@@ -683,4 +659,3 @@ void vpx_svc_release(SvcContext *svc_ctx) {
     svc_ctx->internal = NULL;
   }
 }
-
diff --git a/vpx/src/vpx_codec.c b/vpx/src/vpx_codec.c
index 5a495ce81..f222b9e5c 100644
--- a/vpx/src/vpx_codec.c
+++ b/vpx/src/vpx_codec.c
@@ -8,7 +8,6 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
-
 /*!\file
  * \brief Provides the high level interface to wrap decoder algorithms.
  *
@@ -19,67 +18,50 @@
 #include "vpx/internal/vpx_codec_internal.h"
 #include "vpx_version.h"
 
-#define SAVE_STATUS(ctx,var) (ctx?(ctx->err = var):var)
-
-int vpx_codec_version(void) {
-  return VERSION_PACKED;
-}
-
-
-const char *vpx_codec_version_str(void) {
-  return VERSION_STRING_NOSP;
-}
+#define SAVE_STATUS(ctx, var) (ctx ? (ctx->err = var) : var)
 
+int vpx_codec_version(void) { return VERSION_PACKED; }
 
-const char *vpx_codec_version_extra_str(void) {
-  return VERSION_EXTRA;
-}
+const char *vpx_codec_version_str(void) { return VERSION_STRING_NOSP; }
 
+const char *vpx_codec_version_extra_str(void) { return VERSION_EXTRA; }
 
 const char *vpx_codec_iface_name(vpx_codec_iface_t *iface) {
   return iface ? iface->name : "<invalid interface>";
 }
 
-const char *vpx_codec_err_to_string(vpx_codec_err_t  err) {
+const char *vpx_codec_err_to_string(vpx_codec_err_t err) {
   switch (err) {
-    case VPX_CODEC_OK:
-      return "Success";
-    case VPX_CODEC_ERROR:
-      return "Unspecified internal error";
-    case VPX_CODEC_MEM_ERROR:
-      return "Memory allocation error";
-    case VPX_CODEC_ABI_MISMATCH:
-      return "ABI version mismatch";
+    case VPX_CODEC_OK: return "Success";
+    case VPX_CODEC_ERROR: return "Unspecified internal error";
+    case VPX_CODEC_MEM_ERROR: return "Memory allocation error";
+    case VPX_CODEC_ABI_MISMATCH: return "ABI version mismatch";
     case VPX_CODEC_INCAPABLE:
       return "Codec does not implement requested capability";
     case VPX_CODEC_UNSUP_BITSTREAM:
       return "Bitstream not supported by this decoder";
     case VPX_CODEC_UNSUP_FEATURE:
       return "Bitstream required feature not supported by this decoder";
-    case VPX_CODEC_CORRUPT_FRAME:
-      return "Corrupt frame detected";
-    case  VPX_CODEC_INVALID_PARAM:
-      return "Invalid parameter";
-    case VPX_CODEC_LIST_END:
-      return "End of iterated list";
+    case VPX_CODEC_CORRUPT_FRAME: return "Corrupt frame detected";
+    case VPX_CODEC_INVALID_PARAM: return "Invalid parameter";
+    case VPX_CODEC_LIST_END: return "End of iterated list";
   }
 
   return "Unrecognized error code";
 }
 
-const char *vpx_codec_error(vpx_codec_ctx_t  *ctx) {
+const char *vpx_codec_error(vpx_codec_ctx_t *ctx) {
   return (ctx) ? vpx_codec_err_to_string(ctx->err)
-         : vpx_codec_err_to_string(VPX_CODEC_INVALID_PARAM);
+               : vpx_codec_err_to_string(VPX_CODEC_INVALID_PARAM);
 }
 
-const char *vpx_codec_error_detail(vpx_codec_ctx_t  *ctx) {
+const char *vpx_codec_error_detail(vpx_codec_ctx_t *ctx) {
   if (ctx && ctx->err)
     return ctx->priv ? ctx->priv->err_detail : ctx->err_detail;
 
   return NULL;
 }
 
-
 vpx_codec_err_t vpx_codec_destroy(vpx_codec_ctx_t *ctx) {
   vpx_codec_err_t res;
 
@@ -99,15 +81,11 @@ vpx_codec_err_t vpx_codec_destroy(vpx_codec_ctx_t *ctx) {
   return SAVE_STATUS(ctx, res);
 }
 
-
 vpx_codec_caps_t vpx_codec_get_caps(vpx_codec_iface_t *iface) {
   return (iface) ? iface->caps : 0;
 }
 
-
-vpx_codec_err_t vpx_codec_control_(vpx_codec_ctx_t  *ctx,
-                                   int               ctrl_id,
-                                   ...) {
+vpx_codec_err_t vpx_codec_control_(vpx_codec_ctx_t *ctx, int ctrl_id, ...) {
   vpx_codec_err_t res;
 
   if (!ctx || !ctrl_id)
@@ -121,7 +99,7 @@ vpx_codec_err_t vpx_codec_control_(vpx_codec_ctx_t  *ctx,
 
     for (entry = ctx->iface->ctrl_maps; entry && entry->fn; entry++) {
       if (!entry->ctrl_id || entry->ctrl_id == ctrl_id) {
-        va_list  ap;
+        va_list ap;
 
         va_start(ap, ctrl_id);
         res = entry->fn((vpx_codec_alg_priv_t *)ctx->priv, ap);
@@ -135,16 +113,14 @@ vpx_codec_err_t vpx_codec_control_(vpx_codec_ctx_t  *ctx,
 }
 
 void vpx_internal_error(struct vpx_internal_error_info *info,
-                        vpx_codec_err_t                 error,
-                        const char                     *fmt,
-                        ...) {
+                        vpx_codec_err_t error, const char *fmt, ...) {
   va_list ap;
 
   info->error_code = error;
   info->has_detail = 0;
 
   if (fmt) {
-    size_t  sz = sizeof(info->detail);
+    size_t sz = sizeof(info->detail);
 
     info->has_detail = 1;
     va_start(ap, fmt);
@@ -153,6 +129,5 @@ void vpx_internal_error(struct vpx_internal_error_info *info,
     info->detail[sz - 1] = '\0';
   }
 
-  if (info->setjmp)
-    longjmp(info->jmp, info->error_code);
+  if (info->setjmp) longjmp(info->jmp, info->error_code);
 }
diff --git a/vpx/src/vpx_decoder.c b/vpx/src/vpx_decoder.c
index 802d8edd8..fc1c2bcca 100644
--- a/vpx/src/vpx_decoder.c
+++ b/vpx/src/vpx_decoder.c
@@ -8,7 +8,6 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
-
 /*!\file
  * \brief Provides the high level interface to wrap decoder algorithms.
  *
@@ -16,17 +15,16 @@
 #include <string.h>
 #include "vpx/internal/vpx_codec_internal.h"
 
-#define SAVE_STATUS(ctx,var) (ctx?(ctx->err = var):var)
+#define SAVE_STATUS(ctx, var) (ctx ? (ctx->err = var) : var)
 
 static vpx_codec_alg_priv_t *get_alg_priv(vpx_codec_ctx_t *ctx) {
   return (vpx_codec_alg_priv_t *)ctx->priv;
 }
 
-vpx_codec_err_t vpx_codec_dec_init_ver(vpx_codec_ctx_t      *ctx,
-                                       vpx_codec_iface_t    *iface,
+vpx_codec_err_t vpx_codec_dec_init_ver(vpx_codec_ctx_t *ctx,
+                                       vpx_codec_iface_t *iface,
                                        const vpx_codec_dec_cfg_t *cfg,
-                                       vpx_codec_flags_t     flags,
-                                       int                   ver) {
+                                       vpx_codec_flags_t flags, int ver) {
   vpx_codec_err_t res;
 
   if (ver != VPX_DECODER_ABI_VERSION)
@@ -35,7 +33,8 @@ vpx_codec_err_t vpx_codec_dec_init_ver(vpx_codec_ctx_t      *ctx,
     res = VPX_CODEC_INVALID_PARAM;
   else if (iface->abi_version != VPX_CODEC_INTERNAL_ABI_VERSION)
     res = VPX_CODEC_ABI_MISMATCH;
-  else if ((flags & VPX_CODEC_USE_POSTPROC) && !(iface->caps & VPX_CODEC_CAP_POSTPROC))
+  else if ((flags & VPX_CODEC_USE_POSTPROC) &&
+           !(iface->caps & VPX_CODEC_CAP_POSTPROC))
     res = VPX_CODEC_INCAPABLE;
   else if ((flags & VPX_CODEC_USE_ERROR_CONCEALMENT) &&
            !(iface->caps & VPX_CODEC_CAP_ERROR_CONCEALMENT))
@@ -63,15 +62,14 @@ vpx_codec_err_t vpx_codec_dec_init_ver(vpx_codec_ctx_t      *ctx,
   return SAVE_STATUS(ctx, res);
 }
 
-
-vpx_codec_err_t vpx_codec_peek_stream_info(vpx_codec_iface_t       *iface,
-                                           const uint8_t         *data,
-                                           unsigned int           data_sz,
+vpx_codec_err_t vpx_codec_peek_stream_info(vpx_codec_iface_t *iface,
+                                           const uint8_t *data,
+                                           unsigned int data_sz,
                                            vpx_codec_stream_info_t *si) {
   vpx_codec_err_t res;
 
-  if (!iface || !data || !data_sz || !si
-      || si->sz < sizeof(vpx_codec_stream_info_t))
+  if (!iface || !data || !data_sz || !si ||
+      si->sz < sizeof(vpx_codec_stream_info_t))
     res = VPX_CODEC_INVALID_PARAM;
   else {
     /* Set default/unknown values */
@@ -84,8 +82,7 @@ vpx_codec_err_t vpx_codec_peek_stream_info(vpx_codec_iface_t       *iface,
   return res;
 }
 
-
-vpx_codec_err_t vpx_codec_get_stream_info(vpx_codec_ctx_t         *ctx,
+vpx_codec_err_t vpx_codec_get_stream_info(vpx_codec_ctx_t *ctx,
                                           vpx_codec_stream_info_t *si) {
   vpx_codec_err_t res;
 
@@ -104,12 +101,9 @@ vpx_codec_err_t vpx_codec_get_stream_info(vpx_codec_ctx_t         *ctx,
   return SAVE_STATUS(ctx, res);
 }
 
-
-vpx_codec_err_t vpx_codec_decode(vpx_codec_ctx_t    *ctx,
-                                 const uint8_t        *data,
-                                 unsigned int    data_sz,
-                                 void       *user_priv,
-                                 long        deadline) {
+vpx_codec_err_t vpx_codec_decode(vpx_codec_ctx_t *ctx, const uint8_t *data,
+                                 unsigned int data_sz, void *user_priv,
+                                 long deadline) {
   vpx_codec_err_t res;
 
   /* Sanity checks */
@@ -126,8 +120,7 @@ vpx_codec_err_t vpx_codec_decode(vpx_codec_ctx_t    *ctx,
   return SAVE_STATUS(ctx, res);
 }
 
-vpx_image_t *vpx_codec_get_frame(vpx_codec_ctx_t  *ctx,
-                                 vpx_codec_iter_t *iter) {
+vpx_image_t *vpx_codec_get_frame(vpx_codec_ctx_t *ctx, vpx_codec_iter_t *iter) {
   vpx_image_t *img;
 
   if (!ctx || !iter || !ctx->iface || !ctx->priv)
@@ -138,16 +131,15 @@ vpx_image_t *vpx_codec_get_frame(vpx_codec_ctx_t  *ctx,
   return img;
 }
 
-
-vpx_codec_err_t vpx_codec_register_put_frame_cb(vpx_codec_ctx_t             *ctx,
-                                                vpx_codec_put_frame_cb_fn_t  cb,
-                                                void                      *user_priv) {
+vpx_codec_err_t vpx_codec_register_put_frame_cb(vpx_codec_ctx_t *ctx,
+                                                vpx_codec_put_frame_cb_fn_t cb,
+                                                void *user_priv) {
   vpx_codec_err_t res;
 
   if (!ctx || !cb)
     res = VPX_CODEC_INVALID_PARAM;
-  else if (!ctx->iface || !ctx->priv
-           || !(ctx->iface->caps & VPX_CODEC_CAP_PUT_FRAME))
+  else if (!ctx->iface || !ctx->priv ||
+           !(ctx->iface->caps & VPX_CODEC_CAP_PUT_FRAME))
     res = VPX_CODEC_ERROR;
   else {
     ctx->priv->dec.put_frame_cb.u.put_frame = cb;
@@ -158,16 +150,15 @@ vpx_codec_err_t vpx_codec_register_put_frame_cb(vpx_codec_ctx_t             *ctx
   return SAVE_STATUS(ctx, res);
 }
 
-
-vpx_codec_err_t vpx_codec_register_put_slice_cb(vpx_codec_ctx_t             *ctx,
-                                                vpx_codec_put_slice_cb_fn_t  cb,
-                                                void                      *user_priv) {
+vpx_codec_err_t vpx_codec_register_put_slice_cb(vpx_codec_ctx_t *ctx,
+                                                vpx_codec_put_slice_cb_fn_t cb,
+                                                void *user_priv) {
   vpx_codec_err_t res;
 
   if (!ctx || !cb)
     res = VPX_CODEC_INVALID_PARAM;
-  else if (!ctx->iface || !ctx->priv
-           || !(ctx->iface->caps & VPX_CODEC_CAP_PUT_SLICE))
+  else if (!ctx->iface || !ctx->priv ||
+           !(ctx->iface->caps & VPX_CODEC_CAP_PUT_SLICE))
     res = VPX_CODEC_ERROR;
   else {
     ctx->priv->dec.put_slice_cb.u.put_slice = cb;
diff --git a/vpx/src/vpx_encoder.c b/vpx/src/vpx_encoder.c
index cd10c411c..4390cf7c8 100644
--- a/vpx/src/vpx_encoder.c
+++ b/vpx/src/vpx_encoder.c
@@ -8,7 +8,6 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
-
 /*!\file
  * \brief Provides the high level interface to wrap encoder algorithms.
  *
@@ -18,17 +17,16 @@
 #include "vpx_config.h"
 #include "vpx/internal/vpx_codec_internal.h"
 
-#define SAVE_STATUS(ctx,var) (ctx?(ctx->err = var):var)
+#define SAVE_STATUS(ctx, var) (ctx ? (ctx->err = var) : var)
 
 static vpx_codec_alg_priv_t *get_alg_priv(vpx_codec_ctx_t *ctx) {
   return (vpx_codec_alg_priv_t *)ctx->priv;
 }
 
-vpx_codec_err_t vpx_codec_enc_init_ver(vpx_codec_ctx_t      *ctx,
-                                       vpx_codec_iface_t    *iface,
+vpx_codec_err_t vpx_codec_enc_init_ver(vpx_codec_ctx_t *ctx,
+                                       vpx_codec_iface_t *iface,
                                        const vpx_codec_enc_cfg_t *cfg,
-                                       vpx_codec_flags_t     flags,
-                                       int                   ver) {
+                                       vpx_codec_flags_t flags, int ver) {
   vpx_codec_err_t res;
 
   if (ver != VPX_ENCODER_ABI_VERSION)
@@ -39,11 +37,10 @@ vpx_codec_err_t vpx_codec_enc_init_ver(vpx_codec_ctx_t      *ctx,
     res = VPX_CODEC_ABI_MISMATCH;
   else if (!(iface->caps & VPX_CODEC_CAP_ENCODER))
     res = VPX_CODEC_INCAPABLE;
-  else if ((flags & VPX_CODEC_USE_PSNR)
-           && !(iface->caps & VPX_CODEC_CAP_PSNR))
+  else if ((flags & VPX_CODEC_USE_PSNR) && !(iface->caps & VPX_CODEC_CAP_PSNR))
     res = VPX_CODEC_INCAPABLE;
-  else if ((flags & VPX_CODEC_USE_OUTPUT_PARTITION)
-           && !(iface->caps & VPX_CODEC_CAP_OUTPUT_PARTITION))
+  else if ((flags & VPX_CODEC_USE_OUTPUT_PARTITION) &&
+           !(iface->caps & VPX_CODEC_CAP_OUTPUT_PARTITION))
     res = VPX_CODEC_INCAPABLE;
   else {
     ctx->iface = iface;
@@ -62,13 +59,9 @@ vpx_codec_err_t vpx_codec_enc_init_ver(vpx_codec_ctx_t      *ctx,
   return SAVE_STATUS(ctx, res);
 }
 
-vpx_codec_err_t vpx_codec_enc_init_multi_ver(vpx_codec_ctx_t      *ctx,
-                                             vpx_codec_iface_t    *iface,
-                                             vpx_codec_enc_cfg_t  *cfg,
-                                             int                   num_enc,
-                                             vpx_codec_flags_t     flags,
-                                             vpx_rational_t       *dsf,
-                                             int                   ver) {
+vpx_codec_err_t vpx_codec_enc_init_multi_ver(
+    vpx_codec_ctx_t *ctx, vpx_codec_iface_t *iface, vpx_codec_enc_cfg_t *cfg,
+    int num_enc, vpx_codec_flags_t flags, vpx_rational_t *dsf, int ver) {
   vpx_codec_err_t res = VPX_CODEC_OK;
 
   if (ver != VPX_ENCODER_ABI_VERSION)
@@ -79,11 +72,10 @@ vpx_codec_err_t vpx_codec_enc_init_multi_ver(vpx_codec_ctx_t      *ctx,
     res = VPX_CODEC_ABI_MISMATCH;
   else if (!(iface->caps & VPX_CODEC_CAP_ENCODER))
     res = VPX_CODEC_INCAPABLE;
-  else if ((flags & VPX_CODEC_USE_PSNR)
-           && !(iface->caps & VPX_CODEC_CAP_PSNR))
+  else if ((flags & VPX_CODEC_USE_PSNR) && !(iface->caps & VPX_CODEC_CAP_PSNR))
     res = VPX_CODEC_INCAPABLE;
-  else if ((flags & VPX_CODEC_USE_OUTPUT_PARTITION)
-           && !(iface->caps & VPX_CODEC_CAP_OUTPUT_PARTITION))
+  else if ((flags & VPX_CODEC_USE_OUTPUT_PARTITION) &&
+           !(iface->caps & VPX_CODEC_CAP_OUTPUT_PARTITION))
     res = VPX_CODEC_INCAPABLE;
   else {
     int i;
@@ -110,8 +102,7 @@ vpx_codec_err_t vpx_codec_enc_init_multi_ver(vpx_codec_ctx_t      *ctx,
          * resolution always use the same frame_type chosen by the
          * lowest-resolution encoder.
          */
-        if (mr_cfg.mr_encoder_id)
-          cfg->kf_mode = VPX_KF_DISABLED;
+        if (mr_cfg.mr_encoder_id) cfg->kf_mode = VPX_KF_DISABLED;
 
         ctx->iface = iface;
         ctx->name = iface->name;
@@ -121,8 +112,7 @@ vpx_codec_err_t vpx_codec_enc_init_multi_ver(vpx_codec_ctx_t      *ctx,
         res = ctx->iface->init(ctx, &mr_cfg);
 
         if (res) {
-          const char *error_detail =
-            ctx->priv ? ctx->priv->err_detail : NULL;
+          const char *error_detail = ctx->priv ? ctx->priv->err_detail : NULL;
           /* Destroy current ctx */
           ctx->err_detail = error_detail;
           vpx_codec_destroy(ctx);
@@ -136,8 +126,7 @@ vpx_codec_err_t vpx_codec_enc_init_multi_ver(vpx_codec_ctx_t      *ctx,
           }
         }
 
-        if (res)
-          break;
+        if (res) break;
 
         ctx++;
         cfg++;
@@ -150,10 +139,9 @@ vpx_codec_err_t vpx_codec_enc_init_multi_ver(vpx_codec_ctx_t      *ctx,
   return SAVE_STATUS(ctx, res);
 }
 
-
-vpx_codec_err_t  vpx_codec_enc_config_default(vpx_codec_iface_t    *iface,
-                                              vpx_codec_enc_cfg_t  *cfg,
-                                              unsigned int          usage) {
+vpx_codec_err_t vpx_codec_enc_config_default(vpx_codec_iface_t *iface,
+                                             vpx_codec_enc_cfg_t *cfg,
+                                             unsigned int usage) {
   vpx_codec_err_t res;
   vpx_codec_enc_cfg_map_t *map;
   int i;
@@ -179,30 +167,28 @@ vpx_codec_err_t  vpx_codec_enc_config_default(vpx_codec_iface_t    *iface,
   return res;
 }
 
-
 #if ARCH_X86 || ARCH_X86_64
 /* On X86, disable the x87 unit's internal 80 bit precision for better
  * consistency with the SSE unit's 64 bit precision.
  */
 #include "vpx_ports/x86.h"
-#define FLOATING_POINT_INIT() do {\
+#define FLOATING_POINT_INIT() \
+  do {                        \
     unsigned short x87_orig_mode = x87_set_double_precision();
-#define FLOATING_POINT_RESTORE() \
-  x87_set_control_word(x87_orig_mode); }while(0)
-
+#define FLOATING_POINT_RESTORE()       \
+  x87_set_control_word(x87_orig_mode); \
+  }                                    \
+  while (0)
 
 #else
 static void FLOATING_POINT_INIT() {}
 static void FLOATING_POINT_RESTORE() {}
 #endif
 
-
-vpx_codec_err_t  vpx_codec_encode(vpx_codec_ctx_t            *ctx,
-                                  const vpx_image_t          *img,
-                                  vpx_codec_pts_t             pts,
-                                  unsigned long               duration,
-                                  vpx_enc_frame_flags_t       flags,
-                                  unsigned long               deadline) {
+vpx_codec_err_t vpx_codec_encode(vpx_codec_ctx_t *ctx, const vpx_image_t *img,
+                                 vpx_codec_pts_t pts, unsigned long duration,
+                                 vpx_enc_frame_flags_t flags,
+                                 unsigned long deadline) {
   vpx_codec_err_t res = VPX_CODEC_OK;
 
   if (!ctx || (img && !duration))
@@ -220,8 +206,8 @@ vpx_codec_err_t  vpx_codec_encode(vpx_codec_ctx_t            *ctx,
     FLOATING_POINT_INIT();
 
     if (num_enc == 1)
-      res = ctx->iface->enc.encode(get_alg_priv(ctx), img, pts,
-                                   duration, flags, deadline);
+      res = ctx->iface->enc.encode(get_alg_priv(ctx), img, pts, duration, flags,
+                                   deadline);
     else {
       /* Multi-resolution encoding:
        * Encode multi-levels in reverse order. For example,
@@ -234,8 +220,8 @@ vpx_codec_err_t  vpx_codec_encode(vpx_codec_ctx_t            *ctx,
       if (img) img += num_enc - 1;
 
       for (i = num_enc - 1; i >= 0; i--) {
-        if ((res = ctx->iface->enc.encode(get_alg_priv(ctx), img, pts,
-                                          duration, flags, deadline)))
+        if ((res = ctx->iface->enc.encode(get_alg_priv(ctx), img, pts, duration,
+                                          flags, deadline)))
           break;
 
         ctx--;
@@ -250,7 +236,6 @@ vpx_codec_err_t  vpx_codec_encode(vpx_codec_ctx_t            *ctx,
   return SAVE_STATUS(ctx, res);
 }
 
-
 const vpx_codec_cx_pkt_t *vpx_codec_get_cx_data(vpx_codec_ctx_t *ctx,
                                                 vpx_codec_iter_t *iter) {
   const vpx_codec_cx_pkt_t *pkt = NULL;
@@ -273,18 +258,18 @@ const vpx_codec_cx_pkt_t *vpx_codec_get_cx_data(vpx_codec_ctx_t *ctx,
     vpx_codec_priv_t *const priv = ctx->priv;
     char *const dst_buf = (char *)priv->enc.cx_data_dst_buf.buf;
 
-    if (dst_buf &&
-        pkt->data.raw.buf != dst_buf &&
+    if (dst_buf && pkt->data.raw.buf != dst_buf &&
         pkt->data.raw.sz + priv->enc.cx_data_pad_before +
-            priv->enc.cx_data_pad_after <= priv->enc.cx_data_dst_buf.sz) {
+                priv->enc.cx_data_pad_after <=
+            priv->enc.cx_data_dst_buf.sz) {
       vpx_codec_cx_pkt_t *modified_pkt = &priv->enc.cx_data_pkt;
 
       memcpy(dst_buf + priv->enc.cx_data_pad_before, pkt->data.raw.buf,
              pkt->data.raw.sz);
       *modified_pkt = *pkt;
       modified_pkt->data.raw.buf = dst_buf;
-      modified_pkt->data.raw.sz += priv->enc.cx_data_pad_before +
-                                       priv->enc.cx_data_pad_after;
+      modified_pkt->data.raw.sz +=
+          priv->enc.cx_data_pad_before + priv->enc.cx_data_pad_after;
       pkt = modified_pkt;
     }
 
@@ -297,13 +282,11 @@ const vpx_codec_cx_pkt_t *vpx_codec_get_cx_data(vpx_codec_ctx_t *ctx,
   return pkt;
 }
 
-
-vpx_codec_err_t vpx_codec_set_cx_data_buf(vpx_codec_ctx_t       *ctx,
+vpx_codec_err_t vpx_codec_set_cx_data_buf(vpx_codec_ctx_t *ctx,
                                           const vpx_fixed_buf_t *buf,
-                                          unsigned int           pad_before,
-                                          unsigned int           pad_after) {
-  if (!ctx || !ctx->priv)
-    return VPX_CODEC_INVALID_PARAM;
+                                          unsigned int pad_before,
+                                          unsigned int pad_after) {
+  if (!ctx || !ctx->priv) return VPX_CODEC_INVALID_PARAM;
 
   if (buf) {
     ctx->priv->enc.cx_data_dst_buf = *buf;
@@ -319,8 +302,7 @@ vpx_codec_err_t vpx_codec_set_cx_data_buf(vpx_codec_ctx_t       *ctx,
   return VPX_CODEC_OK;
 }
 
-
-const vpx_image_t *vpx_codec_get_preview_frame(vpx_codec_ctx_t   *ctx) {
+const vpx_image_t *vpx_codec_get_preview_frame(vpx_codec_ctx_t *ctx) {
   vpx_image_t *img = NULL;
 
   if (ctx) {
@@ -337,8 +319,7 @@ const vpx_image_t *vpx_codec_get_preview_frame(vpx_codec_ctx_t   *ctx) {
   return img;
 }
 
-
-vpx_fixed_buf_t *vpx_codec_get_global_headers(vpx_codec_ctx_t   *ctx) {
+vpx_fixed_buf_t *vpx_codec_get_global_headers(vpx_codec_ctx_t *ctx) {
   vpx_fixed_buf_t *buf = NULL;
 
   if (ctx) {
@@ -355,9 +336,8 @@ vpx_fixed_buf_t *vpx_codec_get_global_headers(vpx_codec_ctx_t   *ctx) {
   return buf;
 }
 
-
-vpx_codec_err_t  vpx_codec_enc_config_set(vpx_codec_ctx_t            *ctx,
-                                          const vpx_codec_enc_cfg_t  *cfg) {
+vpx_codec_err_t vpx_codec_enc_config_set(vpx_codec_ctx_t *ctx,
+                                         const vpx_codec_enc_cfg_t *cfg) {
   vpx_codec_err_t res;
 
   if (!ctx || !ctx->iface || !ctx->priv || !cfg)
@@ -370,7 +350,6 @@ vpx_codec_err_t  vpx_codec_enc_config_set(vpx_codec_ctx_t            *ctx,
   return SAVE_STATUS(ctx, res);
 }
 
-
 int vpx_codec_pkt_list_add(struct vpx_codec_pkt_list *list,
                            const struct vpx_codec_cx_pkt *pkt) {
   if (list->cnt < list->max) {
@@ -381,9 +360,8 @@ int vpx_codec_pkt_list_add(struct vpx_codec_pkt_list *list,
   return 1;
 }
 
-
-const vpx_codec_cx_pkt_t *vpx_codec_pkt_list_get(struct vpx_codec_pkt_list *list,
-                                                 vpx_codec_iter_t           *iter) {
+const vpx_codec_cx_pkt_t *vpx_codec_pkt_list_get(
+    struct vpx_codec_pkt_list *list, vpx_codec_iter_t *iter) {
   const vpx_codec_cx_pkt_t *pkt;
 
   if (!(*iter)) {
diff --git a/vpx/src/vpx_image.c b/vpx/src/vpx_image.c
index 9aae12c79..dba439c10 100644
--- a/vpx/src/vpx_image.c
+++ b/vpx/src/vpx_image.c
@@ -15,10 +15,8 @@
 #include "vpx/vpx_integer.h"
 #include "vpx_mem/vpx_mem.h"
 
-static vpx_image_t *img_alloc_helper(vpx_image_t *img,
-                                     vpx_img_fmt_t fmt,
-                                     unsigned int d_w,
-                                     unsigned int d_h,
+static vpx_image_t *img_alloc_helper(vpx_image_t *img, vpx_img_fmt_t fmt,
+                                     unsigned int d_w, unsigned int d_h,
                                      unsigned int buf_align,
                                      unsigned int stride_align,
                                      unsigned char *img_data) {
@@ -27,68 +25,44 @@ static vpx_image_t *img_alloc_helper(vpx_image_t *img,
   int align;
 
   /* Treat align==0 like align==1 */
-  if (!buf_align)
-    buf_align = 1;
+  if (!buf_align) buf_align = 1;
 
   /* Validate alignment (must be power of 2) */
-  if (buf_align & (buf_align - 1))
-    goto fail;
+  if (buf_align & (buf_align - 1)) goto fail;
 
   /* Treat align==0 like align==1 */
-  if (!stride_align)
-    stride_align = 1;
+  if (!stride_align) stride_align = 1;
 
   /* Validate alignment (must be power of 2) */
-  if (stride_align & (stride_align - 1))
-    goto fail;
+  if (stride_align & (stride_align - 1)) goto fail;
 
   /* Get sample size for this format */
   switch (fmt) {
     case VPX_IMG_FMT_RGB32:
     case VPX_IMG_FMT_RGB32_LE:
     case VPX_IMG_FMT_ARGB:
-    case VPX_IMG_FMT_ARGB_LE:
-      bps = 32;
-      break;
+    case VPX_IMG_FMT_ARGB_LE: bps = 32; break;
     case VPX_IMG_FMT_RGB24:
-    case VPX_IMG_FMT_BGR24:
-      bps = 24;
-      break;
+    case VPX_IMG_FMT_BGR24: bps = 24; break;
     case VPX_IMG_FMT_RGB565:
     case VPX_IMG_FMT_RGB565_LE:
     case VPX_IMG_FMT_RGB555:
     case VPX_IMG_FMT_RGB555_LE:
     case VPX_IMG_FMT_UYVY:
     case VPX_IMG_FMT_YUY2:
-    case VPX_IMG_FMT_YVYU:
-      bps = 16;
-      break;
+    case VPX_IMG_FMT_YVYU: bps = 16; break;
     case VPX_IMG_FMT_I420:
     case VPX_IMG_FMT_YV12:
     case VPX_IMG_FMT_VPXI420:
-    case VPX_IMG_FMT_VPXYV12:
-      bps = 12;
-      break;
+    case VPX_IMG_FMT_VPXYV12: bps = 12; break;
     case VPX_IMG_FMT_I422:
-    case VPX_IMG_FMT_I440:
-      bps = 16;
-      break;
-    case VPX_IMG_FMT_I444:
-      bps = 24;
-      break;
-    case VPX_IMG_FMT_I42016:
-      bps = 24;
-      break;
+    case VPX_IMG_FMT_I440: bps = 16; break;
+    case VPX_IMG_FMT_I444: bps = 24; break;
+    case VPX_IMG_FMT_I42016: bps = 24; break;
     case VPX_IMG_FMT_I42216:
-    case VPX_IMG_FMT_I44016:
-      bps = 32;
-      break;
-    case VPX_IMG_FMT_I44416:
-      bps = 48;
-      break;
-    default:
-      bps = 16;
-      break;
+    case VPX_IMG_FMT_I44016: bps = 32; break;
+    case VPX_IMG_FMT_I44416: bps = 48; break;
+    default: bps = 16; break;
   }
 
   /* Get chroma shift values for this format */
@@ -99,12 +73,8 @@ static vpx_image_t *img_alloc_helper(vpx_image_t *img,
     case VPX_IMG_FMT_VPXYV12:
     case VPX_IMG_FMT_I422:
     case VPX_IMG_FMT_I42016:
-    case VPX_IMG_FMT_I42216:
-      xcs = 1;
-      break;
-    default:
-      xcs = 0;
-      break;
+    case VPX_IMG_FMT_I42216: xcs = 1; break;
+    default: xcs = 0; break;
   }
 
   switch (fmt) {
@@ -114,12 +84,8 @@ static vpx_image_t *img_alloc_helper(vpx_image_t *img,
     case VPX_IMG_FMT_VPXI420:
     case VPX_IMG_FMT_VPXYV12:
     case VPX_IMG_FMT_I42016:
-    case VPX_IMG_FMT_I44016:
-      ycs = 1;
-      break;
-    default:
-      ycs = 0;
-      break;
+    case VPX_IMG_FMT_I44016: ycs = 1; break;
+    default: ycs = 0; break;
   }
 
   /* Calculate storage sizes given the chroma subsampling */
@@ -135,8 +101,7 @@ static vpx_image_t *img_alloc_helper(vpx_image_t *img,
   if (!img) {
     img = (vpx_image_t *)calloc(1, sizeof(vpx_image_t));
 
-    if (!img)
-      goto fail;
+    if (!img) goto fail;
 
     img->self_allocd = 1;
   } else {
@@ -146,18 +111,17 @@ static vpx_image_t *img_alloc_helper(vpx_image_t *img,
   img->img_data = img_data;
 
   if (!img_data) {
-    const uint64_t alloc_size = (fmt & VPX_IMG_FMT_PLANAR) ?
-                                (uint64_t)h * s * bps / 8 : (uint64_t)h * s;
+    const uint64_t alloc_size = (fmt & VPX_IMG_FMT_PLANAR)
+                                    ? (uint64_t)h * s * bps / 8
+                                    : (uint64_t)h * s;
 
-    if (alloc_size != (size_t)alloc_size)
-      goto fail;
+    if (alloc_size != (size_t)alloc_size) goto fail;
 
     img->img_data = (uint8_t *)vpx_memalign(buf_align, (size_t)alloc_size);
     img->img_data_owner = 1;
   }
 
-  if (!img->img_data)
-    goto fail;
+  if (!img->img_data) goto fail;
 
   img->fmt = fmt;
   img->bit_depth = (fmt & VPX_IMG_FMT_HIGHBITDEPTH) ? 16 : 8;
@@ -172,39 +136,30 @@ static vpx_image_t *img_alloc_helper(vpx_image_t *img,
   img->stride[VPX_PLANE_U] = img->stride[VPX_PLANE_V] = stride_in_bytes >> xcs;
 
   /* Default viewport to entire image */
-  if (!vpx_img_set_rect(img, 0, 0, d_w, d_h))
-    return img;
+  if (!vpx_img_set_rect(img, 0, 0, d_w, d_h)) return img;
 
 fail:
   vpx_img_free(img);
   return NULL;
 }
 
-vpx_image_t *vpx_img_alloc(vpx_image_t  *img,
-                           vpx_img_fmt_t fmt,
-                           unsigned int  d_w,
-                           unsigned int  d_h,
-                           unsigned int  align) {
+vpx_image_t *vpx_img_alloc(vpx_image_t *img, vpx_img_fmt_t fmt,
+                           unsigned int d_w, unsigned int d_h,
+                           unsigned int align) {
   return img_alloc_helper(img, fmt, d_w, d_h, align, align, NULL);
 }
 
-vpx_image_t *vpx_img_wrap(vpx_image_t  *img,
-                          vpx_img_fmt_t fmt,
-                          unsigned int  d_w,
-                          unsigned int  d_h,
-                          unsigned int  stride_align,
-                          unsigned char       *img_data) {
+vpx_image_t *vpx_img_wrap(vpx_image_t *img, vpx_img_fmt_t fmt, unsigned int d_w,
+                          unsigned int d_h, unsigned int stride_align,
+                          unsigned char *img_data) {
   /* By setting buf_align = 1, we don't change buffer alignment in this
    * function. */
   return img_alloc_helper(img, fmt, d_w, d_h, 1, stride_align, img_data);
 }
 
-int vpx_img_set_rect(vpx_image_t  *img,
-                     unsigned int  x,
-                     unsigned int  y,
-                     unsigned int  w,
-                     unsigned int  h) {
-  unsigned char      *data;
+int vpx_img_set_rect(vpx_image_t *img, unsigned int x, unsigned int y,
+                     unsigned int w, unsigned int h) {
+  unsigned char *data;
 
   if (x + w <= img->w && y + h <= img->h) {
     img->d_w = w;
@@ -213,7 +168,7 @@ int vpx_img_set_rect(vpx_image_t  *img,
     /* Calculate plane pointers */
     if (!(img->fmt & VPX_IMG_FMT_PLANAR)) {
       img->planes[VPX_PLANE_PACKED] =
-        img->img_data + x * img->bps / 8 + y * img->stride[VPX_PLANE_PACKED];
+          img->img_data + x * img->bps / 8 + y * img->stride[VPX_PLANE_PACKED];
     } else {
       const int bytes_per_sample =
           (img->fmt & VPX_IMG_FMT_HIGHBITDEPTH) ? 2 : 1;
@@ -225,8 +180,8 @@ int vpx_img_set_rect(vpx_image_t  *img,
         data += img->h * img->stride[VPX_PLANE_ALPHA];
       }
 
-      img->planes[VPX_PLANE_Y] = data + x * bytes_per_sample +
-          y * img->stride[VPX_PLANE_Y];
+      img->planes[VPX_PLANE_Y] =
+          data + x * bytes_per_sample + y * img->stride[VPX_PLANE_Y];
       data += img->h * img->stride[VPX_PLANE_Y];
 
       if (!(img->fmt & VPX_IMG_FMT_UV_FLIP)) {
@@ -262,24 +217,23 @@ void vpx_img_flip(vpx_image_t *img) {
   img->planes[VPX_PLANE_Y] += (signed)(img->d_h - 1) * img->stride[VPX_PLANE_Y];
   img->stride[VPX_PLANE_Y] = -img->stride[VPX_PLANE_Y];
 
-  img->planes[VPX_PLANE_U] += (signed)((img->d_h >> img->y_chroma_shift) - 1)
-                              * img->stride[VPX_PLANE_U];
+  img->planes[VPX_PLANE_U] += (signed)((img->d_h >> img->y_chroma_shift) - 1) *
+                              img->stride[VPX_PLANE_U];
   img->stride[VPX_PLANE_U] = -img->stride[VPX_PLANE_U];
 
-  img->planes[VPX_PLANE_V] += (signed)((img->d_h >> img->y_chroma_shift) - 1)
-                              * img->stride[VPX_PLANE_V];
+  img->planes[VPX_PLANE_V] += (signed)((img->d_h >> img->y_chroma_shift) - 1) *
+                              img->stride[VPX_PLANE_V];
   img->stride[VPX_PLANE_V] = -img->stride[VPX_PLANE_V];
 
-  img->planes[VPX_PLANE_ALPHA] += (signed)(img->d_h - 1) * img->stride[VPX_PLANE_ALPHA];
+  img->planes[VPX_PLANE_ALPHA] +=
+      (signed)(img->d_h - 1) * img->stride[VPX_PLANE_ALPHA];
   img->stride[VPX_PLANE_ALPHA] = -img->stride[VPX_PLANE_ALPHA];
 }
 
 void vpx_img_free(vpx_image_t *img) {
   if (img) {
-    if (img->img_data && img->img_data_owner)
-      vpx_free(img->img_data);
+    if (img->img_data && img->img_data_owner) vpx_free(img->img_data);
 
-    if (img->self_allocd)
-      free(img);
+    if (img->self_allocd) free(img);
   }
 }
diff --git a/vpx/svc_context.h b/vpx/svc_context.h
index 5bc25189b..c8bde5832 100644
--- a/vpx/svc_context.h
+++ b/vpx/svc_context.h
@@ -31,14 +31,14 @@ typedef enum SVC_LOG_LEVEL {
 
 typedef struct {
   // public interface to svc_command options
-  int spatial_layers;               // number of spatial layers
-  int temporal_layers;               // number of temporal layers
+  int spatial_layers;   // number of spatial layers
+  int temporal_layers;  // number of temporal layers
   int temporal_layering_mode;
   SVC_LOG_LEVEL log_level;  // amount of information to display
-  int log_print;  // when set, printf log messages instead of returning the
-                  // message with svc_get_message
+  int log_print;       // when set, printf log messages instead of returning the
+                       // message with svc_get_message
   int output_rc_stat;  // for outputting rc stats
-  int speed;  // speed setting for codec
+  int speed;           // speed setting for codec
   int threads;
   int aqmode;  // turns on aq-mode=3 (cyclic_refresh): 0=off, 1=on.
   // private storage for vpx_svc_encode
@@ -49,7 +49,7 @@ typedef struct {
 #define COMPONENTS 4  // psnr & sse statistics maintained for total, y, u, v
 
 typedef struct SvcInternal {
-  char options[OPTION_BUFFER_SIZE];        // set by vpx_svc_set_options
+  char options[OPTION_BUFFER_SIZE];  // set by vpx_svc_set_options
 
   // values extracted from option, quantizers
   vpx_svc_extra_cfg_t svc_params;
@@ -57,7 +57,7 @@ typedef struct SvcInternal {
   int bitrates[VPX_SS_MAX_LAYERS];
 
   // accumulated statistics
-  double psnr_sum[VPX_SS_MAX_LAYERS][COMPONENTS];   // total/Y/U/V
+  double psnr_sum[VPX_SS_MAX_LAYERS][COMPONENTS];  // total/Y/U/V
   uint64_t sse_sum[VPX_SS_MAX_LAYERS][COMPONENTS];
   uint32_t bytes_sum[VPX_SS_MAX_LAYERS];
 
@@ -88,17 +88,14 @@ vpx_codec_err_t vpx_svc_set_options(SvcContext *svc_ctx, const char *options);
 /**
  * initialize SVC encoding
  */
-vpx_codec_err_t vpx_svc_init(SvcContext *svc_ctx,
-                             vpx_codec_ctx_t *codec_ctx,
+vpx_codec_err_t vpx_svc_init(SvcContext *svc_ctx, vpx_codec_ctx_t *codec_ctx,
                              vpx_codec_iface_t *iface,
                              vpx_codec_enc_cfg_t *cfg);
 /**
  * encode a frame of video with multiple layers
  */
-vpx_codec_err_t vpx_svc_encode(SvcContext *svc_ctx,
-                               vpx_codec_ctx_t *codec_ctx,
-                               struct vpx_image *rawimg,
-                               vpx_codec_pts_t pts,
+vpx_codec_err_t vpx_svc_encode(SvcContext *svc_ctx, vpx_codec_ctx_t *codec_ctx,
+                               struct vpx_image *rawimg, vpx_codec_pts_t pts,
                                int64_t duration, int deadline);
 
 /**
diff --git a/vpx/vp8.h b/vpx/vp8.h
index 8a035f977..c3eb5265a 100644
--- a/vpx/vp8.h
+++ b/vpx/vp8.h
@@ -42,21 +42,24 @@ extern "C" {
  * The set of macros define the control functions of VP8 interface
  */
 enum vp8_com_control_id {
-  VP8_SET_REFERENCE           = 1,    /**< pass in an external frame into decoder to be used as reference frame */
-  VP8_COPY_REFERENCE          = 2,    /**< get a copy of reference frame from the decoder */
-  VP8_SET_POSTPROC            = 3,    /**< set the decoder's post processing settings  */
-  VP8_SET_DBG_COLOR_REF_FRAME = 4,    /**< set the reference frames to color for each macroblock */
-  VP8_SET_DBG_COLOR_MB_MODES  = 5,    /**< set which macro block modes to color */
-  VP8_SET_DBG_COLOR_B_MODES   = 6,    /**< set which blocks modes to color */
-  VP8_SET_DBG_DISPLAY_MV      = 7,    /**< set which motion vector modes to draw */
+  /*!\brief pass in an external frame into decoder to be used as reference frame
+   */
+  VP8_SET_REFERENCE = 1,
+  VP8_COPY_REFERENCE = 2, /**< get a copy of reference frame from the decoder */
+  VP8_SET_POSTPROC = 3,   /**< set the decoder's post processing settings  */
+  VP8_SET_DBG_COLOR_REF_FRAME =
+      4, /**< set the reference frames to color for each macroblock */
+  VP8_SET_DBG_COLOR_MB_MODES = 5, /**< set which macro block modes to color */
+  VP8_SET_DBG_COLOR_B_MODES = 6,  /**< set which blocks modes to color */
+  VP8_SET_DBG_DISPLAY_MV = 7,     /**< set which motion vector modes to draw */
 
   /* TODO(jkoleszar): The encoder incorrectly reuses some of these values (5+)
    * for its control ids. These should be migrated to something like the
    * VP8_DECODER_CTRL_ID_START range next time we're ready to break the ABI.
    */
-  VP9_GET_REFERENCE           = 128,  /**< get a pointer to a reference frame */
+  VP9_GET_REFERENCE = 128, /**< get a pointer to a reference frame */
   VP8_COMMON_CTRL_ID_MAX,
-  VP8_DECODER_CTRL_ID_START   = 256
+  VP8_DECODER_CTRL_ID_START = 256
 };
 
 /*!\brief post process flags
@@ -64,15 +67,16 @@ enum vp8_com_control_id {
  * The set of macros define VP8 decoder post processing flags
  */
 enum vp8_postproc_level {
-  VP8_NOFILTERING             = 0,
-  VP8_DEBLOCK                 = 1 << 0,
-  VP8_DEMACROBLOCK            = 1 << 1,
-  VP8_ADDNOISE                = 1 << 2,
-  VP8_DEBUG_TXT_FRAME_INFO    = 1 << 3, /**< print frame information */
-  VP8_DEBUG_TXT_MBLK_MODES    = 1 << 4, /**< print macro block modes over each macro block */
-  VP8_DEBUG_TXT_DC_DIFF       = 1 << 5, /**< print dc diff for each macro block */
-  VP8_DEBUG_TXT_RATE_INFO     = 1 << 6, /**< print video rate info (encoder only) */
-  VP8_MFQE                    = 1 << 10
+  VP8_NOFILTERING = 0,
+  VP8_DEBLOCK = 1 << 0,
+  VP8_DEMACROBLOCK = 1 << 1,
+  VP8_ADDNOISE = 1 << 2,
+  VP8_DEBUG_TXT_FRAME_INFO = 1 << 3, /**< print frame information */
+  VP8_DEBUG_TXT_MBLK_MODES =
+      1 << 4, /**< print macro block modes over each macro block */
+  VP8_DEBUG_TXT_DC_DIFF = 1 << 5,   /**< print dc diff for each macro block */
+  VP8_DEBUG_TXT_RATE_INFO = 1 << 6, /**< print video rate info (encoder only) */
+  VP8_MFQE = 1 << 10
 };
 
 /*!\brief post process flags
@@ -83,9 +87,11 @@ enum vp8_postproc_level {
  */
 
 typedef struct vp8_postproc_cfg {
-  int post_proc_flag;         /**< the types of post processing to be done, should be combination of "vp8_postproc_level" */
-  int deblocking_level;       /**< the strength of deblocking, valid range [0, 16] */
-  int noise_level;            /**< the strength of additive noise, valid range [0, 16] */
+  /*!\brief the types of post processing to be done, should be combination of
+   * "vp8_postproc_level" */
+  int post_proc_flag;
+  int deblocking_level; /**< the strength of deblocking, valid range [0, 16] */
+  int noise_level; /**< the strength of additive noise, valid range [0, 16] */
 } vp8_postproc_cfg_t;
 
 /*!\brief reference frame type
@@ -103,8 +109,8 @@ typedef enum vpx_ref_frame_type {
  * Define the data struct to access vp8 reference frames.
  */
 typedef struct vpx_ref_frame {
-  vpx_ref_frame_type_t  frame_type;   /**< which reference frame */
-  vpx_image_t           img;          /**< reference frame data in image format */
+  vpx_ref_frame_type_t frame_type; /**< which reference frame */
+  vpx_image_t img;                 /**< reference frame data in image format */
 } vpx_ref_frame_t;
 
 /*!\brief VP9 specific reference frame data struct
@@ -112,8 +118,8 @@ typedef struct vpx_ref_frame {
  * Define the data struct to access vp9 reference frames.
  */
 typedef struct vp9_ref_frame {
-  int idx; /**< frame index to get (input) */
-  vpx_image_t  img; /**< img structure to populate (output) */
+  int idx;         /**< frame index to get (input) */
+  vpx_image_t img; /**< img structure to populate (output) */
 } vp9_ref_frame_t;
 
 /*!\cond */
@@ -121,21 +127,21 @@ typedef struct vp9_ref_frame {
  *
  * defines the data type for each of VP8 decoder control function requires
  */
-VPX_CTRL_USE_TYPE(VP8_SET_REFERENCE,           vpx_ref_frame_t *)
+VPX_CTRL_USE_TYPE(VP8_SET_REFERENCE, vpx_ref_frame_t *)
 #define VPX_CTRL_VP8_SET_REFERENCE
-VPX_CTRL_USE_TYPE(VP8_COPY_REFERENCE,          vpx_ref_frame_t *)
+VPX_CTRL_USE_TYPE(VP8_COPY_REFERENCE, vpx_ref_frame_t *)
 #define VPX_CTRL_VP8_COPY_REFERENCE
-VPX_CTRL_USE_TYPE(VP8_SET_POSTPROC,            vp8_postproc_cfg_t *)
+VPX_CTRL_USE_TYPE(VP8_SET_POSTPROC, vp8_postproc_cfg_t *)
 #define VPX_CTRL_VP8_SET_POSTPROC
 VPX_CTRL_USE_TYPE(VP8_SET_DBG_COLOR_REF_FRAME, int)
 #define VPX_CTRL_VP8_SET_DBG_COLOR_REF_FRAME
-VPX_CTRL_USE_TYPE(VP8_SET_DBG_COLOR_MB_MODES,  int)
+VPX_CTRL_USE_TYPE(VP8_SET_DBG_COLOR_MB_MODES, int)
 #define VPX_CTRL_VP8_SET_DBG_COLOR_MB_MODES
-VPX_CTRL_USE_TYPE(VP8_SET_DBG_COLOR_B_MODES,   int)
+VPX_CTRL_USE_TYPE(VP8_SET_DBG_COLOR_B_MODES, int)
 #define VPX_CTRL_VP8_SET_DBG_COLOR_B_MODES
-VPX_CTRL_USE_TYPE(VP8_SET_DBG_DISPLAY_MV,      int)
+VPX_CTRL_USE_TYPE(VP8_SET_DBG_DISPLAY_MV, int)
 #define VPX_CTRL_VP8_SET_DBG_DISPLAY_MV
-VPX_CTRL_USE_TYPE(VP9_GET_REFERENCE,           vp9_ref_frame_t *)
+VPX_CTRL_USE_TYPE(VP9_GET_REFERENCE, vp9_ref_frame_t *)
 #define VPX_CTRL_VP9_GET_REFERENCE
 
 /*!\endcond */
diff --git a/vpx/vp8cx.h b/vpx/vp8cx.h
index 61882e650..a28cb5e7a 100644
--- a/vpx/vp8cx.h
+++ b/vpx/vp8cx.h
@@ -32,7 +32,7 @@ extern "C" {
  * This interface provides the capability to encode raw VP8 streams.
  * @{
  */
-extern vpx_codec_iface_t  vpx_codec_vp8_cx_algo;
+extern vpx_codec_iface_t vpx_codec_vp8_cx_algo;
 extern vpx_codec_iface_t *vpx_codec_vp8_cx(void);
 /*!@} - end algorithm interface member group*/
 
@@ -41,7 +41,7 @@ extern vpx_codec_iface_t *vpx_codec_vp8_cx(void);
  * This interface provides the capability to encode raw VP9 streams.
  * @{
  */
-extern vpx_codec_iface_t  vpx_codec_vp9_cx_algo;
+extern vpx_codec_iface_t vpx_codec_vp9_cx_algo;
 extern vpx_codec_iface_t *vpx_codec_vp9_cx(void);
 /*!@} - end algorithm interface member group*/
 
@@ -55,8 +55,7 @@ extern vpx_codec_iface_t *vpx_codec_vp9_cx(void);
  * predictor. When not set, the encoder will choose whether to use the
  * last frame or not automatically.
  */
-#define VP8_EFLAG_NO_REF_LAST      (1<<16)
-
+#define VP8_EFLAG_NO_REF_LAST (1 << 16)
 
 /*!\brief Don't reference the golden frame
  *
@@ -64,8 +63,7 @@ extern vpx_codec_iface_t *vpx_codec_vp9_cx(void);
  * predictor. When not set, the encoder will choose whether to use the
  * golden frame or not automatically.
  */
-#define VP8_EFLAG_NO_REF_GF        (1<<17)
-
+#define VP8_EFLAG_NO_REF_GF (1 << 17)
 
 /*!\brief Don't reference the alternate reference frame
  *
@@ -73,56 +71,49 @@ extern vpx_codec_iface_t *vpx_codec_vp9_cx(void);
  * predictor. When not set, the encoder will choose whether to use the
  * alt ref frame or not automatically.
  */
-#define VP8_EFLAG_NO_REF_ARF       (1<<21)
-
+#define VP8_EFLAG_NO_REF_ARF (1 << 21)
 
 /*!\brief Don't update the last frame
  *
  * When this flag is set, the encoder will not update the last frame with
  * the contents of the current frame.
  */
-#define VP8_EFLAG_NO_UPD_LAST      (1<<18)
-
+#define VP8_EFLAG_NO_UPD_LAST (1 << 18)
 
 /*!\brief Don't update the golden frame
  *
  * When this flag is set, the encoder will not update the golden frame with
  * the contents of the current frame.
  */
-#define VP8_EFLAG_NO_UPD_GF        (1<<22)
-
+#define VP8_EFLAG_NO_UPD_GF (1 << 22)
 
 /*!\brief Don't update the alternate reference frame
  *
  * When this flag is set, the encoder will not update the alt ref frame with
  * the contents of the current frame.
  */
-#define VP8_EFLAG_NO_UPD_ARF       (1<<23)
-
+#define VP8_EFLAG_NO_UPD_ARF (1 << 23)
 
 /*!\brief Force golden frame update
  *
  * When this flag is set, the encoder copy the contents of the current frame
  * to the golden frame buffer.
  */
-#define VP8_EFLAG_FORCE_GF         (1<<19)
-
+#define VP8_EFLAG_FORCE_GF (1 << 19)
 
 /*!\brief Force alternate reference frame update
  *
  * When this flag is set, the encoder copy the contents of the current frame
  * to the alternate reference frame buffer.
  */
-#define VP8_EFLAG_FORCE_ARF        (1<<24)
-
+#define VP8_EFLAG_FORCE_ARF (1 << 24)
 
 /*!\brief Disable entropy update
  *
  * When this flag is set, the encoder will not update its internal entropy
  * model based on the entropy of this frame.
  */
-#define VP8_EFLAG_NO_UPD_ENTROPY   (1<<20)
-
+#define VP8_EFLAG_NO_UPD_ENTROPY (1 << 20)
 
 /*!\brief VPx encoder control functions
  *
@@ -136,7 +127,7 @@ enum vp8e_enc_control_id {
    *
    * Supported in codecs: VP8, VP9
    */
-  VP8E_SET_ROI_MAP           = 8,
+  VP8E_SET_ROI_MAP = 8,
 
   /*!\brief Codec control function to pass an Active map to encoder.
    *
@@ -148,7 +139,7 @@ enum vp8e_enc_control_id {
    *
    * Supported in codecs: VP8, VP9
    */
-  VP8E_SET_SCALEMODE         = 11,
+  VP8E_SET_SCALEMODE = 11,
 
   /*!\brief Codec control function to set encoder internal speed settings.
    *
@@ -161,7 +152,7 @@ enum vp8e_enc_control_id {
    *
    * Supported in codecs: VP8, VP9
    */
-  VP8E_SET_CPUUSED           = 13,
+  VP8E_SET_CPUUSED = 13,
 
   /*!\brief Codec control function to enable automatic set and use alf frames.
    *
@@ -489,7 +480,8 @@ enum vp8e_enc_control_id {
   VP9E_SET_COLOR_SPACE,
 
   /*!\brief Codec control function to set temporal layering mode.
-   * \note Valid ranges: 0..3, default is "0" (VP9E_TEMPORAL_LAYERING_MODE_NOLAYERING).
+   * \note Valid ranges: 0..3, default is "0"
+   * (VP9E_TEMPORAL_LAYERING_MODE_NOLAYERING).
    *                     0 = VP9E_TEMPORAL_LAYERING_MODE_NOLAYERING
    *                     1 = VP9E_TEMPORAL_LAYERING_MODE_BYPASS
    *                     2 = VP9E_TEMPORAL_LAYERING_MODE_0101
@@ -567,10 +559,10 @@ enum vp8e_enc_control_id {
  * This set of constants define 1-D vpx scaling modes
  */
 typedef enum vpx_scaling_mode_1d {
-  VP8E_NORMAL      = 0,
-  VP8E_FOURFIVE    = 1,
-  VP8E_THREEFIVE   = 2,
-  VP8E_ONETWO      = 3
+  VP8E_NORMAL = 0,
+  VP8E_FOURFIVE = 1,
+  VP8E_THREEFIVE = 2,
+  VP8E_ONETWO = 3
 } VPX_SCALING_MODE;
 
 /*!\brief Temporal layering mode enum for VP9 SVC.
@@ -583,21 +575,21 @@ typedef enum vp9e_temporal_layering_mode {
   /*!\brief No temporal layering.
    * Used when only spatial layering is used.
    */
-  VP9E_TEMPORAL_LAYERING_MODE_NOLAYERING   = 0,
+  VP9E_TEMPORAL_LAYERING_MODE_NOLAYERING = 0,
 
   /*!\brief Bypass mode.
    * Used when application needs to control temporal layering.
    * This will only work when the number of spatial layers equals 1.
    */
-  VP9E_TEMPORAL_LAYERING_MODE_BYPASS       = 1,
+  VP9E_TEMPORAL_LAYERING_MODE_BYPASS = 1,
 
   /*!\brief 0-1-0-1... temporal layering scheme with two temporal layers.
    */
-  VP9E_TEMPORAL_LAYERING_MODE_0101         = 2,
+  VP9E_TEMPORAL_LAYERING_MODE_0101 = 2,
 
   /*!\brief 0-2-1-2... temporal layering scheme with three temporal layers.
    */
-  VP9E_TEMPORAL_LAYERING_MODE_0212         = 3
+  VP9E_TEMPORAL_LAYERING_MODE_0212 = 3
 } VP9E_TEMPORAL_LAYERING_MODE;
 
 /*!\brief  vpx region of interest map
@@ -609,13 +601,13 @@ typedef enum vp9e_temporal_layering_mode {
 typedef struct vpx_roi_map {
   /*! An id between 0 and 3 for each 16x16 region within a frame. */
   unsigned char *roi_map;
-  unsigned int rows;       /**< Number of rows. */
-  unsigned int cols;       /**< Number of columns. */
+  unsigned int rows; /**< Number of rows. */
+  unsigned int cols; /**< Number of columns. */
   // TODO(paulwilkins): broken for VP9 which has 8 segments
   // q and loop filter deltas for each segment
   // (see MAX_MB_SEGMENTS)
-  int delta_q[4];          /**< Quantizer deltas. */
-  int delta_lf[4];         /**< Loop filter deltas. */
+  int delta_q[4];  /**< Quantizer deltas. */
+  int delta_lf[4]; /**< Loop filter deltas. */
   /*! Static breakout threshold for each segment. */
   unsigned int static_threshold[4];
 } vpx_roi_map_t;
@@ -626,11 +618,11 @@ typedef struct vpx_roi_map {
  *
  */
 
-
 typedef struct vpx_active_map {
-  unsigned char  *active_map; /**< specify an on (1) or off (0) each 16x16 region within a frame */
-  unsigned int    rows;       /**< number of rows */
-  unsigned int    cols;       /**< number of cols */
+  /*!\brief specify an on (1) or off (0) each 16x16 region within a frame */
+  unsigned char *active_map;
+  unsigned int rows; /**< number of rows */
+  unsigned int cols; /**< number of cols */
 } vpx_active_map_t;
 
 /*!\brief  vpx image scaling mode
@@ -639,8 +631,8 @@ typedef struct vpx_active_map {
  *
  */
 typedef struct vpx_scaling_mode {
-  VPX_SCALING_MODE    h_scaling_mode;  /**< horizontal scaling mode */
-  VPX_SCALING_MODE    v_scaling_mode;  /**< vertical scaling mode   */
+  VPX_SCALING_MODE h_scaling_mode; /**< horizontal scaling mode */
+  VPX_SCALING_MODE v_scaling_mode; /**< vertical scaling mode   */
 } vpx_scaling_mode_t;
 
 /*!\brief VP8 token partition mode
@@ -651,9 +643,9 @@ typedef struct vpx_scaling_mode {
  */
 
 typedef enum {
-  VP8_ONE_TOKENPARTITION   = 0,
-  VP8_TWO_TOKENPARTITION   = 1,
-  VP8_FOUR_TOKENPARTITION  = 2,
+  VP8_ONE_TOKENPARTITION = 0,
+  VP8_TWO_TOKENPARTITION = 1,
+  VP8_FOUR_TOKENPARTITION = 2,
   VP8_EIGHT_TOKENPARTITION = 3
 } vp8e_token_partitions;
 
@@ -669,10 +661,7 @@ typedef enum {
  * Changes the encoder to tune for certain types of input material.
  *
  */
-typedef enum {
-  VP8_TUNE_PSNR,
-  VP8_TUNE_SSIM
-} vp8e_tuning;
+typedef enum { VP8_TUNE_PSNR, VP8_TUNE_SSIM } vp8e_tuning;
 
 /*!\brief  vp9 svc layer parameters
  *
@@ -682,8 +671,8 @@ typedef enum {
  *
  */
 typedef struct vpx_svc_layer_id {
-  int spatial_layer_id;       /**< Spatial layer id number. */
-  int temporal_layer_id;      /**< Temporal layer id number. */
+  int spatial_layer_id;  /**< Spatial layer id number. */
+  int temporal_layer_id; /**< Temporal layer id number. */
 } vpx_svc_layer_id_t;
 
 /*!\brief  vp9 svc frame flag parameters.
@@ -695,7 +684,7 @@ typedef struct vpx_svc_layer_id {
  *
  */
 typedef struct vpx_svc_ref_frame_config {
-  int frame_flags[VPX_TS_MAX_LAYERS];  /**< Frame flags. */
+  int frame_flags[VPX_TS_MAX_LAYERS]; /**< Frame flags. */
   int lst_fb_idx[VPX_TS_MAX_LAYERS];  /**< Last buffer index. */
   int gld_fb_idx[VPX_TS_MAX_LAYERS];  /**< Golden buffer index. */
   int alt_fb_idx[VPX_TS_MAX_LAYERS];  /**< Altref buffer index. */
@@ -709,60 +698,60 @@ typedef struct vpx_svc_ref_frame_config {
  *
  */
 
-VPX_CTRL_USE_TYPE(VP8E_SET_FRAME_FLAGS,        int)
+VPX_CTRL_USE_TYPE(VP8E_SET_FRAME_FLAGS, int)
 #define VPX_CTRL_VP8E_SET_FRAME_FLAGS
-VPX_CTRL_USE_TYPE(VP8E_SET_TEMPORAL_LAYER_ID,  int)
+VPX_CTRL_USE_TYPE(VP8E_SET_TEMPORAL_LAYER_ID, int)
 #define VPX_CTRL_VP8E_SET_TEMPORAL_LAYER_ID
-VPX_CTRL_USE_TYPE(VP8E_SET_ROI_MAP,            vpx_roi_map_t *)
+VPX_CTRL_USE_TYPE(VP8E_SET_ROI_MAP, vpx_roi_map_t *)
 #define VPX_CTRL_VP8E_SET_ROI_MAP
-VPX_CTRL_USE_TYPE(VP8E_SET_ACTIVEMAP,          vpx_active_map_t *)
+VPX_CTRL_USE_TYPE(VP8E_SET_ACTIVEMAP, vpx_active_map_t *)
 #define VPX_CTRL_VP8E_SET_ACTIVEMAP
-VPX_CTRL_USE_TYPE(VP8E_SET_SCALEMODE,          vpx_scaling_mode_t *)
+VPX_CTRL_USE_TYPE(VP8E_SET_SCALEMODE, vpx_scaling_mode_t *)
 #define VPX_CTRL_VP8E_SET_SCALEMODE
 
-VPX_CTRL_USE_TYPE(VP9E_SET_SVC,                int)
+VPX_CTRL_USE_TYPE(VP9E_SET_SVC, int)
 #define VPX_CTRL_VP9E_SET_SVC
-VPX_CTRL_USE_TYPE(VP9E_SET_SVC_PARAMETERS,     void *)
+VPX_CTRL_USE_TYPE(VP9E_SET_SVC_PARAMETERS, void *)
 #define VPX_CTRL_VP9E_SET_SVC_PARAMETERS
-VPX_CTRL_USE_TYPE(VP9E_REGISTER_CX_CALLBACK,   void *)
+VPX_CTRL_USE_TYPE(VP9E_REGISTER_CX_CALLBACK, void *)
 #define VPX_CTRL_VP9E_REGISTER_CX_CALLBACK
-VPX_CTRL_USE_TYPE(VP9E_SET_SVC_LAYER_ID,       vpx_svc_layer_id_t *)
+VPX_CTRL_USE_TYPE(VP9E_SET_SVC_LAYER_ID, vpx_svc_layer_id_t *)
 #define VPX_CTRL_VP9E_SET_SVC_LAYER_ID
 
-VPX_CTRL_USE_TYPE(VP8E_SET_CPUUSED,            int)
+VPX_CTRL_USE_TYPE(VP8E_SET_CPUUSED, int)
 #define VPX_CTRL_VP8E_SET_CPUUSED
-VPX_CTRL_USE_TYPE(VP8E_SET_ENABLEAUTOALTREF,   unsigned int)
+VPX_CTRL_USE_TYPE(VP8E_SET_ENABLEAUTOALTREF, unsigned int)
 #define VPX_CTRL_VP8E_SET_ENABLEAUTOALTREF
-VPX_CTRL_USE_TYPE(VP8E_SET_NOISE_SENSITIVITY,  unsigned int)
+VPX_CTRL_USE_TYPE(VP8E_SET_NOISE_SENSITIVITY, unsigned int)
 #define VPX_CTRL_VP8E_SET_NOISE_SENSITIVITY
-VPX_CTRL_USE_TYPE(VP8E_SET_SHARPNESS,          unsigned int)
+VPX_CTRL_USE_TYPE(VP8E_SET_SHARPNESS, unsigned int)
 #define VPX_CTRL_VP8E_SET_SHARPNESS
-VPX_CTRL_USE_TYPE(VP8E_SET_STATIC_THRESHOLD,   unsigned int)
+VPX_CTRL_USE_TYPE(VP8E_SET_STATIC_THRESHOLD, unsigned int)
 #define VPX_CTRL_VP8E_SET_STATIC_THRESHOLD
-VPX_CTRL_USE_TYPE(VP8E_SET_TOKEN_PARTITIONS,   int) /* vp8e_token_partitions */
+VPX_CTRL_USE_TYPE(VP8E_SET_TOKEN_PARTITIONS, int) /* vp8e_token_partitions */
 #define VPX_CTRL_VP8E_SET_TOKEN_PARTITIONS
 
-VPX_CTRL_USE_TYPE(VP8E_SET_ARNR_MAXFRAMES,     unsigned int)
+VPX_CTRL_USE_TYPE(VP8E_SET_ARNR_MAXFRAMES, unsigned int)
 #define VPX_CTRL_VP8E_SET_ARNR_MAXFRAMES
-VPX_CTRL_USE_TYPE(VP8E_SET_ARNR_STRENGTH,     unsigned int)
+VPX_CTRL_USE_TYPE(VP8E_SET_ARNR_STRENGTH, unsigned int)
 #define VPX_CTRL_VP8E_SET_ARNR_STRENGTH
-VPX_CTRL_USE_TYPE_DEPRECATED(VP8E_SET_ARNR_TYPE,     unsigned int)
+VPX_CTRL_USE_TYPE_DEPRECATED(VP8E_SET_ARNR_TYPE, unsigned int)
 #define VPX_CTRL_VP8E_SET_ARNR_TYPE
-VPX_CTRL_USE_TYPE(VP8E_SET_TUNING,             int) /* vp8e_tuning */
+VPX_CTRL_USE_TYPE(VP8E_SET_TUNING, int) /* vp8e_tuning */
 #define VPX_CTRL_VP8E_SET_TUNING
-VPX_CTRL_USE_TYPE(VP8E_SET_CQ_LEVEL,      unsigned int)
+VPX_CTRL_USE_TYPE(VP8E_SET_CQ_LEVEL, unsigned int)
 #define VPX_CTRL_VP8E_SET_CQ_LEVEL
 
-VPX_CTRL_USE_TYPE(VP9E_SET_TILE_COLUMNS,  int)
+VPX_CTRL_USE_TYPE(VP9E_SET_TILE_COLUMNS, int)
 #define VPX_CTRL_VP9E_SET_TILE_COLUMNS
-VPX_CTRL_USE_TYPE(VP9E_SET_TILE_ROWS,  int)
+VPX_CTRL_USE_TYPE(VP9E_SET_TILE_ROWS, int)
 #define VPX_CTRL_VP9E_SET_TILE_ROWS
 
-VPX_CTRL_USE_TYPE(VP8E_GET_LAST_QUANTIZER,     int *)
+VPX_CTRL_USE_TYPE(VP8E_GET_LAST_QUANTIZER, int *)
 #define VPX_CTRL_VP8E_GET_LAST_QUANTIZER
-VPX_CTRL_USE_TYPE(VP8E_GET_LAST_QUANTIZER_64,  int *)
+VPX_CTRL_USE_TYPE(VP8E_GET_LAST_QUANTIZER_64, int *)
 #define VPX_CTRL_VP8E_GET_LAST_QUANTIZER_64
-VPX_CTRL_USE_TYPE(VP9E_GET_SVC_LAYER_ID,  vpx_svc_layer_id_t *)
+VPX_CTRL_USE_TYPE(VP9E_GET_SVC_LAYER_ID, vpx_svc_layer_id_t *)
 #define VPX_CTRL_VP9E_GET_SVC_LAYER_ID
 
 VPX_CTRL_USE_TYPE(VP8E_SET_MAX_INTRA_BITRATE_PCT, unsigned int)
@@ -788,7 +777,7 @@ VPX_CTRL_USE_TYPE(VP9E_SET_AQ_MODE, unsigned int)
 VPX_CTRL_USE_TYPE(VP9E_SET_FRAME_PERIODIC_BOOST, unsigned int)
 #define VPX_CTRL_VP9E_SET_FRAME_PERIODIC_BOOST
 
-VPX_CTRL_USE_TYPE(VP9E_SET_NOISE_SENSITIVITY,  unsigned int)
+VPX_CTRL_USE_TYPE(VP9E_SET_NOISE_SENSITIVITY, unsigned int)
 #define VPX_CTRL_VP9E_SET_NOISE_SENSITIVITY
 
 VPX_CTRL_USE_TYPE(VP9E_SET_TUNE_CONTENT, int) /* vp9e_tune_content */
@@ -797,10 +786,10 @@ VPX_CTRL_USE_TYPE(VP9E_SET_TUNE_CONTENT, int) /* vp9e_tune_content */
 VPX_CTRL_USE_TYPE(VP9E_SET_COLOR_SPACE, int)
 #define VPX_CTRL_VP9E_SET_COLOR_SPACE
 
-VPX_CTRL_USE_TYPE(VP9E_SET_MIN_GF_INTERVAL,  unsigned int)
+VPX_CTRL_USE_TYPE(VP9E_SET_MIN_GF_INTERVAL, unsigned int)
 #define VPX_CTRL_VP9E_SET_MIN_GF_INTERVAL
 
-VPX_CTRL_USE_TYPE(VP9E_SET_MAX_GF_INTERVAL,  unsigned int)
+VPX_CTRL_USE_TYPE(VP9E_SET_MAX_GF_INTERVAL, unsigned int)
 #define VPX_CTRL_VP9E_SET_MAX_GF_INTERVAL
 
 VPX_CTRL_USE_TYPE(VP9E_GET_ACTIVEMAP, vpx_active_map_t *)
@@ -815,7 +804,7 @@ VPX_CTRL_USE_TYPE(VP9E_SET_SVC_REF_FRAME_CONFIG, vpx_svc_ref_frame_config_t *)
 VPX_CTRL_USE_TYPE(VP9E_SET_RENDER_SIZE, int *)
 #define VPX_CTRL_VP9E_SET_RENDER_SIZE
 
-VPX_CTRL_USE_TYPE(VP9E_SET_TARGET_LEVEL,  unsigned int)
+VPX_CTRL_USE_TYPE(VP9E_SET_TARGET_LEVEL, unsigned int)
 #define VPX_CTRL_VP9E_SET_TARGET_LEVEL
 
 VPX_CTRL_USE_TYPE(VP9E_GET_LEVEL, int *)
diff --git a/vpx/vp8dx.h b/vpx/vp8dx.h
index 67c97bb6c..88204acd3 100644
--- a/vpx/vp8dx.h
+++ b/vpx/vp8dx.h
@@ -8,7 +8,6 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
-
 /*!\defgroup vp8_decoder WebM VP8/VP9 Decoder
  * \ingroup vp8
  *
@@ -33,7 +32,7 @@ extern "C" {
  * This interface provides the capability to decode VP8 streams.
  * @{
  */
-extern vpx_codec_iface_t  vpx_codec_vp8_dx_algo;
+extern vpx_codec_iface_t vpx_codec_vp8_dx_algo;
 extern vpx_codec_iface_t *vpx_codec_vp8_dx(void);
 /*!@} - end algorithm interface member group*/
 
@@ -42,7 +41,7 @@ extern vpx_codec_iface_t *vpx_codec_vp8_dx(void);
  * This interface provides the capability to decode VP9 streams.
  * @{
  */
-extern vpx_codec_iface_t  vpx_codec_vp9_dx_algo;
+extern vpx_codec_iface_t vpx_codec_vp9_dx_algo;
 extern vpx_codec_iface_t *vpx_codec_vp9_dx(void);
 /*!@} - end algorithm interface member group*/
 
@@ -126,18 +125,17 @@ typedef void (*vpx_decrypt_cb)(void *decrypt_state, const unsigned char *input,
  * Defines a structure to hold the decryption state and access function.
  */
 typedef struct vpx_decrypt_init {
-    /*! Decrypt callback. */
-    vpx_decrypt_cb decrypt_cb;
+  /*! Decrypt callback. */
+  vpx_decrypt_cb decrypt_cb;
 
-    /*! Decryption state. */
-    void *decrypt_state;
+  /*! Decryption state. */
+  void *decrypt_state;
 } vpx_decrypt_init;
 
 /*!\brief A deprecated alias for vpx_decrypt_init.
  */
 typedef vpx_decrypt_init vp8_decrypt_init;
 
-
 /*!\cond */
 /*!\brief VP8 decoder control function parameter type
  *
@@ -146,22 +144,21 @@ typedef vpx_decrypt_init vp8_decrypt_init;
  *
  */
 
-
-VPX_CTRL_USE_TYPE(VP8D_GET_LAST_REF_UPDATES,    int *)
+VPX_CTRL_USE_TYPE(VP8D_GET_LAST_REF_UPDATES, int *)
 #define VPX_CTRL_VP8D_GET_LAST_REF_UPDATES
-VPX_CTRL_USE_TYPE(VP8D_GET_FRAME_CORRUPTED,     int *)
+VPX_CTRL_USE_TYPE(VP8D_GET_FRAME_CORRUPTED, int *)
 #define VPX_CTRL_VP8D_GET_FRAME_CORRUPTED
-VPX_CTRL_USE_TYPE(VP8D_GET_LAST_REF_USED,       int *)
+VPX_CTRL_USE_TYPE(VP8D_GET_LAST_REF_USED, int *)
 #define VPX_CTRL_VP8D_GET_LAST_REF_USED
-VPX_CTRL_USE_TYPE(VPXD_SET_DECRYPTOR,           vpx_decrypt_init *)
+VPX_CTRL_USE_TYPE(VPXD_SET_DECRYPTOR, vpx_decrypt_init *)
 #define VPX_CTRL_VPXD_SET_DECRYPTOR
-VPX_CTRL_USE_TYPE(VP8D_SET_DECRYPTOR,           vpx_decrypt_init *)
+VPX_CTRL_USE_TYPE(VP8D_SET_DECRYPTOR, vpx_decrypt_init *)
 #define VPX_CTRL_VP8D_SET_DECRYPTOR
-VPX_CTRL_USE_TYPE(VP9D_GET_DISPLAY_SIZE,        int *)
+VPX_CTRL_USE_TYPE(VP9D_GET_DISPLAY_SIZE, int *)
 #define VPX_CTRL_VP9D_GET_DISPLAY_SIZE
-VPX_CTRL_USE_TYPE(VP9D_GET_BIT_DEPTH,           unsigned int *)
+VPX_CTRL_USE_TYPE(VP9D_GET_BIT_DEPTH, unsigned int *)
 #define VPX_CTRL_VP9D_GET_BIT_DEPTH
-VPX_CTRL_USE_TYPE(VP9D_GET_FRAME_SIZE,          int *)
+VPX_CTRL_USE_TYPE(VP9D_GET_FRAME_SIZE, int *)
 #define VPX_CTRL_VP9D_GET_FRAME_SIZE
 VPX_CTRL_USE_TYPE(VP9_INVERT_TILE_DECODE_ORDER, int)
 #define VPX_CTRL_VP9_INVERT_TILE_DECODE_ORDER
diff --git a/vpx/vpx_codec.h b/vpx/vpx_codec.h
index b6037bb4d..fe75d2387 100644
--- a/vpx/vpx_codec.h
+++ b/vpx/vpx_codec.h
@@ -8,7 +8,6 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
-
 /*!\defgroup codec Common Algorithm Interface
  * This abstraction allows applications to easily support multiple video
  * formats with minimal code duplication. This section describes the interface
@@ -46,434 +45,419 @@ extern "C" {
 #include "./vpx_integer.h"
 #include "./vpx_image.h"
 
-  /*!\brief Decorator indicating a function is deprecated */
+/*!\brief Decorator indicating a function is deprecated */
 #ifndef DEPRECATED
 #if defined(__GNUC__) && __GNUC__
-#define DEPRECATED          __attribute__ ((deprecated))
+#define DEPRECATED __attribute__((deprecated))
 #elif defined(_MSC_VER)
 #define DEPRECATED
 #else
 #define DEPRECATED
 #endif
-#endif  /* DEPRECATED */
+#endif /* DEPRECATED */
 
 #ifndef DECLSPEC_DEPRECATED
 #if defined(__GNUC__) && __GNUC__
 #define DECLSPEC_DEPRECATED /**< \copydoc #DEPRECATED */
 #elif defined(_MSC_VER)
-#define DECLSPEC_DEPRECATED __declspec(deprecated) /**< \copydoc #DEPRECATED */
+/*!\brief \copydoc #DEPRECATED */
+#define DECLSPEC_DEPRECATED __declspec(deprecated)
 #else
 #define DECLSPEC_DEPRECATED /**< \copydoc #DEPRECATED */
 #endif
-#endif  /* DECLSPEC_DEPRECATED */
+#endif /* DECLSPEC_DEPRECATED */
 
-  /*!\brief Decorator indicating a function is potentially unused */
+/*!\brief Decorator indicating a function is potentially unused */
 #ifdef UNUSED
 #elif defined(__GNUC__) || defined(__clang__)
-#define UNUSED __attribute__ ((unused))
+#define UNUSED __attribute__((unused))
 #else
 #define UNUSED
 #endif
 
-  /*!\brief Current ABI version number
-   *
-   * \internal
-   * If this file is altered in any way that changes the ABI, this value
-   * must be bumped.  Examples include, but are not limited to, changing
-   * types, removing or reassigning enums, adding/removing/rearranging
-   * fields to structures
-   */
+/*!\brief Current ABI version number
+ *
+ * \internal
+ * If this file is altered in any way that changes the ABI, this value
+ * must be bumped.  Examples include, but are not limited to, changing
+ * types, removing or reassigning enums, adding/removing/rearranging
+ * fields to structures
+ */
 #define VPX_CODEC_ABI_VERSION (3 + VPX_IMAGE_ABI_VERSION) /**<\hideinitializer*/
 
-  /*!\brief Algorithm return codes */
-  typedef enum {
-    /*!\brief Operation completed without error */
-    VPX_CODEC_OK,
-
-    /*!\brief Unspecified error */
-    VPX_CODEC_ERROR,
-
-    /*!\brief Memory operation failed */
-    VPX_CODEC_MEM_ERROR,
-
-    /*!\brief ABI version mismatch */
-    VPX_CODEC_ABI_MISMATCH,
-
-    /*!\brief Algorithm does not have required capability */
-    VPX_CODEC_INCAPABLE,
-
-    /*!\brief The given bitstream is not supported.
-     *
-     * The bitstream was unable to be parsed at the highest level. The decoder
-     * is unable to proceed. This error \ref SHOULD be treated as fatal to the
-     * stream. */
-    VPX_CODEC_UNSUP_BITSTREAM,
-
-    /*!\brief Encoded bitstream uses an unsupported feature
-     *
-     * The decoder does not implement a feature required by the encoder. This
-     * return code should only be used for features that prevent future
-     * pictures from being properly decoded. This error \ref MAY be treated as
-     * fatal to the stream or \ref MAY be treated as fatal to the current GOP.
-     */
-    VPX_CODEC_UNSUP_FEATURE,
-
-    /*!\brief The coded data for this stream is corrupt or incomplete
-     *
-     * There was a problem decoding the current frame.  This return code
-     * should only be used for failures that prevent future pictures from
-     * being properly decoded. This error \ref MAY be treated as fatal to the
-     * stream or \ref MAY be treated as fatal to the current GOP. If decoding
-     * is continued for the current GOP, artifacts may be present.
-     */
-    VPX_CODEC_CORRUPT_FRAME,
-
-    /*!\brief An application-supplied parameter is not valid.
-     *
-     */
-    VPX_CODEC_INVALID_PARAM,
-
-    /*!\brief An iterator reached the end of list.
-     *
-     */
-    VPX_CODEC_LIST_END
-
-  }
-  vpx_codec_err_t;
-
-
-  /*! \brief Codec capabilities bitfield
-   *
-   *  Each codec advertises the capabilities it supports as part of its
-   *  ::vpx_codec_iface_t interface structure. Capabilities are extra interfaces
-   *  or functionality, and are not required to be supported.
-   *
-   *  The available flags are specified by VPX_CODEC_CAP_* defines.
-   */
-  typedef long vpx_codec_caps_t;
-#define VPX_CODEC_CAP_DECODER 0x1 /**< Is a decoder */
-#define VPX_CODEC_CAP_ENCODER 0x2 /**< Is an encoder */
+/*!\brief Algorithm return codes */
+typedef enum {
+  /*!\brief Operation completed without error */
+  VPX_CODEC_OK,
 
+  /*!\brief Unspecified error */
+  VPX_CODEC_ERROR,
 
-  /*! \brief Initialization-time Feature Enabling
-   *
-   *  Certain codec features must be known at initialization time, to allow for
-   *  proper memory allocation.
-   *
-   *  The available flags are specified by VPX_CODEC_USE_* defines.
-   */
-  typedef long vpx_codec_flags_t;
-
+  /*!\brief Memory operation failed */
+  VPX_CODEC_MEM_ERROR,
 
-  /*!\brief Codec interface structure.
-   *
-   * Contains function pointers and other data private to the codec
-   * implementation. This structure is opaque to the application.
-   */
-  typedef const struct vpx_codec_iface vpx_codec_iface_t;
+  /*!\brief ABI version mismatch */
+  VPX_CODEC_ABI_MISMATCH,
 
+  /*!\brief Algorithm does not have required capability */
+  VPX_CODEC_INCAPABLE,
 
-  /*!\brief Codec private data structure.
+  /*!\brief The given bitstream is not supported.
    *
-   * Contains data private to the codec implementation. This structure is opaque
-   * to the application.
-   */
-  typedef       struct vpx_codec_priv  vpx_codec_priv_t;
-
+   * The bitstream was unable to be parsed at the highest level. The decoder
+   * is unable to proceed. This error \ref SHOULD be treated as fatal to the
+   * stream. */
+  VPX_CODEC_UNSUP_BITSTREAM,
 
-  /*!\brief Iterator
+  /*!\brief Encoded bitstream uses an unsupported feature
    *
-   * Opaque storage used for iterating over lists.
+   * The decoder does not implement a feature required by the encoder. This
+   * return code should only be used for features that prevent future
+   * pictures from being properly decoded. This error \ref MAY be treated as
+   * fatal to the stream or \ref MAY be treated as fatal to the current GOP.
    */
-  typedef const void *vpx_codec_iter_t;
-
+  VPX_CODEC_UNSUP_FEATURE,
 
-  /*!\brief Codec context structure
+  /*!\brief The coded data for this stream is corrupt or incomplete
    *
-   * All codecs \ref MUST support this context structure fully. In general,
-   * this data should be considered private to the codec algorithm, and
-   * not be manipulated or examined by the calling application. Applications
-   * may reference the 'name' member to get a printable description of the
-   * algorithm.
+   * There was a problem decoding the current frame.  This return code
+   * should only be used for failures that prevent future pictures from
+   * being properly decoded. This error \ref MAY be treated as fatal to the
+   * stream or \ref MAY be treated as fatal to the current GOP. If decoding
+   * is continued for the current GOP, artifacts may be present.
    */
-  typedef struct vpx_codec_ctx {
-    const char              *name;        /**< Printable interface name */
-    vpx_codec_iface_t       *iface;       /**< Interface pointers */
-    vpx_codec_err_t          err;         /**< Last returned error */
-    const char              *err_detail;  /**< Detailed info, if available */
-    vpx_codec_flags_t        init_flags;  /**< Flags passed at init time */
-    union {
-      /**< Decoder Configuration Pointer */
-      const struct vpx_codec_dec_cfg *dec;
-      /**< Encoder Configuration Pointer */
-      const struct vpx_codec_enc_cfg *enc;
-      const void                     *raw;
-    }                        config;      /**< Configuration pointer aliasing union */
-    vpx_codec_priv_t        *priv;        /**< Algorithm private storage */
-  } vpx_codec_ctx_t;
-
-  /*!\brief Bit depth for codec
-   * *
-   * This enumeration determines the bit depth of the codec.
-   */
-  typedef enum vpx_bit_depth {
-    VPX_BITS_8  =  8,  /**<  8 bits */
-    VPX_BITS_10 = 10,  /**< 10 bits */
-    VPX_BITS_12 = 12,  /**< 12 bits */
-  } vpx_bit_depth_t;
-
-  /*
-   * Library Version Number Interface
+  VPX_CODEC_CORRUPT_FRAME,
+
+  /*!\brief An application-supplied parameter is not valid.
    *
-   * For example, see the following sample return values:
-   *     vpx_codec_version()           (1<<16 | 2<<8 | 3)
-   *     vpx_codec_version_str()       "v1.2.3-rc1-16-gec6a1ba"
-   *     vpx_codec_version_extra_str() "rc1-16-gec6a1ba"
    */
+  VPX_CODEC_INVALID_PARAM,
 
-  /*!\brief Return the version information (as an integer)
-   *
-   * Returns a packed encoding of the library version number. This will only include
-   * the major.minor.patch component of the version number. Note that this encoded
-   * value should be accessed through the macros provided, as the encoding may change
-   * in the future.
+  /*!\brief An iterator reached the end of list.
    *
    */
-  int vpx_codec_version(void);
-#define VPX_VERSION_MAJOR(v) ((v>>16)&0xff) /**< extract major from packed version */
-#define VPX_VERSION_MINOR(v) ((v>>8)&0xff)  /**< extract minor from packed version */
-#define VPX_VERSION_PATCH(v) ((v>>0)&0xff)  /**< extract patch from packed version */
-
-  /*!\brief Return the version major number */
-#define vpx_codec_version_major() ((vpx_codec_version()>>16)&0xff)
+  VPX_CODEC_LIST_END
 
-  /*!\brief Return the version minor number */
-#define vpx_codec_version_minor() ((vpx_codec_version()>>8)&0xff)
+} vpx_codec_err_t;
 
-  /*!\brief Return the version patch number */
-#define vpx_codec_version_patch() ((vpx_codec_version()>>0)&0xff)
+/*! \brief Codec capabilities bitfield
+ *
+ *  Each codec advertises the capabilities it supports as part of its
+ *  ::vpx_codec_iface_t interface structure. Capabilities are extra interfaces
+ *  or functionality, and are not required to be supported.
+ *
+ *  The available flags are specified by VPX_CODEC_CAP_* defines.
+ */
+typedef long vpx_codec_caps_t;
+#define VPX_CODEC_CAP_DECODER 0x1 /**< Is a decoder */
+#define VPX_CODEC_CAP_ENCODER 0x2 /**< Is an encoder */
 
+/*! \brief Initialization-time Feature Enabling
+ *
+ *  Certain codec features must be known at initialization time, to allow for
+ *  proper memory allocation.
+ *
+ *  The available flags are specified by VPX_CODEC_USE_* defines.
+ */
+typedef long vpx_codec_flags_t;
 
-  /*!\brief Return the version information (as a string)
-   *
-   * Returns a printable string containing the full library version number. This may
-   * contain additional text following the three digit version number, as to indicate
-   * release candidates, prerelease versions, etc.
-   *
-   */
-  const char *vpx_codec_version_str(void);
+/*!\brief Codec interface structure.
+ *
+ * Contains function pointers and other data private to the codec
+ * implementation. This structure is opaque to the application.
+ */
+typedef const struct vpx_codec_iface vpx_codec_iface_t;
 
+/*!\brief Codec private data structure.
+ *
+ * Contains data private to the codec implementation. This structure is opaque
+ * to the application.
+ */
+typedef struct vpx_codec_priv vpx_codec_priv_t;
 
-  /*!\brief Return the version information (as a string)
-   *
-   * Returns a printable "extra string". This is the component of the string returned
-   * by vpx_codec_version_str() following the three digit version number.
-   *
-   */
-  const char *vpx_codec_version_extra_str(void);
+/*!\brief Iterator
+ *
+ * Opaque storage used for iterating over lists.
+ */
+typedef const void *vpx_codec_iter_t;
 
+/*!\brief Codec context structure
+ *
+ * All codecs \ref MUST support this context structure fully. In general,
+ * this data should be considered private to the codec algorithm, and
+ * not be manipulated or examined by the calling application. Applications
+ * may reference the 'name' member to get a printable description of the
+ * algorithm.
+ */
+typedef struct vpx_codec_ctx {
+  const char *name;             /**< Printable interface name */
+  vpx_codec_iface_t *iface;     /**< Interface pointers */
+  vpx_codec_err_t err;          /**< Last returned error */
+  const char *err_detail;       /**< Detailed info, if available */
+  vpx_codec_flags_t init_flags; /**< Flags passed at init time */
+  union {
+    /**< Decoder Configuration Pointer */
+    const struct vpx_codec_dec_cfg *dec;
+    /**< Encoder Configuration Pointer */
+    const struct vpx_codec_enc_cfg *enc;
+    const void *raw;
+  } config;               /**< Configuration pointer aliasing union */
+  vpx_codec_priv_t *priv; /**< Algorithm private storage */
+} vpx_codec_ctx_t;
+
+/*!\brief Bit depth for codec
+ * *
+ * This enumeration determines the bit depth of the codec.
+ */
+typedef enum vpx_bit_depth {
+  VPX_BITS_8 = 8,   /**<  8 bits */
+  VPX_BITS_10 = 10, /**< 10 bits */
+  VPX_BITS_12 = 12, /**< 12 bits */
+} vpx_bit_depth_t;
 
-  /*!\brief Return the build configuration
-   *
-   * Returns a printable string containing an encoded version of the build
-   * configuration. This may be useful to vpx support.
-   *
-   */
-  const char *vpx_codec_build_config(void);
+/*
+ * Library Version Number Interface
+ *
+ * For example, see the following sample return values:
+ *     vpx_codec_version()           (1<<16 | 2<<8 | 3)
+ *     vpx_codec_version_str()       "v1.2.3-rc1-16-gec6a1ba"
+ *     vpx_codec_version_extra_str() "rc1-16-gec6a1ba"
+ */
 
+/*!\brief Return the version information (as an integer)
+ *
+ * Returns a packed encoding of the library version number. This will only
+ * include
+ * the major.minor.patch component of the version number. Note that this encoded
+ * value should be accessed through the macros provided, as the encoding may
+ * change
+ * in the future.
+ *
+ */
+int vpx_codec_version(void);
+#define VPX_VERSION_MAJOR(v) \
+  ((v >> 16) & 0xff) /**< extract major from packed version */
+#define VPX_VERSION_MINOR(v) \
+  ((v >> 8) & 0xff) /**< extract minor from packed version */
+#define VPX_VERSION_PATCH(v) \
+  ((v >> 0) & 0xff) /**< extract patch from packed version */
 
-  /*!\brief Return the name for a given interface
-   *
-   * Returns a human readable string for name of the given codec interface.
-   *
-   * \param[in]    iface     Interface pointer
-   *
-   */
-  const char *vpx_codec_iface_name(vpx_codec_iface_t *iface);
+/*!\brief Return the version major number */
+#define vpx_codec_version_major() ((vpx_codec_version() >> 16) & 0xff)
 
+/*!\brief Return the version minor number */
+#define vpx_codec_version_minor() ((vpx_codec_version() >> 8) & 0xff)
 
-  /*!\brief Convert error number to printable string
-   *
-   * Returns a human readable string for the last error returned by the
-   * algorithm. The returned error will be one line and will not contain
-   * any newline characters.
-   *
-   *
-   * \param[in]    err     Error number.
-   *
-   */
-  const char *vpx_codec_err_to_string(vpx_codec_err_t  err);
+/*!\brief Return the version patch number */
+#define vpx_codec_version_patch() ((vpx_codec_version() >> 0) & 0xff)
 
+/*!\brief Return the version information (as a string)
+ *
+ * Returns a printable string containing the full library version number. This
+ * may
+ * contain additional text following the three digit version number, as to
+ * indicate
+ * release candidates, prerelease versions, etc.
+ *
+ */
+const char *vpx_codec_version_str(void);
 
-  /*!\brief Retrieve error synopsis for codec context
-   *
-   * Returns a human readable string for the last error returned by the
-   * algorithm. The returned error will be one line and will not contain
-   * any newline characters.
-   *
-   *
-   * \param[in]    ctx     Pointer to this instance's context.
-   *
-   */
-  const char *vpx_codec_error(vpx_codec_ctx_t  *ctx);
+/*!\brief Return the version information (as a string)
+ *
+ * Returns a printable "extra string". This is the component of the string
+ * returned
+ * by vpx_codec_version_str() following the three digit version number.
+ *
+ */
+const char *vpx_codec_version_extra_str(void);
 
+/*!\brief Return the build configuration
+ *
+ * Returns a printable string containing an encoded version of the build
+ * configuration. This may be useful to vpx support.
+ *
+ */
+const char *vpx_codec_build_config(void);
 
-  /*!\brief Retrieve detailed error information for codec context
-   *
-   * Returns a human readable string providing detailed information about
-   * the last error.
-   *
-   * \param[in]    ctx     Pointer to this instance's context.
-   *
-   * \retval NULL
-   *     No detailed information is available.
-   */
-  const char *vpx_codec_error_detail(vpx_codec_ctx_t  *ctx);
+/*!\brief Return the name for a given interface
+ *
+ * Returns a human readable string for name of the given codec interface.
+ *
+ * \param[in]    iface     Interface pointer
+ *
+ */
+const char *vpx_codec_iface_name(vpx_codec_iface_t *iface);
 
+/*!\brief Convert error number to printable string
+ *
+ * Returns a human readable string for the last error returned by the
+ * algorithm. The returned error will be one line and will not contain
+ * any newline characters.
+ *
+ *
+ * \param[in]    err     Error number.
+ *
+ */
+const char *vpx_codec_err_to_string(vpx_codec_err_t err);
 
-  /* REQUIRED FUNCTIONS
-   *
-   * The following functions are required to be implemented for all codecs.
-   * They represent the base case functionality expected of all codecs.
-   */
+/*!\brief Retrieve error synopsis for codec context
+ *
+ * Returns a human readable string for the last error returned by the
+ * algorithm. The returned error will be one line and will not contain
+ * any newline characters.
+ *
+ *
+ * \param[in]    ctx     Pointer to this instance's context.
+ *
+ */
+const char *vpx_codec_error(vpx_codec_ctx_t *ctx);
 
-  /*!\brief Destroy a codec instance
-   *
-   * Destroys a codec context, freeing any associated memory buffers.
-   *
-   * \param[in] ctx   Pointer to this instance's context
-   *
-   * \retval #VPX_CODEC_OK
-   *     The codec algorithm initialized.
-   * \retval #VPX_CODEC_MEM_ERROR
-   *     Memory allocation failed.
-   */
-  vpx_codec_err_t vpx_codec_destroy(vpx_codec_ctx_t *ctx);
+/*!\brief Retrieve detailed error information for codec context
+ *
+ * Returns a human readable string providing detailed information about
+ * the last error.
+ *
+ * \param[in]    ctx     Pointer to this instance's context.
+ *
+ * \retval NULL
+ *     No detailed information is available.
+ */
+const char *vpx_codec_error_detail(vpx_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.
+ */
 
-  /*!\brief Get the capabilities of an algorithm.
-   *
-   * Retrieves the capabilities bitfield from the algorithm's interface.
-   *
-   * \param[in] iface   Pointer to the algorithm interface
-   *
-   */
-  vpx_codec_caps_t vpx_codec_get_caps(vpx_codec_iface_t *iface);
+/*!\brief Destroy a codec instance
+ *
+ * Destroys a codec context, freeing any associated memory buffers.
+ *
+ * \param[in] ctx   Pointer to this instance's context
+ *
+ * \retval #VPX_CODEC_OK
+ *     The codec algorithm initialized.
+ * \retval #VPX_CODEC_MEM_ERROR
+ *     Memory allocation failed.
+ */
+vpx_codec_err_t vpx_codec_destroy(vpx_codec_ctx_t *ctx);
 
+/*!\brief Get the capabilities of an algorithm.
+ *
+ * Retrieves the capabilities bitfield from the algorithm's interface.
+ *
+ * \param[in] iface   Pointer to the algorithm interface
+ *
+ */
+vpx_codec_caps_t vpx_codec_get_caps(vpx_codec_iface_t *iface);
 
-  /*!\brief Control algorithm
-   *
-   * This function is used to exchange algorithm specific data with the codec
-   * instance. This can be used to implement features specific to a particular
-   * algorithm.
-   *
-   * This wrapper function dispatches the request to the helper function
-   * associated with the given ctrl_id. It tries to call this function
-   * transparently, but will return #VPX_CODEC_ERROR if the request could not
-   * be dispatched.
-   *
-   * Note that this function should not be used directly. Call the
-   * #vpx_codec_control wrapper macro instead.
-   *
-   * \param[in]     ctx              Pointer to this instance's context
-   * \param[in]     ctrl_id          Algorithm specific control identifier
-   *
-   * \retval #VPX_CODEC_OK
-   *     The control request was processed.
-   * \retval #VPX_CODEC_ERROR
-   *     The control request was not processed.
-   * \retval #VPX_CODEC_INVALID_PARAM
-   *     The data was not valid.
-   */
-  vpx_codec_err_t vpx_codec_control_(vpx_codec_ctx_t  *ctx,
-                                     int               ctrl_id,
-                                     ...);
+/*!\brief Control algorithm
+ *
+ * This function is used to exchange algorithm specific data with the codec
+ * instance. This can be used to implement features specific to a particular
+ * algorithm.
+ *
+ * This wrapper function dispatches the request to the helper function
+ * associated with the given ctrl_id. It tries to call this function
+ * transparently, but will return #VPX_CODEC_ERROR if the request could not
+ * be dispatched.
+ *
+ * Note that this function should not be used directly. Call the
+ * #vpx_codec_control wrapper macro instead.
+ *
+ * \param[in]     ctx              Pointer to this instance's context
+ * \param[in]     ctrl_id          Algorithm specific control identifier
+ *
+ * \retval #VPX_CODEC_OK
+ *     The control request was processed.
+ * \retval #VPX_CODEC_ERROR
+ *     The control request was not processed.
+ * \retval #VPX_CODEC_INVALID_PARAM
+ *     The data was not valid.
+ */
+vpx_codec_err_t vpx_codec_control_(vpx_codec_ctx_t *ctx, int ctrl_id, ...);
 #if defined(VPX_DISABLE_CTRL_TYPECHECKS) && VPX_DISABLE_CTRL_TYPECHECKS
-#    define vpx_codec_control(ctx,id,data) vpx_codec_control_(ctx,id,data)
-#    define VPX_CTRL_USE_TYPE(id, typ)
-#    define VPX_CTRL_USE_TYPE_DEPRECATED(id, typ)
-#    define VPX_CTRL_VOID(id, typ)
+#define vpx_codec_control(ctx, id, data) vpx_codec_control_(ctx, id, data)
+#define VPX_CTRL_USE_TYPE(id, typ)
+#define VPX_CTRL_USE_TYPE_DEPRECATED(id, typ)
+#define VPX_CTRL_VOID(id, typ)
 
 #else
-  /*!\brief vpx_codec_control wrapper macro
-   *
-   * This macro allows for type safe conversions across the variadic parameter
-   * to vpx_codec_control_().
-   *
-   * \internal
-   * It works by dispatching the call to the control function through a wrapper
-   * function named with the id parameter.
-   */
-#    define vpx_codec_control(ctx,id,data) vpx_codec_control_##id(ctx,id,data)\
-  /**<\hideinitializer*/
-
+/*!\brief vpx_codec_control wrapper macro
+ *
+ * This macro allows for type safe conversions across the variadic parameter
+ * to vpx_codec_control_().
+ *
+ * \internal
+ * It works by dispatching the call to the control function through a wrapper
+ * function named with the id parameter.
+ */
+#define vpx_codec_control(ctx, id, data) \
+  vpx_codec_control_##id(ctx, id, data) /**<\hideinitializer*/
 
-  /*!\brief vpx_codec_control type definition macro
-   *
-   * This macro allows for type safe conversions across the variadic parameter
-   * to vpx_codec_control_(). It defines the type of the argument for a given
-   * control identifier.
-   *
-   * \internal
-   * It defines a static function with
-   * the correctly typed arguments as a wrapper to the type-unsafe internal
-   * function.
-   */
-#    define VPX_CTRL_USE_TYPE(id, typ) \
-  static vpx_codec_err_t \
-  vpx_codec_control_##id(vpx_codec_ctx_t*, int, typ) UNUSED;\
-  \
-  static vpx_codec_err_t \
-  vpx_codec_control_##id(vpx_codec_ctx_t  *ctx, int ctrl_id, typ data) {\
-    return vpx_codec_control_(ctx, ctrl_id, data);\
+/*!\brief vpx_codec_control type definition macro
+ *
+ * This macro allows for type safe conversions across the variadic parameter
+ * to vpx_codec_control_(). It defines the type of the argument for a given
+ * control identifier.
+ *
+ * \internal
+ * It defines a static function with
+ * the correctly typed arguments as a wrapper to the type-unsafe internal
+ * function.
+ */
+#define VPX_CTRL_USE_TYPE(id, typ)                                           \
+  static vpx_codec_err_t vpx_codec_control_##id(vpx_codec_ctx_t *, int, typ) \
+      UNUSED;                                                                \
+                                                                             \
+  static vpx_codec_err_t vpx_codec_control_##id(vpx_codec_ctx_t *ctx,        \
+                                                int ctrl_id, typ data) {     \
+    return vpx_codec_control_(ctx, ctrl_id, data);                           \
   } /**<\hideinitializer*/
 
-
-  /*!\brief vpx_codec_control deprecated type definition macro
-   *
-   * Like #VPX_CTRL_USE_TYPE, but indicates that the specified control is
-   * deprecated and should not be used. Consult the documentation for your
-   * codec for more information.
-   *
-   * \internal
-   * It defines a static function with the correctly typed arguments as a
-   * wrapper to the type-unsafe internal function.
-   */
-#    define VPX_CTRL_USE_TYPE_DEPRECATED(id, typ) \
-  DECLSPEC_DEPRECATED static vpx_codec_err_t \
-  vpx_codec_control_##id(vpx_codec_ctx_t*, int, typ) DEPRECATED UNUSED;\
-  \
-  DECLSPEC_DEPRECATED static vpx_codec_err_t \
-  vpx_codec_control_##id(vpx_codec_ctx_t  *ctx, int ctrl_id, typ data) {\
-    return vpx_codec_control_(ctx, ctrl_id, data);\
+/*!\brief vpx_codec_control deprecated type definition macro
+ *
+ * Like #VPX_CTRL_USE_TYPE, but indicates that the specified control is
+ * deprecated and should not be used. Consult the documentation for your
+ * codec for more information.
+ *
+ * \internal
+ * It defines a static function with the correctly typed arguments as a
+ * wrapper to the type-unsafe internal function.
+ */
+#define VPX_CTRL_USE_TYPE_DEPRECATED(id, typ)                        \
+  DECLSPEC_DEPRECATED static vpx_codec_err_t vpx_codec_control_##id( \
+      vpx_codec_ctx_t *, int, typ) DEPRECATED UNUSED;                \
+                                                                     \
+  DECLSPEC_DEPRECATED static vpx_codec_err_t vpx_codec_control_##id( \
+      vpx_codec_ctx_t *ctx, int ctrl_id, typ data) {                 \
+    return vpx_codec_control_(ctx, ctrl_id, data);                   \
   } /**<\hideinitializer*/
 
-
-  /*!\brief vpx_codec_control void type definition macro
-   *
-   * This macro allows for type safe conversions across the variadic parameter
-   * to vpx_codec_control_(). It indicates that a given control identifier takes
-   * no argument.
-   *
-   * \internal
-   * It defines a static function without a data argument as a wrapper to the
-   * type-unsafe internal function.
-   */
-#    define VPX_CTRL_VOID(id) \
-  static vpx_codec_err_t \
-  vpx_codec_control_##id(vpx_codec_ctx_t*, int) UNUSED;\
-  \
-  static vpx_codec_err_t \
-  vpx_codec_control_##id(vpx_codec_ctx_t  *ctx, int ctrl_id) {\
-    return vpx_codec_control_(ctx, ctrl_id);\
+/*!\brief vpx_codec_control void type definition macro
+ *
+ * This macro allows for type safe conversions across the variadic parameter
+ * to vpx_codec_control_(). It indicates that a given control identifier takes
+ * no argument.
+ *
+ * \internal
+ * It defines a static function without a data argument as a wrapper to the
+ * type-unsafe internal function.
+ */
+#define VPX_CTRL_VOID(id)                                               \
+  static vpx_codec_err_t vpx_codec_control_##id(vpx_codec_ctx_t *, int) \
+      UNUSED;                                                           \
+                                                                        \
+  static vpx_codec_err_t vpx_codec_control_##id(vpx_codec_ctx_t *ctx,   \
+                                                int ctrl_id) {          \
+    return vpx_codec_control_(ctx, ctrl_id);                            \
   } /**<\hideinitializer*/
 
-
 #endif
 
-  /*!@} - end defgroup codec*/
+/*!@} - end defgroup codec*/
 #ifdef __cplusplus
 }
 #endif
 #endif  // VPX_VPX_CODEC_H_
-
diff --git a/vpx/vpx_decoder.h b/vpx/vpx_decoder.h
index 62fd91975..2ff12112b 100644
--- a/vpx/vpx_decoder.h
+++ b/vpx/vpx_decoder.h
@@ -32,347 +32,334 @@ extern "C" {
 #include "./vpx_codec.h"
 #include "./vpx_frame_buffer.h"
 
-  /*!\brief Current ABI version number
-   *
-   * \internal
-   * If this file is altered in any way that changes the ABI, this value
-   * must be bumped.  Examples include, but are not limited to, changing
-   * types, removing or reassigning enums, adding/removing/rearranging
-   * fields to structures
-   */
-#define VPX_DECODER_ABI_VERSION (3 + VPX_CODEC_ABI_VERSION) /**<\hideinitializer*/
-
-  /*! \brief Decoder capabilities bitfield
-   *
-   *  Each decoder advertises the capabilities it supports as part of its
-   *  ::vpx_codec_iface_t interface structure. Capabilities are extra interfaces
-   *  or functionality, and are not required to be supported by a decoder.
-   *
-   *  The available flags are specified by VPX_CODEC_CAP_* defines.
-   */
-#define VPX_CODEC_CAP_PUT_SLICE  0x10000 /**< Will issue put_slice callbacks */
-#define VPX_CODEC_CAP_PUT_FRAME  0x20000 /**< Will issue put_frame callbacks */
-#define VPX_CODEC_CAP_POSTPROC   0x40000 /**< Can postprocess decoded frame */
-#define VPX_CODEC_CAP_ERROR_CONCEALMENT   0x80000 /**< Can conceal errors due to
-  packet loss */
-#define VPX_CODEC_CAP_INPUT_FRAGMENTS   0x100000 /**< Can receive encoded frames
-  one fragment at a time */
-
-  /*! \brief Initialization-time Feature Enabling
-   *
-   *  Certain codec features must be known at initialization time, to allow for
-   *  proper memory allocation.
-   *
-   *  The available flags are specified by VPX_CODEC_USE_* defines.
-   */
-#define VPX_CODEC_CAP_FRAME_THREADING   0x200000 /**< Can support frame-based
-                                                      multi-threading */
-#define VPX_CODEC_CAP_EXTERNAL_FRAME_BUFFER 0x400000 /**< Can support external
-                                                          frame buffers */
-
-#define VPX_CODEC_USE_POSTPROC   0x10000 /**< Postprocess decoded frame */
-#define VPX_CODEC_USE_ERROR_CONCEALMENT 0x20000 /**< Conceal errors in decoded
-  frames */
-#define VPX_CODEC_USE_INPUT_FRAGMENTS   0x40000 /**< The input frame should be
-  passed to the decoder one
-  fragment at a time */
-#define VPX_CODEC_USE_FRAME_THREADING   0x80000 /**< Enable frame-based
-                                                     multi-threading */
-
-  /*!\brief Stream properties
-   *
-   * This structure is used to query or set properties of the decoded
-   * stream. Algorithms may extend this structure with data specific
-   * to their bitstream by setting the sz member appropriately.
-   */
-  typedef struct vpx_codec_stream_info {
-    unsigned int sz;     /**< Size of this structure */
-    unsigned int w;      /**< Width (or 0 for unknown/default) */
-    unsigned int h;      /**< Height (or 0 for unknown/default) */
-    unsigned int is_kf;  /**< Current frame is a keyframe */
-  } vpx_codec_stream_info_t;
-
-  /* REQUIRED FUNCTIONS
-   *
-   * The following functions are required to be implemented for all decoders.
-   * They represent the base case functionality expected of all decoders.
-   */
-
+/*!\brief Current ABI version number
+ *
+ * \internal
+ * If this file is altered in any way that changes the ABI, this value
+ * must be bumped.  Examples include, but are not limited to, changing
+ * types, removing or reassigning enums, adding/removing/rearranging
+ * fields to structures
+ */
+#define VPX_DECODER_ABI_VERSION \
+  (3 + VPX_CODEC_ABI_VERSION) /**<\hideinitializer*/
 
-  /*!\brief Initialization Configurations
-   *
-   * This structure is used to pass init time configuration options to the
-   * decoder.
-   */
-  typedef struct vpx_codec_dec_cfg {
-    unsigned int threads; /**< Maximum number of threads to use, default 1 */
-    unsigned int w;      /**< Width */
-    unsigned int h;      /**< Height */
-  } vpx_codec_dec_cfg_t; /**< alias for struct vpx_codec_dec_cfg */
+/*! \brief Decoder capabilities bitfield
+ *
+ *  Each decoder advertises the capabilities it supports as part of its
+ *  ::vpx_codec_iface_t interface structure. Capabilities are extra interfaces
+ *  or functionality, and are not required to be supported by a decoder.
+ *
+ *  The available flags are specified by VPX_CODEC_CAP_* defines.
+ */
+#define VPX_CODEC_CAP_PUT_SLICE 0x10000 /**< Will issue put_slice callbacks */
+#define VPX_CODEC_CAP_PUT_FRAME 0x20000 /**< Will issue put_frame callbacks */
+#define VPX_CODEC_CAP_POSTPROC 0x40000  /**< Can postprocess decoded frame */
+/*!\brief Can conceal errors due to packet loss */
+#define VPX_CODEC_CAP_ERROR_CONCEALMENT 0x80000
+/*!\brief Can receive encoded frames one fragment at a time */
+#define VPX_CODEC_CAP_INPUT_FRAGMENTS 0x100000
+
+/*! \brief Initialization-time Feature Enabling
+ *
+ *  Certain codec features must be known at initialization time, to allow for
+ *  proper memory allocation.
+ *
+ *  The available flags are specified by VPX_CODEC_USE_* defines.
+ */
+/*!\brief Can support frame-based multi-threading */
+#define VPX_CODEC_CAP_FRAME_THREADING 0x200000
+/*!brief Can support external frame buffers */
+#define VPX_CODEC_CAP_EXTERNAL_FRAME_BUFFER 0x400000
+
+#define VPX_CODEC_USE_POSTPROC 0x10000 /**< Postprocess decoded frame */
+/*!\brief Conceal errors in decoded frames */
+#define VPX_CODEC_USE_ERROR_CONCEALMENT 0x20000
+/*!\brief The input frame should be passed to the decoder one fragment at a
+ * time */
+#define VPX_CODEC_USE_INPUT_FRAGMENTS 0x40000
+/*!\brief Enable frame-based multi-threading */
+#define VPX_CODEC_USE_FRAME_THREADING 0x80000
+
+/*!\brief Stream properties
+ *
+ * This structure is used to query or set properties of the decoded
+ * stream. Algorithms may extend this structure with data specific
+ * to their bitstream by setting the sz member appropriately.
+ */
+typedef struct vpx_codec_stream_info {
+  unsigned int sz;    /**< Size of this structure */
+  unsigned int w;     /**< Width (or 0 for unknown/default) */
+  unsigned int h;     /**< Height (or 0 for unknown/default) */
+  unsigned int is_kf; /**< Current frame is a keyframe */
+} vpx_codec_stream_info_t;
+
+/* REQUIRED FUNCTIONS
+ *
+ * The following functions are required to be implemented for all decoders.
+ * They represent the base case functionality expected of all decoders.
+ */
 
+/*!\brief Initialization Configurations
+ *
+ * This structure is used to pass init time configuration options to the
+ * decoder.
+ */
+typedef struct vpx_codec_dec_cfg {
+  unsigned int threads; /**< Maximum number of threads to use, default 1 */
+  unsigned int w;       /**< Width */
+  unsigned int h;       /**< Height */
+} vpx_codec_dec_cfg_t;  /**< alias for struct vpx_codec_dec_cfg */
 
-  /*!\brief Initialize a decoder instance
-   *
-   * Initializes a decoder context using the given interface. Applications
-   * should call the vpx_codec_dec_init convenience macro instead of this
-   * function directly, to ensure that the ABI version number parameter
-   * is properly initialized.
-   *
-   * If the library was configured with --disable-multithread, this call
-   * is not thread safe and should be guarded with a lock if being used
-   * in a multithreaded context.
-   *
-   * \param[in]    ctx     Pointer to this instance's context.
-   * \param[in]    iface   Pointer to the algorithm interface to use.
-   * \param[in]    cfg     Configuration to use, if known. May be NULL.
-   * \param[in]    flags   Bitfield of VPX_CODEC_USE_* flags
-   * \param[in]    ver     ABI version number. Must be set to
-   *                       VPX_DECODER_ABI_VERSION
-   * \retval #VPX_CODEC_OK
-   *     The decoder algorithm initialized.
-   * \retval #VPX_CODEC_MEM_ERROR
-   *     Memory allocation failed.
-   */
-  vpx_codec_err_t vpx_codec_dec_init_ver(vpx_codec_ctx_t      *ctx,
-                                         vpx_codec_iface_t    *iface,
-                                         const vpx_codec_dec_cfg_t *cfg,
-                                         vpx_codec_flags_t     flags,
-                                         int                   ver);
+/*!\brief Initialize a decoder instance
+ *
+ * Initializes a decoder context using the given interface. Applications
+ * should call the vpx_codec_dec_init convenience macro instead of this
+ * function directly, to ensure that the ABI version number parameter
+ * is properly initialized.
+ *
+ * If the library was configured with --disable-multithread, this call
+ * is not thread safe and should be guarded with a lock if being used
+ * in a multithreaded context.
+ *
+ * \param[in]    ctx     Pointer to this instance's context.
+ * \param[in]    iface   Pointer to the algorithm interface to use.
+ * \param[in]    cfg     Configuration to use, if known. May be NULL.
+ * \param[in]    flags   Bitfield of VPX_CODEC_USE_* flags
+ * \param[in]    ver     ABI version number. Must be set to
+ *                       VPX_DECODER_ABI_VERSION
+ * \retval #VPX_CODEC_OK
+ *     The decoder algorithm initialized.
+ * \retval #VPX_CODEC_MEM_ERROR
+ *     Memory allocation failed.
+ */
+vpx_codec_err_t vpx_codec_dec_init_ver(vpx_codec_ctx_t *ctx,
+                                       vpx_codec_iface_t *iface,
+                                       const vpx_codec_dec_cfg_t *cfg,
+                                       vpx_codec_flags_t flags, int ver);
 
-  /*!\brief Convenience macro for vpx_codec_dec_init_ver()
-   *
-   * Ensures the ABI version parameter is properly set.
-   */
+/*!\brief Convenience macro for vpx_codec_dec_init_ver()
+ *
+ * Ensures the ABI version parameter is properly set.
+ */
 #define vpx_codec_dec_init(ctx, iface, cfg, flags) \
   vpx_codec_dec_init_ver(ctx, iface, cfg, flags, VPX_DECODER_ABI_VERSION)
 
+/*!\brief Parse stream info from a buffer
+ *
+ * Performs high level parsing of the bitstream. Construction of a decoder
+ * context is not necessary. Can be used to determine if the bitstream is
+ * of the proper format, and to extract information from the stream.
+ *
+ * \param[in]      iface   Pointer to the algorithm interface
+ * \param[in]      data    Pointer to a block of data to parse
+ * \param[in]      data_sz Size of the data buffer
+ * \param[in,out]  si      Pointer to stream info to update. The size member
+ *                         \ref MUST be properly initialized, but \ref MAY be
+ *                         clobbered by the algorithm. This parameter \ref MAY
+ *                         be NULL.
+ *
+ * \retval #VPX_CODEC_OK
+ *     Bitstream is parsable and stream information updated
+ */
+vpx_codec_err_t vpx_codec_peek_stream_info(vpx_codec_iface_t *iface,
+                                           const uint8_t *data,
+                                           unsigned int data_sz,
+                                           vpx_codec_stream_info_t *si);
 
-  /*!\brief Parse stream info from a buffer
-   *
-   * Performs high level parsing of the bitstream. Construction of a decoder
-   * context is not necessary. Can be used to determine if the bitstream is
-   * of the proper format, and to extract information from the stream.
-   *
-   * \param[in]      iface   Pointer to the algorithm interface
-   * \param[in]      data    Pointer to a block of data to parse
-   * \param[in]      data_sz Size of the data buffer
-   * \param[in,out]  si      Pointer to stream info to update. The size member
-   *                         \ref MUST be properly initialized, but \ref MAY be
-   *                         clobbered by the algorithm. This parameter \ref MAY
-   *                         be NULL.
-   *
-   * \retval #VPX_CODEC_OK
-   *     Bitstream is parsable and stream information updated
-   */
-  vpx_codec_err_t vpx_codec_peek_stream_info(vpx_codec_iface_t       *iface,
-                                             const uint8_t           *data,
-                                             unsigned int             data_sz,
-                                             vpx_codec_stream_info_t *si);
-
-
-  /*!\brief Return information about the current stream.
-   *
-   * Returns information about the stream that has been parsed during decoding.
-   *
-   * \param[in]      ctx     Pointer to this instance's context
-   * \param[in,out]  si      Pointer to stream info to update. The size member
-   *                         \ref MUST be properly initialized, but \ref MAY be
-   *                         clobbered by the algorithm. This parameter \ref MAY
-   *                         be NULL.
-   *
-   * \retval #VPX_CODEC_OK
-   *     Bitstream is parsable and stream information updated
-   */
-  vpx_codec_err_t vpx_codec_get_stream_info(vpx_codec_ctx_t         *ctx,
-                                            vpx_codec_stream_info_t *si);
-
-
-  /*!\brief Decode data
-   *
-   * Processes a buffer of coded data. If the processing results in a new
-   * decoded frame becoming available, PUT_SLICE and PUT_FRAME events may be
-   * generated, as appropriate. Encoded data \ref MUST be passed in DTS (decode
-   * time stamp) order. Frames produced will always be in PTS (presentation
-   * time stamp) order.
-   * If the decoder is configured with VPX_CODEC_USE_INPUT_FRAGMENTS enabled,
-   * data and data_sz can contain a fragment of the encoded frame. Fragment
-   * \#n must contain at least partition \#n, but can also contain subsequent
-   * partitions (\#n+1 - \#n+i), and if so, fragments \#n+1, .., \#n+i must
-   * be empty. When no more data is available, this function should be called
-   * with NULL as data and 0 as data_sz. The memory passed to this function
-   * must be available until the frame has been decoded.
-   *
-   * \param[in] ctx          Pointer to this instance's context
-   * \param[in] data         Pointer to this block of new coded data. If
-   *                         NULL, a VPX_CODEC_CB_PUT_FRAME event is posted
-   *                         for the previously decoded frame.
-   * \param[in] data_sz      Size of the coded data, in bytes.
-   * \param[in] user_priv    Application specific data to associate with
-   *                         this frame.
-   * \param[in] deadline     Soft deadline the decoder should attempt to meet,
-   *                         in us. Set to zero for unlimited.
-   *
-   * \return Returns #VPX_CODEC_OK if the coded data was processed completely
-   *         and future pictures can be decoded without error. Otherwise,
-   *         see the descriptions of the other error codes in ::vpx_codec_err_t
-   *         for recoverability capabilities.
-   */
-  vpx_codec_err_t vpx_codec_decode(vpx_codec_ctx_t    *ctx,
-                                   const uint8_t        *data,
-                                   unsigned int            data_sz,
-                                   void               *user_priv,
-                                   long                deadline);
-
-
-  /*!\brief Decoded frames iterator
-   *
-   * Iterates over a list of the frames available for display. The iterator
-   * storage should be initialized to NULL to start the iteration. Iteration is
-   * complete when this function returns NULL.
-   *
-   * The list of available frames becomes valid upon completion of the
-   * vpx_codec_decode call, and remains valid until the next call to vpx_codec_decode.
-   *
-   * \param[in]     ctx      Pointer to this instance's context
-   * \param[in,out] iter     Iterator storage, initialized to NULL
-   *
-   * \return Returns a pointer to an image, if one is ready for display. Frames
-   *         produced will always be in PTS (presentation time stamp) order.
-   */
-  vpx_image_t *vpx_codec_get_frame(vpx_codec_ctx_t  *ctx,
-                                   vpx_codec_iter_t *iter);
-
-
-  /*!\defgroup cap_put_frame Frame-Based Decoding Functions
-   *
-   * The following functions are required to be implemented for all decoders
-   * that advertise the VPX_CODEC_CAP_PUT_FRAME capability. Calling these functions
-   * for codecs that don't advertise this capability will result in an error
-   * code being returned, usually VPX_CODEC_ERROR
-   * @{
-   */
-
-  /*!\brief put frame callback prototype
-   *
-   * This callback is invoked by the decoder to notify the application of
-   * the availability of decoded image data.
-   */
-  typedef void (*vpx_codec_put_frame_cb_fn_t)(void        *user_priv,
-                                              const vpx_image_t *img);
+/*!\brief Return information about the current stream.
+ *
+ * Returns information about the stream that has been parsed during decoding.
+ *
+ * \param[in]      ctx     Pointer to this instance's context
+ * \param[in,out]  si      Pointer to stream info to update. The size member
+ *                         \ref MUST be properly initialized, but \ref MAY be
+ *                         clobbered by the algorithm. This parameter \ref MAY
+ *                         be NULL.
+ *
+ * \retval #VPX_CODEC_OK
+ *     Bitstream is parsable and stream information updated
+ */
+vpx_codec_err_t vpx_codec_get_stream_info(vpx_codec_ctx_t *ctx,
+                                          vpx_codec_stream_info_t *si);
 
+/*!\brief Decode data
+ *
+ * Processes a buffer of coded data. If the processing results in a new
+ * decoded frame becoming available, PUT_SLICE and PUT_FRAME events may be
+ * generated, as appropriate. Encoded data \ref MUST be passed in DTS (decode
+ * time stamp) order. Frames produced will always be in PTS (presentation
+ * time stamp) order.
+ * If the decoder is configured with VPX_CODEC_USE_INPUT_FRAGMENTS enabled,
+ * data and data_sz can contain a fragment of the encoded frame. Fragment
+ * \#n must contain at least partition \#n, but can also contain subsequent
+ * partitions (\#n+1 - \#n+i), and if so, fragments \#n+1, .., \#n+i must
+ * be empty. When no more data is available, this function should be called
+ * with NULL as data and 0 as data_sz. The memory passed to this function
+ * must be available until the frame has been decoded.
+ *
+ * \param[in] ctx          Pointer to this instance's context
+ * \param[in] data         Pointer to this block of new coded data. If
+ *                         NULL, a VPX_CODEC_CB_PUT_FRAME event is posted
+ *                         for the previously decoded frame.
+ * \param[in] data_sz      Size of the coded data, in bytes.
+ * \param[in] user_priv    Application specific data to associate with
+ *                         this frame.
+ * \param[in] deadline     Soft deadline the decoder should attempt to meet,
+ *                         in us. Set to zero for unlimited.
+ *
+ * \return Returns #VPX_CODEC_OK if the coded data was processed completely
+ *         and future pictures can be decoded without error. Otherwise,
+ *         see the descriptions of the other error codes in ::vpx_codec_err_t
+ *         for recoverability capabilities.
+ */
+vpx_codec_err_t vpx_codec_decode(vpx_codec_ctx_t *ctx, const uint8_t *data,
+                                 unsigned int data_sz, void *user_priv,
+                                 long deadline);
 
-  /*!\brief Register for notification of frame completion.
-   *
-   * Registers a given function to be called when a decoded frame is
-   * available.
-   *
-   * \param[in] ctx          Pointer to this instance's context
-   * \param[in] cb           Pointer to the callback function
-   * \param[in] user_priv    User's private data
-   *
-   * \retval #VPX_CODEC_OK
-   *     Callback successfully registered.
-   * \retval #VPX_CODEC_ERROR
-   *     Decoder context not initialized, or algorithm not capable of
-   *     posting slice completion.
-   */
-  vpx_codec_err_t vpx_codec_register_put_frame_cb(vpx_codec_ctx_t             *ctx,
-                                                  vpx_codec_put_frame_cb_fn_t  cb,
-                                                  void                        *user_priv);
+/*!\brief Decoded frames iterator
+ *
+ * Iterates over a list of the frames available for display. The iterator
+ * storage should be initialized to NULL to start the iteration. Iteration is
+ * complete when this function returns NULL.
+ *
+ * The list of available frames becomes valid upon completion of the
+ * vpx_codec_decode call, and remains valid until the next call to
+ * vpx_codec_decode.
+ *
+ * \param[in]     ctx      Pointer to this instance's context
+ * \param[in,out] iter     Iterator storage, initialized to NULL
+ *
+ * \return Returns a pointer to an image, if one is ready for display. Frames
+ *         produced will always be in PTS (presentation time stamp) order.
+ */
+vpx_image_t *vpx_codec_get_frame(vpx_codec_ctx_t *ctx, vpx_codec_iter_t *iter);
 
+/*!\defgroup cap_put_frame Frame-Based Decoding Functions
+ *
+ * The following functions are required to be implemented for all decoders
+ * that advertise the VPX_CODEC_CAP_PUT_FRAME capability. Calling these
+ * functions
+ * for codecs that don't advertise this capability will result in an error
+ * code being returned, usually VPX_CODEC_ERROR
+ * @{
+ */
 
-  /*!@} - end defgroup cap_put_frame */
+/*!\brief put frame callback prototype
+ *
+ * This callback is invoked by the decoder to notify the application of
+ * the availability of decoded image data.
+ */
+typedef void (*vpx_codec_put_frame_cb_fn_t)(void *user_priv,
+                                            const vpx_image_t *img);
 
-  /*!\defgroup cap_put_slice Slice-Based Decoding Functions
-   *
-   * The following functions are required to be implemented for all decoders
-   * that advertise the VPX_CODEC_CAP_PUT_SLICE capability. Calling these functions
-   * for codecs that don't advertise this capability will result in an error
-   * code being returned, usually VPX_CODEC_ERROR
-   * @{
-   */
+/*!\brief Register for notification of frame completion.
+ *
+ * Registers a given function to be called when a decoded frame is
+ * available.
+ *
+ * \param[in] ctx          Pointer to this instance's context
+ * \param[in] cb           Pointer to the callback function
+ * \param[in] user_priv    User's private data
+ *
+ * \retval #VPX_CODEC_OK
+ *     Callback successfully registered.
+ * \retval #VPX_CODEC_ERROR
+ *     Decoder context not initialized, or algorithm not capable of
+ *     posting slice completion.
+ */
+vpx_codec_err_t vpx_codec_register_put_frame_cb(vpx_codec_ctx_t *ctx,
+                                                vpx_codec_put_frame_cb_fn_t cb,
+                                                void *user_priv);
 
-  /*!\brief put slice callback prototype
-   *
-   * This callback is invoked by the decoder to notify the application of
-   * the availability of partially decoded image data. The
-   */
-  typedef void (*vpx_codec_put_slice_cb_fn_t)(void         *user_priv,
-                                              const vpx_image_t      *img,
-                                              const vpx_image_rect_t *valid,
-                                              const vpx_image_rect_t *update);
+/*!@} - end defgroup cap_put_frame */
 
+/*!\defgroup cap_put_slice Slice-Based Decoding Functions
+ *
+ * The following functions are required to be implemented for all decoders
+ * that advertise the VPX_CODEC_CAP_PUT_SLICE capability. Calling these
+ * functions
+ * for codecs that don't advertise this capability will result in an error
+ * code being returned, usually VPX_CODEC_ERROR
+ * @{
+ */
 
-  /*!\brief Register for notification of slice completion.
-   *
-   * Registers a given function to be called when a decoded slice is
-   * available.
-   *
-   * \param[in] ctx          Pointer to this instance's context
-   * \param[in] cb           Pointer to the callback function
-   * \param[in] user_priv    User's private data
-   *
-   * \retval #VPX_CODEC_OK
-   *     Callback successfully registered.
-   * \retval #VPX_CODEC_ERROR
-   *     Decoder context not initialized, or algorithm not capable of
-   *     posting slice completion.
-   */
-  vpx_codec_err_t vpx_codec_register_put_slice_cb(vpx_codec_ctx_t             *ctx,
-                                                  vpx_codec_put_slice_cb_fn_t  cb,
-                                                  void                        *user_priv);
+/*!\brief put slice callback prototype
+ *
+ * This callback is invoked by the decoder to notify the application of
+ * the availability of partially decoded image data. The
+ */
+typedef void (*vpx_codec_put_slice_cb_fn_t)(void *user_priv,
+                                            const vpx_image_t *img,
+                                            const vpx_image_rect_t *valid,
+                                            const vpx_image_rect_t *update);
 
+/*!\brief Register for notification of slice completion.
+ *
+ * Registers a given function to be called when a decoded slice is
+ * available.
+ *
+ * \param[in] ctx          Pointer to this instance's context
+ * \param[in] cb           Pointer to the callback function
+ * \param[in] user_priv    User's private data
+ *
+ * \retval #VPX_CODEC_OK
+ *     Callback successfully registered.
+ * \retval #VPX_CODEC_ERROR
+ *     Decoder context not initialized, or algorithm not capable of
+ *     posting slice completion.
+ */
+vpx_codec_err_t vpx_codec_register_put_slice_cb(vpx_codec_ctx_t *ctx,
+                                                vpx_codec_put_slice_cb_fn_t cb,
+                                                void *user_priv);
 
-  /*!@} - end defgroup cap_put_slice*/
+/*!@} - end defgroup cap_put_slice*/
 
-  /*!\defgroup cap_external_frame_buffer External Frame Buffer Functions
-   *
-   * The following section is required to be implemented for all decoders
-   * that advertise the VPX_CODEC_CAP_EXTERNAL_FRAME_BUFFER capability.
-   * Calling this function for codecs that don't advertise this capability
-   * will result in an error code being returned, usually VPX_CODEC_ERROR.
-   *
-   * \note
-   * Currently this only works with VP9.
-   * @{
-   */
+/*!\defgroup cap_external_frame_buffer External Frame Buffer Functions
+ *
+ * The following section is required to be implemented for all decoders
+ * that advertise the VPX_CODEC_CAP_EXTERNAL_FRAME_BUFFER capability.
+ * Calling this function for codecs that don't advertise this capability
+ * will result in an error code being returned, usually VPX_CODEC_ERROR.
+ *
+ * \note
+ * Currently this only works with VP9.
+ * @{
+ */
 
-  /*!\brief Pass in external frame buffers for the decoder to use.
-   *
-   * Registers functions to be called when libvpx needs a frame buffer
-   * to decode the current frame and a function to be called when libvpx does
-   * not internally reference the frame buffer. This set function must
-   * be called before the first call to decode or libvpx will assume the
-   * default behavior of allocating frame buffers internally.
-   *
-   * \param[in] ctx          Pointer to this instance's context
-   * \param[in] cb_get       Pointer to the get callback function
-   * \param[in] cb_release   Pointer to the release callback function
-   * \param[in] cb_priv      Callback's private data
-   *
-   * \retval #VPX_CODEC_OK
-   *     External frame buffers will be used by libvpx.
-   * \retval #VPX_CODEC_INVALID_PARAM
-   *     One or more of the callbacks were NULL.
-   * \retval #VPX_CODEC_ERROR
-   *     Decoder context not initialized, or algorithm not capable of
-   *     using external frame buffers.
-   *
-   * \note
-   * When decoding VP9, the application may be required to pass in at least
-   * #VP9_MAXIMUM_REF_BUFFERS + #VPX_MAXIMUM_WORK_BUFFERS external frame
-   * buffers.
-   */
-  vpx_codec_err_t vpx_codec_set_frame_buffer_functions(
-      vpx_codec_ctx_t *ctx,
-      vpx_get_frame_buffer_cb_fn_t cb_get,
-      vpx_release_frame_buffer_cb_fn_t cb_release, void *cb_priv);
+/*!\brief Pass in external frame buffers for the decoder to use.
+ *
+ * Registers functions to be called when libvpx needs a frame buffer
+ * to decode the current frame and a function to be called when libvpx does
+ * not internally reference the frame buffer. This set function must
+ * be called before the first call to decode or libvpx will assume the
+ * default behavior of allocating frame buffers internally.
+ *
+ * \param[in] ctx          Pointer to this instance's context
+ * \param[in] cb_get       Pointer to the get callback function
+ * \param[in] cb_release   Pointer to the release callback function
+ * \param[in] cb_priv      Callback's private data
+ *
+ * \retval #VPX_CODEC_OK
+ *     External frame buffers will be used by libvpx.
+ * \retval #VPX_CODEC_INVALID_PARAM
+ *     One or more of the callbacks were NULL.
+ * \retval #VPX_CODEC_ERROR
+ *     Decoder context not initialized, or algorithm not capable of
+ *     using external frame buffers.
+ *
+ * \note
+ * When decoding VP9, the application may be required to pass in at least
+ * #VP9_MAXIMUM_REF_BUFFERS + #VPX_MAXIMUM_WORK_BUFFERS external frame
+ * buffers.
+ */
+vpx_codec_err_t vpx_codec_set_frame_buffer_functions(
+    vpx_codec_ctx_t *ctx, vpx_get_frame_buffer_cb_fn_t cb_get,
+    vpx_release_frame_buffer_cb_fn_t cb_release, void *cb_priv);
 
-  /*!@} - end defgroup cap_external_frame_buffer */
+/*!@} - end defgroup cap_external_frame_buffer */
 
-  /*!@} - end defgroup decoder*/
+/*!@} - end defgroup decoder*/
 #ifdef __cplusplus
 }
 #endif
 #endif  // VPX_VPX_DECODER_H_
-
diff --git a/vpx/vpx_encoder.h b/vpx/vpx_encoder.h
index 955e87351..12869043b 100644
--- a/vpx/vpx_encoder.h
+++ b/vpx/vpx_encoder.h
@@ -31,1013 +31,949 @@ extern "C" {
 
 #include "./vpx_codec.h"
 
-  /*! Temporal Scalability: Maximum length of the sequence defining frame
-   * layer membership
-   */
+/*! Temporal Scalability: Maximum length of the sequence defining frame
+ * layer membership
+ */
 #define VPX_TS_MAX_PERIODICITY 16
 
-  /*! Temporal Scalability: Maximum number of coding layers */
-#define VPX_TS_MAX_LAYERS       5
+/*! Temporal Scalability: Maximum number of coding layers */
+#define VPX_TS_MAX_LAYERS 5
 
-  /*!\deprecated Use #VPX_TS_MAX_PERIODICITY instead. */
+/*!\deprecated Use #VPX_TS_MAX_PERIODICITY instead. */
 #define MAX_PERIODICITY VPX_TS_MAX_PERIODICITY
 
 /*! Temporal+Spatial Scalability: Maximum number of coding layers */
-#define VPX_MAX_LAYERS  12  // 3 temporal + 4 spatial layers are allowed.
+#define VPX_MAX_LAYERS 12  // 3 temporal + 4 spatial layers are allowed.
 
 /*!\deprecated Use #VPX_MAX_LAYERS instead. */
-#define MAX_LAYERS    VPX_MAX_LAYERS  // 3 temporal + 4 spatial layers allowed.
+#define MAX_LAYERS VPX_MAX_LAYERS  // 3 temporal + 4 spatial layers allowed.
 
 /*! Spatial Scalability: Maximum number of coding layers */
-#define VPX_SS_MAX_LAYERS       5
+#define VPX_SS_MAX_LAYERS 5
 
 /*! Spatial Scalability: Default number of coding layers */
-#define VPX_SS_DEFAULT_LAYERS       1
-
-  /*!\brief Current ABI version number
-   *
-   * \internal
-   * If this file is altered in any way that changes the ABI, this value
-   * must be bumped.  Examples include, but are not limited to, changing
-   * types, removing or reassigning enums, adding/removing/rearranging
-   * fields to structures
-   */
-#define VPX_ENCODER_ABI_VERSION (5 + VPX_CODEC_ABI_VERSION) /**<\hideinitializer*/
+#define VPX_SS_DEFAULT_LAYERS 1
 
+/*!\brief Current ABI version number
+ *
+ * \internal
+ * If this file is altered in any way that changes the ABI, this value
+ * must be bumped.  Examples include, but are not limited to, changing
+ * types, removing or reassigning enums, adding/removing/rearranging
+ * fields to structures
+ */
+#define VPX_ENCODER_ABI_VERSION \
+  (5 + VPX_CODEC_ABI_VERSION) /**<\hideinitializer*/
 
-  /*! \brief Encoder capabilities bitfield
-   *
-   *  Each encoder advertises the capabilities it supports as part of its
-   *  ::vpx_codec_iface_t interface structure. Capabilities are extra
-   *  interfaces or functionality, and are not required to be supported
-   *  by an encoder.
-   *
-   *  The available flags are specified by VPX_CODEC_CAP_* defines.
-   */
-#define VPX_CODEC_CAP_PSNR  0x10000 /**< Can issue PSNR packets */
+/*! \brief Encoder capabilities bitfield
+ *
+ *  Each encoder advertises the capabilities it supports as part of its
+ *  ::vpx_codec_iface_t interface structure. Capabilities are extra
+ *  interfaces or functionality, and are not required to be supported
+ *  by an encoder.
+ *
+ *  The available flags are specified by VPX_CODEC_CAP_* defines.
+ */
+#define VPX_CODEC_CAP_PSNR 0x10000 /**< Can issue PSNR packets */
 
-  /*! Can output one partition at a time. Each partition is returned in its
-   *  own VPX_CODEC_CX_FRAME_PKT, with the FRAME_IS_FRAGMENT flag set for
-   *  every partition but the last. In this mode all frames are always
-   *  returned partition by partition.
-   */
-#define VPX_CODEC_CAP_OUTPUT_PARTITION  0x20000
+/*! Can output one partition at a time. Each partition is returned in its
+ *  own VPX_CODEC_CX_FRAME_PKT, with the FRAME_IS_FRAGMENT flag set for
+ *  every partition but the last. In this mode all frames are always
+ *  returned partition by partition.
+ */
+#define VPX_CODEC_CAP_OUTPUT_PARTITION 0x20000
 
 /*! Can support input images at greater than 8 bitdepth.
  */
-#define VPX_CODEC_CAP_HIGHBITDEPTH  0x40000
+#define VPX_CODEC_CAP_HIGHBITDEPTH 0x40000
 
-  /*! \brief Initialization-time Feature Enabling
-   *
-   *  Certain codec features must be known at initialization time, to allow
-   *  for proper memory allocation.
-   *
-   *  The available flags are specified by VPX_CODEC_USE_* defines.
-   */
-#define VPX_CODEC_USE_PSNR  0x10000 /**< Calculate PSNR on each frame */
-#define VPX_CODEC_USE_OUTPUT_PARTITION  0x20000 /**< Make the encoder output one
-  partition at a time. */
+/*! \brief Initialization-time Feature Enabling
+ *
+ *  Certain codec features must be known at initialization time, to allow
+ *  for proper memory allocation.
+ *
+ *  The available flags are specified by VPX_CODEC_USE_* defines.
+ */
+#define VPX_CODEC_USE_PSNR 0x10000 /**< Calculate PSNR on each frame */
+/*!\brief Make the encoder output one  partition at a time. */
+#define VPX_CODEC_USE_OUTPUT_PARTITION 0x20000
 #define VPX_CODEC_USE_HIGHBITDEPTH 0x40000 /**< Use high bitdepth */
 
+/*!\brief Generic fixed size buffer structure
+ *
+ * This structure is able to hold a reference to any fixed size buffer.
+ */
+typedef struct vpx_fixed_buf {
+  void *buf;       /**< Pointer to the data */
+  size_t sz;       /**< Length of the buffer, in chars */
+} vpx_fixed_buf_t; /**< alias for struct vpx_fixed_buf */
 
-  /*!\brief Generic fixed size buffer structure
-   *
-   * This structure is able to hold a reference to any fixed size buffer.
-   */
-  typedef struct vpx_fixed_buf {
-    void          *buf; /**< Pointer to the data */
-    size_t         sz;  /**< Length of the buffer, in chars */
-  } vpx_fixed_buf_t; /**< alias for struct vpx_fixed_buf */
+/*!\brief Time Stamp Type
+ *
+ * An integer, which when multiplied by the stream's time base, provides
+ * the absolute time of a sample.
+ */
+typedef int64_t vpx_codec_pts_t;
 
+/*!\brief Compressed Frame Flags
+ *
+ * This type represents a bitfield containing information about a compressed
+ * frame that may be useful to an application. The most significant 16 bits
+ * can be used by an algorithm to provide additional detail, for example to
+ * support frame types that are codec specific (MPEG-1 D-frames for example)
+ */
+typedef uint32_t vpx_codec_frame_flags_t;
+#define VPX_FRAME_IS_KEY 0x1 /**< frame is the start of a GOP */
+/*!\brief frame can be dropped without affecting the stream (no future frame
+ * depends on this one) */
+#define VPX_FRAME_IS_DROPPABLE 0x2
+/*!\brief frame should be decoded but will not be shown */
+#define VPX_FRAME_IS_INVISIBLE 0x4
+/*!\brief this is a fragment of the encoded frame */
+#define VPX_FRAME_IS_FRAGMENT 0x8
+
+/*!\brief Error Resilient flags
+ *
+ * These flags define which error resilient features to enable in the
+ * encoder. The flags are specified through the
+ * vpx_codec_enc_cfg::g_error_resilient variable.
+ */
+typedef uint32_t vpx_codec_er_flags_t;
+/*!\brief Improve resiliency against losses of whole frames */
+#define VPX_ERROR_RESILIENT_DEFAULT 0x1
+/*!\brief The frame partitions are independently decodable by the bool decoder,
+ * meaning that partitions can be decoded even though earlier partitions have
+ * been lost. Note that intra prediction is still done over the partition
+ * boundary. */
+#define VPX_ERROR_RESILIENT_PARTITIONS 0x2
+
+/*!\brief Encoder output packet variants
+ *
+ * This enumeration lists the different kinds of data packets that can be
+ * returned by calls to vpx_codec_get_cx_data(). Algorithms \ref MAY
+ * extend this list to provide additional functionality.
+ */
+enum vpx_codec_cx_pkt_kind {
+  VPX_CODEC_CX_FRAME_PKT,   /**< Compressed video frame */
+  VPX_CODEC_STATS_PKT,      /**< Two-pass statistics for this frame */
+  VPX_CODEC_FPMB_STATS_PKT, /**< first pass mb statistics for this frame */
+  VPX_CODEC_PSNR_PKT,       /**< PSNR statistics for this frame */
+// Spatial SVC is still experimental and may be removed before the next ABI
+// bump.
+#if VPX_ENCODER_ABI_VERSION > (5 + VPX_CODEC_ABI_VERSION)
+  VPX_CODEC_SPATIAL_SVC_LAYER_SIZES, /**< Sizes for each layer in this frame*/
+  VPX_CODEC_SPATIAL_SVC_LAYER_PSNR,  /**< PSNR for each layer in this frame*/
+#endif
+  VPX_CODEC_CUSTOM_PKT = 256 /**< Algorithm extensions  */
+};
 
-  /*!\brief Time Stamp Type
-   *
-   * An integer, which when multiplied by the stream's time base, provides
-   * the absolute time of a sample.
-   */
-  typedef int64_t vpx_codec_pts_t;
+/*!\brief Encoder output packet
+ *
+ * This structure contains the different kinds of output data the encoder
+ * may produce while compressing a frame.
+ */
+typedef struct vpx_codec_cx_pkt {
+  enum vpx_codec_cx_pkt_kind kind; /**< packet variant */
+  union {
+    struct {
+      void *buf; /**< compressed data buffer */
+      size_t sz; /**< length of compressed data */
+      /*!\brief time stamp to show frame (in timebase units) */
+      vpx_codec_pts_t pts;
+      /*!\brief duration to show frame (in timebase units) */
+      unsigned long duration;
+      vpx_codec_frame_flags_t flags; /**< flags for this frame */
+      /*!\brief the partition id defines the decoding order of the partitions.
+       * Only applicable when "output partition" mode is enabled. First
+       * partition has id 0.*/
+      int partition_id;
+    } frame;                            /**< data for compressed frame packet */
+    vpx_fixed_buf_t twopass_stats;      /**< data for two-pass packet */
+    vpx_fixed_buf_t firstpass_mb_stats; /**< first pass mb packet */
+    struct vpx_psnr_pkt {
+      unsigned int samples[4]; /**< Number of samples, total/y/u/v */
+      uint64_t sse[4];         /**< sum squared error, total/y/u/v */
+      double psnr[4];          /**< PSNR, total/y/u/v */
+    } psnr;                    /**< data for PSNR packet */
+    vpx_fixed_buf_t raw;       /**< data for arbitrary packets */
+// Spatial SVC is still experimental and may be removed before the next
+// ABI bump.
+#if VPX_ENCODER_ABI_VERSION > (5 + VPX_CODEC_ABI_VERSION)
+    size_t layer_sizes[VPX_SS_MAX_LAYERS];
+    struct vpx_psnr_pkt layer_psnr[VPX_SS_MAX_LAYERS];
+#endif
 
+    /* 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 vpx_codec_cx_pkt_kind)]; /**< fixed sz */
+  } data;                                               /**< packet data */
+} vpx_codec_cx_pkt_t; /**< alias for struct vpx_codec_cx_pkt */
 
-  /*!\brief Compressed Frame Flags
-   *
-   * This type represents a bitfield containing information about a compressed
-   * frame that may be useful to an application. The most significant 16 bits
-   * can be used by an algorithm to provide additional detail, for example to
-   * support frame types that are codec specific (MPEG-1 D-frames for example)
+/*!\brief Encoder return output buffer callback
+ *
+ * This callback function, when registered, returns with packets when each
+ * spatial layer is encoded.
+ */
+// putting the definitions here for now. (agrange: find if there
+// is a better place for this)
+typedef void (*vpx_codec_enc_output_cx_pkt_cb_fn_t)(vpx_codec_cx_pkt_t *pkt,
+                                                    void *user_data);
+
+/*!\brief Callback function pointer / user data pair storage */
+typedef struct vpx_codec_enc_output_cx_cb_pair {
+  vpx_codec_enc_output_cx_pkt_cb_fn_t output_cx_pkt; /**< Callback function */
+  void *user_priv; /**< Pointer to private data */
+} vpx_codec_priv_output_cx_pkt_cb_pair_t;
+
+/*!\brief Rational Number
+ *
+ * This structure holds a fractional value.
+ */
+typedef struct vpx_rational {
+  int num;        /**< fraction numerator */
+  int den;        /**< fraction denominator */
+} vpx_rational_t; /**< alias for struct vpx_rational */
+
+/*!\brief Multi-pass Encoding Pass */
+enum vpx_enc_pass {
+  VPX_RC_ONE_PASS,   /**< Single pass mode */
+  VPX_RC_FIRST_PASS, /**< First pass of multi-pass mode */
+  VPX_RC_LAST_PASS   /**< Final pass of multi-pass mode */
+};
+
+/*!\brief Rate control mode */
+enum vpx_rc_mode {
+  VPX_VBR, /**< Variable Bit Rate (VBR) mode */
+  VPX_CBR, /**< Constant Bit Rate (CBR) mode */
+  VPX_CQ,  /**< Constrained Quality (CQ)  mode */
+  VPX_Q,   /**< Constant Quality (Q) mode */
+};
+
+/*!\brief Keyframe placement mode.
+ *
+ * This enumeration determines whether keyframes are placed automatically by
+ * the encoder or whether this behavior is disabled. Older releases of this
+ * SDK were implemented such that VPX_KF_FIXED meant keyframes were disabled.
+ * This name is confusing for this behavior, so the new symbols to be used
+ * are VPX_KF_AUTO and VPX_KF_DISABLED.
+ */
+enum vpx_kf_mode {
+  VPX_KF_FIXED,       /**< deprecated, implies VPX_KF_DISABLED */
+  VPX_KF_AUTO,        /**< Encoder determines optimal placement automatically */
+  VPX_KF_DISABLED = 0 /**< Encoder does not place keyframes. */
+};
+
+/*!\brief Encoded Frame Flags
+ *
+ * This type indicates a bitfield to be passed to vpx_codec_encode(), defining
+ * per-frame boolean values. By convention, bits common to all codecs will be
+ * named VPX_EFLAG_*, and bits specific to an algorithm will be named
+ * /algo/_eflag_*. The lower order 16 bits are reserved for common use.
+ */
+typedef long vpx_enc_frame_flags_t;
+#define VPX_EFLAG_FORCE_KF (1 << 0) /**< Force this frame to be a keyframe */
+
+/*!\brief Encoder configuration structure
+ *
+ * This structure contains the encoder settings that have common representations
+ * across all codecs. This doesn't imply that all codecs support all features,
+ * however.
+ */
+typedef struct vpx_codec_enc_cfg {
+  /*
+   * generic settings (g)
    */
-  typedef uint32_t vpx_codec_frame_flags_t;
-#define VPX_FRAME_IS_KEY       0x1 /**< frame is the start of a GOP */
-#define VPX_FRAME_IS_DROPPABLE 0x2 /**< frame can be dropped without affecting
-  the stream (no future frame depends on
-              this one) */
-#define VPX_FRAME_IS_INVISIBLE 0x4 /**< frame should be decoded but will not
-  be shown */
-#define VPX_FRAME_IS_FRAGMENT  0x8 /**< this is a fragment of the encoded
-  frame */
-
-  /*!\brief Error Resilient flags
+
+  /*!\brief Algorithm specific "usage" value
    *
-   * These flags define which error resilient features to enable in the
-   * encoder. The flags are specified through the
-   * vpx_codec_enc_cfg::g_error_resilient variable.
+   * Algorithms may define multiple values for usage, which may convey the
+   * intent of how the application intends to use the stream. If this value
+   * is non-zero, consult the documentation for the codec to determine its
+   * meaning.
    */
-  typedef uint32_t vpx_codec_er_flags_t;
-#define VPX_ERROR_RESILIENT_DEFAULT     0x1 /**< Improve resiliency against
-  losses of whole frames */
-#define VPX_ERROR_RESILIENT_PARTITIONS  0x2 /**< The frame partitions are
-  independently decodable by the
-  bool decoder, meaning that
-  partitions can be decoded even
-  though earlier partitions have
-  been lost. Note that intra
-  prediction is still done over
-  the partition boundary. */
-
-  /*!\brief Encoder output packet variants
+  unsigned int g_usage;
+
+  /*!\brief Maximum number of threads to use
    *
-   * This enumeration lists the different kinds of data packets that can be
-   * returned by calls to vpx_codec_get_cx_data(). Algorithms \ref MAY
-   * extend this list to provide additional functionality.
+   * For multi-threaded implementations, use no more than this number of
+   * threads. The codec may use fewer threads than allowed. The value
+   * 0 is equivalent to the value 1.
    */
-  enum vpx_codec_cx_pkt_kind {
-    VPX_CODEC_CX_FRAME_PKT,    /**< Compressed video frame */
-    VPX_CODEC_STATS_PKT,       /**< Two-pass statistics for this frame */
-    VPX_CODEC_FPMB_STATS_PKT,  /**< first pass mb statistics for this frame */
-    VPX_CODEC_PSNR_PKT,        /**< PSNR statistics for this frame */
-    // Spatial SVC is still experimental and may be removed before the next ABI
-    // bump.
-#if VPX_ENCODER_ABI_VERSION > (5 + VPX_CODEC_ABI_VERSION)
-    VPX_CODEC_SPATIAL_SVC_LAYER_SIZES, /**< Sizes for each layer in this frame*/
-    VPX_CODEC_SPATIAL_SVC_LAYER_PSNR, /**< PSNR for each layer in this frame*/
-#endif
-    VPX_CODEC_CUSTOM_PKT = 256 /**< Algorithm extensions  */
-  };
-
+  unsigned int g_threads;
 
-  /*!\brief Encoder output packet
+  /*!\brief Bitstream profile to use
    *
-   * This structure contains the different kinds of output data the encoder
-   * may produce while compressing a frame.
+   * Some codecs support a notion of multiple bitstream profiles. Typically
+   * this maps to a set of features that are turned on or off. Often the
+   * profile to use is determined by the features of the intended decoder.
+   * Consult the documentation for the codec to determine the valid values
+   * for this parameter, or set to zero for a sane default.
    */
-  typedef struct vpx_codec_cx_pkt {
-    enum vpx_codec_cx_pkt_kind  kind; /**< packet variant */
-    union {
-      struct {
-        void                    *buf;      /**< compressed data buffer */
-        size_t                   sz;       /**< length of compressed data */
-        vpx_codec_pts_t          pts;      /**< time stamp to show frame
-                                                    (in timebase units) */
-        unsigned long            duration; /**< duration to show frame
-                                                    (in timebase units) */
-        vpx_codec_frame_flags_t  flags;    /**< flags for this frame */
-        int                      partition_id; /**< the partition id
-                                              defines the decoding order
-                                              of the partitions. Only
-                                              applicable when "output partition"
-                                              mode is enabled. First partition
-                                              has id 0.*/
-
-      } frame;  /**< data for compressed frame packet */
-      vpx_fixed_buf_t twopass_stats;  /**< data for two-pass packet */
-      vpx_fixed_buf_t firstpass_mb_stats; /**< first pass mb packet */
-      struct vpx_psnr_pkt {
-        unsigned int samples[4];  /**< Number of samples, total/y/u/v */
-        uint64_t     sse[4];      /**< sum squared error, total/y/u/v */
-        double       psnr[4];     /**< PSNR, total/y/u/v */
-      } psnr;                       /**< data for PSNR packet */
-      vpx_fixed_buf_t raw;     /**< data for arbitrary packets */
-      // Spatial SVC is still experimental and may be removed before the next
-      // ABI bump.
-#if VPX_ENCODER_ABI_VERSION > (5 + VPX_CODEC_ABI_VERSION)
-      size_t layer_sizes[VPX_SS_MAX_LAYERS];
-      struct vpx_psnr_pkt layer_psnr[VPX_SS_MAX_LAYERS];
-#endif
+  unsigned int g_profile; /**< profile of bitstream to use */
 
-      /* 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 vpx_codec_cx_pkt_kind)]; /**< fixed sz */
-    } data; /**< packet data */
-  } vpx_codec_cx_pkt_t; /**< alias for struct vpx_codec_cx_pkt */
-
-
-  /*!\brief Encoder return output buffer callback
+  /*!\brief Width of the frame
    *
-   * This callback function, when registered, returns with packets when each
-   * spatial layer is encoded.
+   * This value identifies the presentation resolution of the frame,
+   * in pixels. Note that the frames passed as input to the encoder must
+   * have this resolution. Frames will be presented by the decoder in this
+   * resolution, independent of any spatial resampling the encoder may do.
    */
-  // putting the definitions here for now. (agrange: find if there
-  // is a better place for this)
-  typedef void (* vpx_codec_enc_output_cx_pkt_cb_fn_t)(vpx_codec_cx_pkt_t *pkt,
-                                                       void *user_data);
-
-  /*!\brief Callback function pointer / user data pair storage */
-  typedef struct vpx_codec_enc_output_cx_cb_pair {
-    vpx_codec_enc_output_cx_pkt_cb_fn_t output_cx_pkt; /**< Callback function */
-    void                            *user_priv; /**< Pointer to private data */
-  } vpx_codec_priv_output_cx_pkt_cb_pair_t;
-
-  /*!\brief Rational Number
+  unsigned int g_w;
+
+  /*!\brief Height of the frame
    *
-   * This structure holds a fractional value.
+   * This value identifies the presentation resolution of the frame,
+   * in pixels. Note that the frames passed as input to the encoder must
+   * have this resolution. Frames will be presented by the decoder in this
+   * resolution, independent of any spatial resampling the encoder may do.
    */
-  typedef struct vpx_rational {
-    int num; /**< fraction numerator */
-    int den; /**< fraction denominator */
-  } vpx_rational_t; /**< alias for struct vpx_rational */
-
-
-  /*!\brief Multi-pass Encoding Pass */
-  enum vpx_enc_pass {
-    VPX_RC_ONE_PASS,   /**< Single pass mode */
-    VPX_RC_FIRST_PASS, /**< First pass of multi-pass mode */
-    VPX_RC_LAST_PASS   /**< Final pass of multi-pass mode */
-  };
+  unsigned int g_h;
 
-
-  /*!\brief Rate control mode */
-  enum vpx_rc_mode {
-    VPX_VBR,  /**< Variable Bit Rate (VBR) mode */
-    VPX_CBR,  /**< Constant Bit Rate (CBR) mode */
-    VPX_CQ,   /**< Constrained Quality (CQ)  mode */
-    VPX_Q,    /**< Constant Quality (Q) mode */
-  };
-
-
-  /*!\brief Keyframe placement mode.
+  /*!\brief Bit-depth of the codec
    *
-   * This enumeration determines whether keyframes are placed automatically by
-   * the encoder or whether this behavior is disabled. Older releases of this
-   * SDK were implemented such that VPX_KF_FIXED meant keyframes were disabled.
-   * This name is confusing for this behavior, so the new symbols to be used
-   * are VPX_KF_AUTO and VPX_KF_DISABLED.
+   * This value identifies the bit_depth of the codec,
+   * Only certain bit-depths are supported as identified in the
+   * vpx_bit_depth_t enum.
    */
-  enum vpx_kf_mode {
-    VPX_KF_FIXED, /**< deprecated, implies VPX_KF_DISABLED */
-    VPX_KF_AUTO,  /**< Encoder determines optimal placement automatically */
-    VPX_KF_DISABLED = 0 /**< Encoder does not place keyframes. */
-  };
+  vpx_bit_depth_t g_bit_depth;
 
-
-  /*!\brief Encoded Frame Flags
+  /*!\brief Bit-depth of the input frames
    *
-   * This type indicates a bitfield to be passed to vpx_codec_encode(), defining
-   * per-frame boolean values. By convention, bits common to all codecs will be
-   * named VPX_EFLAG_*, and bits specific to an algorithm will be named
-   * /algo/_eflag_*. The lower order 16 bits are reserved for common use.
+   * This value identifies the bit_depth of the input frames in bits.
+   * Note that the frames passed as input to the encoder must have
+   * this bit-depth.
    */
-  typedef long vpx_enc_frame_flags_t;
-#define VPX_EFLAG_FORCE_KF (1<<0)  /**< Force this frame to be a keyframe */
-
+  unsigned int g_input_bit_depth;
+
+  /*!\brief Stream timebase units
+   *
+   * Indicates the smallest interval of time, in seconds, used by the stream.
+   * For fixed frame rate material, or variable frame rate material where
+   * frames are timed at a multiple of a given clock (ex: video capture),
+   * the \ref RECOMMENDED method is to set the timebase to the reciprocal
+   * of the frame rate (ex: 1001/30000 for 29.970 Hz NTSC). This allows the
+   * pts to correspond to the frame number, which can be handy. For
+   * re-encoding video from containers with absolute time timestamps, the
+   * \ref RECOMMENDED method is to set the timebase to that of the parent
+   * container or multimedia framework (ex: 1/1000 for ms, as in FLV).
+   */
+  struct vpx_rational g_timebase;
 
-  /*!\brief Encoder configuration structure
+  /*!\brief Enable error resilient modes.
    *
-   * This structure contains the encoder settings that have common representations
-   * across all codecs. This doesn't imply that all codecs support all features,
-   * however.
+   * The error resilient bitfield indicates to the encoder which features
+   * it should enable to take measures for streaming over lossy or noisy
+   * links.
    */
-  typedef struct vpx_codec_enc_cfg {
-    /*
-     * generic settings (g)
-     */
-
-    /*!\brief Algorithm specific "usage" value
-     *
-     * Algorithms may define multiple values for usage, which may convey the
-     * intent of how the application intends to use the stream. If this value
-     * is non-zero, consult the documentation for the codec to determine its
-     * meaning.
-     */
-    unsigned int           g_usage;
-
-
-    /*!\brief Maximum number of threads to use
-     *
-     * For multi-threaded implementations, use no more than this number of
-     * threads. The codec may use fewer threads than allowed. The value
-     * 0 is equivalent to the value 1.
-     */
-    unsigned int           g_threads;
-
-
-    /*!\brief Bitstream profile to use
-     *
-     * Some codecs support a notion of multiple bitstream profiles. Typically
-     * this maps to a set of features that are turned on or off. Often the
-     * profile to use is determined by the features of the intended decoder.
-     * Consult the documentation for the codec to determine the valid values
-     * for this parameter, or set to zero for a sane default.
-     */
-    unsigned int           g_profile;  /**< profile of bitstream to use */
-
-
-
-    /*!\brief Width of the frame
-     *
-     * This value identifies the presentation resolution of the frame,
-     * in pixels. Note that the frames passed as input to the encoder must
-     * have this resolution. Frames will be presented by the decoder in this
-     * resolution, independent of any spatial resampling the encoder may do.
-     */
-    unsigned int           g_w;
-
-
-    /*!\brief Height of the frame
-     *
-     * This value identifies the presentation resolution of the frame,
-     * in pixels. Note that the frames passed as input to the encoder must
-     * have this resolution. Frames will be presented by the decoder in this
-     * resolution, independent of any spatial resampling the encoder may do.
-     */
-    unsigned int           g_h;
-
-    /*!\brief Bit-depth of the codec
-     *
-     * This value identifies the bit_depth of the codec,
-     * Only certain bit-depths are supported as identified in the
-     * vpx_bit_depth_t enum.
-     */
-    vpx_bit_depth_t        g_bit_depth;
-
-    /*!\brief Bit-depth of the input frames
-     *
-     * This value identifies the bit_depth of the input frames in bits.
-     * Note that the frames passed as input to the encoder must have
-     * this bit-depth.
-     */
-    unsigned int           g_input_bit_depth;
-
-    /*!\brief Stream timebase units
-     *
-     * Indicates the smallest interval of time, in seconds, used by the stream.
-     * For fixed frame rate material, or variable frame rate material where
-     * frames are timed at a multiple of a given clock (ex: video capture),
-     * the \ref RECOMMENDED method is to set the timebase to the reciprocal
-     * of the frame rate (ex: 1001/30000 for 29.970 Hz NTSC). This allows the
-     * pts to correspond to the frame number, which can be handy. For
-     * re-encoding video from containers with absolute time timestamps, the
-     * \ref RECOMMENDED method is to set the timebase to that of the parent
-     * container or multimedia framework (ex: 1/1000 for ms, as in FLV).
-     */
-    struct vpx_rational    g_timebase;
-
-
-    /*!\brief Enable error resilient modes.
-     *
-     * The error resilient bitfield indicates to the encoder which features
-     * it should enable to take measures for streaming over lossy or noisy
-     * links.
-     */
-    vpx_codec_er_flags_t   g_error_resilient;
-
-
-    /*!\brief Multi-pass Encoding Mode
-     *
-     * This value should be set to the current phase for multi-pass encoding.
-     * For single pass, set to #VPX_RC_ONE_PASS.
-     */
-    enum vpx_enc_pass      g_pass;
-
-
-    /*!\brief Allow lagged encoding
-     *
-     * If set, this value allows the encoder to consume a number of input
-     * frames before producing output frames. This allows the encoder to
-     * base decisions for the current frame on future frames. This does
-     * increase the latency of the encoding pipeline, so it is not appropriate
-     * in all situations (ex: realtime encoding).
-     *
-     * Note that this is a maximum value -- the encoder may produce frames
-     * sooner than the given limit. Set this value to 0 to disable this
-     * feature.
-     */
-    unsigned int           g_lag_in_frames;
-
-
-    /*
-     * rate control settings (rc)
-     */
-
-    /*!\brief Temporal resampling configuration, if supported by the codec.
-     *
-     * Temporal resampling allows the codec to "drop" frames as a strategy to
-     * meet its target data rate. This can cause temporal discontinuities in
-     * the encoded video, which may appear as stuttering during playback. This
-     * trade-off is often acceptable, but for many applications is not. It can
-     * be disabled in these cases.
-     *
-     * Note that not all codecs support this feature. All vpx VPx codecs do.
-     * For other codecs, consult the documentation for that algorithm.
-     *
-     * This threshold is described as a percentage of the target data buffer.
-     * When the data buffer falls below this percentage of fullness, a
-     * dropped frame is indicated. Set the threshold to zero (0) to disable
-     * this feature.
-     */
-    unsigned int           rc_dropframe_thresh;
-
-
-    /*!\brief Enable/disable spatial resampling, if supported by the codec.
-     *
-     * Spatial resampling allows the codec to compress a lower resolution
-     * version of the frame, which is then upscaled by the encoder to the
-     * correct presentation resolution. This increases visual quality at
-     * low data rates, at the expense of CPU time on the encoder/decoder.
-     */
-    unsigned int           rc_resize_allowed;
-
-    /*!\brief Internal coded frame width.
-     *
-     * If spatial resampling is enabled this specifies the width of the
-     * encoded frame.
-     */
-    unsigned int           rc_scaled_width;
-
-    /*!\brief Internal coded frame height.
-     *
-     * If spatial resampling is enabled this specifies the height of the
-     * encoded frame.
-     */
-    unsigned int           rc_scaled_height;
-
-    /*!\brief Spatial resampling up watermark.
-     *
-     * This threshold is described as a percentage of the target data buffer.
-     * When the data buffer rises above this percentage of fullness, the
-     * encoder will step up to a higher resolution version of the frame.
-     */
-    unsigned int           rc_resize_up_thresh;
-
-
-    /*!\brief Spatial resampling down watermark.
-     *
-     * This threshold is described as a percentage of the target data buffer.
-     * When the data buffer falls below this percentage of fullness, the
-     * encoder will step down to a lower resolution version of the frame.
-     */
-    unsigned int           rc_resize_down_thresh;
-
-
-    /*!\brief Rate control algorithm to use.
-     *
-     * Indicates whether the end usage of this stream is to be streamed over
-     * a bandwidth constrained link, indicating that Constant Bit Rate (CBR)
-     * mode should be used, or whether it will be played back on a high
-     * bandwidth link, as from a local disk, where higher variations in
-     * bitrate are acceptable.
-     */
-    enum vpx_rc_mode       rc_end_usage;
-
-
-    /*!\brief Two-pass stats buffer.
-     *
-     * A buffer containing all of the stats packets produced in the first
-     * pass, concatenated.
-     */
-    vpx_fixed_buf_t   rc_twopass_stats_in;
-
-    /*!\brief first pass mb stats buffer.
-     *
-     * A buffer containing all of the first pass mb stats packets produced
-     * in the first pass, concatenated.
-     */
-    vpx_fixed_buf_t   rc_firstpass_mb_stats_in;
-
-    /*!\brief Target data rate
-     *
-     * Target bandwidth to use for this stream, in kilobits per second.
-     */
-    unsigned int           rc_target_bitrate;
-
-
-    /*
-     * quantizer settings
-     */
-
-
-    /*!\brief Minimum (Best Quality) Quantizer
-     *
-     * The quantizer is the most direct control over the quality of the
-     * encoded image. The range of valid values for the quantizer is codec
-     * specific. Consult the documentation for the codec to determine the
-     * values to use. To determine the range programmatically, call
-     * vpx_codec_enc_config_default() with a usage value of 0.
-     */
-    unsigned int           rc_min_quantizer;
-
-
-    /*!\brief Maximum (Worst Quality) Quantizer
-     *
-     * The quantizer is the most direct control over the quality of the
-     * encoded image. The range of valid values for the quantizer is codec
-     * specific. Consult the documentation for the codec to determine the
-     * values to use. To determine the range programmatically, call
-     * vpx_codec_enc_config_default() with a usage value of 0.
-     */
-    unsigned int           rc_max_quantizer;
-
-
-    /*
-     * bitrate tolerance
-     */
-
-
-    /*!\brief Rate control adaptation undershoot control
-     *
-     * This value, expressed as a percentage of the target bitrate,
-     * controls the maximum allowed adaptation speed of the codec.
-     * This factor controls the maximum amount of bits that can
-     * be subtracted from the target bitrate in order to compensate
-     * for prior overshoot.
-     *
-     * Valid values in the range 0-1000.
-     */
-    unsigned int           rc_undershoot_pct;
-
-
-    /*!\brief Rate control adaptation overshoot control
-     *
-     * This value, expressed as a percentage of the target bitrate,
-     * controls the maximum allowed adaptation speed of the codec.
-     * This factor controls the maximum amount of bits that can
-     * be added to the target bitrate in order to compensate for
-     * prior undershoot.
-     *
-     * Valid values in the range 0-1000.
-     */
-    unsigned int           rc_overshoot_pct;
-
-
-    /*
-     * decoder buffer model parameters
-     */
-
-
-    /*!\brief Decoder Buffer Size
-     *
-     * This value indicates the amount of data that may be buffered by the
-     * decoding application. Note that this value is expressed in units of
-     * time (milliseconds). For example, a value of 5000 indicates that the
-     * client will buffer (at least) 5000ms worth of encoded data. Use the
-     * target bitrate (#rc_target_bitrate) to convert to bits/bytes, if
-     * necessary.
-     */
-    unsigned int           rc_buf_sz;
-
-
-    /*!\brief Decoder Buffer Initial Size
-     *
-     * This value indicates the amount of data that will be buffered by the
-     * decoding application prior to beginning playback. This value is
-     * expressed in units of time (milliseconds). Use the target bitrate
-     * (#rc_target_bitrate) to convert to bits/bytes, if necessary.
-     */
-    unsigned int           rc_buf_initial_sz;
-
-
-    /*!\brief Decoder Buffer Optimal Size
-     *
-     * This value indicates the amount of data that the encoder should try
-     * to maintain in the decoder's buffer. This value is expressed in units
-     * of time (milliseconds). Use the target bitrate (#rc_target_bitrate)
-     * to convert to bits/bytes, if necessary.
-     */
-    unsigned int           rc_buf_optimal_sz;
-
-
-    /*
-     * 2 pass rate control parameters
-     */
-
-
-    /*!\brief Two-pass mode CBR/VBR bias
-     *
-     * Bias, expressed on a scale of 0 to 100, for determining target size
-     * for the current frame. The value 0 indicates the optimal CBR mode
-     * value should be used. The value 100 indicates the optimal VBR mode
-     * value should be used. Values in between indicate which way the
-     * encoder should "lean."
-     */
-    unsigned int           rc_2pass_vbr_bias_pct;       /**< RC mode bias between CBR and VBR(0-100: 0->CBR, 100->VBR)   */
-
-
-    /*!\brief Two-pass mode per-GOP minimum bitrate
-     *
-     * This value, expressed as a percentage of the target bitrate, indicates
-     * the minimum bitrate to be used for a single GOP (aka "section")
-     */
-    unsigned int           rc_2pass_vbr_minsection_pct;
+  vpx_codec_er_flags_t g_error_resilient;
 
+  /*!\brief Multi-pass Encoding Mode
+   *
+   * This value should be set to the current phase for multi-pass encoding.
+   * For single pass, set to #VPX_RC_ONE_PASS.
+   */
+  enum vpx_enc_pass g_pass;
 
-    /*!\brief Two-pass mode per-GOP maximum bitrate
-     *
-     * This value, expressed as a percentage of the target bitrate, indicates
-     * the maximum bitrate to be used for a single GOP (aka "section")
-     */
-    unsigned int           rc_2pass_vbr_maxsection_pct;
+  /*!\brief Allow lagged encoding
+   *
+   * If set, this value allows the encoder to consume a number of input
+   * frames before producing output frames. This allows the encoder to
+   * base decisions for the current frame on future frames. This does
+   * increase the latency of the encoding pipeline, so it is not appropriate
+   * in all situations (ex: realtime encoding).
+   *
+   * Note that this is a maximum value -- the encoder may produce frames
+   * sooner than the given limit. Set this value to 0 to disable this
+   * feature.
+   */
+  unsigned int g_lag_in_frames;
 
+  /*
+   * rate control settings (rc)
+   */
 
-    /*
-     * keyframing settings (kf)
-     */
+  /*!\brief Temporal resampling configuration, if supported by the codec.
+   *
+   * Temporal resampling allows the codec to "drop" frames as a strategy to
+   * meet its target data rate. This can cause temporal discontinuities in
+   * the encoded video, which may appear as stuttering during playback. This
+   * trade-off is often acceptable, but for many applications is not. It can
+   * be disabled in these cases.
+   *
+   * Note that not all codecs support this feature. All vpx VPx codecs do.
+   * For other codecs, consult the documentation for that algorithm.
+   *
+   * This threshold is described as a percentage of the target data buffer.
+   * When the data buffer falls below this percentage of fullness, a
+   * dropped frame is indicated. Set the threshold to zero (0) to disable
+   * this feature.
+   */
+  unsigned int rc_dropframe_thresh;
 
-    /*!\brief Keyframe placement mode
-     *
-     * This value indicates whether the encoder should place keyframes at a
-     * fixed interval, or determine the optimal placement automatically
-     * (as governed by the #kf_min_dist and #kf_max_dist parameters)
-     */
-    enum vpx_kf_mode       kf_mode;
+  /*!\brief Enable/disable spatial resampling, if supported by the codec.
+   *
+   * Spatial resampling allows the codec to compress a lower resolution
+   * version of the frame, which is then upscaled by the encoder to the
+   * correct presentation resolution. This increases visual quality at
+   * low data rates, at the expense of CPU time on the encoder/decoder.
+   */
+  unsigned int rc_resize_allowed;
 
+  /*!\brief Internal coded frame width.
+   *
+   * If spatial resampling is enabled this specifies the width of the
+   * encoded frame.
+   */
+  unsigned int rc_scaled_width;
 
-    /*!\brief Keyframe minimum interval
-     *
-     * This value, expressed as a number of frames, prevents the encoder from
-     * placing a keyframe nearer than kf_min_dist to the previous keyframe. At
-     * least kf_min_dist frames non-keyframes will be coded before the next
-     * keyframe. Set kf_min_dist equal to kf_max_dist for a fixed interval.
-     */
-    unsigned int           kf_min_dist;
+  /*!\brief Internal coded frame height.
+   *
+   * If spatial resampling is enabled this specifies the height of the
+   * encoded frame.
+   */
+  unsigned int rc_scaled_height;
 
+  /*!\brief Spatial resampling up watermark.
+   *
+   * This threshold is described as a percentage of the target data buffer.
+   * When the data buffer rises above this percentage of fullness, the
+   * encoder will step up to a higher resolution version of the frame.
+   */
+  unsigned int rc_resize_up_thresh;
 
-    /*!\brief Keyframe maximum interval
-     *
-     * This value, expressed as a number of frames, forces the encoder to code
-     * a keyframe if one has not been coded in the last kf_max_dist frames.
-     * A value of 0 implies all frames will be keyframes. Set kf_min_dist
-     * equal to kf_max_dist for a fixed interval.
-     */
-    unsigned int           kf_max_dist;
+  /*!\brief Spatial resampling down watermark.
+   *
+   * This threshold is described as a percentage of the target data buffer.
+   * When the data buffer falls below this percentage of fullness, the
+   * encoder will step down to a lower resolution version of the frame.
+   */
+  unsigned int rc_resize_down_thresh;
 
-    /*
-     * Spatial scalability settings (ss)
-     */
+  /*!\brief Rate control algorithm to use.
+   *
+   * Indicates whether the end usage of this stream is to be streamed over
+   * a bandwidth constrained link, indicating that Constant Bit Rate (CBR)
+   * mode should be used, or whether it will be played back on a high
+   * bandwidth link, as from a local disk, where higher variations in
+   * bitrate are acceptable.
+   */
+  enum vpx_rc_mode rc_end_usage;
 
-    /*!\brief Number of spatial coding layers.
-     *
-     * This value specifies the number of spatial coding layers to be used.
-     */
-    unsigned int           ss_number_layers;
+  /*!\brief Two-pass stats buffer.
+   *
+   * A buffer containing all of the stats packets produced in the first
+   * pass, concatenated.
+   */
+  vpx_fixed_buf_t rc_twopass_stats_in;
 
-    /*!\brief Enable auto alt reference flags for each spatial layer.
-     *
-     * These values specify if auto alt reference frame is enabled for each
-     * spatial layer.
-     */
-    int                    ss_enable_auto_alt_ref[VPX_SS_MAX_LAYERS];
+  /*!\brief first pass mb stats buffer.
+   *
+   * A buffer containing all of the first pass mb stats packets produced
+   * in the first pass, concatenated.
+   */
+  vpx_fixed_buf_t rc_firstpass_mb_stats_in;
 
-    /*!\brief Target bitrate for each spatial layer.
-     *
-     * These values specify the target coding bitrate to be used for each
-     * spatial layer.
-     */
-    unsigned int           ss_target_bitrate[VPX_SS_MAX_LAYERS];
+  /*!\brief Target data rate
+   *
+   * Target bandwidth to use for this stream, in kilobits per second.
+   */
+  unsigned int rc_target_bitrate;
 
-    /*!\brief Number of temporal coding layers.
-     *
-     * This value specifies the number of temporal layers to be used.
-     */
-    unsigned int           ts_number_layers;
+  /*
+   * quantizer settings
+   */
 
-    /*!\brief Target bitrate for each temporal layer.
-     *
-     * These values specify the target coding bitrate to be used for each
-     * temporal layer.
-     */
-    unsigned int           ts_target_bitrate[VPX_TS_MAX_LAYERS];
+  /*!\brief Minimum (Best Quality) Quantizer
+   *
+   * The quantizer is the most direct control over the quality of the
+   * encoded image. The range of valid values for the quantizer is codec
+   * specific. Consult the documentation for the codec to determine the
+   * values to use. To determine the range programmatically, call
+   * vpx_codec_enc_config_default() with a usage value of 0.
+   */
+  unsigned int rc_min_quantizer;
 
-    /*!\brief Frame rate decimation factor for each temporal layer.
-     *
-     * These values specify the frame rate decimation factors to apply
-     * to each temporal layer.
-     */
-    unsigned int           ts_rate_decimator[VPX_TS_MAX_LAYERS];
-
-    /*!\brief Length of the sequence defining frame temporal layer membership.
-     *
-     * This value specifies the length of the sequence that defines the
-     * membership of frames to temporal layers. For example, if the
-     * ts_periodicity = 8, then the frames are assigned to coding layers with a
-     * repeated sequence of length 8.
-    */
-    unsigned int           ts_periodicity;
-
-    /*!\brief Template defining the membership of frames to temporal layers.
-     *
-     * This array defines the membership of frames to temporal coding layers.
-     * For a 2-layer encoding that assigns even numbered frames to one temporal
-     * layer (0) and odd numbered frames to a second temporal layer (1) with
-     * ts_periodicity=8, then ts_layer_id = (0,1,0,1,0,1,0,1).
-    */
-    unsigned int           ts_layer_id[VPX_TS_MAX_PERIODICITY];
-
-    /*!\brief Target bitrate for each spatial/temporal layer.
-     *
-     * These values specify the target coding bitrate to be used for each
-     * spatial/temporal layer.
-     *
-     */
-    unsigned int           layer_target_bitrate[VPX_MAX_LAYERS];
+  /*!\brief Maximum (Worst Quality) Quantizer
+   *
+   * The quantizer is the most direct control over the quality of the
+   * encoded image. The range of valid values for the quantizer is codec
+   * specific. Consult the documentation for the codec to determine the
+   * values to use. To determine the range programmatically, call
+   * vpx_codec_enc_config_default() with a usage value of 0.
+   */
+  unsigned int rc_max_quantizer;
 
-    /*!\brief Temporal layering mode indicating which temporal layering scheme to use.
-     *
-     * The value (refer to VP9E_TEMPORAL_LAYERING_MODE) specifies the
-     * temporal layering mode to use.
-     *
-     */
-    int                    temporal_layering_mode;
-  } vpx_codec_enc_cfg_t; /**< alias for struct vpx_codec_enc_cfg */
+  /*
+   * bitrate tolerance
+   */
 
-  /*!\brief  vp9 svc extra configure parameters
+  /*!\brief Rate control adaptation undershoot control
    *
-   * This defines max/min quantizers and scale factors for each layer
+   * This value, expressed as a percentage of the target bitrate,
+   * controls the maximum allowed adaptation speed of the codec.
+   * This factor controls the maximum amount of bits that can
+   * be subtracted from the target bitrate in order to compensate
+   * for prior overshoot.
    *
+   * Valid values in the range 0-1000.
    */
-  typedef struct vpx_svc_parameters {
-    int max_quantizers[VPX_MAX_LAYERS]; /**< Max Q for each layer */
-    int min_quantizers[VPX_MAX_LAYERS]; /**< Min Q for each layer */
-    int scaling_factor_num[VPX_MAX_LAYERS]; /**< Scaling factor-numerator */
-    int scaling_factor_den[VPX_MAX_LAYERS]; /**< Scaling factor-denominator */
-    int temporal_layering_mode; /**< Temporal layering mode */
-  } vpx_svc_extra_cfg_t;
-
+  unsigned int rc_undershoot_pct;
 
-  /*!\brief Initialize an encoder instance
+  /*!\brief Rate control adaptation overshoot control
    *
-   * Initializes a encoder context using the given interface. Applications
-   * should call the vpx_codec_enc_init convenience macro instead of this
-   * function directly, to ensure that the ABI version number parameter
-   * is properly initialized.
+   * This value, expressed as a percentage of the target bitrate,
+   * controls the maximum allowed adaptation speed of the codec.
+   * This factor controls the maximum amount of bits that can
+   * be added to the target bitrate in order to compensate for
+   * prior undershoot.
    *
-   * If the library was configured with --disable-multithread, this call
-   * is not thread safe and should be guarded with a lock if being used
-   * in a multithreaded context.
-   *
-   * \param[in]    ctx     Pointer to this instance's context.
-   * \param[in]    iface   Pointer to the algorithm interface to use.
-   * \param[in]    cfg     Configuration to use, if known. May be NULL.
-   * \param[in]    flags   Bitfield of VPX_CODEC_USE_* flags
-   * \param[in]    ver     ABI version number. Must be set to
-   *                       VPX_ENCODER_ABI_VERSION
-   * \retval #VPX_CODEC_OK
-   *     The decoder algorithm initialized.
-   * \retval #VPX_CODEC_MEM_ERROR
-   *     Memory allocation failed.
+   * Valid values in the range 0-1000.
    */
-  vpx_codec_err_t vpx_codec_enc_init_ver(vpx_codec_ctx_t      *ctx,
-                                         vpx_codec_iface_t    *iface,
-                                         const vpx_codec_enc_cfg_t *cfg,
-                                         vpx_codec_flags_t     flags,
-                                         int                   ver);
+  unsigned int rc_overshoot_pct;
 
+  /*
+   * decoder buffer model parameters
+   */
 
-  /*!\brief Convenience macro for vpx_codec_enc_init_ver()
+  /*!\brief Decoder Buffer Size
    *
-   * Ensures the ABI version parameter is properly set.
+   * This value indicates the amount of data that may be buffered by the
+   * decoding application. Note that this value is expressed in units of
+   * time (milliseconds). For example, a value of 5000 indicates that the
+   * client will buffer (at least) 5000ms worth of encoded data. Use the
+   * target bitrate (#rc_target_bitrate) to convert to bits/bytes, if
+   * necessary.
    */
-#define vpx_codec_enc_init(ctx, iface, cfg, flags) \
-  vpx_codec_enc_init_ver(ctx, iface, cfg, flags, VPX_ENCODER_ABI_VERSION)
-
+  unsigned int rc_buf_sz;
 
-  /*!\brief Initialize multi-encoder instance
+  /*!\brief Decoder Buffer Initial Size
    *
-   * Initializes multi-encoder context using the given interface.
-   * Applications should call the vpx_codec_enc_init_multi convenience macro
-   * instead of this function directly, to ensure that the ABI version number
-   * parameter is properly initialized.
-   *
-   * \param[in]    ctx     Pointer to this instance's context.
-   * \param[in]    iface   Pointer to the algorithm interface to use.
-   * \param[in]    cfg     Configuration to use, if known. May be NULL.
-   * \param[in]    num_enc Total number of encoders.
-   * \param[in]    flags   Bitfield of VPX_CODEC_USE_* flags
-   * \param[in]    dsf     Pointer to down-sampling factors.
-   * \param[in]    ver     ABI version number. Must be set to
-   *                       VPX_ENCODER_ABI_VERSION
-   * \retval #VPX_CODEC_OK
-   *     The decoder algorithm initialized.
-   * \retval #VPX_CODEC_MEM_ERROR
-   *     Memory allocation failed.
+   * This value indicates the amount of data that will be buffered by the
+   * decoding application prior to beginning playback. This value is
+   * expressed in units of time (milliseconds). Use the target bitrate
+   * (#rc_target_bitrate) to convert to bits/bytes, if necessary.
    */
-  vpx_codec_err_t vpx_codec_enc_init_multi_ver(vpx_codec_ctx_t      *ctx,
-                                               vpx_codec_iface_t    *iface,
-                                               vpx_codec_enc_cfg_t  *cfg,
-                                               int                   num_enc,
-                                               vpx_codec_flags_t     flags,
-                                               vpx_rational_t       *dsf,
-                                               int                   ver);
-
+  unsigned int rc_buf_initial_sz;
 
-  /*!\brief Convenience macro for vpx_codec_enc_init_multi_ver()
+  /*!\brief Decoder Buffer Optimal Size
    *
-   * Ensures the ABI version parameter is properly set.
+   * This value indicates the amount of data that the encoder should try
+   * to maintain in the decoder's buffer. This value is expressed in units
+   * of time (milliseconds). Use the target bitrate (#rc_target_bitrate)
+   * to convert to bits/bytes, if necessary.
    */
-#define vpx_codec_enc_init_multi(ctx, iface, cfg, num_enc, flags, dsf) \
-  vpx_codec_enc_init_multi_ver(ctx, iface, cfg, num_enc, flags, dsf, \
-                               VPX_ENCODER_ABI_VERSION)
+  unsigned int rc_buf_optimal_sz;
 
+  /*
+   * 2 pass rate control parameters
+   */
 
-  /*!\brief Get a default configuration
-   *
-   * Initializes a encoder configuration structure with default values. Supports
-   * the notion of "usages" so that an algorithm may offer different default
-   * settings depending on the user's intended goal. This function \ref SHOULD
-   * be called by all applications to initialize the configuration structure
-   * before specializing the configuration with application specific values.
-   *
-   * \param[in]    iface     Pointer to the algorithm interface to use.
-   * \param[out]   cfg       Configuration buffer to populate.
-   * \param[in]    reserved  Must set to 0 for VP8 and VP9.
+  /*!\brief Two-pass mode CBR/VBR bias
    *
-   * \retval #VPX_CODEC_OK
-   *     The configuration was populated.
-   * \retval #VPX_CODEC_INCAPABLE
-   *     Interface is not an encoder interface.
-   * \retval #VPX_CODEC_INVALID_PARAM
-   *     A parameter was NULL, or the usage value was not recognized.
+   * Bias, expressed on a scale of 0 to 100, for determining target size
+   * for the current frame. The value 0 indicates the optimal CBR mode
+   * value should be used. The value 100 indicates the optimal VBR mode
+   * value should be used. Values in between indicate which way the
+   * encoder should "lean."
    */
-  vpx_codec_err_t  vpx_codec_enc_config_default(vpx_codec_iface_t    *iface,
-                                                vpx_codec_enc_cfg_t  *cfg,
-                                                unsigned int          reserved);
+  unsigned int rc_2pass_vbr_bias_pct;
 
-
-  /*!\brief Set or change configuration
-   *
-   * Reconfigures an encoder instance according to the given configuration.
+  /*!\brief Two-pass mode per-GOP minimum bitrate
    *
-   * \param[in]    ctx     Pointer to this instance's context
-   * \param[in]    cfg     Configuration buffer to use
+   * This value, expressed as a percentage of the target bitrate, indicates
+   * the minimum bitrate to be used for a single GOP (aka "section")
+   */
+  unsigned int rc_2pass_vbr_minsection_pct;
+
+  /*!\brief Two-pass mode per-GOP maximum bitrate
    *
-   * \retval #VPX_CODEC_OK
-   *     The configuration was populated.
-   * \retval #VPX_CODEC_INCAPABLE
-   *     Interface is not an encoder interface.
-   * \retval #VPX_CODEC_INVALID_PARAM
-   *     A parameter was NULL, or the usage value was not recognized.
+   * This value, expressed as a percentage of the target bitrate, indicates
+   * the maximum bitrate to be used for a single GOP (aka "section")
    */
-  vpx_codec_err_t  vpx_codec_enc_config_set(vpx_codec_ctx_t            *ctx,
-                                            const vpx_codec_enc_cfg_t  *cfg);
+  unsigned int rc_2pass_vbr_maxsection_pct;
 
+  /*
+   * keyframing settings (kf)
+   */
 
-  /*!\brief Get global stream headers
+  /*!\brief Keyframe placement mode
    *
-   * Retrieves a stream level global header packet, if supported by the codec.
+   * This value indicates whether the encoder should place keyframes at a
+   * fixed interval, or determine the optimal placement automatically
+   * (as governed by the #kf_min_dist and #kf_max_dist parameters)
+   */
+  enum vpx_kf_mode kf_mode;
+
+  /*!\brief Keyframe minimum interval
    *
-   * \param[in]    ctx     Pointer to this instance's context
+   * This value, expressed as a number of frames, prevents the encoder from
+   * placing a keyframe nearer than kf_min_dist to the previous keyframe. At
+   * least kf_min_dist frames non-keyframes will be coded before the next
+   * keyframe. Set kf_min_dist equal to kf_max_dist for a fixed interval.
+   */
+  unsigned int kf_min_dist;
+
+  /*!\brief Keyframe maximum interval
    *
-   * \retval NULL
-   *     Encoder does not support global header
-   * \retval Non-NULL
-   *     Pointer to buffer containing global header packet
+   * This value, expressed as a number of frames, forces the encoder to code
+   * a keyframe if one has not been coded in the last kf_max_dist frames.
+   * A value of 0 implies all frames will be keyframes. Set kf_min_dist
+   * equal to kf_max_dist for a fixed interval.
    */
-  vpx_fixed_buf_t *vpx_codec_get_global_headers(vpx_codec_ctx_t   *ctx);
+  unsigned int kf_max_dist;
 
+  /*
+   * Spatial scalability settings (ss)
+   */
 
-#define VPX_DL_REALTIME     (1)        /**< deadline parameter analogous to
-  *   VPx REALTIME mode. */
-#define VPX_DL_GOOD_QUALITY (1000000)  /**< deadline parameter analogous to
-  *   VPx GOOD QUALITY mode. */
-#define VPX_DL_BEST_QUALITY (0)        /**< deadline parameter analogous to
-  *   VPx BEST QUALITY mode. */
-  /*!\brief Encode a frame
+  /*!\brief Number of spatial coding layers.
    *
-   * Encodes a video frame at the given "presentation time." The presentation
-   * time stamp (PTS) \ref MUST be strictly increasing.
-   *
-   * The encoder supports the notion of a soft real-time deadline. Given a
-   * non-zero value to the deadline parameter, the encoder will make a "best
-   * effort" guarantee to  return before the given time slice expires. It is
-   * implicit that limiting the available time to encode will degrade the
-   * output quality. The encoder can be given an unlimited time to produce the
-   * best possible frame by specifying a deadline of '0'. This deadline
-   * supercedes the VPx notion of "best quality, good quality, realtime".
-   * Applications that wish to map these former settings to the new deadline
-   * based system can use the symbols #VPX_DL_REALTIME, #VPX_DL_GOOD_QUALITY,
-   * and #VPX_DL_BEST_QUALITY.
-   *
-   * When the last frame has been passed to the encoder, this function should
-   * continue to be called, with the img parameter set to NULL. This will
-   * signal the end-of-stream condition to the encoder and allow it to encode
-   * any held buffers. Encoding is complete when vpx_codec_encode() is called
-   * and vpx_codec_get_cx_data() returns no data.
-   *
-   * \param[in]    ctx       Pointer to this instance's context
-   * \param[in]    img       Image data to encode, NULL to flush.
-   * \param[in]    pts       Presentation time stamp, in timebase units.
-   * \param[in]    duration  Duration to show frame, in timebase units.
-   * \param[in]    flags     Flags to use for encoding this frame.
-   * \param[in]    deadline  Time to spend encoding, in microseconds. (0=infinite)
-   *
-   * \retval #VPX_CODEC_OK
-   *     The configuration was populated.
-   * \retval #VPX_CODEC_INCAPABLE
-   *     Interface is not an encoder interface.
-   * \retval #VPX_CODEC_INVALID_PARAM
-   *     A parameter was NULL, the image format is unsupported, etc.
+   * This value specifies the number of spatial coding layers to be used.
    */
-  vpx_codec_err_t  vpx_codec_encode(vpx_codec_ctx_t            *ctx,
-                                    const vpx_image_t          *img,
-                                    vpx_codec_pts_t             pts,
-                                    unsigned long               duration,
-                                    vpx_enc_frame_flags_t       flags,
-                                    unsigned long               deadline);
-
-  /*!\brief Set compressed data output buffer
-   *
-   * Sets the buffer that the codec should output the compressed data
-   * into. This call effectively sets the buffer pointer returned in the
-   * next VPX_CODEC_CX_FRAME_PKT packet. Subsequent packets will be
-   * appended into this buffer. The buffer is preserved across frames,
-   * so applications must periodically call this function after flushing
-   * the accumulated compressed data to disk or to the network to reset
-   * the pointer to the buffer's head.
-   *
-   * `pad_before` bytes will be skipped before writing the compressed
-   * data, and `pad_after` bytes will be appended to the packet. The size
-   * of the packet will be the sum of the size of the actual compressed
-   * data, pad_before, and pad_after. The padding bytes will be preserved
-   * (not overwritten).
-   *
-   * Note that calling this function does not guarantee that the returned
-   * compressed data will be placed into the specified buffer. In the
-   * event that the encoded data will not fit into the buffer provided,
-   * the returned packet \ref MAY point to an internal buffer, as it would
-   * if this call were never used. In this event, the output packet will
-   * NOT have any padding, and the application must free space and copy it
-   * to the proper place. This is of particular note in configurations
-   * that may output multiple packets for a single encoded frame (e.g., lagged
-   * encoding) or if the application does not reset the buffer periodically.
-   *
-   * Applications may restore the default behavior of the codec providing
-   * the compressed data buffer by calling this function with a NULL
-   * buffer.
-   *
-   * Applications \ref MUSTNOT call this function during iteration of
-   * vpx_codec_get_cx_data().
-   *
-   * \param[in]    ctx         Pointer to this instance's context
-   * \param[in]    buf         Buffer to store compressed data into
-   * \param[in]    pad_before  Bytes to skip before writing compressed data
-   * \param[in]    pad_after   Bytes to skip after writing compressed data
+  unsigned int ss_number_layers;
+
+  /*!\brief Enable auto alt reference flags for each spatial layer.
    *
-   * \retval #VPX_CODEC_OK
-   *     The buffer was set successfully.
-   * \retval #VPX_CODEC_INVALID_PARAM
-   *     A parameter was NULL, the image format is unsupported, etc.
+   * These values specify if auto alt reference frame is enabled for each
+   * spatial layer.
    */
-  vpx_codec_err_t vpx_codec_set_cx_data_buf(vpx_codec_ctx_t       *ctx,
-                                            const vpx_fixed_buf_t *buf,
-                                            unsigned int           pad_before,
-                                            unsigned int           pad_after);
+  int ss_enable_auto_alt_ref[VPX_SS_MAX_LAYERS];
 
+  /*!\brief Target bitrate for each spatial layer.
+   *
+   * These values specify the target coding bitrate to be used for each
+   * spatial layer.
+   */
+  unsigned int ss_target_bitrate[VPX_SS_MAX_LAYERS];
 
-  /*!\brief Encoded data iterator
+  /*!\brief Number of temporal coding layers.
    *
-   * Iterates over a list of data packets to be passed from the encoder to the
-   * application. The different kinds of packets available are enumerated in
-   * #vpx_codec_cx_pkt_kind.
+   * This value specifies the number of temporal layers to be used.
+   */
+  unsigned int ts_number_layers;
+
+  /*!\brief Target bitrate for each temporal layer.
    *
-   * #VPX_CODEC_CX_FRAME_PKT packets should be passed to the application's
-   * muxer. Multiple compressed frames may be in the list.
-   * #VPX_CODEC_STATS_PKT packets should be appended to a global buffer.
+   * These values specify the target coding bitrate to be used for each
+   * temporal layer.
+   */
+  unsigned int ts_target_bitrate[VPX_TS_MAX_LAYERS];
+
+  /*!\brief Frame rate decimation factor for each temporal layer.
    *
-   * The application \ref MUST silently ignore any packet kinds that it does
-   * not recognize or support.
+   * These values specify the frame rate decimation factors to apply
+   * to each temporal layer.
+   */
+  unsigned int ts_rate_decimator[VPX_TS_MAX_LAYERS];
+
+  /*!\brief Length of the sequence defining frame temporal layer membership.
    *
-   * The data buffers returned from this function are only guaranteed to be
-   * valid until the application makes another call to any vpx_codec_* function.
+   * This value specifies the length of the sequence that defines the
+   * membership of frames to temporal layers. For example, if the
+   * ts_periodicity = 8, then the frames are assigned to coding layers with a
+   * repeated sequence of length 8.
+  */
+  unsigned int ts_periodicity;
+
+  /*!\brief Template defining the membership of frames to temporal layers.
    *
-   * \param[in]     ctx      Pointer to this instance's context
-   * \param[in,out] iter     Iterator storage, initialized to NULL
+   * This array defines the membership of frames to temporal coding layers.
+   * For a 2-layer encoding that assigns even numbered frames to one temporal
+   * layer (0) and odd numbered frames to a second temporal layer (1) with
+   * ts_periodicity=8, then ts_layer_id = (0,1,0,1,0,1,0,1).
+  */
+  unsigned int ts_layer_id[VPX_TS_MAX_PERIODICITY];
+
+  /*!\brief Target bitrate for each spatial/temporal layer.
    *
-   * \return Returns a pointer to an output data packet (compressed frame data,
-   *         two-pass statistics, etc.) or NULL to signal end-of-list.
+   * These values specify the target coding bitrate to be used for each
+   * spatial/temporal layer.
    *
    */
-  const vpx_codec_cx_pkt_t *vpx_codec_get_cx_data(vpx_codec_ctx_t   *ctx,
-                                                  vpx_codec_iter_t  *iter);
+  unsigned int layer_target_bitrate[VPX_MAX_LAYERS];
 
-
-  /*!\brief Get Preview Frame
-   *
-   * Returns an image that can be used as a preview. Shows the image as it would
-   * exist at the decompressor. The application \ref MUST NOT write into this
-   * image buffer.
-   *
-   * \param[in]     ctx      Pointer to this instance's context
+  /*!\brief Temporal layering mode indicating which temporal layering scheme to
+   * use.
    *
-   * \return Returns a pointer to a preview image, or NULL if no image is
-   *         available.
+   * The value (refer to VP9E_TEMPORAL_LAYERING_MODE) specifies the
+   * temporal layering mode to use.
    *
    */
-  const vpx_image_t *vpx_codec_get_preview_frame(vpx_codec_ctx_t   *ctx);
+  int temporal_layering_mode;
+} vpx_codec_enc_cfg_t; /**< alias for struct vpx_codec_enc_cfg */
 
+/*!\brief  vp9 svc extra configure parameters
+ *
+ * This defines max/min quantizers and scale factors for each layer
+ *
+ */
+typedef struct vpx_svc_parameters {
+  int max_quantizers[VPX_MAX_LAYERS];     /**< Max Q for each layer */
+  int min_quantizers[VPX_MAX_LAYERS];     /**< Min Q for each layer */
+  int scaling_factor_num[VPX_MAX_LAYERS]; /**< Scaling factor-numerator */
+  int scaling_factor_den[VPX_MAX_LAYERS]; /**< Scaling factor-denominator */
+  int temporal_layering_mode;             /**< Temporal layering mode */
+} vpx_svc_extra_cfg_t;
+
+/*!\brief Initialize an encoder instance
+ *
+ * Initializes a encoder context using the given interface. Applications
+ * should call the vpx_codec_enc_init convenience macro instead of this
+ * function directly, to ensure that the ABI version number parameter
+ * is properly initialized.
+ *
+ * If the library was configured with --disable-multithread, this call
+ * is not thread safe and should be guarded with a lock if being used
+ * in a multithreaded context.
+ *
+ * \param[in]    ctx     Pointer to this instance's context.
+ * \param[in]    iface   Pointer to the algorithm interface to use.
+ * \param[in]    cfg     Configuration to use, if known. May be NULL.
+ * \param[in]    flags   Bitfield of VPX_CODEC_USE_* flags
+ * \param[in]    ver     ABI version number. Must be set to
+ *                       VPX_ENCODER_ABI_VERSION
+ * \retval #VPX_CODEC_OK
+ *     The decoder algorithm initialized.
+ * \retval #VPX_CODEC_MEM_ERROR
+ *     Memory allocation failed.
+ */
+vpx_codec_err_t vpx_codec_enc_init_ver(vpx_codec_ctx_t *ctx,
+                                       vpx_codec_iface_t *iface,
+                                       const vpx_codec_enc_cfg_t *cfg,
+                                       vpx_codec_flags_t flags, int ver);
 
-  /*!@} - end defgroup encoder*/
+/*!\brief Convenience macro for vpx_codec_enc_init_ver()
+ *
+ * Ensures the ABI version parameter is properly set.
+ */
+#define vpx_codec_enc_init(ctx, iface, cfg, flags) \
+  vpx_codec_enc_init_ver(ctx, iface, cfg, flags, VPX_ENCODER_ABI_VERSION)
+
+/*!\brief Initialize multi-encoder instance
+ *
+ * Initializes multi-encoder context using the given interface.
+ * Applications should call the vpx_codec_enc_init_multi convenience macro
+ * instead of this function directly, to ensure that the ABI version number
+ * parameter is properly initialized.
+ *
+ * \param[in]    ctx     Pointer to this instance's context.
+ * \param[in]    iface   Pointer to the algorithm interface to use.
+ * \param[in]    cfg     Configuration to use, if known. May be NULL.
+ * \param[in]    num_enc Total number of encoders.
+ * \param[in]    flags   Bitfield of VPX_CODEC_USE_* flags
+ * \param[in]    dsf     Pointer to down-sampling factors.
+ * \param[in]    ver     ABI version number. Must be set to
+ *                       VPX_ENCODER_ABI_VERSION
+ * \retval #VPX_CODEC_OK
+ *     The decoder algorithm initialized.
+ * \retval #VPX_CODEC_MEM_ERROR
+ *     Memory allocation failed.
+ */
+vpx_codec_err_t vpx_codec_enc_init_multi_ver(
+    vpx_codec_ctx_t *ctx, vpx_codec_iface_t *iface, vpx_codec_enc_cfg_t *cfg,
+    int num_enc, vpx_codec_flags_t flags, vpx_rational_t *dsf, int ver);
+
+/*!\brief Convenience macro for vpx_codec_enc_init_multi_ver()
+ *
+ * Ensures the ABI version parameter is properly set.
+ */
+#define vpx_codec_enc_init_multi(ctx, iface, cfg, num_enc, flags, dsf) \
+  vpx_codec_enc_init_multi_ver(ctx, iface, cfg, num_enc, flags, dsf,   \
+                               VPX_ENCODER_ABI_VERSION)
+
+/*!\brief Get a default configuration
+ *
+ * Initializes a encoder configuration structure with default values. Supports
+ * the notion of "usages" so that an algorithm may offer different default
+ * settings depending on the user's intended goal. This function \ref SHOULD
+ * be called by all applications to initialize the configuration structure
+ * before specializing the configuration with application specific values.
+ *
+ * \param[in]    iface     Pointer to the algorithm interface to use.
+ * \param[out]   cfg       Configuration buffer to populate.
+ * \param[in]    reserved  Must set to 0 for VP8 and VP9.
+ *
+ * \retval #VPX_CODEC_OK
+ *     The configuration was populated.
+ * \retval #VPX_CODEC_INCAPABLE
+ *     Interface is not an encoder interface.
+ * \retval #VPX_CODEC_INVALID_PARAM
+ *     A parameter was NULL, or the usage value was not recognized.
+ */
+vpx_codec_err_t vpx_codec_enc_config_default(vpx_codec_iface_t *iface,
+                                             vpx_codec_enc_cfg_t *cfg,
+                                             unsigned int reserved);
+
+/*!\brief Set or change configuration
+ *
+ * Reconfigures an encoder instance according to the given configuration.
+ *
+ * \param[in]    ctx     Pointer to this instance's context
+ * \param[in]    cfg     Configuration buffer to use
+ *
+ * \retval #VPX_CODEC_OK
+ *     The configuration was populated.
+ * \retval #VPX_CODEC_INCAPABLE
+ *     Interface is not an encoder interface.
+ * \retval #VPX_CODEC_INVALID_PARAM
+ *     A parameter was NULL, or the usage value was not recognized.
+ */
+vpx_codec_err_t vpx_codec_enc_config_set(vpx_codec_ctx_t *ctx,
+                                         const vpx_codec_enc_cfg_t *cfg);
+
+/*!\brief Get global stream headers
+ *
+ * Retrieves a stream level global header packet, if supported by the codec.
+ *
+ * \param[in]    ctx     Pointer to this instance's context
+ *
+ * \retval NULL
+ *     Encoder does not support global header
+ * \retval Non-NULL
+ *     Pointer to buffer containing global header packet
+ */
+vpx_fixed_buf_t *vpx_codec_get_global_headers(vpx_codec_ctx_t *ctx);
+
+/*!\brief deadline parameter analogous to VPx REALTIME mode. */
+#define VPX_DL_REALTIME (1)
+/*!\brief deadline parameter analogous to  VPx GOOD QUALITY mode. */
+#define VPX_DL_GOOD_QUALITY (1000000)
+/*!\brief deadline parameter analogous to VPx BEST QUALITY mode. */
+#define VPX_DL_BEST_QUALITY (0)
+/*!\brief Encode a frame
+ *
+ * Encodes a video frame at the given "presentation time." The presentation
+ * time stamp (PTS) \ref MUST be strictly increasing.
+ *
+ * The encoder supports the notion of a soft real-time deadline. Given a
+ * non-zero value to the deadline parameter, the encoder will make a "best
+ * effort" guarantee to  return before the given time slice expires. It is
+ * implicit that limiting the available time to encode will degrade the
+ * output quality. The encoder can be given an unlimited time to produce the
+ * best possible frame by specifying a deadline of '0'. This deadline
+ * supercedes the VPx notion of "best quality, good quality, realtime".
+ * Applications that wish to map these former settings to the new deadline
+ * based system can use the symbols #VPX_DL_REALTIME, #VPX_DL_GOOD_QUALITY,
+ * and #VPX_DL_BEST_QUALITY.
+ *
+ * When the last frame has been passed to the encoder, this function should
+ * continue to be called, with the img parameter set to NULL. This will
+ * signal the end-of-stream condition to the encoder and allow it to encode
+ * any held buffers. Encoding is complete when vpx_codec_encode() is called
+ * and vpx_codec_get_cx_data() returns no data.
+ *
+ * \param[in]    ctx       Pointer to this instance's context
+ * \param[in]    img       Image data to encode, NULL to flush.
+ * \param[in]    pts       Presentation time stamp, in timebase units.
+ * \param[in]    duration  Duration to show frame, in timebase units.
+ * \param[in]    flags     Flags to use for encoding this frame.
+ * \param[in]    deadline  Time to spend encoding, in microseconds. (0=infinite)
+ *
+ * \retval #VPX_CODEC_OK
+ *     The configuration was populated.
+ * \retval #VPX_CODEC_INCAPABLE
+ *     Interface is not an encoder interface.
+ * \retval #VPX_CODEC_INVALID_PARAM
+ *     A parameter was NULL, the image format is unsupported, etc.
+ */
+vpx_codec_err_t vpx_codec_encode(vpx_codec_ctx_t *ctx, const vpx_image_t *img,
+                                 vpx_codec_pts_t pts, unsigned long duration,
+                                 vpx_enc_frame_flags_t flags,
+                                 unsigned long deadline);
+
+/*!\brief Set compressed data output buffer
+ *
+ * Sets the buffer that the codec should output the compressed data
+ * into. This call effectively sets the buffer pointer returned in the
+ * next VPX_CODEC_CX_FRAME_PKT packet. Subsequent packets will be
+ * appended into this buffer. The buffer is preserved across frames,
+ * so applications must periodically call this function after flushing
+ * the accumulated compressed data to disk or to the network to reset
+ * the pointer to the buffer's head.
+ *
+ * `pad_before` bytes will be skipped before writing the compressed
+ * data, and `pad_after` bytes will be appended to the packet. The size
+ * of the packet will be the sum of the size of the actual compressed
+ * data, pad_before, and pad_after. The padding bytes will be preserved
+ * (not overwritten).
+ *
+ * Note that calling this function does not guarantee that the returned
+ * compressed data will be placed into the specified buffer. In the
+ * event that the encoded data will not fit into the buffer provided,
+ * the returned packet \ref MAY point to an internal buffer, as it would
+ * if this call were never used. In this event, the output packet will
+ * NOT have any padding, and the application must free space and copy it
+ * to the proper place. This is of particular note in configurations
+ * that may output multiple packets for a single encoded frame (e.g., lagged
+ * encoding) or if the application does not reset the buffer periodically.
+ *
+ * Applications may restore the default behavior of the codec providing
+ * the compressed data buffer by calling this function with a NULL
+ * buffer.
+ *
+ * Applications \ref MUSTNOT call this function during iteration of
+ * vpx_codec_get_cx_data().
+ *
+ * \param[in]    ctx         Pointer to this instance's context
+ * \param[in]    buf         Buffer to store compressed data into
+ * \param[in]    pad_before  Bytes to skip before writing compressed data
+ * \param[in]    pad_after   Bytes to skip after writing compressed data
+ *
+ * \retval #VPX_CODEC_OK
+ *     The buffer was set successfully.
+ * \retval #VPX_CODEC_INVALID_PARAM
+ *     A parameter was NULL, the image format is unsupported, etc.
+ */
+vpx_codec_err_t vpx_codec_set_cx_data_buf(vpx_codec_ctx_t *ctx,
+                                          const vpx_fixed_buf_t *buf,
+                                          unsigned int pad_before,
+                                          unsigned int pad_after);
+
+/*!\brief Encoded data iterator
+ *
+ * Iterates over a list of data packets to be passed from the encoder to the
+ * application. The different kinds of packets available are enumerated in
+ * #vpx_codec_cx_pkt_kind.
+ *
+ * #VPX_CODEC_CX_FRAME_PKT packets should be passed to the application's
+ * muxer. Multiple compressed frames may be in the list.
+ * #VPX_CODEC_STATS_PKT packets should be appended to a global buffer.
+ *
+ * The application \ref MUST silently ignore any packet kinds that it does
+ * not recognize or support.
+ *
+ * The data buffers returned from this function are only guaranteed to be
+ * valid until the application makes another call to any vpx_codec_* function.
+ *
+ * \param[in]     ctx      Pointer to this instance's context
+ * \param[in,out] iter     Iterator storage, initialized to NULL
+ *
+ * \return Returns a pointer to an output data packet (compressed frame data,
+ *         two-pass statistics, etc.) or NULL to signal end-of-list.
+ *
+ */
+const vpx_codec_cx_pkt_t *vpx_codec_get_cx_data(vpx_codec_ctx_t *ctx,
+                                                vpx_codec_iter_t *iter);
+
+/*!\brief Get Preview Frame
+ *
+ * Returns an image that can be used as a preview. Shows the image as it would
+ * exist at the decompressor. The application \ref MUST NOT write into this
+ * image buffer.
+ *
+ * \param[in]     ctx      Pointer to this instance's context
+ *
+ * \return Returns a pointer to a preview image, or NULL if no image is
+ *         available.
+ *
+ */
+const vpx_image_t *vpx_codec_get_preview_frame(vpx_codec_ctx_t *ctx);
+
+/*!@} - end defgroup encoder*/
 #ifdef __cplusplus
 }
 #endif
 #endif  // VPX_VPX_ENCODER_H_
-
diff --git a/vpx/vpx_frame_buffer.h b/vpx/vpx_frame_buffer.h
index 9036459af..ad70cdd57 100644
--- a/vpx/vpx_frame_buffer.h
+++ b/vpx/vpx_frame_buffer.h
@@ -37,9 +37,9 @@ extern "C" {
  * This structure holds allocated frame buffers used by the decoder.
  */
 typedef struct vpx_codec_frame_buffer {
-  uint8_t *data;  /**< Pointer to the data buffer */
-  size_t size;  /**< Size of data in bytes */
-  void *priv;  /**< Frame's private data */
+  uint8_t *data; /**< Pointer to the data buffer */
+  size_t size;   /**< Size of data in bytes */
+  void *priv;    /**< Frame's private data */
 } vpx_codec_frame_buffer_t;
 
 /*!\brief get frame buffer callback prototype
@@ -60,8 +60,8 @@ typedef struct vpx_codec_frame_buffer {
  * \param[in] new_size     Size in bytes needed by the buffer
  * \param[in,out] fb       Pointer to vpx_codec_frame_buffer_t
  */
-typedef int (*vpx_get_frame_buffer_cb_fn_t)(
-    void *priv, size_t min_size, vpx_codec_frame_buffer_t *fb);
+typedef int (*vpx_get_frame_buffer_cb_fn_t)(void *priv, size_t min_size,
+                                            vpx_codec_frame_buffer_t *fb);
 
 /*!\brief release frame buffer callback prototype
  *
@@ -73,8 +73,8 @@ typedef int (*vpx_get_frame_buffer_cb_fn_t)(
  * \param[in] priv         Callback's private data
  * \param[in] fb           Pointer to vpx_codec_frame_buffer_t
  */
-typedef int (*vpx_release_frame_buffer_cb_fn_t)(
-    void *priv, vpx_codec_frame_buffer_t *fb);
+typedef int (*vpx_release_frame_buffer_cb_fn_t)(void *priv,
+                                                vpx_codec_frame_buffer_t *fb);
 
 #ifdef __cplusplus
 }  // extern "C"
diff --git a/vpx/vpx_image.h b/vpx/vpx_image.h
index 7958c6980..d6d3166d2 100644
--- a/vpx/vpx_image.h
+++ b/vpx/vpx_image.h
@@ -8,7 +8,6 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
-
 /*!\file
  * \brief Describes the vpx image descriptor and associated operations
  *
@@ -20,213 +19,203 @@
 extern "C" {
 #endif
 
-  /*!\brief Current ABI version number
-   *
-   * \internal
-   * If this file is altered in any way that changes the ABI, this value
-   * must be bumped.  Examples include, but are not limited to, changing
-   * types, removing or reassigning enums, adding/removing/rearranging
-   * fields to structures
-   */
+/*!\brief Current ABI version number
+ *
+ * \internal
+ * If this file is altered in any way that changes the ABI, this value
+ * must be bumped.  Examples include, but are not limited to, changing
+ * types, removing or reassigning enums, adding/removing/rearranging
+ * fields to structures
+ */
 #define VPX_IMAGE_ABI_VERSION (4) /**<\hideinitializer*/
 
-
-#define VPX_IMG_FMT_PLANAR     0x100  /**< Image is a planar format. */
-#define VPX_IMG_FMT_UV_FLIP    0x200  /**< V plane precedes U in memory. */
-#define VPX_IMG_FMT_HAS_ALPHA  0x400  /**< Image has an alpha channel. */
-#define VPX_IMG_FMT_HIGHBITDEPTH 0x800  /**< Image uses 16bit framebuffer. */
-
-  /*!\brief List of supported image formats */
-  typedef enum vpx_img_fmt {
-    VPX_IMG_FMT_NONE,
-    VPX_IMG_FMT_RGB24,   /**< 24 bit per pixel packed RGB */
-    VPX_IMG_FMT_RGB32,   /**< 32 bit per pixel packed 0RGB */
-    VPX_IMG_FMT_RGB565,  /**< 16 bit per pixel, 565 */
-    VPX_IMG_FMT_RGB555,  /**< 16 bit per pixel, 555 */
-    VPX_IMG_FMT_UYVY,    /**< UYVY packed YUV */
-    VPX_IMG_FMT_YUY2,    /**< YUYV packed YUV */
-    VPX_IMG_FMT_YVYU,    /**< YVYU packed YUV */
-    VPX_IMG_FMT_BGR24,   /**< 24 bit per pixel packed BGR */
-    VPX_IMG_FMT_RGB32_LE, /**< 32 bit packed BGR0 */
-    VPX_IMG_FMT_ARGB,     /**< 32 bit packed ARGB, alpha=255 */
-    VPX_IMG_FMT_ARGB_LE,  /**< 32 bit packed BGRA, alpha=255 */
-    VPX_IMG_FMT_RGB565_LE,  /**< 16 bit per pixel, gggbbbbb rrrrrggg */
-    VPX_IMG_FMT_RGB555_LE,  /**< 16 bit per pixel, gggbbbbb 0rrrrrgg */
-    VPX_IMG_FMT_YV12    = VPX_IMG_FMT_PLANAR | VPX_IMG_FMT_UV_FLIP | 1, /**< planar YVU */
-    VPX_IMG_FMT_I420    = VPX_IMG_FMT_PLANAR | 2,
-    VPX_IMG_FMT_VPXYV12 = VPX_IMG_FMT_PLANAR | VPX_IMG_FMT_UV_FLIP | 3, /** < planar 4:2:0 format with vpx color space */
-    VPX_IMG_FMT_VPXI420 = VPX_IMG_FMT_PLANAR | 4,
-    VPX_IMG_FMT_I422    = VPX_IMG_FMT_PLANAR | 5,
-    VPX_IMG_FMT_I444    = VPX_IMG_FMT_PLANAR | 6,
-    VPX_IMG_FMT_I440    = VPX_IMG_FMT_PLANAR | 7,
-    VPX_IMG_FMT_444A    = VPX_IMG_FMT_PLANAR | VPX_IMG_FMT_HAS_ALPHA | 6,
-    VPX_IMG_FMT_I42016    = VPX_IMG_FMT_I420 | VPX_IMG_FMT_HIGHBITDEPTH,
-    VPX_IMG_FMT_I42216    = VPX_IMG_FMT_I422 | VPX_IMG_FMT_HIGHBITDEPTH,
-    VPX_IMG_FMT_I44416    = VPX_IMG_FMT_I444 | VPX_IMG_FMT_HIGHBITDEPTH,
-    VPX_IMG_FMT_I44016    = VPX_IMG_FMT_I440 | VPX_IMG_FMT_HIGHBITDEPTH
-  } vpx_img_fmt_t; /**< alias for enum vpx_img_fmt */
-
-  /*!\brief List of supported color spaces */
-  typedef enum vpx_color_space {
-    VPX_CS_UNKNOWN    = 0,  /**< Unknown */
-    VPX_CS_BT_601     = 1,  /**< BT.601 */
-    VPX_CS_BT_709     = 2,  /**< BT.709 */
-    VPX_CS_SMPTE_170  = 3,  /**< SMPTE.170 */
-    VPX_CS_SMPTE_240  = 4,  /**< SMPTE.240 */
-    VPX_CS_BT_2020    = 5,  /**< BT.2020 */
-    VPX_CS_RESERVED   = 6,  /**< Reserved */
-    VPX_CS_SRGB       = 7   /**< sRGB */
-  } vpx_color_space_t; /**< alias for enum vpx_color_space */
-
-  /*!\brief List of supported color range */
-  typedef enum vpx_color_range {
-    VPX_CR_STUDIO_RANGE = 0,    /**< Y [16..235], UV [16..240] */
-    VPX_CR_FULL_RANGE   = 1     /**< YUV/RGB [0..255] */
-  } vpx_color_range_t; /**< alias for enum vpx_color_range */
-
-  /**\brief Image Descriptor */
-  typedef struct vpx_image {
-    vpx_img_fmt_t fmt; /**< Image Format */
-    vpx_color_space_t cs; /**< Color Space */
-    vpx_color_range_t range; /**< Color Range */
-
-    /* Image storage dimensions */
-    unsigned int  w;           /**< Stored image width */
-    unsigned int  h;           /**< Stored image height */
-    unsigned int  bit_depth;   /**< Stored image bit-depth */
-
-    /* Image display dimensions */
-    unsigned int  d_w;   /**< Displayed image width */
-    unsigned int  d_h;   /**< Displayed image height */
-
-    /* Image intended rendering dimensions */
-    unsigned int  r_w;   /**< Intended rendering image width */
-    unsigned int  r_h;   /**< Intended rendering image height */
-
-    /* Chroma subsampling info */
-    unsigned int  x_chroma_shift;   /**< subsampling order, X */
-    unsigned int  y_chroma_shift;   /**< subsampling order, Y */
-
-    /* Image data pointers. */
-#define VPX_PLANE_PACKED 0   /**< To be used for all packed formats */
-#define VPX_PLANE_Y      0   /**< Y (Luminance) plane */
-#define VPX_PLANE_U      1   /**< U (Chroma) plane */
-#define VPX_PLANE_V      2   /**< V (Chroma) plane */
-#define VPX_PLANE_ALPHA  3   /**< A (Transparency) plane */
-    unsigned char *planes[4];  /**< pointer to the top left pixel for each plane */
-    int      stride[4];  /**< stride between rows for each plane */
-
-    int     bps; /**< bits per sample (for packed formats) */
-
-    /* The following member may be set by the application to associate data
-     * with this image.
-     */
-    void    *user_priv; /**< may be set by the application to associate data
-                         *   with this image. */
-
-    /* The following members should be treated as private. */
-    unsigned char *img_data;       /**< private */
-    int      img_data_owner; /**< private */
-    int      self_allocd;    /**< private */
-
-    void    *fb_priv; /**< Frame buffer data associated with the image. */
-  } vpx_image_t; /**< alias for struct vpx_image */
-
-  /**\brief Representation of a rectangle on a surface */
-  typedef struct vpx_image_rect {
-    unsigned int x; /**< leftmost column */
-    unsigned int y; /**< topmost row */
-    unsigned int w; /**< width */
-    unsigned int h; /**< height */
-  } vpx_image_rect_t; /**< alias for struct vpx_image_rect */
-
-  /*!\brief Open a descriptor, allocating storage for the underlying image
-   *
-   * Returns a descriptor for storing an image of the given format. The
-   * storage for the descriptor is allocated on the heap.
-   *
-   * \param[in]    img       Pointer to storage for descriptor. If this parameter
-   *                         is NULL, the storage for the descriptor will be
-   *                         allocated on the heap.
-   * \param[in]    fmt       Format for the image
-   * \param[in]    d_w       Width of the image
-   * \param[in]    d_h       Height of the image
-   * \param[in]    align     Alignment, in bytes, of the image buffer and
-   *                         each row in the image(stride).
-   *
-   * \return Returns a pointer to the initialized image descriptor. If the img
-   *         parameter is non-null, the value of the img parameter will be
-   *         returned.
+#define VPX_IMG_FMT_PLANAR 0x100       /**< Image is a planar format. */
+#define VPX_IMG_FMT_UV_FLIP 0x200      /**< V plane precedes U in memory. */
+#define VPX_IMG_FMT_HAS_ALPHA 0x400    /**< Image has an alpha channel. */
+#define VPX_IMG_FMT_HIGHBITDEPTH 0x800 /**< Image uses 16bit framebuffer. */
+
+/*!\brief List of supported image formats */
+typedef enum vpx_img_fmt {
+  VPX_IMG_FMT_NONE,
+  VPX_IMG_FMT_RGB24,     /**< 24 bit per pixel packed RGB */
+  VPX_IMG_FMT_RGB32,     /**< 32 bit per pixel packed 0RGB */
+  VPX_IMG_FMT_RGB565,    /**< 16 bit per pixel, 565 */
+  VPX_IMG_FMT_RGB555,    /**< 16 bit per pixel, 555 */
+  VPX_IMG_FMT_UYVY,      /**< UYVY packed YUV */
+  VPX_IMG_FMT_YUY2,      /**< YUYV packed YUV */
+  VPX_IMG_FMT_YVYU,      /**< YVYU packed YUV */
+  VPX_IMG_FMT_BGR24,     /**< 24 bit per pixel packed BGR */
+  VPX_IMG_FMT_RGB32_LE,  /**< 32 bit packed BGR0 */
+  VPX_IMG_FMT_ARGB,      /**< 32 bit packed ARGB, alpha=255 */
+  VPX_IMG_FMT_ARGB_LE,   /**< 32 bit packed BGRA, alpha=255 */
+  VPX_IMG_FMT_RGB565_LE, /**< 16 bit per pixel, gggbbbbb rrrrrggg */
+  VPX_IMG_FMT_RGB555_LE, /**< 16 bit per pixel, gggbbbbb 0rrrrrgg */
+  VPX_IMG_FMT_YV12 =
+      VPX_IMG_FMT_PLANAR | VPX_IMG_FMT_UV_FLIP | 1, /**< planar YVU */
+  VPX_IMG_FMT_I420 = VPX_IMG_FMT_PLANAR | 2,
+  VPX_IMG_FMT_VPXYV12 = VPX_IMG_FMT_PLANAR | VPX_IMG_FMT_UV_FLIP |
+                        3, /** < planar 4:2:0 format with vpx color space */
+  VPX_IMG_FMT_VPXI420 = VPX_IMG_FMT_PLANAR | 4,
+  VPX_IMG_FMT_I422 = VPX_IMG_FMT_PLANAR | 5,
+  VPX_IMG_FMT_I444 = VPX_IMG_FMT_PLANAR | 6,
+  VPX_IMG_FMT_I440 = VPX_IMG_FMT_PLANAR | 7,
+  VPX_IMG_FMT_444A = VPX_IMG_FMT_PLANAR | VPX_IMG_FMT_HAS_ALPHA | 6,
+  VPX_IMG_FMT_I42016 = VPX_IMG_FMT_I420 | VPX_IMG_FMT_HIGHBITDEPTH,
+  VPX_IMG_FMT_I42216 = VPX_IMG_FMT_I422 | VPX_IMG_FMT_HIGHBITDEPTH,
+  VPX_IMG_FMT_I44416 = VPX_IMG_FMT_I444 | VPX_IMG_FMT_HIGHBITDEPTH,
+  VPX_IMG_FMT_I44016 = VPX_IMG_FMT_I440 | VPX_IMG_FMT_HIGHBITDEPTH
+} vpx_img_fmt_t; /**< alias for enum vpx_img_fmt */
+
+/*!\brief List of supported color spaces */
+typedef enum vpx_color_space {
+  VPX_CS_UNKNOWN = 0,   /**< Unknown */
+  VPX_CS_BT_601 = 1,    /**< BT.601 */
+  VPX_CS_BT_709 = 2,    /**< BT.709 */
+  VPX_CS_SMPTE_170 = 3, /**< SMPTE.170 */
+  VPX_CS_SMPTE_240 = 4, /**< SMPTE.240 */
+  VPX_CS_BT_2020 = 5,   /**< BT.2020 */
+  VPX_CS_RESERVED = 6,  /**< Reserved */
+  VPX_CS_SRGB = 7       /**< sRGB */
+} vpx_color_space_t;    /**< alias for enum vpx_color_space */
+
+/*!\brief List of supported color range */
+typedef enum vpx_color_range {
+  VPX_CR_STUDIO_RANGE = 0, /**< Y [16..235], UV [16..240] */
+  VPX_CR_FULL_RANGE = 1    /**< YUV/RGB [0..255] */
+} vpx_color_range_t;       /**< alias for enum vpx_color_range */
+
+/**\brief Image Descriptor */
+typedef struct vpx_image {
+  vpx_img_fmt_t fmt;       /**< Image Format */
+  vpx_color_space_t cs;    /**< Color Space */
+  vpx_color_range_t range; /**< Color Range */
+
+  /* Image storage dimensions */
+  unsigned int w;         /**< Stored image width */
+  unsigned int h;         /**< Stored image height */
+  unsigned int bit_depth; /**< Stored image bit-depth */
+
+  /* Image display dimensions */
+  unsigned int d_w; /**< Displayed image width */
+  unsigned int d_h; /**< Displayed image height */
+
+  /* Image intended rendering dimensions */
+  unsigned int r_w; /**< Intended rendering image width */
+  unsigned int r_h; /**< Intended rendering image height */
+
+  /* Chroma subsampling info */
+  unsigned int x_chroma_shift; /**< subsampling order, X */
+  unsigned int y_chroma_shift; /**< subsampling order, Y */
+
+/* Image data pointers. */
+#define VPX_PLANE_PACKED 0  /**< To be used for all packed formats */
+#define VPX_PLANE_Y 0       /**< Y (Luminance) plane */
+#define VPX_PLANE_U 1       /**< U (Chroma) plane */
+#define VPX_PLANE_V 2       /**< V (Chroma) plane */
+#define VPX_PLANE_ALPHA 3   /**< A (Transparency) plane */
+  unsigned char *planes[4]; /**< pointer to the top left pixel for each plane */
+  int stride[4];            /**< stride between rows for each plane */
+
+  int bps; /**< bits per sample (for packed formats) */
+
+  /*!\brief The following member may be set by the application to associate
+   * data with this image.
    */
-  vpx_image_t *vpx_img_alloc(vpx_image_t  *img,
-                             vpx_img_fmt_t fmt,
-                             unsigned int d_w,
-                             unsigned int d_h,
-                             unsigned int align);
-
-  /*!\brief Open a descriptor, using existing storage for the underlying image
-   *
-   * Returns a descriptor for storing an image of the given format. The
-   * storage for descriptor has been allocated elsewhere, and a descriptor is
-   * desired to "wrap" that storage.
-   *
-   * \param[in]    img       Pointer to storage for descriptor. If this parameter
-   *                         is NULL, the storage for the descriptor will be
-   *                         allocated on the heap.
-   * \param[in]    fmt       Format for the image
-   * \param[in]    d_w       Width of the image
-   * \param[in]    d_h       Height of the image
-   * \param[in]    align     Alignment, in bytes, of each row in the image.
-   * \param[in]    img_data  Storage to use for the image
-   *
-   * \return Returns a pointer to the initialized image descriptor. If the img
-   *         parameter is non-null, the value of the img parameter will be
-   *         returned.
-   */
-  vpx_image_t *vpx_img_wrap(vpx_image_t  *img,
-                            vpx_img_fmt_t fmt,
-                            unsigned int d_w,
-                            unsigned int d_h,
-                            unsigned int align,
-                            unsigned char      *img_data);
-
-
-  /*!\brief Set the rectangle identifying the displayed portion of the image
-   *
-   * Updates the displayed rectangle (aka viewport) on the image surface to
-   * match the specified coordinates and size.
-   *
-   * \param[in]    img       Image descriptor
-   * \param[in]    x         leftmost column
-   * \param[in]    y         topmost row
-   * \param[in]    w         width
-   * \param[in]    h         height
-   *
-   * \return 0 if the requested rectangle is valid, nonzero otherwise.
-   */
-  int vpx_img_set_rect(vpx_image_t  *img,
-                       unsigned int  x,
-                       unsigned int  y,
-                       unsigned int  w,
-                       unsigned int  h);
-
-
-  /*!\brief Flip the image vertically (top for bottom)
-   *
-   * Adjusts the image descriptor's pointers and strides to make the image
-   * be referenced upside-down.
-   *
-   * \param[in]    img       Image descriptor
-   */
-  void vpx_img_flip(vpx_image_t *img);
+  void *user_priv;
 
-  /*!\brief Close an image descriptor
-   *
-   * Frees all allocated storage associated with an image descriptor.
-   *
-   * \param[in]    img       Image descriptor
-   */
-  void vpx_img_free(vpx_image_t *img);
+  /* The following members should be treated as private. */
+  unsigned char *img_data; /**< private */
+  int img_data_owner;      /**< private */
+  int self_allocd;         /**< private */
+
+  void *fb_priv; /**< Frame buffer data associated with the image. */
+} vpx_image_t;   /**< alias for struct vpx_image */
+
+/**\brief Representation of a rectangle on a surface */
+typedef struct vpx_image_rect {
+  unsigned int x;   /**< leftmost column */
+  unsigned int y;   /**< topmost row */
+  unsigned int w;   /**< width */
+  unsigned int h;   /**< height */
+} vpx_image_rect_t; /**< alias for struct vpx_image_rect */
+
+/*!\brief Open a descriptor, allocating storage for the underlying image
+ *
+ * Returns a descriptor for storing an image of the given format. The
+ * storage for the descriptor is allocated on the heap.
+ *
+ * \param[in]    img       Pointer to storage for descriptor. If this parameter
+ *                         is NULL, the storage for the descriptor will be
+ *                         allocated on the heap.
+ * \param[in]    fmt       Format for the image
+ * \param[in]    d_w       Width of the image
+ * \param[in]    d_h       Height of the image
+ * \param[in]    align     Alignment, in bytes, of the image buffer and
+ *                         each row in the image(stride).
+ *
+ * \return Returns a pointer to the initialized image descriptor. If the img
+ *         parameter is non-null, the value of the img parameter will be
+ *         returned.
+ */
+vpx_image_t *vpx_img_alloc(vpx_image_t *img, vpx_img_fmt_t fmt,
+                           unsigned int d_w, unsigned int d_h,
+                           unsigned int align);
+
+/*!\brief Open a descriptor, using existing storage for the underlying image
+ *
+ * Returns a descriptor for storing an image of the given format. The
+ * storage for descriptor has been allocated elsewhere, and a descriptor is
+ * desired to "wrap" that storage.
+ *
+ * \param[in]    img       Pointer to storage for descriptor. If this parameter
+ *                         is NULL, the storage for the descriptor will be
+ *                         allocated on the heap.
+ * \param[in]    fmt       Format for the image
+ * \param[in]    d_w       Width of the image
+ * \param[in]    d_h       Height of the image
+ * \param[in]    align     Alignment, in bytes, of each row in the image.
+ * \param[in]    img_data  Storage to use for the image
+ *
+ * \return Returns a pointer to the initialized image descriptor. If the img
+ *         parameter is non-null, the value of the img parameter will be
+ *         returned.
+ */
+vpx_image_t *vpx_img_wrap(vpx_image_t *img, vpx_img_fmt_t fmt, unsigned int d_w,
+                          unsigned int d_h, unsigned int align,
+                          unsigned char *img_data);
+
+/*!\brief Set the rectangle identifying the displayed portion of the image
+ *
+ * Updates the displayed rectangle (aka viewport) on the image surface to
+ * match the specified coordinates and size.
+ *
+ * \param[in]    img       Image descriptor
+ * \param[in]    x         leftmost column
+ * \param[in]    y         topmost row
+ * \param[in]    w         width
+ * \param[in]    h         height
+ *
+ * \return 0 if the requested rectangle is valid, nonzero otherwise.
+ */
+int vpx_img_set_rect(vpx_image_t *img, unsigned int x, unsigned int y,
+                     unsigned int w, unsigned int h);
+
+/*!\brief Flip the image vertically (top for bottom)
+ *
+ * Adjusts the image descriptor's pointers and strides to make the image
+ * be referenced upside-down.
+ *
+ * \param[in]    img       Image descriptor
+ */
+void vpx_img_flip(vpx_image_t *img);
+
+/*!\brief Close an image descriptor
+ *
+ * Frees all allocated storage associated with an image descriptor.
+ *
+ * \param[in]    img       Image descriptor
+ */
+void vpx_img_free(vpx_image_t *img);
 
 #ifdef __cplusplus
 }  // extern "C"
diff --git a/vpx/vpx_integer.h b/vpx/vpx_integer.h
index 2945c87ca..09bad9222 100644
--- a/vpx/vpx_integer.h
+++ b/vpx/vpx_integer.h
@@ -8,7 +8,6 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
-
 #ifndef VPX_VPX_INTEGER_H_
 #define VPX_VPX_INTEGER_H_
 
@@ -25,13 +24,13 @@
 #endif
 
 #if defined(VPX_EMULATE_INTTYPES)
-typedef signed char  int8_t;
+typedef signed char int8_t;
 typedef signed short int16_t;
-typedef signed int   int32_t;
+typedef signed int int32_t;
 
-typedef unsigned char  uint8_t;
+typedef unsigned char uint8_t;
 typedef unsigned short uint16_t;
-typedef unsigned int   uint32_t;
+typedef unsigned int uint32_t;
 
 #ifndef _UINTPTR_T_DEFINED
 typedef size_t uintptr_t;
@@ -42,12 +41,12 @@ typedef size_t uintptr_t;
 /* Most platforms have the C99 standard integer types. */
 
 #if defined(__cplusplus)
-# if !defined(__STDC_FORMAT_MACROS)
-#  define __STDC_FORMAT_MACROS
-# endif
-# if !defined(__STDC_LIMIT_MACROS)
-#  define __STDC_LIMIT_MACROS
-# endif
+#if !defined(__STDC_FORMAT_MACROS)
+#define __STDC_FORMAT_MACROS
+#endif
+#if !defined(__STDC_LIMIT_MACROS)
+#define __STDC_LIMIT_MACROS
+#endif
 #endif  // __cplusplus
 
 #include <stdint.h>