1 files changed, 159 insertions, 93 deletions

diff --git a/third_party/aom/av1/encoder/ethread.c b/third_party/aom/av1/encoder/ethread.c
index 637d6824c..e8ac30bb5 100644
--- a/third_party/aom/av1/encoder/ethread.c
+++ b/third_party/aom/av1/encoder/ethread.c
@@ -27,7 +27,8 @@ static void accumulate_rd_opt(ThreadData *td, ThreadData *td_t) {
   td->rd_counts.skip_mode_used_flag |= td_t->rd_counts.skip_mode_used_flag;
 }
 
-static int enc_worker_hook(EncWorkerData *const thread_data, void *unused) {
+static int enc_worker_hook(void *arg1, void *unused) {
+  EncWorkerData *const thread_data = (EncWorkerData *)arg1;
   AV1_COMP *const cpi = thread_data->cpi;
   const AV1_COMMON *const cm = &cpi->common;
   const int tile_cols = cm->tile_cols;
@@ -47,88 +48,141 @@ static int enc_worker_hook(EncWorkerData *const thread_data, void *unused) {
   return 1;
 }
 
-void av1_encode_tiles_mt(AV1_COMP *cpi) {
+static void create_enc_workers(AV1_COMP *cpi, int num_workers) {
   AV1_COMMON *const cm = &cpi->common;
-  const int tile_cols = cm->tile_cols;
   const AVxWorkerInterface *const winterface = aom_get_worker_interface();
-  int num_workers = AOMMIN(cpi->oxcf.max_threads, tile_cols);
-  int i;
 
-  av1_init_tile_data(cpi);
+  CHECK_MEM_ERROR(cm, cpi->workers,
+                  aom_malloc(num_workers * sizeof(*cpi->workers)));
 
-  // Only run once to create threads and allocate thread data.
-  if (cpi->num_workers == 0) {
-    CHECK_MEM_ERROR(cm, cpi->workers,
-                    aom_malloc(num_workers * sizeof(*cpi->workers)));
+  CHECK_MEM_ERROR(cm, cpi->tile_thr_data,
+                  aom_calloc(num_workers, sizeof(*cpi->tile_thr_data)));
 
-    CHECK_MEM_ERROR(cm, cpi->tile_thr_data,
-                    aom_calloc(num_workers, sizeof(*cpi->tile_thr_data)));
+  for (int i = 0; i < num_workers; i++) {
+    AVxWorker *const worker = &cpi->workers[i];
+    EncWorkerData *const thread_data = &cpi->tile_thr_data[i];
 
-    for (i = 0; i < num_workers; i++) {
-      AVxWorker *const worker = &cpi->workers[i];
-      EncWorkerData *const thread_data = &cpi->tile_thr_data[i];
+    ++cpi->num_workers;
+    winterface->init(worker);
+
+    thread_data->cpi = cpi;
+
+    if (i < num_workers - 1) {
+      // Allocate thread data.
+      CHECK_MEM_ERROR(cm, thread_data->td,
+                      aom_memalign(32, sizeof(*thread_data->td)));
+      av1_zero(*thread_data->td);
+
+      // Set up pc_tree.
+      thread_data->td->pc_tree = NULL;
+      av1_setup_pc_tree(cm, thread_data->td);
+
+      CHECK_MEM_ERROR(cm, thread_data->td->above_pred_buf,
+                      (uint8_t *)aom_memalign(
+                          16, MAX_MB_PLANE * MAX_SB_SQUARE *
+                                  sizeof(*thread_data->td->above_pred_buf)));
+      CHECK_MEM_ERROR(cm, thread_data->td->left_pred_buf,
+                      (uint8_t *)aom_memalign(
+                          16, MAX_MB_PLANE * MAX_SB_SQUARE *
+                                  sizeof(*thread_data->td->left_pred_buf)));
+
+      CHECK_MEM_ERROR(
+          cm, thread_data->td->wsrc_buf,
+          (int32_t *)aom_memalign(
+              16, MAX_SB_SQUARE * sizeof(*thread_data->td->wsrc_buf)));
+
+      for (int x = 0; x < 2; x++)
+        for (int y = 0; y < 2; y++)
+          CHECK_MEM_ERROR(
+              cm, thread_data->td->hash_value_buffer[x][y],
+              (uint32_t *)aom_malloc(
+                  AOM_BUFFER_SIZE_FOR_BLOCK_HASH *
+                  sizeof(*thread_data->td->hash_value_buffer[0][0])));
+
+      CHECK_MEM_ERROR(
+          cm, thread_data->td->mask_buf,
+          (int32_t *)aom_memalign(
+              16, MAX_SB_SQUARE * sizeof(*thread_data->td->mask_buf)));
+      // Allocate frame counters in thread data.
+      CHECK_MEM_ERROR(cm, thread_data->td->counts,
+                      aom_calloc(1, sizeof(*thread_data->td->counts)));
+
+      // Allocate buffers used by palette coding mode.
+      CHECK_MEM_ERROR(
+          cm, thread_data->td->palette_buffer,
+          aom_memalign(16, sizeof(*thread_data->td->palette_buffer)));
+
+      CHECK_MEM_ERROR(
+          cm, thread_data->td->tmp_conv_dst,
+          aom_memalign(32, MAX_SB_SIZE * MAX_SB_SIZE *
+                               sizeof(*thread_data->td->tmp_conv_dst)));
+      for (int j = 0; j < 2; ++j) {
+        CHECK_MEM_ERROR(
+            cm, thread_data->td->tmp_obmc_bufs[j],
+            aom_memalign(16, 2 * MAX_MB_PLANE * MAX_SB_SQUARE *
+                                 sizeof(*thread_data->td->tmp_obmc_bufs[j])));
+      }
 
-      ++cpi->num_workers;
-      winterface->init(worker);
+      // Create threads
+      if (!winterface->reset(worker))
+        aom_internal_error(&cm->error, AOM_CODEC_ERROR,
+                           "Tile encoder thread creation failed");
+    } else {
+      // Main thread acts as a worker and uses the thread data in cpi.
+      thread_data->td = &cpi->td;
+    }
+    winterface->sync(worker);
+  }
+}
 
-      thread_data->cpi = cpi;
+static void launch_enc_workers(AV1_COMP *cpi, int num_workers) {
+  const AVxWorkerInterface *const winterface = aom_get_worker_interface();
+  // Encode a frame
+  for (int i = 0; i < num_workers; i++) {
+    AVxWorker *const worker = &cpi->workers[i];
+    EncWorkerData *const thread_data = (EncWorkerData *)worker->data1;
 
-      if (i < num_workers - 1) {
-        // Allocate thread data.
-        CHECK_MEM_ERROR(cm, thread_data->td,
-                        aom_memalign(32, sizeof(*thread_data->td)));
-        av1_zero(*thread_data->td);
+    // Set the starting tile for each thread.
+    thread_data->start = i;
 
-        // Set up pc_tree.
-        thread_data->td->pc_tree = NULL;
-        av1_setup_pc_tree(cm, thread_data->td);
+    if (i == cpi->num_workers - 1)
+      winterface->execute(worker);
+    else
+      winterface->launch(worker);
+  }
+}
 
-        CHECK_MEM_ERROR(cm, thread_data->td->above_pred_buf,
-                        (uint8_t *)aom_memalign(
-                            16, MAX_MB_PLANE * MAX_SB_SQUARE *
-                                    sizeof(*thread_data->td->above_pred_buf)));
-        CHECK_MEM_ERROR(cm, thread_data->td->left_pred_buf,
-                        (uint8_t *)aom_memalign(
-                            16, MAX_MB_PLANE * MAX_SB_SQUARE *
-                                    sizeof(*thread_data->td->left_pred_buf)));
+static void sync_enc_workers(AV1_COMP *cpi, int num_workers) {
+  const AVxWorkerInterface *const winterface = aom_get_worker_interface();
 
-        CHECK_MEM_ERROR(
-            cm, thread_data->td->wsrc_buf,
-            (int32_t *)aom_memalign(
-                16, MAX_SB_SQUARE * sizeof(*thread_data->td->wsrc_buf)));
-        CHECK_MEM_ERROR(
-            cm, thread_data->td->mask_buf,
-            (int32_t *)aom_memalign(
-                16, MAX_SB_SQUARE * sizeof(*thread_data->td->mask_buf)));
-        // Allocate frame counters in thread data.
-        CHECK_MEM_ERROR(cm, thread_data->td->counts,
-                        aom_calloc(1, sizeof(*thread_data->td->counts)));
-
-        // Allocate buffers used by palette coding mode.
-        CHECK_MEM_ERROR(
-            cm, thread_data->td->palette_buffer,
-            aom_memalign(16, sizeof(*thread_data->td->palette_buffer)));
-
-        // Create threads
-        if (!winterface->reset(worker))
-          aom_internal_error(&cm->error, AOM_CODEC_ERROR,
-                             "Tile encoder thread creation failed");
-      } else {
-        // Main thread acts as a worker and uses the thread data in cpi.
-        thread_data->td = &cpi->td;
-      }
+  // Encoding ends.
+  for (int i = 0; i < num_workers; i++) {
+    AVxWorker *const worker = &cpi->workers[i];
+    winterface->sync(worker);
+  }
+}
 
-      winterface->sync(worker);
+static void accumulate_counters_enc_workers(AV1_COMP *cpi, int num_workers) {
+  for (int i = 0; i < num_workers; i++) {
+    AVxWorker *const worker = &cpi->workers[i];
+    EncWorkerData *const thread_data = (EncWorkerData *)worker->data1;
+    cpi->intrabc_used |= thread_data->td->intrabc_used_this_tile;
+    // Accumulate counters.
+    if (i < cpi->num_workers - 1) {
+      av1_accumulate_frame_counts(&cpi->counts, thread_data->td->counts);
+      accumulate_rd_opt(&cpi->td, thread_data->td);
+      cpi->td.mb.txb_split_count += thread_data->td->mb.txb_split_count;
     }
-  } else {
-    num_workers = AOMMIN(num_workers, cpi->num_workers);
   }
+}
 
-  for (i = 0; i < num_workers; i++) {
+static void prepare_enc_workers(AV1_COMP *cpi, AVxWorkerHook hook,
+                                int num_workers) {
+  for (int i = 0; i < num_workers; i++) {
     AVxWorker *const worker = &cpi->workers[i];
     EncWorkerData *const thread_data = &cpi->tile_thr_data[i];
 
-    worker->hook = (AVxWorkerHook)enc_worker_hook;
+    worker->hook = hook;
     worker->data1 = thread_data;
     worker->data2 = NULL;
 
@@ -139,47 +193,59 @@ void av1_encode_tiles_mt(AV1_COMP *cpi) {
       thread_data->td->mb.above_pred_buf = thread_data->td->above_pred_buf;
       thread_data->td->mb.left_pred_buf = thread_data->td->left_pred_buf;
       thread_data->td->mb.wsrc_buf = thread_data->td->wsrc_buf;
+      for (int x = 0; x < 2; x++) {
+        for (int y = 0; y < 2; y++) {
+          memcpy(thread_data->td->hash_value_buffer[x][y],
+                 cpi->td.mb.hash_value_buffer[x][y],
+                 AOM_BUFFER_SIZE_FOR_BLOCK_HASH *
+                     sizeof(*thread_data->td->hash_value_buffer[0][0]));
+          thread_data->td->mb.hash_value_buffer[x][y] =
+              thread_data->td->hash_value_buffer[x][y];
+        }
+      }
       thread_data->td->mb.mask_buf = thread_data->td->mask_buf;
     }
     if (thread_data->td->counts != &cpi->counts) {
       memcpy(thread_data->td->counts, &cpi->counts, sizeof(cpi->counts));
     }
 
-    if (i < num_workers - 1)
+    if (i < num_workers - 1) {
       thread_data->td->mb.palette_buffer = thread_data->td->palette_buffer;
-  }
-
-  // Encode a frame
-  for (i = 0; i < num_workers; i++) {
-    AVxWorker *const worker = &cpi->workers[i];
-    EncWorkerData *const thread_data = (EncWorkerData *)worker->data1;
-
-    // Set the starting tile for each thread.
-    thread_data->start = i;
+      thread_data->td->mb.tmp_conv_dst = thread_data->td->tmp_conv_dst;
+      for (int j = 0; j < 2; ++j) {
+        thread_data->td->mb.tmp_obmc_bufs[j] =
+            thread_data->td->tmp_obmc_bufs[j];
+      }
 
-    if (i == cpi->num_workers - 1)
-      winterface->execute(worker);
-    else
-      winterface->launch(worker);
+      thread_data->td->mb.e_mbd.tmp_conv_dst = thread_data->td->mb.tmp_conv_dst;
+      for (int j = 0; j < 2; ++j) {
+        thread_data->td->mb.e_mbd.tmp_obmc_bufs[j] =
+            thread_data->td->mb.tmp_obmc_bufs[j];
+      }
+    }
   }
+}
 
-  // Encoding ends.
-  for (i = 0; i < num_workers; i++) {
-    AVxWorker *const worker = &cpi->workers[i];
-    winterface->sync(worker);
-  }
+void av1_encode_tiles_mt(AV1_COMP *cpi) {
+  AV1_COMMON *const cm = &cpi->common;
+  const int tile_cols = cm->tile_cols;
+  const int tile_rows = cm->tile_rows;
+  int num_workers = AOMMIN(cpi->oxcf.max_threads, tile_cols * tile_rows);
 
-  for (i = 0; i < num_workers; i++) {
-    AVxWorker *const worker = &cpi->workers[i];
-    EncWorkerData *const thread_data = (EncWorkerData *)worker->data1;
-    cpi->intrabc_used |= thread_data->td->intrabc_used_this_tile;
-    // Accumulate counters.
-    if (i < cpi->num_workers - 1) {
-      av1_accumulate_frame_counts(&cpi->counts, thread_data->td->counts);
-      accumulate_rd_opt(&cpi->td, thread_data->td);
-      cpi->td.mb.txb_split_count += thread_data->td->mb.txb_split_count;
-    }
+  if (cpi->tile_data == NULL || cpi->allocated_tiles < tile_cols * tile_rows)
+    av1_alloc_tile_data(cpi);
+
+  av1_init_tile_data(cpi);
+  // Only run once to create threads and allocate thread data.
+  if (cpi->num_workers == 0) {
+    create_enc_workers(cpi, num_workers);
+  } else {
+    num_workers = AOMMIN(num_workers, cpi->num_workers);
   }
+  prepare_enc_workers(cpi, enc_worker_hook, num_workers);
+  launch_enc_workers(cpi, num_workers);
+  sync_enc_workers(cpi, num_workers);
+  accumulate_counters_enc_workers(cpi, num_workers);
 }
 
 // Accumulate frame counts. FRAME_COUNTS consist solely of 'unsigned int'