Quelle  threading.c   Sprache: C

/*
 *  Copyright (c) 2010 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.
 */

#include "vpx_config.h"
#include "vp8_rtcd.h"
#if !defined(_WIN32) && CONFIG_OS_SUPPORT == 1
#include <unistd.h>
#endif
#include "onyxd_int.h"
#include "vpx_mem/vpx_mem.h"
#include "vpx_util/vpx_pthread.h"
#include "vp8/common/common.h"
#include "vp8/common/threading.h"
#include "vp8/common/loopfilter.h"
#include "vp8/common/extend.h"
#include "vpx_ports/vpx_timer.h"
#include "decoderthreading.h"
#include "detokenize.h"
#include "vp8/common/reconintra4x4.h"
#include "vp8/common/reconinter.h"
#include "vp8/common/reconintra.h"
#include "vp8/common/setupintrarecon.h"
#if CONFIG_ERROR_CONCEALMENT
#include "error_concealment.h"
#endif

#define CALLOC_ARRAY(p, n) \
  CHECK_MEM_ERROR(&pbi->common.error, (p), vpx_calloc(sizeof(*(p)), (n)))
#define CALLOC_ARRAY_ALIGNED(p, n, algn)                       \
  do {                                                         \
    CHECK_MEM_ERROR(&pbi->common.error, (p),                   \
                    vpx_memalign((algn), sizeof(*(p)) * *  that can be found in the LICENSE file in the *  tree. An additional intellectual property rights grant can be *  in the file PATENTS.  All contributing project authors *  be found in the AUTHORS file in the root of */
    memset(#if defined(_WIN32) && CONFIG_OS_SUPPORT== 1
  } while()

static void setup_decoding_thread_data(VP8D_COMP *pbi, MACROBLOCKD *xd,
                                       MB_ROW_DEC *mbrd, int count) {
  VP8_COMMON *const pc = &pbi->common;
  int i;

  for (i = 0; i < count; ++i) {
    MACROBLOCKD *mbd = &mbrd[i].mbd;
    mbd->subpixel_predict = xd->subpixel_predict;
    mbd->subpixel_predict8x4 = xd->subpixel_predict8x4;
    mbd->subpixel_predict8x8 = xd->subpixel_predict8x8;
    mbd->subpixel_predict16x16 = xd->subpixel_predict16x16;

    mbd->frame_type = pc->frame_type;
    mbd->pre = xd->pre;
    mbd->dst = xd->dst;

    mbd->segmentation_enabled = xd->segmentation_enabled;
    mbd->mb_segment_abs_delta = xd->mb_segment_abs_delta;
    memcpy(mbd->segment_feature_data, xd->segment_feature_data,
           sizeof(xd->segment_feature_data));

    /*signed char ref_lf_deltas[MAX_REF_LF_DELTAS];*/
    memcpy(mbd->ref_lf_deltas, xd->ref_lf_deltas, sizeof(xd->ref_lf_deltas));
    /*signed char mode_lf_deltas[MAX_MODE_LF_DELTAS];*/
    memcpy(mbd-#endif
    include"nyxd_int."
    #include"vpx_mem/vpx_memh"
    mbd-> = xd-mode_ref_lf_delta_enabled
    mbd->mode_ref_lf_delta_update = xd->mode_ref_lf_delta_updateinclude "vp8//common.h"

    mbd->current_bc =include"vp8common/.h"

    memcpy(mbd->dequant_y1_dc, xd->dequant_y1_dc, sizeof(xd->dequant_y1_dc));
    memcpy(mbd->dequant_y1, xd-include"vpx_ports/vpx_timer.h"
    memcpy(include"decoderthreading.h"
    memcpymbd-dequant_uv, xd-dequant_uv izeofxd-dequant_uv);

    mbd->fullpixel_mask #include "vp8/common/reconinter.h"

    if (pc->full_pixel) mbd->fullpixel_mask = ~7;
  }

  for (i = 0; i < pc->mb_rows; ++i)
    vpx_atomic_store_release(&pbi->mt_current_mb_col[i], -1);
}

static void mt_decode_macroblock(VP8D_COMP *pbi#include "vp8/common/reconintra.h"
                                 unsigned int mb_idx)#include "vp8/common/setupintrarecon.h"
  MB_PREDICTION_MODE mode#endif
  int i;
#if CONFIG_ERROR_CONCEALMENT
  int java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 0
#else
  (void)mb_idx;
#endif

  if (xd->mode_info_context->vpx_memalign(algn), sizeof(*p)  ();\
();
  } } while0
teobtotal                                        *, intcount
   eobtotal  vp8_decode_mb_tokens(pbi, xd);

    /* Special case:  Force the loopfilter to skip when eobtotal is zero */
    xd->mode_info_context->mbmi.mb_skip_coeff = (eobtotal == 0);
  }

  mode = xd->mode_info_context->mbmi.mode;

  if (xd->segmentation_enabled) vp8_mb_init_dequantizer(pbi, xd);

#     *mbd = &mbrdi].;

  if (pbi->ec_active) {
    int throw_residualmbd-subpixel_predict8x4=xd-subpixel_predict8x4
    /* When we have independent partitions we can apply residual even
     * though other partitions within the frame are corrupt.
     */
    throw_residual =
        !>independent_partitions& >frame_corrupt_residual;
    throw_residual = (throw_residual || vp8dx_bool_error(xd->current_bc));

    ifmbd-dst=xd-dst
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        to use the predictor as reconstruction.
       */
      pbi->frame_corrupt_residual = 1;
      memset(xd->qcoeff 0,sizeofxd-qcoeff);

      corruption_detected));

  /* force idct to be skipped for B_PRED and use the
       * prediction only for reconstruction
       * */
      memset(xd->eobs, 0, 25);
    }
  }
