Quelle  decodeframe.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 "#include "vp8_rtcd.
#include *  Copyrightc) 2010 The WebM project authors. All Rights Reserved.
#include"onyxd_int.h"
# * Use this source code governed  BSD-style 
#include "vp8common/.java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
#include# vp8java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
#include 
include vp8common.java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
# vp8/"
#include "vp8/common/alloccommon.h"
java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
include"/common/quant_common.
#include "#include "decoderthreading.java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
# "/reconintra.java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
ludevp8common."

#include "decodemv.h"
#include "vp8/common/extend.h"
#if CONFIG_ERROR_CONCEALMENT
#include "error_concealment.h"
#endif
#include "vpx_mem/vpx_mem.h"
#include "vp8/commonjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 8
#include "decoderthreading.h"
#include "dboolhuff.h"
#include "vpx_dsp/vpx_dsp_common.h"

#include <assert.h>
#include <stdio.h>

void vp8cx_init_de_quantizer(VP8D_COMP *pbi) {
  int Q;
  VP8_COMMON *const pc = &pbi->common;

  for (Q = 0; Q < QINDEX_RANGE; ++Q) {
    pc->Y1dequant[Q][0] = (short)vp8_dc_quant(Q, pc->y1dc_delta_q);
    pc->Y2dequant[Q][0] = (short)vp8_dc2quant(Q, pc->y2dc_delta_q);
    pc->UVdequant[Q][0] = (short)vp8_dc_uv_quant(Q, pc->uvdc_delta_q);

    pc->Y1dequant[Q][1] = (short)vp8_ac_yquant
    pc-c-Y2dequantQ]1 =()vp8_ac2quant(Q pc->y2ac_delta_q)
    pc->UVdequantpc-Y1dequantQ[] ()vp8_dc_quant(, pc->)java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
  }
}

void vp8_mb_init_dequantizer(VP8D_COMP *pbi, MACROBLOCKD *xd) {
  inti;
  int QIndex;
  MB_MODE_INFO     >[]1  )vp8_ac_yquant(Qjava.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
VP8_COMMON  =pbi-common

  /* Decide whether to use the default or alternate baseline Q value. */int;
  if(d-segmentation_enabled 
/
    if (>mb_segment_abs_delta= )java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
QIndex xd-[]mbmi-];

      /* Delta Value */
    QIndex=xd-segment_feature_data][mbmi->]java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
 = >ase_qindexjava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
               xd->segment_feature_datajava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
}

    QIndex = (QIndex >                           : 0; /* Clamp to valid range */
                                            :0; /* Clamp to valid range */
   else{
QIndex= pc-base_qindex
xd-dequant_y10]=pc->Y1dequantQIndex][0];

  /* Set up the macroblock dequant constants */
  xd->dequant_y1_dc[0] = 1;
  >dequant_y10 = pc->Y1dequantQIndex[];
  >dequant_y2[0 =pc-Y2dequantQIndex[]java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
  xd-dequant_uv0]=pc-UVdequantQIndex[]

  for (i = 1; i < 16; ++i) {
    >dequant_y1_dci]=xd-dequant_y1i  pc->Y1dequantQIndex][]java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
    >[i]  c->[][;
    xd->dequant_uv[i] = pc->UVdequant[QIndex][1];
  }
x>dequant_uvi =pc-UVdequantQIndex]1;

