/*

 * Copyright (c) 2016, Alliance for Open Media. All rights reserved.

 *

 * This source code is subject to the terms of the BSD 2 Clause License and

 * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License

 * was not distributed with this source code in the LICENSE file, you can

 * obtain it at www.aomedia.org/license/software. If the Alliance for Open

 * Media Patent License 1.0 was not distributed with this source code in the

 * PATENTS file, you can obtain it at www.aomedia.org/license/patent.

 */

#include <assert.h>

#include <stdbool.h>

#include "aom_util/aom_pthread.h"

#include "av1/common/warped_motion.h"

#include "av1/common/thread_common.h"

#include "av1/encoder/allintra_vis.h"

#include "av1/encoder/bitstream.h"

#include "av1/encoder/enc_enums.h"

#include "av1/encoder/encodeframe.h"

#include "av1/encoder/encodeframe_utils.h"

#include "av1/encoder/encoder.h"

#include "av1/encoder/encoder_alloc.h"

#include "av1/encoder/ethread.h"

#if !CONFIG_REALTIME_ONLY

#include "av1/encoder/firstpass.h"

#endif

#include "av1/encoder/global_motion.h"

#include "av1/encoder/global_motion_facade.h"

#include "av1/encoder/intra_mode_search_utils.h"

#include "av1/encoder/picklpf.h"

#include "av1/encoder/rdopt.h"

#include "aom_dsp/aom_dsp_common.h"

#include "av1/encoder/temporal_filter.h"

#include "av1/encoder/tpl_model.h"

static inline void accumulate_rd_opt(ThreadData *td, ThreadData *td_t) {

  td->rd_counts.compound_ref_used_flag |=

      td_t->rd_counts.compound_ref_used_flag;

  td->rd_counts.skip_mode_used_flag |= td_t->rd_counts.skip_mode_used_flag;

  for (int i = 0; i < TX_SIZES_ALL; i++) {

    for (int j = 0; j < TX_TYPES; j++)

      td->rd_counts.tx_type_used[i][j] += td_t->rd_counts.tx_type_used[i][j];

  }

  for (int i = 0; i < BLOCK_SIZES_ALL; i++) {

    for (int j = 0; j < 2; j++) {

      td->rd_counts.obmc_used[i][j] += td_t->rd_counts.obmc_used[i][j];

    }

  }

  for (int i = 0; i < 2; i++) {

    td->rd_counts.warped_used[i] += td_t->rd_counts.warped_used[i];

  }

  td->rd_counts.seg_tmp_pred_cost[0] += td_t->rd_counts.seg_tmp_pred_cost[0];

  td->rd_counts.seg_tmp_pred_cost[1] += td_t->rd_counts.seg_tmp_pred_cost[1];

  td->rd_counts.newmv_or_intra_blocks += td_t->rd_counts.newmv_or_intra_blocks;

}

static inline void update_delta_lf_for_row_mt(AV1_COMP *cpi) {

  AV1_COMMON *cm = &cpi->common;

  MACROBLOCKD *xd = &cpi->td.mb.e_mbd;

  const int mib_size = cm->seq_params->mib_size;

  const int frame_lf_count =

      av1_num_planes(cm) > 1 ? FRAME_LF_COUNT : FRAME_LF_COUNT - 2;

  for (int row = 0; row < cm->tiles.rows; row++) {

    for (int col = 0; col < cm->tiles.cols; col++) {

      TileDataEnc *tile_data = &cpi->tile_data[row * cm->tiles.cols + col];

      const TileInfo *const tile_info = &tile_data->tile_info;

      for (int mi_row = tile_info->mi_row_start; mi_row < tile_info->mi_row_end;

           mi_row += mib_size) {

        if (mi_row == tile_info->mi_row_start)

          av1_reset_loop_filter_delta(xd, av1_num_planes(cm));

        for (int mi_col = tile_info->mi_col_start;

             mi_col < tile_info->mi_col_end; mi_col += mib_size) {

          const int idx_str = cm->mi_params.mi_stride * mi_row + mi_col;

          MB_MODE_INFO **mi = cm->mi_params.mi_grid_base + idx_str;

          MB_MODE_INFO *mbmi = mi[0];

          if (mbmi->skip_txfm == 1 &&

              (mbmi->bsize == cm->seq_params->sb_size)) {

            for (int lf_id = 0; lf_id < frame_lf_count; ++lf_id)

              mbmi->delta_lf[lf_id] = xd->delta_lf[lf_id];

            mbmi->delta_lf_from_base = xd->delta_lf_from_base;

          } else {

            if (cm->delta_q_info.delta_lf_multi) {

              for (int lf_id = 0; lf_id < frame_lf_count; ++lf_id)

                xd->delta_lf[lf_id] = mbmi->delta_lf[lf_id];

            } else {

              xd->delta_lf_from_base = mbmi->delta_lf_from_base;

            }

          }

        }

      }

    }

  }

}

void av1_row_mt_sync_read_dummy(AV1EncRowMultiThreadSync *row_mt_sync, int r,

                                int c) {

  (void)row_mt_sync;

  (void)r;

  (void)c;

}

void av1_row_mt_sync_write_dummy(AV1EncRowMultiThreadSync *row_mt_sync, int r,

                                 int c, int cols) {

  (void)row_mt_sync;

  (void)r;

  (void)c;

  (void)cols;

}

void av1_row_mt_sync_read(AV1EncRowMultiThreadSync *row_mt_sync, int r, int c) {

#if CONFIG_MULTITHREAD

  const int nsync = row_mt_sync->sync_range;

  if (r) {

    pthread_mutex_t *const mutex = &row_mt_sync->mutex_[r - 1];

    pthread_mutex_lock(mutex);

    while (c > row_mt_sync->num_finished_cols[r - 1] - nsync -

                   row_mt_sync->intrabc_extra_top_right_sb_delay) {

      pthread_cond_wait(&row_mt_sync->cond_[r - 1], mutex);

    }

    pthread_mutex_unlock(mutex);

  }

#else

  (void)row_mt_sync;

  (void)r;

  (void)c;

#endif  // CONFIG_MULTITHREAD

}

