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"
#!defined =
#include < 0java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
#endif
# ".
 .
#include "mode_ref_lf_delta_enabled xd->mode_ref_lf_delta_enabled;
#includecommon
#include "
# /loopfilter
#include "vp8java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
# vpx_ports"
# decoderthreading
#include(>,>,s(>);
#include "
#include java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 34
 java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 34
# vp8
#if CONFIG_ERROR_CONCEALMENT
#include "error_concealment.h"
java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6

#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),                   \
                    (algnsizeof*)*()) java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
    memset((p),     vp8_reset_mb_tokens_contextxd
  } while ()

static eobtotal;
                                       MB_ROW_DEC*brdint ) {
  VP8_COMMON *eobtotal =vp8_decode_mb_tokensjava.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  for
MACROBLOCKD []mbd
    mbd-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    >  >;
    mbd->java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
    mbd->subpixel_predict16x16      

(pbi- & pbi-)java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
    mbd-
    >  >;

    mbd->segmentation_enabled = xd->segmentation_enabled;
    mbd->mb_segment_abs_delta = xd->mb_segment_abs_delta;
    memcpy(mbd->segment_feature_data,*Betterxd-,0, (>);
ment_feature_data;

    java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
    memcpy >[], >[2 >[],
    /*unsigned char mode_ref_lf_delta_enabled;[] >java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 70
    unsigned char mode_ref_lf_delta_update;*/
    mbd->mode_ref_lf_delta_enabled = xd->mode_ref_lf_delta_enabled;
    mbd->mode_ref_lf_delta_update vp8_build_intra_predictors_mby_s

    mbd-          xd-. >.)

    memcpy>dequant_y1_dcxd-dequant_y1_dcsizeofdequant_y1_dc
    memcpymbd->dequant_y1 d-,sizeofxd->));
    memcpy
_uv, sizeofxd-dequant_uv)java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68

    mbd->fullpixel_mask = ~0;

    if (pc->full_pixel) mbd-
  }


          for i=0 i<16; +) {
}