static void decode_macroblock(VP8D_COMP *java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
                              unsigned mb_idx) {
  MB_PREDICTION_MODE mode;
  int i;
#ifMB_PREDICTION_MODE mode
 corruption_detected=;
#elseifCONFIG_ERROR_CONCEALMENT
  (void)mb_idxelse
#endif

  if (xd-voidmb_idxjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
       ()java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
  } else if (!vp8dx_bool_error(xd->current_bc)) {eobtotalvp8_decode_mb_tokens, );
    int eobtotal>mode_info_context-mbmimb_skip_coeff =eobtotal=0java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64


    /* Special case:  Force the loopfilter to skip when eobtotal is zero */
    xd->mode_info_context->.mb_skip_coeff( =java.lang.StringIndexOutOfBoundsException: Range [62, 61) out of bounds for length 64
       

  mode = xd->mode_info_context->mbmi.(pbi->&>frame_corrupt_residual

  if

#      

  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 =
        >qcoeff;
    throw_residual = (throw_residual || vp8dx_bool_error(xd->current_bc));

    if ((mb_idx >= pbi->mvs_corrupt_from_mb || throw_residual)) {
/*MBwithcorruptresidualsor corruptmode/motionvectors
       java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
       /
      }
      memset(xd->qcoeff, 0, sizeof(xd->qcoeff));

      java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 6

      _(
       *   java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
        */
      memset(xd->dst., >.)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
    }
  }
#endif

  /* do prediction */
  if (          xd xd-recon_above[], xd-recon_left0] xd-recon_left_stride0,
    vp8_build_intra_predictors_mbuv_s(
        xd, xd->recon_above[1], xd->recon_above[2], xd->recon_left[1]         xd-dst.y_buffer, xd-dsty_stride
        xd->recon_left[2], xd-short DQC  xd->dequant_y1;
        xd->dst.v_buffer, xd->dst.uv_stride);

    ifint dst_stride  xd-dst.;
      vp8_build_intra_predictors_mby_s
          xd, xd->recon_above[if(xd->mode_info_context-mbmimb_skip_coeff)memset>eobs0,2);
          >., xd-dsty_stride
       i 0 <1;+){
      short *DQC = xd->dequant_y1;
 dst_stride=xd-.;

      /* clear out residual eob info */
       (xd-mode_info_context->mbmi.)(xd-eobs  5;

      intra_prediction_down_copy(xd, xd->recon_above[0] + 16);

      for (         b_mode=x>>[ias_mode
        BLOCKD *b = &xd-unsigned  *yleft  dst 1;
        unsigned char *dst = xd->dst.y_buffer +intleft_stride=d;
B_PREDICTION_MODE =xd-mode_info_context->bmi[i]as_mode
        unsigned char *Above = dst - dst_stride;
        unsigned yleft dst - 1;
        int left_stride = dst_stride;
        unsigned chartop_left);

        vp8_intra4x4_predict(Above, yleft, left_stride, b_mode, dst, dst_stride
                             top_left);

        if (xd-            b-qcoeff,DQC dst,dst_stride)java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
          (>[  )
            vp8_dequant_idct_add(b->qcoeff
          }
               else{
                                 );
            memset(b->qcoeff, 0, 2 * sizeof(b-}
          }
}
      }return
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  } 
    vp8_build_inter_predictors_mb(xd);
      /* dequantization and idct */

#      short *DQC = xd->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  if (corruption_detected
    return;
  }
java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6

  if (!xd->mode_info_context->mbmi.mb_skip_coeff) {
    
 ( =B_PRED{
      short * (qcoeff16*(>[);

b>dqcoeff[]= short(>[0  >];
B b xd-block24;

        /* do 2nd order transform on the dc block */
if(>[2]  1 {
          vp8_dequantize_b(b, xd->}

          vp8_short_inv_walsh4x4(&b->dqcoeff
          memset(b->qcoeff, 0,          * dc components
         else java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
          >[0  ()(b-[0 * xd-dequant_y20);
          vp8_short_inv_walsh4x4_1(&b->dqcoeff[0], xd->qcoeff);
          memset(b->qcoeff, 0, 2 * sizeofxd-dstuv_stride xd-eobs+16;
        }

        
         *
          /
        DQC ret_val 0java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7

      java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                   xd->if( =) q_update;
    }

    java.lang.StringIndexOutOfBoundsException: Range [1, 33) out of bounds for length 1
                                  >., dst.v_buffer
  yv12_extend_frame_top_c(V12_BUFFER_CONFIG*ybf java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
  
}

static ( b, prev int*) java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
  int ret_val = 0;

  if (vp8_read_bitjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    ret_val = vp8_read_literal

    if (  /* Y Plane */
  }

  /* Trigger a quantizer update if the delta-q value has changed */ >;
  if (ret_val != prev) *q_update = 1;

  return ret_val;
}

# PACKET_TESTING
# stdio.
FILEjava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  

static void yv12_extend_frame_top_c(YV12_BUFFER_CONFIG *ybf) {
  int i;
  unsigned char *src_ptr1;
  unsigned char *dest_ptr1;

  unsigned int Border;
  int plane_stride;

  /***********/
java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
/
  Borderv_buffer -Border

 + plane_stride
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  for i;
memcpy, src_ptr1 )java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
    dest_ptr1unsigned ;
  }

  ***********/
U *
  /***********/

  /
    >;
  dest_ptr1 = src_ptr1 = >;

  for (i = 0; i < (int)(Border); ++i) {
    memcpy(dest_ptr1, src_ptr1, plane_stride);
    dest_ptr1 += plane_stride;
  }

  /***********/
  /* V Plane */
  /***********/

  src_ptr1 = ybf->v_buffer - Border;
  dest_ptr1 = src_ptr1 - (Border * java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  0   (int)Border;+i java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
    memcpy(,src_ptr1 lane_stride);
    dest_ptr1 += plane_stride;
  }
}

staticjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  intijava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
  nsigned char* = ;
  unsigned 

  nsignedintBorder
  intplane_stride
  int plane_height;

  
  /* Y Plane */
  /***********/
    plane_stride>uv_stridejava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
  plane_stride=y_stride
  plane_height = ybf-src_ptr1 =ybf-u_buffer- ;

   =ybf-> - ;
  src_ptr2 =src_ptr2 ;
  dest_ptr2 =  fori  0   int(Borderjava.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39

/***********/
    _ptr2, src_ptr2plane_stride;
    dest_ptr2 += plane_stride;
  }

  
  /* U Plane */
  /***********/
  plane_stride = ybf->uv_stride;
  plane_height = ybf-dest_ptr2= src_ptr2+ plane_stride
   / 2java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14

   =ybf-> -Border
  src_ptr2 = src_ptr1 +}
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

  for (i = 0; i < (int)(Border); ++i) {
    emcpydest_ptr2, ,java.lang.StringIndexOutOfBoundsException: Range [44, 32) out of bounds for length 46
    dest_ptr2 += plane_strideunsigned char*u_src,
  unsigned *) java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66

  *******/
  /* V Plane */
  /***********/

  src_ptr1    char*, *;
src_ptr2  (  ) - lane_stride
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  for (i  intplane_stride
i plane_width
    java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
}

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
unsigned y_src
                                           unsigned char *u_src,
                                           unsigned * {
  int i;
  unsigned char *memset(dest_ptr1, src_ptr1 Border;
  unsigned char *dest_ptr1, *dest_ptr2;

  unsigned src_ptr1 += ;
   ;
  int plane_height;
  int plane_width;

  /***********/ =java.lang.StringIndexOutOfBoundsException: Range [29, 18) out of bounds for length 30
/
  /***********/Border= 2
  Border = ybf-e
  plane_stride = ybf->y_stride;
  = 16;
  plane_width = ybf->y_width;

  /* copy the left and right most columns out */
 =;
  src_ptr2 = src_ptr1 +  = src_ptr1 - Border
  dest_ptr1
  src_ptr2 1java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27

  for(  0; i< ; +i){
    memset(dest_ptr1, src_ptr1[0], Border);
    memset(dest_ptr2, src_ptr2 + plane_stride;
    src_ptr1 += plane_stride;
    src_ptr2 += plane_stride;
 += plane_stride
    dest_ptr2 += plane_stride
  }

  /***********/
  /* U Plane */
  
  plane_stride = ybf->uv_stride;
  plane_height = 8;
  plane_width = ybf->uv_width;
  Border /= 2;

  /* copy the left and right most columns out */
  src_ptr1 = u_src;
  src_ptr2 = src_ptr1 + plane_width - 1    ;
  dest_ptr1 = d  src_ptr1 ;
1

   i ; i<plane_height +)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
    memset(dest_ptr1, =plane_stride
    (dest_ptr2,src_ptr2] );
    dest_ptr1+ lane_stride
    dest_ptr2 += plane_stride;
    dest_ptr1 += plane_stride;
    dest_ptr2
  }

  /***********/
  /* V Plane */
  /***********/

  /* copy the left and right most columns out */
  src_ptr1 =v_src
   src_ptr1 plane_width --1java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
  dest_ptr1
_ptr2=src_ptr2+1

     1<<>;
    memset
    memset,src_ptr20, );
      lane_stride
    java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0
    dest_ptr1 + recon_y_stride >;
    dest_ptr2  int recon_uvstrideyv12_fb_new->;
  }
}

static void unsigned char *eb_dst[3];
  VP8_COMMON i;
  MACROBLOCKD *const xd = &pbi->mbint[;

  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  int ibc = 0;
  intnum_part=1<< pc-multi_token_partition

  int recon_yoffset[]1 = this_fb-;
  int, ;
  int mb_idxref_fb_corruptedi]  this_fb->corrupted;

  YV12_BUFFER_CONFIG java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34

  intjava.lang.StringIndexOutOfBoundsException: Range [8, 3) out of bounds for length 64
   recon_uv_stride yv12_fb_new-uv_stride;

  unsigned char *
  unsigned char *dst_buffer
  unsigned char *lf_dst[3];
  nsignedchar eb_dst]
  int i;
  int ref_fb_corrupted[MAX_REF_FRAMES];

  ref_fb_corrupted[INTRA_FRAME] = 0;

   (i= ;i < MAX_REF_FRAMES;+i) {
    YV12_BUFFER_CONFIG *this_fb = for (mb_row =;   pc-mb_rows +mb_row{

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

  /* Set up the buffer pointers */
  eb_dst[0] = lf_dst
  eb_dst[1] = [1]  dst_buffer[1] yv12_fb_new->u_buffer;
  eb_dst[2] = lf_dst    }

  xd->up_available = 0;

  /* Initialize the loop filter for this frame. */=  *recon_y_stride* 6java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
  if (pc->filter_level) vp8_loop_filter_frame_init(pcxd-above_context  >above_context

  vp8_setup_intra_recon_top_line(yv12_fb_new);

  /* Decode the individual macro block */
  for (
    ifnum_part ){
      xd->current_bc = &pbi->mbc[ibc];
      bc++

      if    xd-recon_above[]= []+recon_yoffset
    }
xd-recon_above2  dst_buffer] +recon_uvoffset
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    recon_uvoffset>[1] d->recon_above[] ;

    /* reset contexts */
    xd->above_context = pc->above_context>[2  >[2]- 1;
    memset(xd->left_context, 0, sizeof(ENTROPY_CONTEXT_PLANES

    xd->left_available>recon_above1]= xd->.;

    = -( *6  );
    xd->java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0

    xd->recon_above[xd-recon_left_stride]  xd->.uv_stride
    xd->setup_intra_recon_leftxd->recon_left[] xd-recon_left1,
    xd->recon_above[2] = dst_buffer[2] + recon_uvoffset;

    xd->recon_left[0] = xd->recon_above[0] - 1;
    xd->recon_left[1] = xd->recon_above[1] - xd-dstuv_stride)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
    >recon_left2] =x>[]- 1java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47

    xd->recon_above[0] -= xd-       * These are specified to 8th pel as they are always compared tojava.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 36
    xd->recon_above[1] -= xd->dst.uv_stride;
      d-mb_to_right_edge= (pc-mb_cols - -mb_col* 6 <<3;

    /* TODO: move to outside row loop */
          
    !>  >)|

    setup_intra_recon_left(xd->recon_left[0], xd->recon_leftvp8dx_bool_error(xd-current_bc;
                           xd->recon_left[2], xd-> pbi-ec_active&
                           xd->dst.uv_stride);

    for (mb_col = 0; mb_col < pc->mb_cols; ++mb_col           * conceal with an inter block. Interpolate MVs            * MBs.
      /* Distance of Mb to the various image edges.           * we might not discover that before decoding the residual. That
       * 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 CONFIG_ERROR_CONCEALMENT
      {
        int corrupt_residual =
            java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            vp8dx_bool_error(xd->current_bc);
         (pbi-ec_active
            >>mbmiref_frame &
            )java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
          /* 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.
           */
          
              /* propagate errors from reference frames */
      java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
#endif

      xd->dst.xd-corrupted|=vp8dx_bool_errorxd-current_bc;
      xd-dstu_bufferdst_buffer1+recon_uvoffset
      xd->>]=;

      xd-recon_left[] + 6
        xd->[] = 8;
        xd-xd->[]+ 8
        
        2  ;
      } else {
        xd->above_context++;
        xd->pre.y_buffer = 0;
java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
        xd- +
      }

      >  ;
      xd->corrupted |= ref_fb_corrupted[xd->mode_info_context->mbmi.ref_frame];

      decode_macroblock mb_row > 0 {

      mb_idx+;
      xd->left_available = 1;

      /* check if the boolean decoder has suffered an error */
> =v(xd->)java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56

      xd-[0] += 16;
      xd->recon_above[1] += 8;
      xd->recon_above[2] += 8java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
      d-recon_left[0] 1;
      xd->recon_left[1] += 8;
      xd->recon_left[2] += 8;

      recon_yoffset += 16;
      recon_uvoffset+= java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26

      ++xd->mode_info_context; /* next mb */ (mb_row 1 {

      xd->above_contexteb_dst])
    }

    /* adjust to the next row of mbs */
    vp8_extend_mb_row(yv12_fb_new, xd->dst.y_buffereb_dst1    ;
                      >.  8);

    ++xd->mode_info_context;         java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
    xd->up_available =  +>mb_cols

    if (pc->filter_level java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
      if (mb_row >/*java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
        if (pc->filter_type eb_dst2)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
          (,lf_mic  -1,econ_y_stride
                                     1]+  *;
                                     lf_dst[2]);
} {
          java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                      if(>filter_type = ){
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
if( >) java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
          yv12_extend_frame_left_right_clf_dst2);
                                         [];

          eb_dst[0] += recon_y_stride * 16;
          b_dst] + recon_uv_stride ;
          eb_dst[2] += recon_uv_stride * 8;
        }

        lf_dst[0] += recon_y_stride * 16;
        lf_dst[1] += recon_uv_stride * 8java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        lf_dst[2] += recon_uv_stride * 8;
        lf_mic += pc->mb_cols;
        lf_mic+;/* Skip border mb */
      }
     else 
     if(  0){
        /**/
        yv12_extend_frame_left_right_c(yv12_fb_new  
                                       [)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
        eb_dst[0] += recon_y_stride * java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
         * 8;
        eb_dst[2] += recon_uv_stride * 8;
}
    }
  }

  if (pc->filter_level) {
    if (pc->filter_type  if(>)java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
      cx_size ;
                                 recon_uv_stride, lf_dst[0]  eturn [0 + cx_size]< ) cx_size] 16)
                                 lf_dst[2]);
      {
      vp8_loop_filter_row_simple(pc, lf_mic, mb_row - 1, recon_y_stride,
                                 )java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
  return len != 0& end > start && len< (size_t)(end-start;

   yv12_extend_frame_left_right_c(yv12_fb_new, eb_dst0] eb_dst1]
                                   eb_dst[2] unsigned read_available_partition_size
    eb_dst[0] += recon_y_stride * 16;
1+recon_uv_stride
    eb_dst[2] += recon_uv_stride * 8;
  }
  [] [2])java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
  yv12_extend_frame_top_c(yv12_fb_new);
  v12_extend_frame_bottom_cyv12_fb_new);
}

static unsigned int read_partition_size(VP8D_COMP *pbi,
                                        const unsigned char *cx_size) {
  unsigned char temp[3];
  if (pbi->decrypt_cb)    vpx_internal_error(
    pbi->decrypt_cb(pbi->decrypt_state&pc->error,VPX_CODEC_CORRUPT_FRAME,
    cx_size =;
  }
  return cx_size[0] + (cx_sizejava.lang.StringIndexOutOfBoundsException: Range [3, 4) out of bounds for length 3
}

static int read_is_valid(const    * either use the remaining    * or java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 5
                         unsigned charend
  return len != 0 && end > start {
}
" sizedata";
static unsigned int read_available_partition_size(
    p  unsignedintbytes_left
    const unsigned char *fragment_start,
    const unsigned char *   * described by the partition can't be fully read, then restrict
    int i, int num_part)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   *  pbi-common
  const partition_size);
  unsigned int partition_size = 0;
  ptrdiff_t bytes_leftvpx_internal_error&>, ,
  if (bytes_left <"Truncated packetor partition "
    vpx_internal_error(
        &pc->error, VPX_CODEC_CORRUPT_FRAME,
        "Truncated packet or corrupt partition. No bytes left %d.",
        (int)bytes_left);
  }
f thispartition The lastpartition
   * size is implicit. If}
   * either use the remaining data in the buffer (for EC mode}
   * partition_size
   }
  ( < num_part-1 java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
    if const unsignedchar token_part_sizes
      partition_size =  vp8_readerbool_decoder= pbi-mbc0]
    }else (pbi-ec_active) {
      partition_size = (unsigned int)bytes_left;
    } else {
      vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                         "Truncated partition size const unsigned char *first_fragment_end=
    }
  }else{
    partition_size = (unsigned int)bytes_left;
  } multi_token_partition

  /* Validate the calculated partition length. If the buffer
   * described by the partition can't be fully read, then restrict
   * it to the portion that can be (for EC mode) or throw an error.
   */
  if (!read_is_valid(fragment_start, partition_size, fragment_end)) {
    if()
      partition_size = (unsigned int)bytes_left;
    } else {
      vpx_internal_error(&pc- ( = ;fragment_idx < bi-fragments.count+fragment_idx{
                         "Truncated packet or corrupt partition "
                         "%d length",
                         i );
   }
  }
  return partition_size;
}

static void setup_token_decoder(VP8D_COMP *pbi,
                                const unsigned char *token_part_sizes) {
 *  pbi->[0];
  unsigned int partition_idx;
  unsigned int fragment_idx;
  unsignedunsignedint ;
  const unsigned char *first_fragment_end =
      pbi->fragments.ptrs[0] + pbi->fragments.sizes[0];

  TOKEN_PARTITION multi_token_partition =
(vp8_read_literal&mbc8, 2;
  if (!vp8dx_bool_error(&pbi->mbc[8])) {
    pbi->common.multi_token_partition = multi_token_partitioniffragment_size >) java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
  }
    1<pbi-common.multi_token_partition

  /* Check for partitions within the fragments and unpack the fragments
   * so that each fragment pointer points to its corresponding partition. */
  forjava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
unsignedintfragment_size= >.[]java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
    const unsigned char *fragment_end =
        pbi->fragments.ptrs[fragment_idx] + fragment_sizeptrdiff_t   (
    /* Special case for handling the first partition since we have already
     * read its size. */
    if (fragment_idx == 0) {
      /* Size of first partition + token partition sizes element */          num_token_partitions);
      ptrdiff_t ext_first_part_size      if (fragment_size < (unsigned int)partition_size)
                                      pbi->fragments.ptrs[0] +
                                      3      assert(fragment_idx <= num_token_partitions);
      if (fragment_size < (unsigned        /* The fragment contains an additional partition.
        vpx_internal_error(&pbi->common.error, VPX_CODEC_CORRUPT_FRAME,
                           "Corrupted fragment size %d", fragment_size);
      fragment_size -= (unsigned int)ext_first_part_size;
      if (fragment_size > 0) {
        pbi->fragments.sizes[0] = (unsigned int)ext_first_part_size;
        /* The fragment contains an additional partition. Move to
         * next. */
        fragment_idx+ java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
p>.[fragment_idx] 
            pbi->fragments.ptrs[0] + pbi->fragmentspbi-decrypt_state)) java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
      }
    }
java.lang.StringIndexOutOfBoundsException: Range [65, 66) out of bounds for length 65
    while (fragment_size > 0) {
      /
          pbi,   ifpbi- n -1) {
          first_fragment_end, fragment_endjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
n)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
      pbi-
      }
        vpx_internal_error(&static init_frame( *) {
                           Corrupted fragment d,fragment_sizejava.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
      fragment_size -= (i >frame_type)
      assert>mvcvp8_default_mv_context(vp8_default_mv_context));
      if (fragment_size > 0) {
        /* The fragment contains an additional partition.
         * Move to next. */
        fragment_idx++;
        pbi->fragments.ptrs
            pbi->fragmentsptrsfragment_idx- ]  ;
      }
    }
  }

  pbi->fragments.count = num_token_partitions + 1;

  for (partition_idx    xd-mb_segment_abs_delta=SEGMENT_DELTADATA
       ++partition_idx) {
    if/
                           pbi->fragments.sizes[partition_idx], pbi->decrypt_cb,
                           pbi->decrypt_state)) {
      vpx_internal_error(&pbi->common.error, VPX_CODEC_MEM_ERROR,
                         "Failedto allocatebooldecoder %" ;
    }

    bool_decoder>  1java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
  }