void av1_row_mt_sync_write(AV1EncRowMultiThreadSync *row_mt_sync, int r, int c,

                           int cols) {

#if CONFIG_MULTITHREAD

  const int nsync = row_mt_sync->sync_range;

  int cur;

  // Only signal when there are enough encoded blocks for next row to run.

  int sig = 1;

  if (c < cols - 1) {

    cur = c;

    if (c % nsync) sig = 0;

  } else {

    cur = cols + nsync + row_mt_sync->intrabc_extra_top_right_sb_delay;

  }

  if (sig) {

    pthread_mutex_lock(&row_mt_sync->mutex_[r]);

    // When a thread encounters an error, num_finished_cols[r] is set to maximum

    // column number. In this case, the AOMMAX operation here ensures that

    // num_finished_cols[r] is not overwritten with a smaller value thus

    // preventing the infinite waiting of threads in the relevant sync_read()

    // function.

    row_mt_sync->num_finished_cols[r] =

        AOMMAX(row_mt_sync->num_finished_cols[r], cur);

    pthread_cond_signal(&row_mt_sync->cond_[r]);

    pthread_mutex_unlock(&row_mt_sync->mutex_[r]);

  }

#else

  (void)row_mt_sync;

  (void)r;

  (void)c;

  (void)cols;

#endif  // CONFIG_MULTITHREAD

}

// Allocate memory for row synchronization

static void row_mt_sync_mem_alloc(AV1EncRowMultiThreadSync *row_mt_sync,

                                  AV1_COMMON *cm, int rows) {

#if CONFIG_MULTITHREAD

  int i;

  CHECK_MEM_ERROR(cm, row_mt_sync->mutex_,

                  aom_malloc(sizeof(*row_mt_sync->mutex_) * rows));

  if (row_mt_sync->mutex_) {

    for (i = 0; i < rows; ++i) {

      pthread_mutex_init(&row_mt_sync->mutex_[i], NULL);

    }

  }

  CHECK_MEM_ERROR(cm, row_mt_sync->cond_,

                  aom_malloc(sizeof(*row_mt_sync->cond_) * rows));

  if (row_mt_sync->cond_) {

    for (i = 0; i < rows; ++i) {

      pthread_cond_init(&row_mt_sync->cond_[i], NULL);

    }

  }

#endif  // CONFIG_MULTITHREAD

  CHECK_MEM_ERROR(cm, row_mt_sync->num_finished_cols,

                  aom_malloc(sizeof(*row_mt_sync->num_finished_cols) * rows));

  row_mt_sync->rows = rows;

  // Set up nsync.

  row_mt_sync->sync_range = 1;

}

// Deallocate row based multi-threading synchronization related mutex and data

void av1_row_mt_sync_mem_dealloc(AV1EncRowMultiThreadSync *row_mt_sync) {

  if (row_mt_sync != NULL) {

#if CONFIG_MULTITHREAD

    int i;

    if (row_mt_sync->mutex_ != NULL) {

      for (i = 0; i < row_mt_sync->rows; ++i) {

        pthread_mutex_destroy(&row_mt_sync->mutex_[i]);

      }

      aom_free(row_mt_sync->mutex_);

    }

    if (row_mt_sync->cond_ != NULL) {

      for (i = 0; i < row_mt_sync->rows; ++i) {

        pthread_cond_destroy(&row_mt_sync->cond_[i]);

      }

      aom_free(row_mt_sync->cond_);

    }

#endif  // CONFIG_MULTITHREAD

    aom_free(row_mt_sync->num_finished_cols);

    // clear the structure as the source of this call may be dynamic change

    // in tiles in which case this call will be followed by an _alloc()

    // which may fail.

    av1_zero(*row_mt_sync);

  }

}

static inline int get_sb_rows_in_frame(AV1_COMMON *cm) {

  return CEIL_POWER_OF_TWO(cm->mi_params.mi_rows,

                           cm->seq_params->mib_size_log2);

}

static void row_mt_mem_alloc(AV1_COMP *cpi, int max_rows, int max_cols,

                             int alloc_row_ctx) {

  struct AV1Common *cm = &cpi->common;

  AV1EncRowMultiThreadInfo *const enc_row_mt = &cpi->mt_info.enc_row_mt;

  const int tile_cols = cm->tiles.cols;

  const int tile_rows = cm->tiles.rows;

  int tile_col, tile_row;

  av1_row_mt_mem_dealloc(cpi);

  // Allocate memory for row based multi-threading

  assert(cpi->allocated_tiles == tile_cols * tile_rows);

  for (tile_row = 0; tile_row < tile_rows; tile_row++) {

    for (tile_col = 0; tile_col < tile_cols; tile_col++) {

      int tile_index = tile_row * tile_cols + tile_col;

      TileDataEnc *const this_tile = &cpi->tile_data[tile_index];

      row_mt_sync_mem_alloc(&this_tile->row_mt_sync, cm, max_rows);

      if (alloc_row_ctx) {

        assert(max_cols > 0);

        const int num_row_ctx = AOMMAX(1, (max_cols - 1));

        CHECK_MEM_ERROR(cm, this_tile->row_ctx,

                        (FRAME_CONTEXT *)aom_memalign(

                            16, num_row_ctx * sizeof(*this_tile->row_ctx)));

      }

    }

  }

  enc_row_mt->allocated_tile_cols = tile_cols;

  enc_row_mt->allocated_tile_rows = tile_rows;

  const int sb_rows = get_sb_rows_in_frame(cm);

  CHECK_MEM_ERROR(

      cm, enc_row_mt->num_tile_cols_done,

      aom_malloc(sizeof(*enc_row_mt->num_tile_cols_done) * sb_rows));

  enc_row_mt->allocated_rows = max_rows;

  enc_row_mt->allocated_cols = max_cols - 1;

  enc_row_mt->allocated_sb_rows = sb_rows;

}