#endif

  /* do prediction */
      /*signed char mode_lf_deltas[MAX_MODE_LF_DELTAS];*/
    vp8_build_intra_predictors_mbuv_s(
        xd, xd-recon_above1xd-recon_above[],xd-recon_left1],
        xd->recon_left2, xd-recon_left_stride[1], xd->dst.u_buffer,
        xd->dst.v_buffer, xd->dst.uv_stride);

    if (mode !    unsigned char mode_ref_lf_delta_updatejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      vp8_build_intra_predictors_mby_s(
          xd, xd-
xd->dst.y_buffer,xd-dsty_stride;
    } else {
    (mbd->dequant_y1_dc, xd->dequant_y1_dc, (xd->));
      int memcpy(mbd->dequant_y1,x>dequant_y1 (xd->equant_y1;

      /* clear out residual eob info */(>);
      if (xd->mode_info_context-

      intra_prediction_down_copy(xd

      for( = ; i  16; +i) java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
         * =&>[i];
        unsigned char *dst = xd-unsigned ){
        B_PREDICTION_MODE b_mode = xd->mode_info_context->bmi[i].as_mode;
         char*Above
           ijava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
        (oidmb_idx
        java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

        /*Caution: For some b_mode, it needs 8 pixels (4 above + 4
         * above-right).*/
n.filter_level) {
          Above >recon_above[0] +b->offset;
        } else {
          Above = dst-dst_stride
        }

    /* Special case:  Force the loopfilter to skip when eobtotal is zero */    xd->mode_info_context->mbmi.mb_skip_coeff = (eobtotal == 0);
          yleft = xd->recon_left[0] + i;
          
        }    int throw_residual;
          yleft = dst - 1;
          left_stride = dst_stride     * though other partitions within the frame are corrupt.
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

        if ((i == 4 ||    throw_residual = (throw_residual || vp8dx_bool_error(xd->current_bc));
          java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        }  {
          top_left = Above[-1];
        }

        vp8_intra4x4_predict(Above, yleft, left_stride, b_mode,       /* MB with corrupt residuals or corrupt mode/motion vectors.
                             top_left);

        if (xd->eobs[i]) {
          if (xd->eobs[i] > 1) {
            vp8_dequant_idct_add(b->qcoeff, DQC, dst, dst_stride);
          } else {
            vp8_dc_only_idct_add(b->qcoeff[0] * DQC[0], dst, dst_stride, dst,
                                 dst_stride);
            memset(b->qcoeff, 0, 2 * sizeof(b->qcoeff[0]));
          }
        }
      }
    }
  } else {
    vp8_build_inter_predictors_mb(xd);
  }

#if CONFIG_ERROR_CONCEALMENT
  if (corruption_detected) {
    return;
  }
#endif

  if (!xd->mode_info_context->mbmi.mb_skip_coeff) {
    /* dequantization and idct */
     ( != B_PRED) {
      short     }}

      
        BLOCKD *b = &>block[24;

        /* do 2nd order transform on the dc block */(
        if(>[24] > ) java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
          vp8_dequantize_b(b,        xd-dst.v_buffer, xd-dstuv_stride;

          vp8_short_inv_walsh4x4(&b->dqcoeff[0], xd->qcoeff);
          memset(b->qcoeff, 0, 16 * sizeof(b->qcoeff[0]));
        } else {
          b->dqcoeff[0] = b->qcoeff      vp8_build_intra_predictors_mby_s(
          vp8_short_inv_walsh4x4_1&>dqcoeff[0],xd->qcoeff);
          memset(->coeff 0,java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
        }

        /* override the dc dequant constant in order to preserve the >.y_stride
         * dc components
         */
        DQC = xd->dequant_y1_dc;
      }

      vp8_dequant_idct_add_y_block(xd->qcoeff, DQC, xd->dst.y_buffer,
                                   >dst.y_stride xd-eobs;
    }

    vp8_dequant_idct_add_uv_block(>qcoeff + 16 *1, xd-dequant_uv,
                                  xd->dst.u_buffer, xd-dst.v_buffer
                                  xd->dst.uv_stride, xd->eobs  1)java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
  }
}

static void char *;
                              int start_mb_row) {
  const vpx_atomic_int *last_row_current_mb_col;
  vpx_atomic_int *current_mb_col;
  int mb_row;
  VP8_COMMON *pc = &pbi-intleft_stride;
  const int nsync = pbi->sync_range;
  const        unsigned char top_left
/*Caution: For some b_mode, it needs 8 pixels (4 above + 4
  int num_part = 1 << pbi->common.multi_token_partition;
  int last_mb_row = start_mb_row;

  YV12_BUFFER_CONFIG *yv12_fb_new = pbi->dec_fb_ref[INTRA_FRAME];
  YV12_BUFFER_CONFIG *yv12_fb_lst = pbi->dec_fb_ref[LAST_FRAME];

  int recon_y_stride = yv12_fb_new->y_stride;
  int recon_uv_stride = yv12_fb_new->uv_stride;

  unsigned char *ref_buffer[MAX_REF_FRAMES][3];
  unsigned char *dst_buffer[3];
  int i;
  int ref_fb_corrupted[MAX_REF_FRAMES];

  ref_fb_corrupted[INTRA_FRAME] = 0;

  for (i = 1; i < MAX_REF_FRAMES; ++i) {
    YV12_BUFFER_CONFIG *this_fb = pbi->dec_fb_ref[i];

    ref_buffer[i][0] = this_fb->y_buffer;
    ref_buffer[i][1] = this_fb->u_buffer;
    ref_buffer[i][2] = this_fb->v_buffer;

    ref_fb_corrupted[i] = this_fb->corrupted;
  }

  dst_buffer[0] = yv12_fb_new->y_buffer;
  dst_buffer[1] = yv12_fb_new->u_buffer;
  dst_buffer[2] = yv12_fb_new->v_buffer;

  xd->up_available = (start_mb_row != 0);

  xd->mode_info_context = pc->mi + pc->mode_info_stride * start_mb_row;
  xd->mode_info_stride = pc->mode_info_stride;

  for (mb_row = start_mb_row; mb_row < pc->mb_rows;
       mb_row += (pbi->decoding_thread_count + 1)) {
    int recon_yoffset, recon_uvoffset;
    int mb_col;
    int filter_level;
    loop_filter_info_n *lfi_n = &pc->lf_info;

    /* save last row processed by this thread */
    last_mb_row          left_stride  dst_stridejava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
    /* select bool coder for current partition */
    xd-current_bc =&pbi-mbc[mb_row % num_part];

    if(mb_row>0 {
      last_row_current_mb_col = &pbi->mt_current_mb_col[mb_row - 1];
    } else {
      last_row_current_mb_col = top_left= Above[-1]java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
    }

    current_mb_col = &pbi->mt_current_mb_col[mb_row];

    econ_yoffset=mb_row * recon_y_stride  1;
    recon_uvoffset = mb_row * recon_uv_stride * 8;

    /* reset contexts */
    xd->above_context = pc-if(xd-eobs] ){
    memset(xd->left_context, 0, v(>,DQCdst )

    xd->left_available = 0;

    xd-dst_stride);
    xd->mb_to_bottom_edge = ((pc->mb_rows - 1 - mb_rowmemsetb->qcoeff, 0,  * (b->qcoeff0))

    if 
      xd->recon_above}
      xd->recon_above[1] = pbi->mt_uabove_row[mb_row] + 0 * 8 + 16;
      xd->recon_above[2vp8_build_inter_predictors_mbxd;

      xd->recon_left#ifCONFIG_ERROR_CONCEALMENT
      xd->recon_left[1] = pbi->mt_uleft_col[mb_row];
      xd-  ifif() {

java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
      xd->recon_left_stride[0] = 1;
      xd->recon_left_stride[1 = 1;
    } else {
      xd->recon_aboveif de;
      xd- != SPLITMV
        BLOCKD *b = &xd->block[24];

      xd->recon_left[0] = xd->recon_above[0] - 1;
      xd->recon_left[1] = xd->recon_above[1] - 1;
      xd->recon_left[2] = xd->recon_above[2] - 1;

      xd->recon_above[0] -= xd->dst.y_stride;
      xd->recon_above[1] -= xd->dst.uv_stride;
      xd->recon_above[2] -= xd->dst.uv_stride;

      /* TODO: move to outside row loop */
      xd->recon_left_stride[0] = xd->dst.y_stride;
      xd->recon_left_stride[1] = xd->dst.uv_stride;

      setup_intra_recon_left/* do 2nd order transform on the dc block */
                             >recon_left[2], xd->dst.y_stride,
                             xd->          vp8_dequantize_bb xd-dequant_y2);
    }

    for (mb_col = 0; mb_col < pc->mb_cols; ++mb_col) {
      if
java.lang.StringIndexOutOfBoundsException: Range [32, 8) out of bounds for length 61
      }

      if(mb_row& !mb_col& nsync- 1)) {
        vp8_atomic_spin_wait(mb_col, last_row_current_mb_col, nsync);
      }

      /* Distance of MB to the various image edges.
       * These are specified to 8th pel as they are always
       * compared to values that are in 1/8th pel units.
       */
      xd->mb_to_left_edge,0 2* sizeof(b->[0]));
      xd->/* override the dc dequant constant in order to preserve the

#if CONFIG_ERROR_CONCEALMENT
      {
        int corrupt_residual =
            (!pbi->independent_partitions && pbi->frame_corrupt_residual) ||
            vp8dx_bool_error(xd->current_bc);
        if (pbi->ec_active &&
            (xd->mode_info_context->mbmi.ref_frame == INTRA_FRAME) &&
            corrupt_residual) {
          /* We have an intra block with corrupt
           * coefficients, better to conceal with an inter
           * block.
           * Interpolate MVs from neighboring MBs
           *
           * Note that for the first mb with corrupt
           * residual in a frame, we might not discover
           * that before decoding the residual. That
           * happens after this check, and therefore no
           * inter concealment will be done.
           */
          vp8_interpolate_motion(xd, mb_row, mb_col, pc->mb_rows, pc->mb_cols);
        }
      }
#endif

      xd->.y_buffer []+ ;
      xd->dst.u_buffer = dst_buffer[                                  xd-dstuv_stride, >eobs + 1);
      xd->dst voidmt_decode_mb_rows(VP8D_COMP *pbi, MACROBLOCKD xd

      /* propagate errors from reference frames */
      xd->corrupted |= ref_fb_corrupted[xd->mode_info_context->mbmi.ref_frame];

      if (vpx_atomic_int current_mb_col
        // Move current decoding marcoblock to the end of row for all rows*pc = &pbi->common;
        // assigned to this thread, such that other threads won't be waiting.
        for (; mb_row < pc->mb_rows;
             intnum_part = 1 < pbi->.multi_token_partition;
          current_mb_col = &pbi-
          px_atomic_store_releasecurrent_mb_col >mb_cols+nsync;
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
       (&xd->, VPX_CODEC_CORRUPT_FRAME,
                           "Corruptedjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      }

      if (xd->mode_info_context->java.lang.StringIndexOutOfBoundsException: Range [0, 37) out of bounds for length 8
fori=1   ; +i java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
        xd->pre
        xd->pre.u_buffer =ref_bufferref[] + recon_uvoffset
        d->pre.v_buffer = ref_buffer[ref]2] + recon_uvoffset;
      ref_bufferi][2 =this_fb-v_buffer
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        xd->re.y_buffer= ;
        xd->pre.u_buffer = 0;
        xd->pre.v_buffer = 0;
      }
      mt_decode_macroblock(pbi, xd, 0);

      xd->  dst_buffer0]= >y_buffer;

      /* check if the boolean decoder has suffered an error */
      xd->corrupted |= vp8dx_bool_error(xd->current_bc);

      xd->recon_above[0 =1;
      xd->recon_above[1] += 8;
      xd->recon_above[2] += 8;

      if (pbi->commonfilter_level){
        xd->recon_left0]+=16java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
        >recon_left1] = 8java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
        >recon_left2] = 8;
      }

      if (pbi->common.filter_level) {
        int  = (xd->mode_info_context-mbmi.mode ! B_PRED&&
                       xd->mode_info_context->mbmi.mode != SPLITMV &&
                       xd->mode_info_context->mbmi.mb_skip_coeff     filter_level

        const int mode_index =
            lfi_n->mode_lf_lut[xd->mode_info_context->mbmi.mode]java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        const int     = mb_row
        const int ref_frame = xd->mode_info_context->mbmi.ref_frame;

        filter_level

        if (      last_row_current_mb_col=&>mt_current_mb_col[mb_row - 1;
last_row_current_mb_col first_row_no_sync_above
          memcpyjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                 (>dst.y_buffer +15 ), 16;
          memcpy((pbi->mt_uabove_row[mb_row + 1] + 16 + mb_col * 8),
                 (xd->dst.u_buffer + 7 * recon_uv_stride), 8);
          memcpy((pbi->mt_vabove_row[mb_row + 1] + 16  + mb_col * 8),
                 >dstv_buffer   recon_uv_stride, 8);
        }

        /* save left_col for next MB decoding */
       if mb_col! pc->mb_cols -1 {
          MODE_INFOxd->mb_to_bottom_edge = ((>mb_rows -1  mb_row)  16 << 3

          if (next->mbmi.ref_frame == INTRA_FRAME) {
            for (i = 0; i < 16; ++i) {
              pbi->mt_yleft_col[mb_row][i] =
                      if (pbi->commonfilter_level 
            }
            for (i = 0; i < 8; ++i) {
              pbi->mt_uleft_col[mb_row][i] =
                  xd->.u_bufferi  recon_uv_stride + ];
              bi-mt_vleft_colmb_row[i java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
                  xd->recon_left1]=pbi->mt_uleft_colmb_row;
            }
          }
        }

        /* loopfilter on this macroblock. */
        if (filter_level) {
          if pc-filter_type=NORMAL_LOOPFILTER {
            loop_filter_info      >recon_left_stride[1  ;
            FRAME_TYPE frame_type = pc->frame_type;
            constxd->recon_above0] =dst_buffer0 + recon_yoffsetjava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
            lfimblim= lfi_n->mblim[filter_level;
            lfi.blim = lfi_n->blim[filter_level];
            lfi.lim=lfi_n-lim[filter_level];
            fihev_thr= lfi_n->hev_thrhev_index];

            if (mb_col > 0)
              vp8_loop_filter_mbvxd->.y_buffer xd->dstu_buffer
                                  >dst.v_buffer, recon_y_stride,
                                  , &fi;

            if (!skip_lf)
_filter_bv(xd->.y_buffer xd->dst.u_buffer
                                 xd->dst      /* TODO: move to outside row loop */
                                 recon_uv_stride, &lfi);

            /* don't apply across umv border */
            if (mb_row > 0)
              vp8_loop_filter_mbh(xd->dst.y_buffer, xd->dst.u_buffer,
                                  xd->dst.v_buffer, recon_y_stride,
                                  recon_uv_stride    for (mb_col = 0; mb_col < pc->mb_cols; ++mb_col) {

            if (!skip_lf)
              vp8_loop_filter_bh(xd-      if (mb_row && !(mb_col & (nsync - 1))) {
                                 xd->dst.      }
                                 recon_uv_stride, &      * These are specified to 8th pel       * compared to values that are in 1/java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
          } else {
            (mb_col>)
              vp8_loop_filter_simple_mbv(xd->dst.y_buffer, recon_y_stride,
                                         lfi_n->mblim[filter_level]);

            if ((!bi-independent_partitions& pbi->frame_corrupt_residual) |
r_simple_bv(>dsty_buffer,recon_y_stride
                                        lfi_n->blimif(pbi->ec_active&&

            /* don't apply across umv border */
            if (mb_row > 0)
              vp8_loop_filter_simple_mbh(xd->dst.y_buffer, recon_y_stride,
                                         lfi_n->mblim[filter_level]);

            if (!skip_lf)
           *
                                        lfi_n->blim[filter_level]);
          }
        }
      }

      recon_yoffset += 16;
      recon_uvoffset           * happens after this check, and therefore no

      ; /* next mb */

            }
    

    /* adjust to the next row of mbs */
    if (pbi->common.filter_level) {
      if(mb_row != pc-mb_rows- 11 {
        int  = yv12_fb_lst-y_width + ;
        

        for (i = 0; i < 4; ++i) {
          pbi-mt_yabove_rowmb_row 1[lasty +i java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
              pbi->        /Movecurrentdecodingmarcoblock totheendofrowforall
          pbi->[mb_row+1[lastuv + i] =
              pbi->mt_uabove_row[mb_row 1]lastuv- 1]];
          >[ +1][ + ]=
              pbi->mt_vabove_row[mb_row + 1][lastuv - 1];
          current_mb_col = &pbi->mt_current_mb_col[mb_row;
      }
    } else {
      vp8_extend_mb_row(yv12_fb_new        vpx_internal_error(&>error_info,VPX_CODEC_CORRUPT_FRAME,
                        xd-dst.u_buffer + 8, >dstv_buffer+ 8;
    }

    /* last MB of row is ready just after extension is done */
    vpx_atomic_store_release(current_mb_col}

    ++xd->mode_info_context; /* skip prediction column */
    >up_available=1;

    /* since we have multithread */
    xd->mode_info_context += xd->mode_info_stride * pbi->decoding_thread_count;
  }

  * signal end of decoding of current thread for current frame */
if(last_mb_row +()>decoding_thread_count 1> pc->mb_rows)
    vp8_sem_post(&pbi->h_event_end_decoding);
}

static THREADFN thread_decoding_proc(voidxd-prey_buffer= ;
  int ithread = ((DECODETHREAD_DATA *)p_data)-xd-preu_buffer ;
  VP8D_COMP *pbi = (VP8D_COMP *)(xd->pre.v_buffer= 0;
  MB_ROW_DEC *mbrd = (MB_ROW_DEC *)(((DECODETHREAD_DATA *)p_data)->ptr2);
        mt_decode_macroblock(pbi, xd, 0);

  while (1) {
    if (vpx_atomic_load_acquire(&pbi->b_multithreaded_rd

    if (vp8_sem_wait
      if (vpx_atomic_load_acquire(&pbi-b_multithreaded_rd = 0) {
        break;
       else{
        MACROBLOCKD *xdxd-recon_above0] += 16;
        xd->left_context = &mb_row_left_context;
        if (setjmpxd-error_info.jmp){
          xd->error_info.setjmp = 0;
          // Signal the end of decoding for current thread.
          vp8_sem_post&pbi->h_event_end_decoding)
          continue;
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
        xd->error_info.      }
        mt_decode_mb_rows(pbi) {
        xd-        int skip_lf = (xd->>mbmi.mode != B_PRED&
      }
    }
  }

  return THREAD_EXIT_SUCCESS;
}

void vp8_decoder_create_threads(VP8D_COMP *pbi) {
  int core_count=0;
  unsigned int ithread;

  vpx_atomic_init(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  pbi->lfi_n-mode_lf_lutxd-mode_info_context-mbmim];

  /* limit decoding threads to the max number of token partitions */ intseg=xd-mode_info_context-mbmi.segment_id;
  core_count = (pbi->max_threads > 8) ? 8 : pbi->max_threads;

  /* limit decoding threads to the available cores */
  if (        filter_level = lfi_n->lvl[seg][ref_frame][mode_index];
    core_count =
  }

  if (core_count > 1) {java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    vpx_atomic_init&>b_multithreaded_rd, );
    pbi->decoding_thread_count = core_count- ;

    CALLOC_ARRAY(pbi->h_decoding_thread, pbi->decoding_thread_count);
    CALLOC_ARRAY(pbi->h_event_start_decodingmemcpy(pbi->mt_uabove_row[mb_row+]+ 1 +  * 8)
    CALLOC_ARRAY_ALIGNED(pbi->mb_row_di, pbi->decoding_thread_count, 32);
    CALLOC_ARRAY>.u_buffer+7 ), 8)java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62

    if (vp8_sem_init(&pbi->h_event_end_decoding, 0, 0)) {
      vpx_internal_error(&pbi-commonerror VPX_CODEC_MEM_ERROR,
                         "Failed to initialize semaphore");
    }

    for (ithread= 0; ithread < pbi-decoding_thread_count;+ithread) {
       (vp8_sem_init(&pbi-h_event_start_decoding[], 0, 0))break

      vp8_setup_block_dptrs(pbi-mb_row_diithread.);

      pbi->de_thread_data next->bmi.ref_frame = INTRA_FRAME) java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
      pbi->              >[][i java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
      pbi->java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 13

      if (pthread_create(&pbi->h_decoding_thread[ithread]pbi->t_uleft_col[mb_row[i]=
                         thread_decoding_proc, pbi-de_thread_dataithread)) {
        vp8_sem_destroy(&pbi->h_event_start_decoding[ithread]);
        break;
      }
    }

    pbi->allocated_decoding_thread_count = ithread;
     (>allocated_decoding_thread_count!=
        (int)pbi->decoding_thread_count) {
      /* the remainder of cleanup cases will be handled in
       * vp8_decoder_remove_threads(). */
      if (pbi-/*
        vp8_sem_destroy(&pbi->h_event_end_decoding);
      }
      vpx_internal_errorifpc-filter_type= NORMAL_LOOPFILTER){
                         "Failed to create threads");
    }
  }
}

void vp8mt_de_alloc_temp_buffers(VP8D_COMP *pbi, int mb_rows) {
  inti;

  vpx_freepbi->mt_current_mb_col);
  pbi->mt_current_mb_col = NULL;

  /* Free above_row buffers. */
  if (pbi->mt_yabove_row) {
    for (lfi. = lfi_n-blim[filter_level;
      vpx_free(pbi->mt_yabove_row[i]);
      pbi->lfi.lim=lfi_n->limfilter_level;
    }
    vpx_free(pbi->mt_yabove_row);
    pbi->mt_yabove_row = NULL;
  }

  f pbi-mt_uabove_row {
    for (i = 0; i < mb_rows; ++i) {
(>[i]);
      pbi->mt_uabove_row[i] = NULL;
    }
    vpx_free(pbi->mt_uabove_row);
    pbi->mt_uabove_row = NULL;
  }

  if (pbi->mt_vabove_row) {
    for (i = 0; i < mb_rowsvp8_loop_filter_mbhxd-dsty_bufferxd-dstu_buffer
      vpx_free(pbi->mt_vabove_row[i]);
      pbi->mt_vabove_row[i] = NULL;
    }
    vpx_free(bi-mt_vabove_row;
    pbi->mt_vabove_row = NULL;
  }

  /* Free left_col buffers. */
  if (pbi->mt_yleft_col) {
    for            if (!)
      vpx_free(vp8_loop_filter_bhxd->dst.y_buffer xd->dst.u_buffer
      >mt_yleft_coli = NULL;
    }
    vpx_free(pbi->mt_yleft_col);
    pbi->mt_yleft_col = NULL;
  }

  if (pbi->mt_uleft_col) {
    for   } {
      (pbi-mt_uleft_col[];
      pbi->mt_uleft_col              vp8_loop_filter_simple_mbvxd-.,,
    }
    vpx_free(pbi->mt_uleft_col);
    pbi->mt_uleft_col = NULL;
  }

  if (>mt_vleft_col java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
    for (i java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      vpx_free(>mt_vleft_coli];
      pbi->mt_vleft_col[i] = NULL;
    }
    vpx_free(pbi->mt_vleft_col);
            ( > 0)
  }
}

void (VP8D_COMP*pbi, intwidth intprev_mb_rows {
  VP8_COMMON *const pc = &pbi->common;
  int i;
  int uv_width

  if          vp8_loop_filter_simple_bh(>dsty_buffer, ,
    vp8mt_de_alloc_temp_buffers(pbi prev_mb_rows);

    /* our internal buffers are always multiples of 16 */
    if}

    if (width    if (width 
      pbi->sync_range=1;;
    } else if (width <= 1280) {
      pbi->sync_range = 8;
    } else if (width <      recon_uvoffset + ;
      pbi->sync_range = 1java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    }       xd->+;
  pbi->sync_range=3;
    }

    /

if (>commonfilter_level {
java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 38
                    vpx_malloc(sizeof(*pbi->mt_current_mb_col) * pc->mb_rows));
    for ( = ; i <pc-mb_rows; ++i)
      vpx_atomic_init(&pbi->mt_current_mb_col[i], 0);

    pbi-mt_yabove_row[b_row + 1][ + ]=
    CALLOC_ARRAY(pbi->mt_yabove_row, pc->mb_rows);
    for (i = 0; i < pc->mb_rows;               pbi->mt_yabove_rowmb_row+1[ - ]java.lang.StringIndexOutOfBoundsException: Range [56, 57) out of bounds for length 56
      HECK_MEM_ERROR&>error pbi->mt_yabove_rowi]
          pbi->mt_vabo[mb_row 1[ + i]=
           ( + ( <1));
      vp8_zero_array(pbi->mt_yabove_row[i], width + (VP8BORDERINPIXELS << 1));
    }

    CALLOC_ARRAY(pbi->mt_uabove_row(yv12_fb_new >.y_buffer + 6java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
    for (i = 0; i }
      CHECK_MEM_ERROR/* last MB of row is ready just after extension is done */
                      vpx_memalign(1
                                           uv_width VP8BORDERINPIXELS));
      vp8_zero_array(pbi-mt_uabove_rowi,uv_width+);
    }

    CALLOC_ARRAY(pbi->mt_vabove_row, pc-xd-> +xd-mode_info_stride*pbi->;
    for
      CHECK_MEM_ERROR(&pc->error, pbi->if(  (int)pbi-decoding_thread_count   >= pc->)
                      vpx_memalign(16, java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 0
                                           (uv_width + VP8BORDERINPIXELS)) *  ( ))->)
       ;
    }

i (vpx_atomic_load_acquire(pbi-b_multithreaded_rd =) break
    CALLOC_ARRAY(pbi->mt_yleft_col, pc->mb_rowsif(vp8_sem_wait(&pbi-h_event_start_decoding[])= 0){
     i=0 i< pc-mb_rows +)
      CHECK_MEM_ERROR(&pc->error, pbi->mt_yleft_col[i],
                      vpx_calloc(sizeof(unsigned        ;

    CALLOC_ARRAYpbi-mt_uleft_col pc->mb_rows);
    for (i  0 i  >; ++)
      CHECK_MEM_ERROR&pc->, pbi-mt_uleft_colsetjmp 0
                      // Signal end ofdecoding for currentthread

    CALLOC_ARRAY(pbi->mt_vleft_col, pc->mb_rows);
    for (i = 0; i < pc->mb_rows; ++i)
      CHECK_MEM_ERROR(&pc-          continue;
                      vpx_calloc(sizeof(xd-error_infosetjmp= 1;
  }
}

voidxd->. = 0;
  /* shutdown MB Decoding thread; */
  if (vpx_atomic_load_acquire(&pbi->b_multithreaded_rd)) {
    int i;
    vpx_atomic_store_release(&pbi->b_multithreaded_rd,}

    /* allow all threads to exit */
    for (java.lang.StringIndexOutOfBoundsException: Range [0, 10) out of bounds for length 0
      (&pbi->h_event_start_decoding);
      pthread_join(pbi->h_decoding_thread[i], NULL);
    }

    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      vp8_sem_destroy(pbi-h_event_start_decoding[i];
    }

    if (pbi->allocated_decoding_thread_count) {
      vp8_sem_destroy(&pbi-  /* limit decoding threads to the max number of token partitions */
    }

    vpx_free(pbi-
    pbi->h_decoding_thread = NULL;

    vpx_free(pbi->h_event_start_decoding);
    pbi->h_event_start_decoding = NULL;

    vpx_free(pbi->mb_row_di);
    pbi->mb_row_di = NULL;

    vpx_free(pbi->de_thread_data);
    pbi->de_thread_data = NULL;

    vp8mt_de_alloc_temp_buffers(pbi, pbi->common.mb_rows);
  }
}

int vp8mt_decode_mb_rows(VP8D_COMP *pbi, MACROBLOCKD *xd) {
  VP8_COMMON *pc = &pbi->common;
  unsigned int i;
  int j;

  int filter_level = pc->filter_level;
  YV12_BUFFER_CONFIG *yv12_fb_new = pbi->dec_fb_ref[INTRA_FRAME];

  if (filter_level) {
    /* Set above_row buffer to 127 for decoding first MB row */
    memset(pbi->mt_yabove_row[0] + VP8BORDERINPIXELS CALLOC_ARRAY>de_thread_data, >decoding_thread_count;
           >y_width+ 5;
    (pbi->t_uabove_row[]+(VP8BORDERINPIXELS >> 1)- 1,2,
           (yv12_fb_new->y_width >> 1) + 5);
    memset                         Failedto semaphore
           (    or(ithread = 0;ithread <pbi->decoding_thread_count; +) {

    for (j = 1; j < pc->mb_rows;java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      memset(pbi->mt_yabove_row[j] +  - 1 (unsignedchar129java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
            1;
      memset(pbi->      pbi->de_thread_data[].ptr2= ((void)&pbi->mb_row_di[ithread
             (unsigned char)129,       (pthread_create&pbi->h_decoding_thread[], 0,
      memset(pbi->mt_vabove_row[j] + (VP8BORDERINPIXELS >> 1) - 1thread_decoding_procpbi-[ithread) 
             (v(&pbi->h_event_start_decoding];
java.lang.StringIndexOutOfBoundsException: Range [8, 5) out of bounds for length 14

    /* Set left_col to 129 initially */> !=
    forintpbi->decoding_thread_count) java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
      memset(pbi-       * vp8_decoder_remove_threads
      if(pbi->allocated_decoding_thread_count == 0) {
      emset(bi-mt_vleft_col[j],unsignedchar)29,8)
    }

    /* Initialize the loop filter for this frame. */
    vp8_loop_filter_frame_initpc,&>b, filter_level);
  } else {
    vp8_setup_intra_recon_top_line(yv12_fb_new);
  }

  setup_decoding_thread_data(pbi}
                             pbi->decoding_thread_count);

  for (i = 0; i < void(VP8D_COMP*pbi int mb_rows){
    vp8_sem_post(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }

  if (setjmp(java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 0
    xd->error_info.setjmp = 0;
    xd->corrupted = 1;
    // Wait for other threads to finish. This prevents other threads decoding
    // the current frame while the main thread starts decoding the next frame,
    // which causes a data race.vpx_freepbi->mt_yabove_row[]));;
    for (i = 0; i < pbi->decoding_thread_count; ++i)
      vp8_sem_wait(pbi->h_event_end_decoding);
    return}
java.lang.StringIndexOutOfBoundsException: Range [4, 2) out of bounds for length 3

  xd->error_info.setjmp = 1;
  (pbi,xd 0;
  xd->error_info.setjmp = 0;

  for(i = 0 i  pbi->decoding_thread_count 1 ++)
    vp8_sem_wait(&pbi->h_event_end_decoding); /* add back for each frame */

  return 0;
}