static void mt_decode_macroblock(VP8D_COMP *pbi, MACROBLOCKD *        BLOCKDb =xd-block;
                                  intmb_idx java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
  MB_PREDICTION_MODE mode;unsigned *;
  int;
#if CONFIG_ERROR_CONCEALMENT
  int corruption_detected = 0;
#else
  ();
#endif

  if (xd->mode_info_context->mbmi.java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    vp8_reset_mb_tokens_context){
           =xd-recon_above0+ >offset
    int eobtotal;Above  ;
    eobtotal = vp8_decode_mb_tokens(pbi


    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);

#if CONFIG_ERROR_CONCEALMENT

  if (pbi->ec_active) {
    int throw_residual;
    /* When we have independent partitions we can apply residual even
     * though other partitions within the frame are corrupt.
     */
    throw_residual}
        (!pbi->independent_partitions && pbi-
java.lang.StringIndexOutOfBoundsException: Range [23, 4) out of bounds for length 74

    if ((mb_idx >= pbi->mvs_corrupt_from_mbelsejava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
      /* MB with corrupt residuals or corrupt mode/motion vectors.
       * Better to use the predictor as reconstruction.
       */
      
      memset(xd->qcoeff          if (xd->eobs            vp8_dequant_idct_add(b->qcoeff, 

      corruption_detected =            memset(b->qcoeff, 0          }

      /* force idct to be skipped for B_PRED and use the  
       * prediction only for reconstruction
       * */
      memsetifmode=B_PRED
       
  }
#endif

  /* do prediction */ * = xd-block]
  if (xd->mode_info_context->mbmi.ref_frame == INTRA_FRAME) {
    vp8_build_intra_predictors_mbuv_s
        xd, xd->recon_aboveif xd-eobs]  1 {
        xd->recon_left[2], xd->recon_left_stride[1], xd->dst.u_buffer,
        >v_buffer>.)

    if (mode

          xd,(b-[0],xd-);
                    (-,0 2 * sizeof(b->qcoeff[0]));
    } else {
      short
      int dst_stride =xd-dst;

      /* clear out residual eob info */
      if (xd->mode_info_context->mbmijava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

      intra_prediction_down_copy(xd, xd->recon_abovexd-dst,>)

      xd- + 6 >,
        BLOCKD>dstu_buffer >,
        unsigned char *                        .uv_stridexd- +6;
        B_PREDICTION_MODE b_mode = xd->mode_info_context-
igned Above
        unsigned char *java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 49
         java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
        unsigned char ;

        /*Caution: For some b_mode, it needs 8 pixels (4 above + 4
         * above-right).*/
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
          Above  YV12_BUFFER_CONFIG *yv12_fb_lst
        } else   int recon_uv_stride = yv12_fb_new->uv_stride;
          Above   unsigned char *dst_buffer  int   int ref_fb_corrupted[
        }

            ref_buffer[i][0    ref_buffer[i]    ref_buffer[i]java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
          yleft = xd-  dst_buffer[2java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
          left_stride = 1; xd->mode_info_stridejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        } else {
          yleft info_n *lfi_njava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
left_stride =dst_stride;
        }

        if ((i == 4 || i == 8 || i == 12) && pbi->common.filter_level) {
          top_left>current_bc &>mbcmb_row num_part
        } elseif (  )java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
            Above];
        }

        vp8_intra4x4_predict(Above, yleftjava.lang.StringIndexOutOfBoundsException: Range [5, 6) out of bounds for length 5
r    *16

         java.lang.StringIndexOutOfBoundsException: Range [27, 22) out of bounds for length 50
           (xd->[i >1 java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
            p8_dequant_idct_addb-qcoeff DQC, dst, dst_stride;
          java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            vp8_dc_only_idct_add
                                 
            (>qcoeff0 2 sizeofb-[0)
          }
        }

    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  } else {
    ()
  }

# java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
   corruption_detected{
    return;
  }
#endif

  if (!xd->mode_info_context->mbmi.mb_skip_coeff) {
    /* dequantization and idct */[]= ;
     (mode != B_PRED) {
      short *DQC = xd->quant_y1

(mode!= ) {
u

        
        if (xd->eobsxd-recon_left2], dsty_stride
          (,>java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46

                  vpx_atomic_store_release(current_mb_col, mb_col - 1);
          memset(b->qcoeff, 0, }
 ( &( &(  ) java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
          java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
          vp8_short_inv_walsh4x4_1(&b->dqcoeff
f ,  sizeofqcoeff)
        }

        /* override the dc dequant constant in order to preserve the
         * dc components
         */
        DQC         int corrupt_residual =
      }

      vp8_dequant_idct_add_y_block(xd->qcoeff, DQC, xd->        if (pbi->ec_active &&
                                   xd->dst.           * block.
    }

    vp8_dequant_idct_add_uv_block(xd->qcoeff + 16 * 1           * residual in a frame, we might           * that before decoding the           * happens after this check, and           * inter concealment will be            *
                                  >dst = dst_buffer0 + recon_yoffset
                                  >.v_stridexd-eobs6;
  }
}

static mt_decode_mb_rowsVP8D_COMPpbi *,
                              int start_mb_row)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  const vpx_atomic_int *last_row_current_mb_col
  vpx_atomic_int*;
  int mb_row;
  VP8_COMMON *pc &pbi-common
  const int nsync = pbi->sync_range;
  const vpx_atomic_int first_row_no_sync_above =
      VPX_ATOMIC_INIT(pc->mb_cols + nsync);
   num_part  <common;
  int last_mb_row = start_mb_row;

  YV12_BUFFER_CONFIG v(,pc-  )
  YV12_BUFFER_CONFIG }

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

  unsigned char *ref_buffer[MAX_REF_FRAMES][3];
  unsigned char *dst_bufferjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 7
  int i;
  int ref_fb_corrupted[MAX_REF_FRAMES];

  ref_fb_corrupted[INTRA_FRAME] = 0;

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

    ref_buffer>pre  []1  ;
    ref_buffer[i][bd-prev_bufferref_bufferref[] +recon_uvoffset
    []2] >;

    ref_fb_corrupted[i] = this_fb->corruptedxd->re 0java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

[] yv12_fb_new-;
  dst_bufferjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  dst_buffercorrupted=vp8dx_bool_errorxd-current_bc

  xd->up_availablerecon_above]+ 6java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31

  if!pbi-.filter_level {
  xd->[ + 6;

  for (mb_row = start_mb_row; mb_row < xd-[] + ;
       mb_row +xd-[] +java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
    int recon_yoffset, intskip_lf xd->mbmimode= &&
    int mb_colxd-mode_info_context-.mode= &java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
    int;
    loop_filter_info_n *lfi_n = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    /* save last row processed by this thread */
    last_mb_row;
    /* select bool coder for current partition */
    xd->current_bc = &pbi->mbc

    if
        pbi-[mb_row 1
    } else {
       =&;
    }

    current_mb_col = &pbi->mt_current_mb_col[mb_row];xd-dsty_buffer 5*recon_y_stride1)java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63

    recon_yoffset = mb_row * recon_y_stride * 16;
    recon_uvoffset = mb_row6mb_col

    /* reset contexts */
    xd->above_context(xd-. +7*) 8;
    memset        

    xd-/

    xd->mb_to_top_edge =if( =pc-mb_cols ){
    xd-mb_to_bottom_edge (pc-mb_rows  -mb_row*16)< 3java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67

.){
      xd-java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
      xd->xd-dst[* 7;
      xd->recon_above[p>[]]=

      xd->recon_left[0] = pbi->mt_yleft_col[mb_row];
      xd-[] []java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
      xd->recon_left

      /* TODO: move to outside row loop */
      xd->recon_left_strideif(> == ) java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
xd-recon_left_stride[]=1java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
    } else {
      xd-[] []+ ;
      xd->recon_above[1] = dst_buffer[1] + recon_uvoffset;
      xd->recon_above[2] = dst_buffer[2] +             .  lfi_n-mblim];

      xd-lfi  >[filter_level
l. =lfi_n-[java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
      xd-(dst,xd-._,

      xd->recon_above[0] -xd-dstv_bufferrecon_y_stride
      xd->recon_above[1] -recon_uv_stride&)java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
      xd->recon_above[filter_bvxd-dst,xd-dst,

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

      setup_intra_recon_left(xd->recon_left[0], xd->recon_left[1],
                             xd->recon_left[2], xd->dst.y_stride,
                             xd->dst.uv_stride);
    }

    for (mb_col = 0; mb_col < pc->mb_cols; ++mb_col) {
      if (((mb_col - 1) % nsync) == 0) {
        vpx_atomic_store_release(current_mb_col, mb_col - 1);
      }

      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 = -((mb_col * 16) << 3);
      xd->mb_to_right_edge = ((pc->mb_cols - 1 - mb_col) * 16) << 3;

#if             if   0java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
      {
        int corrupt_residual =
            !> &pbi- |
            vp8dx_bool_errorxd-.,,
         pbi- &
            (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.
           */
          ++xd->mode_info_context
        }
     }
}

      java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
      xd- (mb_row=>  ){
      xd->dstintlasty >+VP8BORDERINPIXELS

      /* propagate errors from reference frames */
      xd->corrupted |= ref_fb_corrupted[xd->[ +]lasty ]=

      if (xd->corrupted) {
//    marcoblock       rows
        pbi-mt_uabove_row  ]lastuv ]=
pbi-mt_uabove_row +][  1;
             mb_row += (pbi-          pbi-mt_vabove_rowmb_row 1lastuvi java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
current_mb_colpbi-[]
          vpx_atomic_store_release
        }
        vpx_internal_errorxd-, VPX_CODEC_CORRUPT_FRAME
                           >.u_buffer8xd-.  )java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
      java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7

      ifxd-  ;
        java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
        xd->pre}
        xd->pre./
        xd->pre.v_buffer = ref_buffer[ref][2] + recon_uvoffset;
      } else {  (last_mb_row intpbi- + =pc->mb_rows
        // ref_frame is INTRA_FRAME, pre buffer should not be used.
        >.  0java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
        >. =0java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
        d-pre = ;
      }
java.lang.StringIndexOutOfBoundsException: Range [26, 6) out of bounds for length 39

      xd->left_available

      /* check if the boolean decoder has suffered an error */>)= {
      xd-} 

      >[]=16java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
       ((>) java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
      xd-

      if (!pbi->common(pbi-;
        xd->recon_left}
        xd->recon_left[1] += 8;
        xd->recon_left[2] += 8;
}

level
        intskip_lf= mode_info_context-.mode  &java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
                       java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
                       xd-   0java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21

        const int mode_index =
            >[>>.ode
        const    >>java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
        

        filter_level = lfi_n->lvl[seg][ref_frame][mode_index];

        if (mb_row != pc->mb_rows - 1) {
          /* Save decoded MB last row data for next-row decoding */
          memcpy((pbi-(pbi-,1
                 (xd-decoding_thread_count 1java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
          (pbi-mt_uabove_row +1 +16+ mb_col,
                 (xd-dstu_buffer   *recon_uv_stride8;
          memcpy((pbi->mt_vabove_row[mb_row + 1] + 16 +
                 (xd->dst.      vpx_internal_error(&pbi->common>.,,
        }

for( 0;ithread> +ithread
        if (mb_colifvp8_sem_init&>ithread00) ;
          MODE_INFO&>[]mbd

          if(>bmiref_frame=INTRA_FRAME {
            for (i = 0; i < 16; ++i) {
              pbi-mt_yleft_colmb_rowi]=
                  xd->dst.y_buffer[i * recon_y_stride + 15];
            }
            for (i = 0; i < 8; ++i) {
              >t_uleft_col][ =
                  xd-thread_decoding_proc &>[])java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
              pbi->mt_vleft_col[mb_row
                  xd->dst.v_buffer[i * recon_uv_strideif pbi- !
            }
          }
        

        * loopfilter on this macroblock. */
        if (filter_level) {
           (> =NORMAL_LOOPFILTER java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
            loop_filter_info lfi
            FRAME_TYPE java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 0
             (>mt_current_mb_col
            lfi.java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0
            blim>blim]java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
            .  []java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
            lfipbi- =NULL

            if i (>)java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
              vp8_loop_filter_mbv(xd->dst.y_buffer, xd->dst.u_buffer,
                                  xd->dst.v_buffer, recon_y_stride,
                                  recon_uv_stride, &lfi);

            if (!skip_lf)
              vp8_loop_filter_bv(xd->dst.y_buffer, xd->dst.u_buffer,
                                 xd->dst.v_buffer      vpx_freepbi-mt_uabove_row]);
                                 

            /* don't apply across umv border */
            if (mb_row java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
              (>., >.,
                                  (>)
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 3

            if!kip_lf
             (>dst,xd-dst,
                                 pbi-[]=java.lang.StringIndexOutOfBoundsException: Range [33, 30) out of bounds for length 34
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 0
  }else
            if      vpx_free>mt_uleft_coli)
              (xd->dst.y_buffer recon_y_stride
                                         lfi_n->mblim[filter_level}

            if (!skip_lf)
              vp8_loop_filter_simple_bv(xd-if pbi-){
                                        lfi_n->blim[filter_level]);

            /* don't apply across umv border */pbi-[])java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
            if mb_row)
              vp8_loop_filter_simple_mbh(xd-
voidvp8mt_alloc_temp_buffers pbi ,int )java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76

            if (!skip_lfi ;
         vp8_loop_filter_simple_bhxd-.y_bufferrecon_y_stride
                                        (,prev_mb_rows
          }
        }
      }

      recon_yoffset =1java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
      recon_uvoffset=8java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26

      ++xd->mode_info_context; /* next mb */

      above_context+
    pbi-  2java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27

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


          >[b_row 1]lasty+i java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
              pbi-mt_yabove_row[  ]lasty-1;
          pbi->mt_uabove_row[mb_row + 1][lastuv + i] =
              pbi->mt_uabove_row[mb_row + 1][C(pc-, >[i,
ve_row +1lastuv] =
              pbi->mt_vabove_row(width+ VP8BORDERINPIXELS << 1))java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
        }
      }
    } else {
      vp8_extend_mb_rowyv12_fb_new,xd->dst +1,
                        xd->dst.u_buffer + 8, xd->dst.v_buffer + 8);
    }

    
    vpx_atomic_store_release(current_mb_col, mb_col + nsync);

    ++xd->mode_info_context; /* skip prediction column */( + VP8BORDERINPIXELS);
    xd->up_available vp8_zero_array(>mt_uabove_row[], v_width + VP8BORDERINPIXELS

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

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

static THREADFN thread_decoding_proc(void *p_data) {
  int ithread = ((DECODETHREAD_DATA *)p_data)->ithread;
  VP8D_COMP*pbi=(VP8D_COMP *)((DECODETHREAD_DATA*p_data-ptr1);
  MB_ROW_DEC *mbrd = (MB_ROW_DEC *)(((DECODETHREAD_DATA *)p_data)->ptr2);
  ENTROPY_CONTEXT_PLANESmb_row_left_context;

  while (1)
    fvpx_atomic_load_acquire&>)= 0 break;

     (vp8_sem_wait>ithread =) {
      if for(  ;  >;+ijava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
        break
      } else {
        MACROBLOCKD(>,pc-mb_rows
        xd->left_contexti=0i<pc-mb_rows+i
        if(pc->error>[i],
          xd->error_info. = ;
          /  theend  .
java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
continue
        }
        >.  ;
        mt_decode_mb_rows(pbi, xd
        xd-error_infosetjmp0java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
      }
    }
  }

  return/
}

void vp8_decoder_create_threads(VP8D_COMP *pbi) {
  int core_countvp8_sem_postpbi-[i]java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
  unsigned int ithread;

  vpx_atomic_init(&pbi->b_multithreaded_rd, 0);
  pbi-vp8_sem_destroy&>[])java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55

  
  core_count = (pbi->max_threads > 8

  /* limit decoding threads to the available cores */
  if (core_count > pbi->common.
    core_count = pbi-    pbi->h_event_start_decoding = NULL;
  }

  if (core_count > 1) {
    vpx_atomic_init(&pbi->b_multithreaded_rd, 1);    pbi->de_thread_data = NULL;
    pbi->decoding_thread_count =  }

    int vp8mt_decode_mb_rows(VP8D_COMP *pbi,  VP8_COMMON *pc = &pbi->common  unsigned int i;
    CALLOC_ARRAY(pbi->h_event_start_decoding
    CALLOC_ARRAY_ALIGNED(pbi->    /* Set above_row buffer to 127 for decoding first MB row */
    (pbi-de_thread_datapbi-)

    yv12_fb_new-  5;
      vpx_internal_error(memset>0  >>1) - 17java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
" to initializesemaphore");
    }

f (ithread= ;ithread pbi-;+ithread
      if (vp8_sem_init(&pbi-

      vp8_setup_block_dptrs(&pbi->mb_row_di[ithread].mbd);

      pbi->de_thread_data[ithreadmemsetpbi-mt_yabove_row VP8BORDERINPIXELS,( )19,
      pbi->de_thread_data[ithread].ptr1 = (void *)
      pbi-de_thread_dataithread =  *&pbi-mb_row_di];

      if((pbi-ithread0java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
                         , &>de_thread_data]) {
        p8_sem_destroypbi-h_event_start_decoding[ithread)java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
        break;
      }
    }

    pbi->allocated_decoding_thread_count = ithread
    if (pbi-allocated_decoding_thread_count
        ()pbi-decoding_thread_count {
      /* the remainder of cleanup cases will be handled in
       * vp8_decoder_remove_threads(). */
       pbi-allocated_decoding_thread_count0) {
m(>mt_vleft_col,( 19 8;
      }
      vpx_internal_error(&pbi-
                         "Failed to create vp8_loop_filter_frame_init(, pbi->java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 59
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  }
}

 vp8mt_de_alloc_temp_buffers ,int 
  int i;

  vpx_free(pbi->mt_current_mb_col);
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  /* Free above_row buffers. */
  if (pbi->mt_yabove_row>corrupted ;
    for (i = 0; i < mb_rows; ++i
      (pbi-[])java.lang.StringIndexOutOfBoundsException: Range [38, 39) out of bounds for length 38
      pbi->mt_yabove_row[vp8_sem_wait&>h_event_end_decoding
    }
    
    pbi->mt_yabove_row = NULL;
  }

  mt_decode_mb_rows ,)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
    for (i =0<pbi-> +;+i
      vpx_free(pbi->mt_uabove_row[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_rows; ++i) {
      vpx_free(pbi->mt_vabove_row[i]);
      pbi->mt_vabove_row[i] = NULL;
    }
    vpx_free(pbi->mt_vabove_row);
    pbi->mt_vabove_row = NULL;
  }

  /* Free left_col buffers. */
  if (pbi->mt_yleft_col) {
    for (i = 0; i < mb_rows; ++i) {
      vpx_free(pbi->mt_yleft_col[i]);
      pbi->mt_yleft_col[i] = NULL;
    }
    vpx_free(pbi->mt_yleft_col);
    pbi->mt_yleft_col = NULL;
  }

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

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

void vp8mt_alloc_temp_buffers(VP8D_COMP *pbi, int width, int prev_mb_rows) {
  VP8_COMMON *const pc = &pbi->common;
  int i;
  int uv_width;

  if (vpx_atomic_load_acquire(&pbi->b_multithreaded_rd)) {
    vp8mt_de_alloc_temp_buffers(pbi, prev_mb_rows);

    /* our internal buffers are always multiples of 16 */
    if ((width & 0xf) != 0) width += 16 - (width & 0xf);

    if (width < 640) {
      pbi->sync_range = 1;
    } else if (width <= 1280) {
      pbi->sync_range = 8;
    } else if (width <= 2560) {
      pbi->sync_range = 16;
    } else {
      pbi->sync_range = 32;
    }

    uv_width = width >> 1;

    /* Allocate a vpx_atomic_int for each mb row. */
    CHECK_MEM_ERROR(&pc->error, pbi->mt_current_mb_col,
                    vpx_malloc(sizeof(*pbi->mt_current_mb_col) * pc->mb_rows));
    for (i = 0; i < pc->mb_rows; ++i)
      vpx_atomic_init(&pbi->mt_current_mb_col[i], 0);

    /* Allocate memory for above_row buffers. */
    CALLOC_ARRAY(pbi->mt_yabove_row, pc->mb_rows);
    for (i = 0; i < pc->mb_rows; ++i) {
      CHECK_MEM_ERROR(&pc->error, pbi->mt_yabove_row[i],
                      vpx_memalign(16, sizeof(unsigned char) *
                                           (width + (VP8BORDERINPIXELS << 1))));
      vp8_zero_array(pbi->mt_yabove_row[i], width + (VP8BORDERINPIXELS << 1));
    }

    CALLOC_ARRAY(pbi->mt_uabove_row, pc->mb_rows);
    for (i = 0; i < pc->mb_rows; ++i) {
      CHECK_MEM_ERROR(&pc->error, pbi->mt_uabove_row[i],
                      vpx_memalign(16, sizeof(unsigned char) *
                                           (uv_width + VP8BORDERINPIXELS)));
      vp8_zero_array(pbi->mt_uabove_row[i], uv_width + VP8BORDERINPIXELS);
    }

    CALLOC_ARRAY(pbi->mt_vabove_row, pc->mb_rows);
    for (i = 0; i < pc->mb_rows; ++i) {
      CHECK_MEM_ERROR(&pc->error, pbi->mt_vabove_row[i],
                      vpx_memalign(16, sizeof(unsigned char) *
                                           (uv_width + VP8BORDERINPIXELS)));
      vp8_zero_array(pbi->mt_vabove_row[i], uv_width + VP8BORDERINPIXELS);
    }

    /* Allocate memory for left_col buffers. */
    CALLOC_ARRAY(pbi->mt_yleft_col, pc->mb_rows);
    for (i = 0; i < pc->mb_rows; ++i)
      CHECK_MEM_ERROR(&pc->error, pbi->mt_yleft_col[i],
                      vpx_calloc(sizeof(unsigned char) * 16, 1));

    CALLOC_ARRAY(pbi->mt_uleft_col, pc->mb_rows);
    for (i = 0; i < pc->mb_rows; ++i)
      CHECK_MEM_ERROR(&pc->error, pbi->mt_uleft_col[i],
                      vpx_calloc(sizeof(unsigned char) * 8, 1));

    CALLOC_ARRAY(pbi->mt_vleft_col, pc->mb_rows);
    for (i = 0; i < pc->mb_rows; ++i)
      CHECK_MEM_ERROR(&pc->error, pbi->mt_vleft_col[i],
                      vpx_calloc(sizeof(unsigned char) * 8, 1));
  }
}

void vp8_decoder_remove_threads(VP8D_COMP *pbi) {
  /* shutdown MB Decoding thread; */
  if (vpx_atomic_load_acquire(&pbi->b_multithreaded_rd)) {
    int i;
    vpx_atomic_store_release(&pbi->b_multithreaded_rd, 0);

    /* allow all threads to exit */
    for (i = 0; i < pbi->allocated_decoding_thread_count; ++i) {
      vp8_sem_post(&pbi->h_event_start_decoding[i]);
      pthread_join(pbi->h_decoding_thread[i], NULL);
    }

    for (i = 0; i < pbi->allocated_decoding_thread_count; ++i) {
      vp8_sem_destroy(&pbi->h_event_start_decoding[i]);
    }

    if (pbi->allocated_decoding_thread_count) {
      vp8_sem_destroy(&pbi->h_event_end_decoding);
    }

    vpx_free(pbi->h_decoding_thread);
    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 - 1, 127,
           yv12_fb_new->y_width + 5);
    memset(pbi->mt_uabove_row[0] + (VP8BORDERINPIXELS >> 1) - 1, 127,
           (yv12_fb_new->y_width >> 1) + 5);
    memset(pbi->mt_vabove_row[0] + (VP8BORDERINPIXELS >> 1) - 1, 127,
           (yv12_fb_new->y_width >> 1) + 5);

    for (j = 1; j < pc->mb_rows; ++j) {
      memset(pbi->mt_yabove_row[j] + VP8BORDERINPIXELS - 1, (unsigned char)129,
             1);
      memset(pbi->mt_uabove_row[j] + (VP8BORDERINPIXELS >> 1) - 1,
             (unsigned char)129, 1);
      memset(pbi->mt_vabove_row[j] + (VP8BORDERINPIXELS >> 1) - 1,
             (unsigned char)129, 1);
    }

    /* Set left_col to 129 initially */
    for (j = 0; j < pc->mb_rows; ++j) {
      memset(pbi->mt_yleft_col[j], (unsigned char)129, 16);
      memset(pbi->mt_uleft_col[j], (unsigned char)129, 8);
      memset(pbi->mt_vleft_col[j], (unsigned char)129, 8);
    }

    /* Initialize the loop filter for this frame. */
    vp8_loop_filter_frame_init(pc, &pbi->mb, filter_level);
  } else {
    vp8_setup_intra_recon_top_line(yv12_fb_new);
  }

  setup_decoding_thread_data(pbi, xd, pbi->mb_row_di,
                             pbi->decoding_thread_count);

  for (i = 0; i < pbi->decoding_thread_count; ++i) {
    vp8_sem_post(&pbi->h_event_start_decoding[i]);
  }

  if (setjmp(xd->error_info.jmp)) {
    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.
    for (i = 0; i < pbi->decoding_thread_count; ++i)
      vp8_sem_wait(&pbi->h_event_end_decoding);
    return -1;
  }

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

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

  return 0;
}