void av1_row_mt_mem_dealloc(AV1_COMP *cpi) {

  AV1EncRowMultiThreadInfo *const enc_row_mt = &cpi->mt_info.enc_row_mt;

  const int tile_cols = enc_row_mt->allocated_tile_cols;

  const int tile_rows = enc_row_mt->allocated_tile_rows;

  int tile_col, tile_row;

  // Free row based multi-threading sync memory

  for (tile_row = 0; tile_row < tile_rows; tile_row++) {

    for (tile_col = 0; tile_col < tile_cols; tile_col++) {

      int tile_index = tile_row * tile_cols + tile_col;

      TileDataEnc *const this_tile = &cpi->tile_data[tile_index];

      av1_row_mt_sync_mem_dealloc(&this_tile->row_mt_sync);

      if (cpi->oxcf.algo_cfg.cdf_update_mode) {

        aom_free(this_tile->row_ctx);

        this_tile->row_ctx = NULL;

      }

    }

  }

  enc_row_mt->allocated_tile_cols = 0;

  enc_row_mt->allocated_tile_rows = 0;

  aom_free(enc_row_mt->num_tile_cols_done);

  enc_row_mt->num_tile_cols_done = NULL;

  enc_row_mt->allocated_rows = 0;

  enc_row_mt->allocated_cols = 0;

  enc_row_mt->allocated_sb_rows = 0;

}

static inline void assign_tile_to_thread(int *thread_id_to_tile_id,

                                         int num_tiles, int num_workers) {

  int tile_id = 0;

  int i;

  for (i = 0; i < num_workers; i++) {

    thread_id_to_tile_id[i] = tile_id++;

    if (tile_id == num_tiles) tile_id = 0;

  }

}

static inline int get_next_job(TileDataEnc *const tile_data,

                               int *current_mi_row, int mib_size) {

  AV1EncRowMultiThreadSync *const row_mt_sync = &tile_data->row_mt_sync;

  const int mi_row_end = tile_data->tile_info.mi_row_end;

  if (row_mt_sync->next_mi_row < mi_row_end) {

    *current_mi_row = row_mt_sync->next_mi_row;

    row_mt_sync->num_threads_working++;

    row_mt_sync->next_mi_row += mib_size;

    return 1;

  }

  return 0;

}

static inline void switch_tile_and_get_next_job(

    AV1_COMMON *const cm, TileDataEnc *const tile_data, int *cur_tile_id,

    int *current_mi_row, int *end_of_frame, int is_firstpass,

    const BLOCK_SIZE fp_block_size) {

  const int tile_cols = cm->tiles.cols;

  const int tile_rows = cm->tiles.rows;

  int tile_id = -1;  // Stores the tile ID with minimum proc done

  int max_mis_to_encode = 0;

  int min_num_threads_working = INT_MAX;

  for (int tile_row = 0; tile_row < tile_rows; tile_row++) {

    for (int tile_col = 0; tile_col < tile_cols; tile_col++) {

      int tile_index = tile_row * tile_cols + tile_col;

      TileDataEnc *const this_tile = &tile_data[tile_index];

      AV1EncRowMultiThreadSync *const row_mt_sync = &this_tile->row_mt_sync;

#if CONFIG_REALTIME_ONLY

      int num_b_rows_in_tile =

          av1_get_sb_rows_in_tile(cm, &this_tile->tile_info);

      int num_b_cols_in_tile =

          av1_get_sb_cols_in_tile(cm, &this_tile->tile_info);

#else

      int num_b_rows_in_tile =

          is_firstpass

              ? av1_get_unit_rows_in_tile(&this_tile->tile_info, fp_block_size)

              : av1_get_sb_rows_in_tile(cm, &this_tile->tile_info);

      int num_b_cols_in_tile =

          is_firstpass

              ? av1_get_unit_cols_in_tile(&this_tile->tile_info, fp_block_size)

              : av1_get_sb_cols_in_tile(cm, &this_tile->tile_info);

#endif

      int theoretical_limit_on_threads =

          AOMMIN((num_b_cols_in_tile + 1) >> 1, num_b_rows_in_tile);

      int num_threads_working = row_mt_sync->num_threads_working;

      if (num_threads_working < theoretical_limit_on_threads) {

        int num_mis_to_encode =

            this_tile->tile_info.mi_row_end - row_mt_sync->next_mi_row;

        // Tile to be processed by this thread is selected on the basis of

        // availability of jobs:

        // 1) If jobs are available, tile to be processed is chosen on the

        // basis of minimum number of threads working for that tile. If two or

        // more tiles have same number of threads working for them, then the

        // tile with maximum number of jobs available will be chosen.

        // 2) If no jobs are available, then end_of_frame is reached.

        if (num_mis_to_encode > 0) {

          if (num_threads_working < min_num_threads_working) {

            min_num_threads_working = num_threads_working;

            max_mis_to_encode = 0;

          }

          if (num_threads_working == min_num_threads_working &&

              num_mis_to_encode > max_mis_to_encode) {

            tile_id = tile_index;

            max_mis_to_encode = num_mis_to_encode;

          }

        }

      }

    }

  }

  if (tile_id == -1) {

    *end_of_frame = 1;

  } else {

    // Update the current tile id to the tile id that will be processed next,

    // which will be the least processed tile.

    *cur_tile_id = tile_id;

    const int unit_height = mi_size_high[fp_block_size];

    get_next_job(&tile_data[tile_id], current_mi_row,

                 is_firstpass ? unit_height : cm->seq_params->mib_size);

  }

}

#if !CONFIG_REALTIME_ONLY

