libvpx: Pull from upstream

source/libvpx/vp9/encoder/vp9_ethread.c

 /*
  *  Copyright (c) 2014 The WebM project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 149 matching lines @@
   const int num_workers = MIN(cpi->oxcf.max_threads, tile_cols);
   int i;
 
   vp9_init_tile_data(cpi);
 
   // Only run once to create threads and allocate thread data.
   if (cpi->num_workers == 0) {
     CHECK_MEM_ERROR(cm, cpi->workers,
                     vpx_malloc(num_workers * sizeof(*cpi->workers)));
 
+    CHECK_MEM_ERROR(cm, cpi->tile_thr_data,
+                    vpx_calloc(num_workers, sizeof(*cpi->tile_thr_data)));
+
     for (i = 0; i < num_workers; i++) {
       VP9Worker *const worker = &cpi->workers[i];
-      EncWorkerData *thread_data;
+      EncWorkerData *thread_data = &cpi->tile_thr_data[i];
 
       ++cpi->num_workers;
-
       winterface->init(worker);
-      CHECK_MEM_ERROR(cm, worker->data1,
-                      (EncWorkerData*)vpx_calloc(1, sizeof(EncWorkerData)));
-      thread_data = (EncWorkerData*)worker->data1;
 
       if (i < num_workers - 1) {
       thread_data->cpi = cpi;
 
       // Allocate thread data.
       CHECK_MEM_ERROR(cm, thread_data->td,
-                      vpx_calloc(1, sizeof(*thread_data->td)));
+                      vpx_memalign(32, sizeof(*thread_data->td)));
+      vp9_zero(*thread_data->td);
+
       // Set up pc_tree.
       thread_data->td->leaf_tree = NULL;
       thread_data->td->pc_tree = NULL;
       vp9_setup_pc_tree(cm, thread_data->td);
 
       // Allocate frame counters in thread data.
       CHECK_MEM_ERROR(cm, thread_data->td->counts,
                       vpx_calloc(1, sizeof(*thread_data->td->counts)));
 
       // Create threads
       if (!winterface->reset(worker))
         vpx_internal_error(&cm->error, VPX_CODEC_ERROR,
                            "Tile encoder thread creation failed");
       } else {
         // Main thread acts as a worker and uses the thread data in cpi.
         thread_data->cpi = cpi;
         thread_data->td = &cpi->td;
       }
 
-      // data2 is unused.
-      worker->data2 = NULL;
-
       winterface->sync(worker);
-      worker->hook = (VP9WorkerHook)enc_worker_hook;
     }
   }
 
   for (i = 0; i < num_workers; i++) {
     VP9Worker *const worker = &cpi->workers[i];
-    EncWorkerData *const thread_data = (EncWorkerData*)worker->data1;
+    EncWorkerData *thread_data;
+
+    worker->hook = (VP9WorkerHook)enc_worker_hook;
+    worker->data1 = &cpi->tile_thr_data[i];
+    worker->data2 = NULL;
+    thread_data = (EncWorkerData*)worker->data1;
 
     // Before encoding a frame, copy the thread data from cpi.
     thread_data->td->mb = cpi->td.mb;
     thread_data->td->rd_counts = cpi->td.rd_counts;
     vpx_memcpy(thread_data->td->counts, &cpi->common.counts,
                sizeof(cpi->common.counts));
 
     // Handle use_nonrd_pick_mode case.
     if (cpi->sf.use_nonrd_pick_mode) {
       MACROBLOCK *const x = &thread_data->td->mb;
@@ skipping 36 matching lines @@
     VP9Worker *const worker = &cpi->workers[i];
     EncWorkerData *const thread_data = (EncWorkerData*)worker->data1;
 
     // Accumulate counters.
     if (i < num_workers - 1) {
       accumulate_frame_counts(&cpi->common, thread_data->td);
       accumulate_rd_opt(&cpi->td, thread_data->td);
     }
   }
 }