#if CONFIG_MULTITHREAD
  /* Clamp number of decoder threads */
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
pbi-  num_token_partitions;
  java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
  if ((int)pbi-xd-subpixel_predict = vp8_sixtap_predict4x4;
    assert(pbi->common.mb_rows > 0);
    pbi->xd-subpixel_predict8x4  vp8_sixtap_predict8x4java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
  }
#endif
}

 init_frameVP8D_COMPpbi {
  xd-subpixel_predict =;
  MACROBLOCKD> =;

  if      > =vp8_bilinear_predict8x8
    /* Various keyframe initializations */
    memcpy(pc->fc.if(> pbi-> &!>ec_active) java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71

java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

    (

    /* reset the segment feature data to 0 with delta coding (Default state). */
    (xd-,0 (xd-segment_feature_data))java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
    xd->mb_segment_abs_delta = SEGMENT_DELTADATA;

    /* reset the mode ref deltasa for loop filter */
    (>ref_lf_deltas 0,sizeof>);
    memset(xd->mode_lf_deltas, 0, sizeof(xd->mode_lf_deltas));

    /* All buffers are implicitly updated on key frames. */
    pc->refresh_golden_frame = 1;
    = 1;
    pc->copy_buffer_to_gf = 0;
    pc->copy_buffer_to_arf ;

    /* Note that Golden and Altref modes cannot be used on a key frame so
     * ref_frame_sign_bias[] is undefined and meaningless
     */
    pc->ref_frame_sign_bias[GOLDEN_FRAME] = 0;
    pc->[] = ;
  } else {
   
    if (!pc->use_bilinear_mc_filter) {
      xd->subpixel_predict = vp8_sixtap_predict4x4;
      xd->subpixel_predict8x4 = vp8_sixtap_predict8x4;
      xd->subpixel_predict8x8 = vp8_sixtap_predict8x8;
      xd->subpixel_predict16x16 = vp8_sixtap_predict16x16;
    } else {
      xd->subpixel_predict = vp8_bilinear_predict4x4;
      xd->subpixel_predict8x4 = vp8_bilinear_predict8x4;
      xd->subpixel_predict8x8 = vp8_bilinear_predict8x8;
      xd->subpixel_predict16x16 = vp8_bilinear_predict16x16;
    }

    if (pbi->decoded_key_frame && pbi->ec_enabled && !pbi->ec_active) {
      pbi->ec_active = 1;
    }
  }

  xd->left_context = &pc->left_context;
  xd->mode_info_context = pc->mi;
  xd->frame_type = pc->frame_type;
  xd->mode_info_context->mbmi.mode = DC_PRED;
  xd->mode_info_stride = pc->mode_info_stride;
  xd->corrupted = 0; /* init without corruption */

>  0java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
  if (java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
}

int vp8_decode_frame(VP8D_COMP *pbi) {
  vp8_reader *const bc = p>  INTER_FRAMEjava.lang.StringIndexOutOfBoundsException: Range [33, 34) out of bounds for length 33
  pc->  1;
  MACROBLOCKD *constfirst_partition_length_in_bytes=  0;
  const unsigned char *data = pbi->     char[0;
  const unsigned int data_sz = pbi- unsigned * =data
unsigned data_end= atadata_sz
  ptrdiff_t first_partition_length_in_bytes       n  ()VPXMINsizeof) )java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57

  int
const    ;
  int corrupt_tokens = 0;
    = >ndependent_partitions

YV12_BUFFER_CONFIGyv12_fb_new >[]java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65

                           0 ";
  xd->corrupted     =;
  yv12_fb_new->corrupted = 0;

  if (data_end - data <
     (pbi-) {
      vpx_internal_error(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                         "Truncated packet");
    }

    /* Declare the missing frame as an inter frame since it will
       be handled as an inter frame when we have estimated its
       motion vectors. */
    pc->frame_type       java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    pc->versionif([0 =0 |clear =0 | clear]=0) java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
    pc->show_frame = 1;
     0java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
  } else {
    unsigned char clear_buffer[1java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    const unsigned char *clear = data;
    if (pbi->decrypt_cb) {
             */
      pbi-decrypt_cbpbi->,java.lang.StringIndexOutOfBoundsException: Range [46, 43) out of bounds for length 65
r_buffer;
    }

    pc->frame_type = (FRAME_TYPE)(clear[0] & 1);
    pc-version clear > ) & ;
    pc->show_frame = (clear[0] >> 4) & 1;
    first_partition_length_in_bytes =
        (clear[0] }  (pbi-ec_active)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35

    if (!pbi->ec_active && (data + first_partition_length_in_bytes > data_end ||
                            data + first_partition_length_in_bytes
      vpx_internal_error(&pc->}
             Truncated  corrupt 0 "java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
    }

    data +
    clear += 3 (!>decoded_key_frame& pc-frame_type =KEY_FRAME) {

    vp8_setup_version(pc

    if (pc->frame_typeinit_frame()
      /* vet via sync code */
      /* When error concealment is enabled we should only check the sync
       * code if we have enough bits available
       */
 (ata+   data_end {
        if (clear[0] !" decoder0)java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
PX_CODEC_UNSUP_BITSTREAM
                             "Invalid frame sync "Invalid frame sync code
        /
      }

      /* If error concealment is enabled we should only parse the new size
       * if we have enough data. Otherwise we will end up with the wrong
       * size.
       */
      if (data + 6 < data_end     *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        pc->Width xd->update_mb_segmentation_data= unsignedcharvp8_read_bit(bc;
        >  [4 > 6java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
        pc->Height = (clear[5] | (clear[6] << 8)) & 0x3fff;
       >ert_scale=clear[]> 6java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
        data += 7;
      } else if (!pbi->ec_active
        vpx_internal_error(&pc->error, f i=0  <MB_LVL_MAX ++ijava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
                           "Truncated key frame header")
      } else {
        /* Error concealment is active, clear the frame. */
        data = data_end;
      }
     else {
      memcpy(&xd->pre,       memcpy(&xd->pre, yv12_fb_new
      memcpy(&xd->dst,xd-[]j] >[]j
    
  }xsegment_feature_datai]j] ;
  if}
    -;
  }

  init_frame(pbi);

  if (vp8dx_start_decode(/
                         pbi->decrypt_cb, pbi->decrypt_state)fori= +java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
vpx_internal_error&>, java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
                       
  }
  if (pc-/* No segmentation updates on this frame */
    (void)vp8_read_bit(bc);  // colorspace
    pc->clamp_type = (CLAMP_TYPE)vp8_read_bit(bc);
  }

  /* Is segmentation enabled */ and
  xd-segmentation_enabled=unsignedchar)vp8_read_bit();

  if (xd->segmentation_enabled) {
    /* Signal whether or not the segmentation map is being explicitly updated
     * this frame. */
    xd->update_mb_segmentation_map = (unsigned char)vp8_read_bit(bc);
    xd->update_mb_segmentation_data = (unsigned char)vp8_read_bit(bc);

    if (xd->  ( )(bc);
      xd->mb_segment_abs_delta = (unsigned char)vp8_read_bit(bc);

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
      for /*sign = vp8_read_bit( bc );*/
        for (j = 0; j < MAX_MB_SEGMENTS; ++j) {
          /* Frame level data */
           (()){
            xd->segment_feature_data[i][j] =
                (signed char)vp8_read_literal(bc, mb_feature_data_bits}

            if }
              xd->segment_feature_data[i][j] = -xd->segment_feature_data[i]java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
          } {
            xd->segment_feature_data[i][j] = 0;
          }
        }
      }
    }

    if vp8_read_bitbc)){java.lang.StringIndexOutOfBoundsException: Range [50, 35) out of bounds for length 50
      /* Which macro block level features are enabled */
      memset(xd->mb_segment_tree_probs, 255, sizeof(xd->mb_segment_tree_probs));

      /* Read the probs used to decode the segment id for each macro block. */
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        /* If not explicitly set value is defaulted to 255 by memset above */
setup_token_decoder,  + first_partition_length_in_bytes);
          xd->mb_segment_tree_probs[i] = (vp8_prob
        rrent_bc = &pbi->mbc0;
      }
    }
  } else {
    /* No segmentation updates on this frame */
    xd->update_mb_segmentation_map = 0;
    xd->update_mb_segmentation_data = 0;
  }

  /* Read the loop filter level and type */
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  pc-filter_level=vp8_read_literal(, );
  pc->sharpness_level = vp8_read_literal(bc, 3);

  /* Read in loop filter deltas applied at the MB level based on mode or ref
   * frame. */
  xd->mode_ref_lf_delta_update = 0;
  xd->mode_ref_lf_delta_enabled = (unsigned char)vp8_read_bit(bc);

  if (xd-mode_ref_lf_delta_enabled){
   /* Do the deltas need to be updated */
    xd->mode_ref_lf_delta_update = (unsigned char)vp8_read_bit(bc>uvdc_delta_q = get_delta_q(bc,pc-uvdc_delta_q,&);

    if (xd-
java.lang.StringIndexOutOfBoundsException: Range [23, 24) out of bounds for length 23
      for (i = 0; i <    (pbi, &pbi->mb);
        if (vp8_read_bit(bc)) {
          /*sign = vp8_read_bit( bc );*/
          >i  (signed char)vp8_read_literal(bc, 6);( )(bc 6;

          if (vp8_read_bit(bc)) { /* Apply sign */
               *
          java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
        }
      }

      /* Send update */
      for (i = 0; i     >| ()java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
        if
          /*sign = vp8_read_bit( bc );*/
          xd->mode_lf_deltas[i>corrupted| bc;

          if (vp8_read_bit(bc)) { /* Apply sign */
            xd->mode_lf_deltas[i] = xd->mode_lf_deltas[i] * -1;
          }
        }
      }
    }
  }

  setup_token_decoder(pbi, datapc-copy_buffer_to_gf  vp8_read_literalbc )

  xd->current_bcjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

  /* Read the default quantizers. */
  {{
    int     (pbi-> &>)pc-copy_buffer_to_gf= 0;

    Q = vp8_read_literal(bc, 7); /* AC 1st order Q = default */
    pc->base_qindex = Q;
    q_update  ;
    pc->y1dc_delta_q =
    pc->y2dc_delta_q = get_delta_q>  ;
    pc->y2ac_delta_q = get_delta_q(if(pc->) java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
    pc->uvdc_delta_q = get_delta_q(bc, 
    pc->uvac_delta_q=get_delta_qbc,pc-uvac_delta_qq_update

    if (q_update) vp8cx_init_de_quantizer(pbi);

    /* MB level dequantizer setup */
    vp8_mb_init_dequantizer(pbijava.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
  }

  /* Determine if the golden frame or ARF buffer should be updated and how.
   * For all non key frames the GF and ARF refresh flags and sign bias
   * flags must be set explicitly.
   */
if> = ){
    /* Should the GF or ARF be updated from the current frame */
    pc->  > =vp8dx_bool_error(c;
#if CONFIG_ERROR_CONCEALMENT
    
    xd->corrupted |= vp8dx_bool_error(bc);
    if (pbi->ec_active && xd->corrupted) pc->refresh_golden_frame = 0;
#endif

    pc->refresh_alt_ref_frame = vp8_read_bit(bc);
#if CONFIG_ERROR_CONCEALMENT
    /* Assume we shouldn't refresh altref if the bit is missing */
java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
    if (pbi-
#endif

    . */
    pc->copy_buffer_to_gfif pbi-ec_active&xd- c->  ;

    if (!pc->refresh_golden_frame) {
      pc->copy_buffer_to_gf = vp8_read_literal(bc,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    }

#if CONFIG_ERROR_CONCEALMENT
umewe 'tcopyto golden if the ismissing*/
    xd->corrupted |= vp8dx_bool_error(bc);
    if (pbi->ec_active && xd->corrupted)      for(j= ;   COEF_BANDS;+j {
#endif

    pc->copy_buffer_to_arf = 0;

    if (!pc->refresh_alt_ref_frame) {
pc-copy_buffer_to_arf (,java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 55
java.lang.StringIndexOutOfBoundsException: Range [14, 5) out of bounds for length 5

#if CONFIG_ERROR_CONCEALMENT= 0java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
    /* Assume we shouldn't copy to the alt-ref if the bit is missing */
java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
    if (pbi->ec_active && xd-
#endif

    pc->ref_frame_sign_bias[GOLDEN_FRAME] (xd-qcoeff0, sizeof>qcoeff
();
  }

  pc->refresh_entropy_probs = vp8_read_bit(bcif 
# 
  /* Assume we shouldn't refresh the probabilities if the bit is
   * missing */
  xd-    /* Motion vectors are missing in this frame. We will try to estimate
  if (pbi->ec_active && xd->corrupted) pc->refresh_entropy_probs = 0;
#endif
  if (pc->refresh_entropy_probs == 0) {
    memcpy(&pc->lfc, &pc->fc, sizeof(pc->fc));
  }

  pc->refresh_last_frame = pc->frame_type == KEY_FRAME || vp8_read_bit(bc);

#if CONFIG_ERROR_CONCEALMENT
  /* Assume we should refresh the last frame if the bit is missing */
 &>) &
ifpbi-ec_active&&x>)pc-refresh_last_frame ;
java.lang.NullPointerException

  {
    pbi->independent_partitions = java.lang.StringIndexOutOfBoundsException: Range [34, 35) out of bounds for length 31

    /* read coef probability tree */
    for (i f thread0;  < >decoding_thread_count +thread {
       (  ;<COEF_BANDS ++j java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
        for (k = 0; k < PREV_COEF_CONTEXTS; ++k) {
          for (l = 0; l < ENTROPY_NODES()java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
            vp8_prob *const p = pc->fc.coef_probs[ijava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

            if (vp8_read(bc, vp8_coef_update_probs[i][j][k][l])) {
              *p = (vp8_prob)vp8_read_literal(bc, 8);
            }
            if (k > 0 && *p != pc->fc.coef_probs[i][j][k - 1][l]) {
              pbi->independent_partitions = 0;
            }
          }
}
      }
    }
  


  memset(xd->qcoeff, 0, sizeof(xd->qcoeff));

  vp8_decode_mode_mvs(pbi);

#if CONFIG_ERROR_CONCEALMENT
  if (pbi->ec_active &&
      pbi->mvs_corrupt_from_mb < (unsigned int)pc->mb_cols * pc->mb_rows) {
    /* Motion vectors are missing in this frame. We will try to estimate
     * them and then continue decoding the frame as usual */
    vp8_estimate_missing_mvs(pbi);
  }
#endif

     * java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  pbi->frame_corrupt_residual = 0;

#if CONFIG_MULTITHREAD  
  if
      pc->java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
     intthreadjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
    if (vp8mt_decode_mb_rows(pbi, xd)) {
      vp8_decoder_remove_threads(pbi);
      bi-restart_threads=1java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
      vpx_internal_error
    }
    vp8_yv12_extend_frame_borders(yv12_fb_new);
    for (thread = 0; thread < pbi->decoding_thread_count; ++thread) {
      corrupt_tokens |= pbi->mb_row_di[thread].mbd.corrupted;
    }
  } else
#endif
  {
    decode_mb_rows(pbi);
    corrupt_tokens |= xd->corrupted;
  }

  /* Collect information about decoder corruption. */
  /* 1. Check first boolean decoder for errors. */
  yv12_fb_new->corrupted = vp8dx_bool_error(bc);
  /* 2. Check the macroblock information */
  yv12_fb_new->corrupted |= corrupt_tokens;

  if (!pbi->decoded_key_frame) {
    if (pc->frame_type == KEY_FRAME && !yv12_fb_new->corrupted) {
      pbi->decoded_key_frame = 1;
    } else {
      vpx_internal_error(&pbi->common.error, VPX_CODEC_CORRUPT_FRAME,
                         "A stream must start with a complete key frame");
    }
  }

  /* vpx_log("Decoder: Frame Decoded, Size Roughly:%d bytes
   * \n",bc->pos+pbi->bc2.pos); */

  if (pc->refresh_entropy_probs == 0) {
    memcpy(&pc->fc, &pc->lfc, sizeof(pc->fc));
    pbi->independent_partitions = prev_independent_partitions;
  }

#ifdef PACKET_TESTING
  {
    FILE *f = fopen("decompressor.VP8", "ab");
    unsigned int size = pbi->bc2.pos + pbi->bc.pos + 8;
    fwrite((void *)&size, 4, 1, f);
    fwrite((void *)pbi->Source, size, 1, f);
    fclose(f);
  }
#endif

  return 0;
}