static void set_firstpass_encode_done(AV1_COMP *cpi) {

  AV1_COMMON *const cm = &cpi->common;

  AV1EncRowMultiThreadInfo *const enc_row_mt = &cpi->mt_info.enc_row_mt;

  const int tile_cols = cm->tiles.cols;

  const int tile_rows = cm->tiles.rows;

  const BLOCK_SIZE fp_block_size = cpi->fp_block_size;

  const int unit_height = mi_size_high[fp_block_size];

  // In case of multithreading of firstpass encode, due to top-right

  // dependency, the worker on a firstpass row waits for the completion of the

  // firstpass processing of the top and top-right fp_blocks. Hence, in case a

  // thread (main/worker) encounters an error, update the firstpass processing

  // of every row in the frame to indicate that it is complete in order to avoid

  // dependent workers waiting indefinitely.

  for (int tile_row = 0; tile_row < tile_rows; ++tile_row) {

    for (int tile_col = 0; tile_col < tile_cols; ++tile_col) {

      TileDataEnc *const tile_data =

          &cpi->tile_data[tile_row * tile_cols + tile_col];

      TileInfo *tile = &tile_data->tile_info;

      AV1EncRowMultiThreadSync *const row_mt_sync = &tile_data->row_mt_sync;

      const int unit_cols_in_tile =

          av1_get_unit_cols_in_tile(tile, fp_block_size);

      for (int mi_row = tile->mi_row_start, unit_row_in_tile = 0;

           mi_row < tile->mi_row_end;

           mi_row += unit_height, unit_row_in_tile++) {

        enc_row_mt->sync_write_ptr(row_mt_sync, unit_row_in_tile,

                                   unit_cols_in_tile - 1, unit_cols_in_tile);

      }

    }

  }

}

static int fp_enc_row_mt_worker_hook(void *arg1, void *unused) {

  EncWorkerData *const thread_data = (EncWorkerData *)arg1;

  AV1_COMP *const cpi = thread_data->cpi;

  int thread_id = thread_data->thread_id;

  AV1EncRowMultiThreadInfo *const enc_row_mt = &cpi->mt_info.enc_row_mt;

#if CONFIG_MULTITHREAD

  pthread_mutex_t *enc_row_mt_mutex_ = enc_row_mt->mutex_;

#endif

  (void)unused;

  struct aom_internal_error_info *const error_info = &thread_data->error_info;

  MACROBLOCKD *const xd = &thread_data->td->mb.e_mbd;

  xd->error_info = error_info;

  // The jmp_buf is valid only for the duration of the function that calls

  // setjmp(). Therefore, this function must reset the 'setjmp' field to 0

  // before it returns.

  if (setjmp(error_info->jmp)) {

    error_info->setjmp = 0;

#if CONFIG_MULTITHREAD

    pthread_mutex_lock(enc_row_mt_mutex_);

    enc_row_mt->firstpass_mt_exit = true;

    pthread_mutex_unlock(enc_row_mt_mutex_);

#endif

    set_firstpass_encode_done(cpi);

    return 0;

  }

  error_info->setjmp = 1;

  AV1_COMMON *const cm = &cpi->common;

  int cur_tile_id = enc_row_mt->thread_id_to_tile_id[thread_id];

  assert(cur_tile_id != -1);

  const BLOCK_SIZE fp_block_size = cpi->fp_block_size;

  const int unit_height = mi_size_high[fp_block_size];

  int end_of_frame = 0;

  while (1) {

    int current_mi_row = -1;

#if CONFIG_MULTITHREAD

    pthread_mutex_lock(enc_row_mt_mutex_);

#endif

    bool firstpass_mt_exit = enc_row_mt->firstpass_mt_exit;

    if (!firstpass_mt_exit && !get_next_job(&cpi->tile_data[cur_tile_id],

                                            &current_mi_row, unit_height)) {

      // No jobs are available for the current tile. Query for the status of

      // other tiles and get the next job if available

      switch_tile_and_get_next_job(cm, cpi->tile_data, &cur_tile_id,

                                   &current_mi_row, &end_of_frame, 1,

                                   fp_block_size);

    }

#if CONFIG_MULTITHREAD

    pthread_mutex_unlock(enc_row_mt_mutex_);

#endif

    // When firstpass_mt_exit is set to true, other workers need not pursue any

    // further jobs.

    if (firstpass_mt_exit || end_of_frame) break;

    TileDataEnc *const this_tile = &cpi->tile_data[cur_tile_id];

    AV1EncRowMultiThreadSync *const row_mt_sync = &this_tile->row_mt_sync;

    ThreadData *td = thread_data->td;

    assert(current_mi_row != -1 &&

           current_mi_row < this_tile->tile_info.mi_row_end);

    const int unit_height_log2 = mi_size_high_log2[fp_block_size];

    av1_first_pass_row(cpi, td, this_tile, current_mi_row >> unit_height_log2,

                       fp_block_size);

#if CONFIG_MULTITHREAD

    pthread_mutex_lock(enc_row_mt_mutex_);

#endif

    row_mt_sync->num_threads_working--;

#if CONFIG_MULTITHREAD

    pthread_mutex_unlock(enc_row_mt_mutex_);

#endif

  }

  error_info->setjmp = 0;

  return 1;

}

#endif

