diff --git a/av1/common/cdef.c b/av1/common/cdef.c
index 3588eea..9ab7d4d 100644
--- a/av1/common/cdef.c
+++ b/av1/common/cdef.c
@@ -87,9 +87,9 @@
   }
 }
 
-void av1_cdef_copy_sb8_16(AV1_COMMON *cm, uint16_t *dst, int dstride,
-                          const uint8_t *src, int src_voffset, int src_hoffset,
-                          int sstride, int vsize, int hsize) {
+void av1_cdef_copy_sb8_16(const AV1_COMMON *const cm, uint16_t *const dst,
+                          int dstride, const uint8_t *src, int src_voffset,
+                          int src_hoffset, int sstride, int vsize, int hsize) {
   if (cm->seq_params->use_highbitdepth) {
     const uint16_t *base =
         &CONVERT_TO_SHORTPTR(src)[src_voffset * sstride + src_hoffset];
@@ -128,9 +128,9 @@
 //   plane: plane index Y/CB/CR.
 // Returns:
 //   Nothing will be returned.
-static void cdef_prepare_fb(AV1_COMMON *cm, CdefBlockInfo *fb_info,
+static void cdef_prepare_fb(const AV1_COMMON *const cm, CdefBlockInfo *fb_info,
                             uint16_t **const colbuf, const int *cdef_left,
-                            int fbc, int fbr, uint8_t plane) {
+                            int fbc, int fbr, int plane) {
   const CommonModeInfoParams *const mi_params = &cm->mi_params;
   uint16_t *src = fb_info->src;
   const int luma_stride =
@@ -140,10 +140,12 @@
   int cstart = 0;
   if (!*cdef_left) cstart = -CDEF_HBORDER;
   int rend, cend;
-  int nhb = AOMMIN(MI_SIZE_64X64, mi_params->mi_cols - MI_SIZE_64X64 * fbc);
-  int nvb = AOMMIN(MI_SIZE_64X64, mi_params->mi_rows - MI_SIZE_64X64 * fbr);
-  int hsize = nhb << fb_info->mi_wide_l2;
-  int vsize = nvb << fb_info->mi_high_l2;
+  const int nhb =
+      AOMMIN(MI_SIZE_64X64, mi_params->mi_cols - MI_SIZE_64X64 * fbc);
+  const int nvb =
+      AOMMIN(MI_SIZE_64X64, mi_params->mi_rows - MI_SIZE_64X64 * fbr);
+  const int hsize = nhb << fb_info->mi_wide_l2;
+  const int vsize = nvb << fb_info->mi_high_l2;
   const uint16_t *top_linebuf = fb_info->top_linebuf[plane];
   const uint16_t *bot_linebuf = fb_info->bot_linebuf[plane];
   const int bot_offset = (vsize + CDEF_VBORDER) * CDEF_BSTRIDE;
@@ -235,7 +237,7 @@
   }
 }
 
-static INLINE void cdef_filter_fb(CdefBlockInfo *fb_info, uint8_t plane,
+static INLINE void cdef_filter_fb(CdefBlockInfo *const fb_info, int plane,
                                   uint8_t use_highbitdepth) {
   int offset = fb_info->dst_stride * fb_info->roffset + fb_info->coffset;
   if (use_highbitdepth) {
@@ -256,11 +258,11 @@
 }
 
 // Initializes block-level parameters for CDEF.
-static INLINE void cdef_init_fb_col(MACROBLOCKD *xd,
+static INLINE void cdef_init_fb_col(const MACROBLOCKD *const xd,
                                     const CdefInfo *const cdef_info,
-                                    CdefBlockInfo *fb_info,
-                                    const int mbmi_cdef_strength, int fbc,
-                                    int fbr, uint8_t plane) {
+                                    CdefBlockInfo *const fb_info,
+                                    int mbmi_cdef_strength, int fbc, int fbr,
+                                    int plane) {
   if (plane == AOM_PLANE_Y) {
     fb_info->level =
         cdef_info->cdef_strengths[mbmi_cdef_strength] / CDEF_SEC_STRENGTHS;
@@ -293,9 +295,9 @@
   fb_info->coffset = MI_SIZE_64X64 * fbc << fb_info->mi_wide_l2;
 }
 
-static void cdef_fb_col(AV1_COMMON *cm, MACROBLOCKD *xd, CdefBlockInfo *fb_info,
-                        uint16_t **const colbuf, int *cdef_left, int fbc,
-                        int fbr) {
+static void cdef_fb_col(const AV1_COMMON *const cm, const MACROBLOCKD *const xd,
+                        CdefBlockInfo *const fb_info, uint16_t **const colbuf,
+                        int *cdef_left, int fbc, int fbr) {
   const CommonModeInfoParams *const mi_params = &cm->mi_params;
   const int mbmi_cdef_strength =
       mi_params
@@ -327,10 +329,11 @@
 }
 
 // Initializes row-level parameters for CDEF frame.
-void av1_cdef_init_fb_row(AV1_COMMON *cm, MACROBLOCKD *const xd,
-                          CdefBlockInfo *fb_info, uint16_t **const linebuf,
-                          uint16_t *const src,
-                          struct AV1CdefSyncData *cdef_sync, int fbr) {
+void av1_cdef_init_fb_row(const AV1_COMMON *const cm,
+                          const MACROBLOCKD *const xd,
+                          CdefBlockInfo *const fb_info,
+                          uint16_t **const linebuf, uint16_t *const src,
+                          struct AV1CdefSyncData *const cdef_sync, int fbr) {
   (void)cdef_sync;
   const int num_planes = av1_num_planes(cm);
   const int nvfb = (cm->mi_params.mi_rows + MI_SIZE_64X64 - 1) / MI_SIZE_64X64;
@@ -383,10 +386,11 @@
   }
 }
 
-void av1_cdef_fb_row(AV1_COMMON *cm, MACROBLOCKD *xd, uint16_t **const linebuf,
-                     uint16_t **const colbuf, uint16_t *const src, int fbr,
+void av1_cdef_fb_row(const AV1_COMMON *const cm, MACROBLOCKD *xd,
+                     uint16_t **const linebuf, uint16_t **const colbuf,
+                     uint16_t *const src, int fbr,
                      cdef_init_fb_row_t cdef_init_fb_row_fn,
-                     struct AV1CdefSyncData *cdef_sync) {
+                     struct AV1CdefSyncData *const cdef_sync) {
   CdefBlockInfo fb_info;
   int cdef_left = 1;
   const int nhfb = (cm->mi_params.mi_cols + MI_SIZE_64X64 - 1) / MI_SIZE_64X64;
@@ -410,8 +414,8 @@
 //   xd: Pointer to common current coding block structure.
 // Returns:
 //   Nothing will be returned.
-void av1_cdef_frame(YV12_BUFFER_CONFIG *frame, AV1_COMMON *cm, MACROBLOCKD *xd,
-                    cdef_init_fb_row_t cdef_init_fb_row_fn) {
+void av1_cdef_frame(YV12_BUFFER_CONFIG *frame, AV1_COMMON *const cm,
+                    MACROBLOCKD *xd, cdef_init_fb_row_t cdef_init_fb_row_fn) {
   const int num_planes = av1_num_planes(cm);
   const int nvfb = (cm->mi_params.mi_rows + MI_SIZE_64X64 - 1) / MI_SIZE_64X64;
 
diff --git a/av1/common/cdef.h b/av1/common/cdef.h
index 81c8469..1941178 100644
--- a/av1/common/cdef.h
+++ b/av1/common/cdef.h
@@ -75,11 +75,10 @@
                              int mi_row, int mi_col, cdef_list *dlist,
                              BLOCK_SIZE bsize);
 
-typedef void (*cdef_init_fb_row_t)(AV1_COMMON *cm, MACROBLOCKD *const xd,
-                                   CdefBlockInfo *fb_info,
-                                   uint16_t **const linebuf,
-                                   uint16_t *const src,
-                                   struct AV1CdefSyncData *cdef_sync, int fbr);
+typedef void (*cdef_init_fb_row_t)(
+    const AV1_COMMON *const cm, const MACROBLOCKD *const xd,
+    CdefBlockInfo *const fb_info, uint16_t **const linebuf, uint16_t *const src,
+    struct AV1CdefSyncData *const cdef_sync, int fbr);
 
 /*!\brief Function for applying CDEF to a frame
  *
@@ -94,16 +93,18 @@
  * \return Nothing is returned. Instead, the filtered frame is output in
  * \c frame.
  */
-void av1_cdef_frame(YV12_BUFFER_CONFIG *frame, AV1_COMMON *cm, MACROBLOCKD *xd,
-                    cdef_init_fb_row_t cdef_init_fb_row_fn);
-void av1_cdef_fb_row(AV1_COMMON *cm, MACROBLOCKD *xd, uint16_t **const linebuf,
-                     uint16_t **const colbuf, uint16_t *const src, int fbr,
+void av1_cdef_frame(YV12_BUFFER_CONFIG *frame, AV1_COMMON *const cm,
+                    MACROBLOCKD *xd, cdef_init_fb_row_t cdef_init_fb_row_fn);
+void av1_cdef_fb_row(const AV1_COMMON *const cm, MACROBLOCKD *xd,
+                     uint16_t **const linebuf, uint16_t **const colbuf,
+                     uint16_t *const src, int fbr,
                      cdef_init_fb_row_t cdef_init_fb_row_fn,
-                     struct AV1CdefSyncData *cdef_sync);
-void av1_cdef_init_fb_row(AV1_COMMON *cm, MACROBLOCKD *const xd,
-                          CdefBlockInfo *fb_info, uint16_t **const linebuf,
-                          uint16_t *const src,
-                          struct AV1CdefSyncData *cdef_sync, int fbr);
+                     struct AV1CdefSyncData *const cdef_sync);
+void av1_cdef_init_fb_row(const AV1_COMMON *const cm,
+                          const MACROBLOCKD *const xd,
+                          CdefBlockInfo *const fb_info,
+                          uint16_t **const linebuf, uint16_t *const src,
+                          struct AV1CdefSyncData *const cdef_sync, int fbr);
 
 #ifdef __cplusplus
 }  // extern "C"
diff --git a/av1/common/thread_common.c b/av1/common/thread_common.c
index 3d4aae1..0339985 100644
--- a/av1/common/thread_common.c
+++ b/av1/common/thread_common.c
@@ -152,7 +152,7 @@
   }
 }
 
-void av1_alloc_cdef_sync(AV1_COMMON *cm, AV1CdefSync *cdef_sync,
+void av1_alloc_cdef_sync(AV1_COMMON *const cm, AV1CdefSync *cdef_sync,
                          int num_workers) {
   if (num_workers < 1) return;
 #if CONFIG_MULTITHREAD
@@ -177,10 +177,11 @@
 #endif  // CONFIG_MULTITHREAD
 }
 
-static INLINE void cdef_row_mt_sync_read(AV1CdefSync *cdef_sync, int row) {
+static INLINE void cdef_row_mt_sync_read(AV1CdefSync *const cdef_sync,
+                                         int row) {
   if (!row) return;
 #if CONFIG_MULTITHREAD
-  AV1CdefRowSync *cdef_row_mt = cdef_sync->cdef_row_mt;
+  AV1CdefRowSync *const cdef_row_mt = cdef_sync->cdef_row_mt;
   pthread_mutex_lock(cdef_row_mt[row - 1].row_mutex_);
   while (cdef_row_mt[row - 1].is_row_done != 1)
     pthread_cond_wait(cdef_row_mt[row - 1].row_cond_,
@@ -192,9 +193,10 @@
 #endif  // CONFIG_MULTITHREAD
 }
 
-static INLINE void cdef_row_mt_sync_write(AV1CdefSync *cdef_sync, int row) {
+static INLINE void cdef_row_mt_sync_write(AV1CdefSync *const cdef_sync,
+                                          int row) {
 #if CONFIG_MULTITHREAD
-  AV1CdefRowSync *cdef_row_mt = cdef_sync->cdef_row_mt;
+  AV1CdefRowSync *const cdef_row_mt = cdef_sync->cdef_row_mt;
   pthread_mutex_lock(cdef_row_mt[row].row_mutex_);
   pthread_cond_signal(cdef_row_mt[row].row_cond_);
   cdef_row_mt[row].is_row_done = 1;
@@ -987,7 +989,7 @@
 #endif
 
 // Initializes cdef_sync parameters.
-static AOM_INLINE void reset_cdef_job_info(AV1CdefSync *cdef_sync) {
+static AOM_INLINE void reset_cdef_job_info(AV1CdefSync *const cdef_sync) {
   cdef_sync->end_of_frame = 0;
   cdef_sync->fbr = 0;
   cdef_sync->fbc = 0;
@@ -1023,7 +1025,8 @@
 
 // Updates the row index of the next job to be processed.
 // Also updates end_of_frame flag when the processing of all rows is complete.
-static void update_cdef_row_next_job_info(AV1CdefSync *cdef_sync, int nvfb) {
+static void update_cdef_row_next_job_info(AV1CdefSync *const cdef_sync,
+                                          const int nvfb) {
   cdef_sync->fbr++;
   if (cdef_sync->fbr == nvfb) {
     cdef_sync->end_of_frame = 1;
@@ -1032,7 +1035,7 @@
 
 // Checks if a job is available. If job is available,
 // populates next job information and returns 1, else returns 0.
-static AOM_INLINE int get_cdef_row_next_job(AV1CdefSync *cdef_sync,
+static AOM_INLINE int get_cdef_row_next_job(AV1CdefSync *const cdef_sync,
                                             int *cur_fbr, const int nvfb) {
 #if CONFIG_MULTITHREAD
   pthread_mutex_lock(cdef_sync->mutex_);
@@ -1054,7 +1057,7 @@
 // Hook function for each thread in CDEF multi-threading.
 static int cdef_sb_row_worker_hook(void *arg1, void *arg2) {
   AV1CdefSync *const cdef_sync = (AV1CdefSync *)arg1;
-  AV1CdefWorkerData *cdef_worker = (AV1CdefWorkerData *)arg2;
+  AV1CdefWorkerData *const cdef_worker = (AV1CdefWorkerData *)arg2;
   const int nvfb =
       (cdef_worker->cm->mi_params.mi_rows + MI_SIZE_64X64 - 1) / MI_SIZE_64X64;
   int cur_fbr;
@@ -1067,18 +1070,17 @@
 }
 
 // Assigns CDEF hook function and thread data to each worker.
-static void prepare_cdef_frame_workers(AV1_COMMON *cm, MACROBLOCKD *xd,
-                                       AV1CdefWorkerData *cdef_worker,
-                                       AVxWorkerHook hook, AVxWorker *workers,
-                                       AV1CdefSync *cdef_sync, int num_workers,
-                                       cdef_init_fb_row_t cdef_init_fb_row_fn) {
+static void prepare_cdef_frame_workers(
+    AV1_COMMON *const cm, MACROBLOCKD *xd, AV1CdefWorkerData *const cdef_worker,
+    AVxWorkerHook hook, AVxWorker *const workers, AV1CdefSync *const cdef_sync,
+    int num_workers, cdef_init_fb_row_t cdef_init_fb_row_fn) {
   const int num_planes = av1_num_planes(cm);
 
   cdef_worker[0].srcbuf = cm->cdef_info.srcbuf;
   for (int plane = 0; plane < num_planes; plane++)
     cdef_worker[0].colbuf[plane] = cm->cdef_info.colbuf[plane];
   for (int i = num_workers - 1; i >= 0; i--) {
-    AVxWorker *worker = &workers[i];
+    AVxWorker *const worker = &workers[i];
     cdef_worker[i].cm = cm;
     cdef_worker[i].xd = xd;
     cdef_worker[i].cdef_init_fb_row_fn = cdef_init_fb_row_fn;
@@ -1092,10 +1094,11 @@
 }
 
 // Initializes row-level parameters for CDEF frame.
-void av1_cdef_init_fb_row_mt(AV1_COMMON *cm, MACROBLOCKD *const xd,
-                             CdefBlockInfo *fb_info, uint16_t **const linebuf,
-                             uint16_t *const src,
-                             struct AV1CdefSyncData *cdef_sync, int fbr) {
+void av1_cdef_init_fb_row_mt(const AV1_COMMON *const cm,
+                             const MACROBLOCKD *const xd,
+                             CdefBlockInfo *const fb_info,
+                             uint16_t **const linebuf, uint16_t *const src,
+                             struct AV1CdefSyncData *const cdef_sync, int fbr) {
   const int num_planes = av1_num_planes(cm);
   const int nvfb = (cm->mi_params.mi_rows + MI_SIZE_64X64 - 1) / MI_SIZE_64X64;
   const int luma_stride =
@@ -1161,9 +1164,10 @@
 //   xd: Pointer to common current coding block structure.
 // Returns:
 //   Nothing will be returned.
-void av1_cdef_frame_mt(AV1_COMMON *cm, MACROBLOCKD *xd,
-                       AV1CdefWorkerData *cdef_worker, AVxWorker *workers,
-                       AV1CdefSync *cdef_sync, int num_workers,
+void av1_cdef_frame_mt(AV1_COMMON *const cm, MACROBLOCKD *const xd,
+                       AV1CdefWorkerData *const cdef_worker,
+                       AVxWorker *const workers, AV1CdefSync *const cdef_sync,
+                       int num_workers,
                        cdef_init_fb_row_t cdef_init_fb_row_fn) {
   YV12_BUFFER_CONFIG *frame = &cm->cur_frame->buf;
   const int num_planes = av1_num_planes(cm);
diff --git a/av1/common/thread_common.h b/av1/common/thread_common.h
index d27baff..b04f4fd 100644
--- a/av1/common/thread_common.h
+++ b/av1/common/thread_common.h
@@ -131,18 +131,19 @@
   int fbc;
 } AV1CdefSync;
 
-void av1_cdef_frame_mt(AV1_COMMON *cm, MACROBLOCKD *xd,
-                       AV1CdefWorkerData *cdef_worker, AVxWorker *workers,
-                       AV1CdefSync *cdef_sync, int num_workers,
-                       cdef_init_fb_row_t cdef_init_fb_row_fn);
-void av1_cdef_init_fb_row_mt(AV1_COMMON *cm, MACROBLOCKD *const xd,
-                             CdefBlockInfo *fb_info, uint16_t **const linebuf,
-                             uint16_t *const src,
-                             struct AV1CdefSyncData *cdef_sync, int fbr);
-void av1_cdef_copy_sb8_16(AV1_COMMON *cm, uint16_t *dst, int dstride,
-                          const uint8_t *src, int src_voffset, int src_hoffset,
-                          int sstride, int vsize, int hsize);
-void av1_alloc_cdef_sync(AV1_COMMON *cm, AV1CdefSync *cdef_sync,
+void av1_cdef_frame_mt(AV1_COMMON *const cm, MACROBLOCKD *const xd,
+                       AV1CdefWorkerData *const cdef_worker,
+                       AVxWorker *const workers, AV1CdefSync *const cdef_sync,
+                       int num_workers, cdef_init_fb_row_t cdef_init_fb_row_fn);
+void av1_cdef_init_fb_row_mt(const AV1_COMMON *const cm,
+                             const MACROBLOCKD *const xd,
+                             CdefBlockInfo *const fb_info,
+                             uint16_t **const linebuf, uint16_t *const src,
+                             struct AV1CdefSyncData *const cdef_sync, int fbr);
+void av1_cdef_copy_sb8_16(const AV1_COMMON *const cm, uint16_t *const dst,
+                          int dstride, const uint8_t *src, int src_voffset,
+                          int src_hoffset, int sstride, int vsize, int hsize);
+void av1_alloc_cdef_sync(AV1_COMMON *const cm, AV1CdefSync *cdef_sync,
                          int num_workers);
 void av1_free_cdef_sync(AV1CdefSync *cdef_sync);