static void launch_loop_filter_rows(AV1_COMMON *cm, EncWorkerData *thread_data,

                                    AV1EncRowMultiThreadInfo *enc_row_mt,

                                    int mib_size_log2) {

  AV1LfSync *const lf_sync = (AV1LfSync *)thread_data->lf_sync;

  const int sb_rows = get_sb_rows_in_frame(cm);

  AV1LfMTInfo *cur_job_info;

  bool row_mt_exit = false;

  (void)enc_row_mt;

#if CONFIG_MULTITHREAD

  pthread_mutex_t *enc_row_mt_mutex_ = enc_row_mt->mutex_;

#endif

  while ((cur_job_info = get_lf_job_info(lf_sync)) != NULL) {

    LFWorkerData *const lf_data = (LFWorkerData *)thread_data->lf_data;

    const int lpf_opt_level = cur_job_info->lpf_opt_level;

    (void)sb_rows;

#if CONFIG_MULTITHREAD

    const int cur_sb_row = cur_job_info->mi_row >> mib_size_log2;

    const int next_sb_row = AOMMIN(sb_rows - 1, cur_sb_row + 1);

    // Wait for current and next superblock row to finish encoding.

    pthread_mutex_lock(enc_row_mt_mutex_);

    while (!enc_row_mt->row_mt_exit &&

           (enc_row_mt->num_tile_cols_done[cur_sb_row] < cm->tiles.cols ||

            enc_row_mt->num_tile_cols_done[next_sb_row] < cm->tiles.cols)) {

      pthread_cond_wait(enc_row_mt->cond_, enc_row_mt_mutex_);

    }

    row_mt_exit = enc_row_mt->row_mt_exit;

    pthread_mutex_unlock(enc_row_mt_mutex_);

#endif

    if (row_mt_exit) return;

    av1_thread_loop_filter_rows(

        lf_data->frame_buffer, lf_data->cm, lf_data->planes, lf_data->xd,

        cur_job_info->mi_row, cur_job_info->plane, cur_job_info->dir,

        lpf_opt_level, lf_sync, &thread_data->error_info, lf_data->params_buf,

        lf_data->tx_buf, mib_size_log2);

  }

}

static void set_encoding_done(AV1_COMP *cpi) {

  AV1_COMMON *const cm = &cpi->common;

  const int tile_cols = cm->tiles.cols;

  const int tile_rows = cm->tiles.rows;

  AV1EncRowMultiThreadInfo *const enc_row_mt = &cpi->mt_info.enc_row_mt;

  const int mib_size = cm->seq_params->mib_size;

  // In case of row-multithreading, due to top-right dependency, the worker on

  // an SB row waits for the completion of the encode of the top and top-right

  // SBs. Hence, in case a thread (main/worker) encounters an error, update that

  // encoding of every SB row in the frame is complete in order to avoid the

  // dependent workers of every tile from waiting indefinitely.

  for (int tile_row = 0; tile_row < tile_rows; tile_row++) {

    for (int tile_col = 0; tile_col < tile_cols; tile_col++) {

      TileDataEnc *const this_tile =

          &cpi->tile_data[tile_row * tile_cols + tile_col];

      const TileInfo *const tile_info = &this_tile->tile_info;

      AV1EncRowMultiThreadSync *const row_mt_sync = &this_tile->row_mt_sync;

      const int sb_cols_in_tile = av1_get_sb_cols_in_tile(cm, tile_info);

      for (int mi_row = tile_info->mi_row_start, sb_row_in_tile = 0;

           mi_row < tile_info->mi_row_end;

           mi_row += mib_size, sb_row_in_tile++) {

        enc_row_mt->sync_write_ptr(row_mt_sync, sb_row_in_tile,

                                   sb_cols_in_tile - 1, sb_cols_in_tile);

      }

    }

  }

}

static bool lpf_mt_with_enc_enabled(int pipeline_lpf_mt_with_enc,

                                    const int filter_level[2]) {

  return pipeline_lpf_mt_with_enc && (filter_level[0] || filter_level[1]);

}

static int enc_row_mt_worker_hook(void *arg1, void *unused) {

  EncWorkerData *const thread_data = (EncWorkerData *)arg1;

  AV1_COMP *const cpi = thread_data->cpi;

  int thread_id = thread_data->thread_id;

  AV1EncRowMultiThreadInfo *const enc_row_mt = &cpi->mt_info.enc_row_mt;

#if CONFIG_MULTITHREAD

  pthread_mutex_t *enc_row_mt_mutex_ = enc_row_mt->mutex_;

#endif

  (void)unused;

  struct aom_internal_error_info *const error_info = &thread_data->error_info;

  AV1LfSync *const lf_sync = thread_data->lf_sync;

  MACROBLOCKD *const xd = &thread_data->td->mb.e_mbd;

  xd->error_info = error_info;

  AV1_COMMON *volatile const cm = &cpi->common;

  volatile const bool do_pipelined_lpf_mt_with_enc = lpf_mt_with_enc_enabled(

      cpi->mt_info.pipeline_lpf_mt_with_enc, cm->lf.filter_level);

  // The jmp_buf is valid only for the duration of the function that calls

  // setjmp(). Therefore, this function must reset the 'setjmp' field to 0

  // before it returns.

  if (setjmp(error_info->jmp)) {

    error_info->setjmp = 0;

#if CONFIG_MULTITHREAD

    pthread_mutex_lock(enc_row_mt_mutex_);

    enc_row_mt->row_mt_exit = true;

    // Wake up all the workers waiting in launch_loop_filter_rows() to exit in

    // case of an error.

    pthread_cond_broadcast(enc_row_mt->cond_);

    pthread_mutex_unlock(enc_row_mt_mutex_);

#endif

    set_encoding_done(cpi);

    if (do_pipelined_lpf_mt_with_enc) {

#if CONFIG_MULTITHREAD

      pthread_mutex_lock(lf_sync->job_mutex);

      lf_sync->lf_mt_exit = true;

      pthread_mutex_unlock(lf_sync->job_mutex);

#endif

      av1_set_vert_loop_filter_done(&cpi->common, lf_sync,

                                    cpi->common.seq_params->mib_size_log2);

    }

    return 0;

  }

  error_info->setjmp = 1;

  const int mib_size_log2 = cm->seq_params->mib_size_log2;

  int cur_tile_id = enc_row_mt->thread_id_to_tile_id[thread_id];

  // Preallocate the pc_tree for realtime coding to reduce the cost of memory

  // allocation.

  if (cpi->sf.rt_sf.use_nonrd_pick_mode) {

    thread_data->td->pc_root = av1_alloc_pc_tree_node(cm->seq_params->sb_size);

    if (!thread_data->td->pc_root)

      aom_internal_error(xd->error_info, AOM_CODEC_MEM_ERROR,

                         "Failed to allocate PC_TREE");

  } else {

    thread_data->td->pc_root = NULL;

  }

  assert(cur_tile_id != -1);

  const BLOCK_SIZE fp_block_size = cpi->fp_block_size;

  int end_of_frame = 0;

  bool row_mt_exit = false;

  // When master thread does not have a valid job to process, xd->tile_ctx

  // is not set and it contains NULL pointer. This can result in NULL pointer

  // access violation if accessed beyond the encode stage. Hence, updating

  // thread_data->td->mb.e_mbd.tile_ctx is initialized with common frame

  // context to avoid NULL pointer access in subsequent stages.

  thread_data->td->mb.e_mbd.tile_ctx = cm->fc;

  while (1) {

    int current_mi_row = -1;

#if CONFIG_MULTITHREAD

    pthread_mutex_lock(enc_row_mt_mutex_);

#endif

    row_mt_exit = enc_row_mt->row_mt_exit;

    // row_mt_exit check here can be avoided as it is checked after

    // sync_read_ptr() in encode_sb_row(). However, checking row_mt_exit here,

    // tries to return before calling the function get_next_job().

    if (!row_mt_exit &&

        !get_next_job(&cpi->tile_data[cur_tile_id], &current_mi_row,

                      cm->seq_params->mib_size)) {

      // No jobs are available for the current tile. Query for the status of

      // other tiles and get the next job if available

      switch_tile_and_get_next_job(cm, cpi->tile_data, &cur_tile_id,

                                   &current_mi_row, &end_of_frame, 0,

                                   fp_block_size);

    }

#if CONFIG_MULTITHREAD

    pthread_mutex_unlock(enc_row_mt_mutex_);

#endif

    // When row_mt_exit is set to true, other workers need not pursue any

    // further jobs.

    if (row_mt_exit) {

      error_info->setjmp = 0;

      return 1;

    }

    if (end_of_frame) break;

    TileDataEnc *const this_tile = &cpi->tile_data[cur_tile_id];

    AV1EncRowMultiThreadSync *const row_mt_sync = &this_tile->row_mt_sync;

    const TileInfo *const tile_info = &this_tile->tile_info;

    const int tile_row = tile_info->tile_row;

    const int tile_col = tile_info->tile_col;

    ThreadData *td = thread_data->td;

    const int sb_row = current_mi_row >> mib_size_log2;

    assert(current_mi_row != -1 && current_mi_row <= tile_info->mi_row_end);

    td->mb.e_mbd.tile_ctx = td->tctx;

    td->mb.tile_pb_ctx = &this_tile->tctx;

    td->abs_sum_level = 0;

    if (this_tile->allow_update_cdf) {

      td->mb.row_ctx = this_tile->row_ctx;

      if (current_mi_row == tile_info->mi_row_start)

        *td->mb.e_mbd.tile_ctx = this_tile->tctx;

    } else {

      *td->mb.e_mbd.tile_ctx = this_tile->tctx;

    }

    av1_init_above_context(&cm->above_contexts, av1_num_planes(cm), tile_row,

                           &td->mb.e_mbd);

#if !CONFIG_REALTIME_ONLY

    cfl_init(&td->mb.e_mbd.cfl, cm->seq_params);

#endif

    if (td->mb.txfm_search_info.mb_rd_record != NULL) {

      av1_crc32c_calculator_init(

          &td->mb.txfm_search_info.mb_rd_record->crc_calculator);

    }

    av1_encode_sb_row(cpi, td, tile_row, tile_col, current_mi_row);

#if CONFIG_MULTITHREAD

    pthread_mutex_lock(enc_row_mt_mutex_);

#endif

    this_tile->abs_sum_level += td->abs_sum_level;

    row_mt_sync->num_threads_working--;

    enc_row_mt->num_tile_cols_done[sb_row]++;

#if CONFIG_MULTITHREAD

    pthread_cond_broadcast(enc_row_mt->cond_);

    pthread_mutex_unlock(enc_row_mt_mutex_);

#endif

  }

  if (do_pipelined_lpf_mt_with_enc) {

    // Loop-filter a superblock row if encoding of the current and next

    // superblock row is complete.

    // TODO(deepa.kg @ittiam.com) Evaluate encoder speed by interleaving

    // encoding and loop filter stage.

    launch_loop_filter_rows(cm, thread_data, enc_row_mt, mib_size_log2);

  }

  av1_free_pc_tree_recursive(thread_data->td->pc_root, av1_num_planes(cm), 0, 0,

                             cpi->sf.part_sf.partition_search_type);

  thread_data->td->pc_root = NULL;

  error_info->setjmp = 0;

  return 1;

}

static int enc_worker_hook(void *arg1, void *unused) {

  EncWorkerData *const thread_data = (EncWorkerData *)arg1;

  AV1_COMP *const cpi = thread_data->cpi;

  MACROBLOCKD *const xd = &thread_data->td->mb.e_mbd;

  struct aom_internal_error_info *const error_info = &thread_data->error_info;

  const AV1_COMMON *const cm = &cpi->common;

  const int tile_cols = cm->tiles.cols;

  const int tile_rows = cm->tiles.rows;

  int t;

  (void)unused;

  xd->error_info = error_info;

  // The jmp_buf is valid only for the duration of the function that calls

  // setjmp(). Therefore, this function must reset the 'setjmp' field to 0

  // before it returns.

  if (setjmp(error_info->jmp)) {

    error_info->setjmp = 0;

    return 0;

  }

  error_info->setjmp = 1;

  // Preallocate the pc_tree for realtime coding to reduce the cost of memory

  // allocation.

  if (cpi->sf.rt_sf.use_nonrd_pick_mode) {

    thread_data->td->pc_root = av1_alloc_pc_tree_node(cm->seq_params->sb_size);

    if (!thread_data->td->pc_root)

      aom_internal_error(xd->error_info, AOM_CODEC_MEM_ERROR,

                         "Failed to allocate PC_TREE");

  } else {

    thread_data->td->pc_root = NULL;

  }

  for (t = thread_data->start; t < tile_rows * tile_cols;

       t += cpi->mt_info.num_workers) {

    int tile_row = t / tile_cols;

    int tile_col = t % tile_cols;

    TileDataEnc *const this_tile =

        &cpi->tile_data[tile_row * cm->tiles.cols + tile_col];

    thread_data->td->mb.e_mbd.tile_ctx = &this_tile->tctx;

    thread_data->td->mb.tile_pb_ctx = &this_tile->tctx;

    av1_encode_tile(cpi, thread_data->td, tile_row, tile_col);

  }

  av1_free_pc_tree_recursive(thread_data->td->pc_root, av1_num_planes(cm), 0, 0,

                             cpi->sf.part_sf.partition_search_type);

  thread_data->td->pc_root = NULL;

  error_info->setjmp = 0;

  return 1;

}

void av1_init_frame_mt(AV1_PRIMARY *ppi, AV1_COMP *cpi) {

  cpi->mt_info.workers = ppi->p_mt_info.workers;

  cpi->mt_info.num_workers = ppi->p_mt_info.num_workers;

  cpi->mt_info.tile_thr_data = ppi->p_mt_info.tile_thr_data;

  int i;

  for (i = MOD_FP; i < NUM_MT_MODULES; i++) {

    cpi->mt_info.num_mod_workers[i] =

        AOMMIN(cpi->mt_info.num_workers, ppi->p_mt_info.num_mod_workers[i]);

  }

}

void av1_init_cdef_worker(AV1_COMP *cpi) {

  // The allocation is done only for level 0 parallel frames. No change

  // in config is supported in the middle of a parallel encode set, since the

  // rest of the MT modules also do not support dynamic change of config.

  if (cpi->ppi->gf_group.frame_parallel_level[cpi->gf_frame_index] > 0) return;

  PrimaryMultiThreadInfo *const p_mt_info = &cpi->ppi->p_mt_info;

  int num_cdef_workers = av1_get_num_mod_workers_for_alloc(p_mt_info, MOD_CDEF);

  av1_alloc_cdef_buffers(&cpi->common, &p_mt_info->cdef_worker,

                         &cpi->mt_info.cdef_sync, num_cdef_workers, 1);

  cpi->mt_info.cdef_worker = p_mt_info->cdef_worker;

}

#if !CONFIG_REALTIME_ONLY

void av1_init_lr_mt_buffers(AV1_COMP *cpi) {

  AV1_COMMON *const cm = &cpi->common;

  AV1LrSync *lr_sync = &cpi->mt_info.lr_row_sync;

  if (lr_sync->sync_range) {

    if (cpi->ppi->gf_group.frame_parallel_level[cpi->gf_frame_index] > 0)

      return;

    int num_lr_workers = lr_sync->num_workers;

    lr_sync->lrworkerdata[num_lr_workers - 1].rst_tmpbuf = cm->rst_tmpbuf;

    lr_sync->lrworkerdata[num_lr_workers - 1].rlbs = cm->rlbs;

  }

}

#endif

#if CONFIG_MULTITHREAD

void av1_init_mt_sync(AV1_COMP *cpi, int is_first_pass) {

  AV1_COMMON *const cm = &cpi->common;

  MultiThreadInfo *const mt_info = &cpi->mt_info;

  if (setjmp(cm->error->jmp)) {

    cm->error->setjmp = 0;

    aom_internal_error_copy(&cpi->ppi->error, cm->error);

  }

  cm->error->setjmp = 1;

  // Initialize enc row MT object.

  if (is_first_pass || cpi->oxcf.row_mt == 1) {

    AV1EncRowMultiThreadInfo *enc_row_mt = &mt_info->enc_row_mt;

    if (enc_row_mt->mutex_ == NULL) {

      CHECK_MEM_ERROR(cm, enc_row_mt->mutex_,

                      aom_malloc(sizeof(*(enc_row_mt->mutex_))));

      if (enc_row_mt->mutex_) pthread_mutex_init(enc_row_mt->mutex_, NULL);

    }

    if (enc_row_mt->cond_ == NULL) {

      CHECK_MEM_ERROR(cm, enc_row_mt->cond_,

                      aom_malloc(sizeof(*(enc_row_mt->cond_))));

      if (enc_row_mt->cond_) pthread_cond_init(enc_row_mt->cond_, NULL);

    }

  }

  if (!is_first_pass) {

    // Initialize global motion MT object.

    AV1GlobalMotionSync *gm_sync = &mt_info->gm_sync;

    if (gm_sync->mutex_ == NULL) {

      CHECK_MEM_ERROR(cm, gm_sync->mutex_,

                      aom_malloc(sizeof(*(gm_sync->mutex_))));

      if (gm_sync->mutex_) pthread_mutex_init(gm_sync->mutex_, NULL);

    }

#if !CONFIG_REALTIME_ONLY

    // Initialize temporal filtering MT object.

    AV1TemporalFilterSync *tf_sync = &mt_info->tf_sync;

    if (tf_sync->mutex_ == NULL) {

      CHECK_MEM_ERROR(cm, tf_sync->mutex_,

                      aom_malloc(sizeof(*tf_sync->mutex_)));

      if (tf_sync->mutex_) pthread_mutex_init(tf_sync->mutex_, NULL);

    }

#endif  // !CONFIG_REALTIME_ONLY

        // Initialize CDEF MT object.

    AV1CdefSync *cdef_sync = &mt_info->cdef_sync;

    if (cdef_sync->mutex_ == NULL) {

      CHECK_MEM_ERROR(cm, cdef_sync->mutex_,

                      aom_malloc(sizeof(*(cdef_sync->mutex_))));

      if (cdef_sync->mutex_) pthread_mutex_init(cdef_sync->mutex_, NULL);

    }

    // Initialize loop filter MT object.

    AV1LfSync *lf_sync = &mt_info->lf_row_sync;

    // Number of superblock rows

    const int sb_rows =

        CEIL_POWER_OF_TWO(cm->height >> MI_SIZE_LOG2, MAX_MIB_SIZE_LOG2);

    PrimaryMultiThreadInfo *const p_mt_info = &cpi->ppi->p_mt_info;

    int num_lf_workers = av1_get_num_mod_workers_for_alloc(p_mt_info, MOD_LPF);

    if (!lf_sync->sync_range || sb_rows != lf_sync->rows ||

        num_lf_workers > lf_sync->num_workers) {

      av1_loop_filter_dealloc(lf_sync);

      av1_loop_filter_alloc(lf_sync, cm, sb_rows, cm->width, num_lf_workers);

    }

    // Initialize tpl MT object.

    AV1TplRowMultiThreadInfo *tpl_row_mt = &mt_info->tpl_row_mt;

    if (tpl_row_mt->mutex_ == NULL) {

      CHECK_MEM_ERROR(cm, tpl_row_mt->mutex_,

                      aom_malloc(sizeof(*(tpl_row_mt->mutex_))));

      if (tpl_row_mt->mutex_) pthread_mutex_init(tpl_row_mt->mutex_, NULL);

    }

#if !CONFIG_REALTIME_ONLY

    if (is_restoration_used(cm)) {

      // Initialize loop restoration MT object.

      AV1LrSync *lr_sync = &mt_info->lr_row_sync;

      int rst_unit_size = cpi->sf.lpf_sf.min_lr_unit_size;

      int num_rows_lr = av1_lr_count_units(rst_unit_size, cm->height);

      int num_lr_workers = av1_get_num_mod_workers_for_alloc(p_mt_info, MOD_LR);

      const int num_planes = av1_num_planes(cm);

      if (!lr_sync->sync_range || num_rows_lr > lr_sync->rows ||

          num_lr_workers > lr_sync->num_workers ||

          num_planes > lr_sync->num_planes) {

        av1_loop_restoration_dealloc(lr_sync);

        av1_loop_restoration_alloc(lr_sync, cm, num_lr_workers, num_rows_lr,

                                   num_planes, cm->width);

      }

    }

#endif

    // Initialization of pack bitstream MT object.

    AV1EncPackBSSync *pack_bs_sync = &mt_info->pack_bs_sync;

    if (pack_bs_sync->mutex_ == NULL) {

      CHECK_MEM_ERROR(cm, pack_bs_sync->mutex_,

                      aom_malloc(sizeof(*pack_bs_sync->mutex_)));

      if (pack_bs_sync->mutex_) pthread_mutex_init(pack_bs_sync->mutex_, NULL);

    }

  }

  cm->error->setjmp = 0;

}

#endif  // CONFIG_MULTITHREAD

// Computes the number of workers to be considered while allocating memory for a

// multi-threaded module under FPMT.

int av1_get_num_mod_workers_for_alloc(const PrimaryMultiThreadInfo *p_mt_info,

                                      MULTI_THREADED_MODULES mod_name) {

  int num_mod_workers = p_mt_info->num_mod_workers[mod_name];

  if (p_mt_info->num_mod_workers[MOD_FRAME_ENC] > 1) {

    // TODO(anyone): Change num_mod_workers to num_mod_workers[MOD_FRAME_ENC].

    // As frame parallel jobs will only perform multi-threading for the encode

    // stage, we can limit the allocations according to num_enc_workers per

    // frame parallel encode(a.k.a num_mod_workers[MOD_FRAME_ENC]).

    num_mod_workers = p_mt_info->num_workers;

  }

  return num_mod_workers;

}

void av1_init_tile_thread_data(AV1_PRIMARY *ppi, int is_first_pass) {

  PrimaryMultiThreadInfo *const p_mt_info = &ppi->p_mt_info;

  assert(p_mt_info->workers != NULL);

  assert(p_mt_info->tile_thr_data != NULL);

  const int is_highbitdepth = ppi->seq_params.use_highbitdepth;

  int num_workers = p_mt_info->num_workers;

  int num_enc_workers = av1_get_num_mod_workers_for_alloc(p_mt_info, MOD_ENC);

  assert(num_enc_workers <= num_workers);

  for (int i = num_workers - 1; i >= 0; i--) {

    EncWorkerData *const thread_data = &p_mt_info->tile_thr_data[i];

    if (i > 0) {

      // Allocate thread data.

      ThreadData *td;

      AOM_CHECK_MEM_ERROR(&ppi->error, td, aom_memalign(32, sizeof(*td)));

      av1_zero(*td);

      thread_data->original_td = thread_data->td = td;

      // Set up shared coeff buffers.

      av1_setup_shared_coeff_buffer(&ppi->seq_params, &td->shared_coeff_buf,

                                    &ppi->error);

      AOM_CHECK_MEM_ERROR(&ppi->error, td->tmp_conv_dst,

                          aom_memalign(32, MAX_SB_SIZE * MAX_SB_SIZE *

                                               sizeof(*td->tmp_conv_dst)));

      if (i < p_mt_info->num_mod_workers[MOD_FP]) {

        // Set up firstpass PICK_MODE_CONTEXT.

        td->firstpass_ctx =

            av1_alloc_pmc(ppi->cpi, BLOCK_16X16, &td->shared_coeff_buf);

        if (!td->firstpass_ctx)

          aom_internal_error(&ppi->error, AOM_CODEC_MEM_ERROR,

                             "Failed to allocate PICK_MODE_CONTEXT");