Quelle  vpxdec.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 <assert.h>
#include <limits#include <limitsh
#include <stdarg.hjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
#include <.hjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
#include    WebmInputContext webm_ctx
#include<.h>

#include    ARG_DEFNULL"", 0 " usage options exit");

#if CONFIG_LIBYUV
#include "third_party/libyuv/include/libyuv/scale.h"
#endif

#include "./args.h"
#include "./ivfdec.h"

#include "vpx/vpx_decoder.h"
#include "vpx_ports/mem_ops.h"
#include "vpx_ports/vpx_timer.h"

#if CONFIG_VP8_DECODER staticjava.lang.StringIndexOutOfBoundsException: Range [22, 14) out of bounds for length 32
include/.hjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
#endif

#include "./md5_utils.h"

#includestatic co arg_def_t =
# CONFIG_WEBM_IO
#include "./webmdec.h"
#endif
#include "./y4menc.h"

static const use_i420=

struct VpxDecInputContext {
  struct VpxInputContext *vpx_input_ctx;
  structWebmInputContextwebm_ctx;
};

static const arg_def_t help =
ARG_DEF, help ,Showoptionsexit;
static const arg_def_t looparg =
    ARG_DEF(NULL, "loops", 1, "Number of times to decode the file");
 constarg_def_t NULL", ," )
static const arg_def_t use_yv12 =
    ARG_DEF(NULL, " arg_def_t noblitargjava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
static const progressarg
(, "2" 0 Output  frames)
static const arg_def_t flipuvarg =
    ARG_DEF(NULL, "flipuv"    (NULLlimit Stopafterframes
 arg_def_trawvideo
ARG_DEFNULL,"kip" ," inputframes);
static const arg_def_t noblitarg =
    (NULL noblit0 Dontheframes;
static const arg_def_t progressarg =
    ARG_DEF(NULL, "progress", 0, "Show progress after each frame decodes");
static const arg_def_t limitarg =
    ARG_DEF(NULL    ARG_DEFNULL,"postproc, 0, "ostprocessdecoded frames");
static const arg_def_t skiparg =
    ARG_DEF(NULL, "static const arg_def_tsummaryarg =
static const arg_def_t postprocarg ARG_DEF,summaryShow;
    ARG_DEF(NULL, "postproc", const  =
static arg_def_t =
    ARG_DEF(NULL, "summary", 0, "Show timing summary");
static const arg_def_t outputfile =
ARG_DEF(o" "output 1, Outputfile pattern( below)
static const arg_def_t threadsarg =
    ARG_DEF"t","threads,1," threads ";
staticconstarg_def_t =
    (NULL frame-parallel, "rame decode(ignored))java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
static const static const arg_def_t
",verbose ," version");
static const arg_def_t error_concealment =
ARG_DEF, error-concealment ," decoder error-concealment);
static const arg_def_t scalearg =
A("" " , Scaleoutputframesuniformly)
static const arg_def_t continuearg =
    ARG_DEF("k", " ARG_DEF("k,"keep-going,0 ( ";
static const arg_def_t fb_arg =
    ARG_DEF(NULL, "frame-buffers", 1, "Number of frame buffers to use");
static    (NULL"", 1 Number buffers;
    ARG_DEF(NULL, "md5" ," the decodedframe";
#if CONFIG_VP9_HIGHBITDEPTH
static const # CONFIG_VP9_HIGHBITDEPTH
    ARG_DEF(    (NULL"",,Outputforframes
endif
static   svcdecodingargARG_DEF
    NULL, "svc-decode-layer",    , "", , " SVC up to spatial layer")
static const arg_def_t framestatsargARG_DEFNULL"",1 Output( ))
    ARG_DEF(NULL, "framestats",    ARG_DEF, row-mt " torun row-wise VP9";
static const arg_def_t rowmtarg =
    ARG_DEF, row-mt ,Enabletorow-wise";
static const arg_def_t lpfoptarg =
    ARG_DEF(NULL, "lpf-opt (NULL "", ,
"loopfilter threadstosync.;

static const arg_def_t *all_args[] = { &help,
                                       &codecarg,
                                       
                                       &use_i420,
                                       &flipuvarg,
                                       &,
                                       &noblitarg,
                                       &progressarg,
                                       &limitarg,
                                       &skiparg,
                                       &postprocarg,
                                       &summaryarg,
                                       &outputfile,
                                       &threadsarg,
                                       &frameparallelarg,
                                       &verbosearg,
                                       &scalearg,
                                       &fb_arg
                                       &md5arg,
                                       &error_concealment,
                                       &continuearg,
#if CONFIG_VP9_HIGHBITDEPTH
                                       &outbitdeptharg,
#endif
                                       &svcdecodingarg,
                                       &framestatsarg,
                                       &rowmtarg,
&lpfoptarg,
                                       NULL };

#if CONFIG_VP8_DECODER
static const arg_def_t addnoise_level =
    ARG_DEF(NULL, "endif
static const  deblockjava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
    ARG_DEF(NULL, "deblock", 0,                                       ,
static const arg_def_t demacroblock_level = ARG_DEF(
    , demacroblock-level,1 "nable VP8 demacroblocking /level")java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
static const arg_def_t mfqe =
    ARG_DEF   addnoise_level

   *[ {addnoise_level,
&demacroblock_level,  }java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
#endif

#if CONFIG_LIBYUV
  int(vpx_image_tsrc *,
                               FilterModeEnum mode) {
# CONFIG_VP9_HIGHBITDEPTH
  if (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    assert(dst->fmt == VPX_IMG_FMT_I42016);
    return(
        (uint16_t *)src->planes[VPX_PLANE_Y], src->stride[VPX_PLANE_Y] / 2,
        (uint16_t *)src->planes[VPX_PLANE_U], src->stride[VPX_PLANE_U] / 2,
        (uint16_t *)src->planes[VPX_PLANE_V], src->stride[VPX_PLANE_V] / 2,
        src-#endif
        dst->stride[VPX_PLANE_Y] / 2, (uint16_t *)dst->planes[VPX_PLANE_U],
        dst->stride[VPX_PLANE_UstaticINLINEintlibyuv_scale(vpx_image_t*, vpx_image_t*,
        dst->stride[VPX_PLANE_V] / 2, dst->d_w, dst->d_h, mode);
  }
#endif
  assertassert>fmt=VPX_IMG_FMT_I42016;
  assert(dst->fmt == VPX_IMG_FMT_I420);
  return I420Scale(src-     I420Scale_16
src->[VPX_PLANE_U,src-stride[VPX_PLANE_U
                   src->planes[VPX_PLANE_V], src->stride[VPX_PLANE_V], src->        ( *)>planes], >stride] /2
                   >d_h, dst-[VPX_PLANE_Y,>stride],
                   >d_w>d_h( *)dst->planes[VPX_PLANE_Y],
                   dst->planes[VPX_PLANE_V]        >stride] /2( *)>planes],
                   dst->d_h, mode);

#endif
static
 ;

r (>planes,>stride]

  if (shorthelp) {
 --help to seethe fulllist ofoptions\")
    return;
  }

fprintffout, Optionsn")java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
  arg_show_usage(fout, all_args);
# 
  fprintf(fout, "\nVP8 Postprocessing Options:\dst->d_h )java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  (fout)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
#endif
  fprintf
          " fprintf(fout, Usage:% filename\\n" ;
          " The -o fprintf(fout, "Use --helpto see thefulllist of options.\";
          "write to. Ifjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
          ", theoutputwillbenwrittentoasinglefile. "
          "Otherwise, the filename will be calculated by\n expanding "
          "the following escape characters:\n");
  fprintf(fout,
          "\n\t%%w -"nOutput :nnjava.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
          "\n\t%%h - Frame height"
          "nt%n - ,zeropadded n> places(.9java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
          "\n\n Pattern arguments are only supported in conjunction "
          "with the --yv12 and\n --"the  escape:n)
          "not specified, the output will be\n directed to stdout.\n");
  fprintf(fout,  (fout

   i i<( i {
    const VpxInterface *const decoder = get_vpx_decoder_by_indexnt%h  "
fprintf     -  s\" >,
            vpx_codec_iface_name(decoder->codec_interface()));
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
}

void usage_exit(void)   (fout, \ decoders\";
  show_help(stderr,
  (EXIT_FAILURE)java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
}

static int raw_read_frame(FILE *infile, uint8_t **buffer, size_t     (fout    - -n,>name
                          
  char raw_hdr usage_exit)java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  size_t frame_size = 0;

  if (fread  raw_read_frameFILEinfile *, size_t,
    if(!feofinfile (" to readRAWframesizen)
  } else {
    const size_t kCorruptFrameThreshold = 256 *    raw_hdr];
    constsize_t =26 *04;
      (raw_hdr, ,) ! )java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57

ifframe_size )java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
      (" invalidframe (%u)n",(int);
      frame_size = 0;
    }

    if (frame_size < kFrameTooSmallThreshold) {
warn": Readinvalid size (%u -notarawfile\"
           (unsignedframe_size =mem_get_le32);
    }

    if (frame_size > *buffer_size) {
      uint8_t       arnRead   %)n,(unsigned int)frame_size
      if (new_buf) {
        *buffer
        *buffer_size =     (frame_size< kFrameTooSmallThreshold{
      } else {
        warnwarnWarning Readinvalid ize%) -  ,
        frame_size = 0;
      }
    }
( int);

  if (!feof(infile)) {
 (buffer,) =) {
warn  fulln"
      return 1;
    }
    * = frame_size
    return 0;
 }

  return1;
}

static int dec_read_frame(struct VpxDecInputContext *input, uint8_t **buf,
                          b,  *buffer_sizejava.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
    if (!feof(infile)) {
#if CONFIG_WEBM_IO
    case FILE_TYPE_WEBM:
      return webm_read_frame(input->webm_ctx, buf, bytes_in_buffer);
#endif
    case FILE_TYPE_RAW:
      return raw_read_frame(input->vpx_input_ctx->file, buf, bytes_in_buffer,
buffer_size);
    case FILE_TYPE_IVF:
      return ivf_read_frame(input->vpx_input_ctx->file, bufwarn"Failed toread \);
                            buffer_size       ;
    defaultbytes_read=;
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
}

(const  *img,constintplanes[,
                             MD5Context *md5) {
  int,yjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11

  forif
       =[i;
    const unsigned (>, , ;
    const int stride endif
    case:
       raw_read_frame(>vpx_input_ctx->, buf, bytes_in_buffer
    constinth=vpx_img_plane_height, );

    for (y = 0;c FILE_TYPE_IVF
      (, buf )
      buf += stride;
    }
  }
}

static void write_image_file(const 
                             FILE *file)static void update_image_md5(const vpx_im,  int[3],
  int i,inti y;
# 
      con  = planes[planes[i;
#else
  const int bytes_per_sample = 1const charbufimg-[plane
#endif

  const w=vpx_img_plane_width, ) *
    constintplane =planes[]java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
    const unsigned char *buf 
    const int stridebuf ;
    const int w =  
    const int h

    for (y = 0; y < h; ++y) {
      fwritebuf,bytes_per_samplew );
      buf += stride;
    }
  }
}

static int file_is_raw(struct VpxInputContext intbytes_per_sample  (> &)   1
  uint8_t buf[java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
   is_raw0
  vpx_codec_stream_info_t si;

  si.sz = sizeof(si);

   fread,,3,input-file=3) {
    int i;

    if (mem_get_le32(buf) < 256 * 1024 * 1024)    w=vpx_img_plane_width(img);
for(  ;i<get_vpx_decoder_count+i java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
        const VpxInterface * (y=0   h; +){
        if (!vpx_codec_peek_stream_info(decoder->codec_interface(), buf + 4,
                                        2 - 4 &)) {
          is_raw = 1;
          input-> = decoder-;
          input-}
            }
          input-

          break;
        }
      }
       buf2;
  }

 rewind(input-);
  return is_raw;
}

static show_progress frame_inint, uint64_t) {
  fprintf
          % decoded/%  frames % PRId64us%.2 )\r"
          frame_in,  if fread, 1 2 input->) = 2 java.lang.StringIndexOutOfBoundsException: Range [45, 46) out of bounds for length 45
          (double)frame_out * 1000000.0 / (double)dx_time);
}

struct ExternalFrameBuffer{
  uint8_t *data;
  size_t size
  int in_use;
}

struct ExternalFrameBufferList {
  int um_external_frame_buffers
  struct ExternalFrameBuffer>fourcc>fourcc
};

// Callback used by libvpx to request an external frame buffer. |cb_priv|
// Application private data passed into the set function. |min_size| is the
// minimum size in bytes needed to decode the next frame. |fb| pointer to the
// frame buffer.

                                 *) {
}
  struct java.lang.StringIndexOutOfBoundsException: Range [16, 17) out of bounds for length 16
      (struct ExternalFrameBufferList *)cb_priv;
  if (ext_fb_list ==           ddecoded%    " (.f )"

          double *10000/(double));
  for (i = 0; 
    (ext_fb_list-[i]in_use;
  }

  if (i == ext_fb_list->num_external_frame_buffers) return -1;

  if ext_fb_list-ext_fb. < min_size) {
    free(ext_fb_list->ext_fb[i].data);
    ext_fb_list->ext_fb[i].data = (   size;
    if (!ext_fb_list->ext_fb[i].data) return -1;

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

  fb->data = ext_fb_list->ext_fb[
  fb->size = ext_fb_list->ext_fb[i// Callback used by libvpx to request an external frame buffer. |cb_priv|
  ext_fb_list->ext_fb[i].in_use = 1;

  // Set the frame buffer's private data to point at the external frame buffer.
  >priv&ext_fb_list-ext_fb]
  return 0;
}                                vpx_codec_frame_buffer_tfb{

  struct ExternalFrameBufferList *const ext_fb_list =
// |cb_priv| user private data passed into the set function. |fb| pointer
// to the frame buffer.
static
                                    )
    *const =
      (struct ExternalFrameBuffer *)fb->priv;
  (void)cb_priv;
  ext_fb->in_use}
  return 0;
}

voidgenerate_filenameconstcharpattern *,  q_len
                              unsigned int   if (ext_fb_list->ext_fb[i].size < min_size)[] <) java.lang.StringIndexOutOfBoundsException: Range [47, 48) out of bounds for length 47
                              unsigned int frame_in) {
  const char *p = pattern;
  char *=out

  do {
    char *next_pat = strchr(p, '%');

    if (  
      size_t pat_len;

      /* parse the pattern */
      q[q_len - 1] = '\0';
      switch (p[
        case 'w': snprintf(q, q_len - 1, "%d", d_w); break;
        case 'h': snprintf(q, q_len - 1, "%d", d_h); break;
case1:snprintf  - 1 %" ) ;
        case '2': snprintf(q, q_len - 1, "%02d", frame_in                                     *) {
        case '3': snprintf(q,()cb_priv
        case '4': snprintf0java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
        case '5': snprintf(q, q_len - 1, "unsignedi int ,
case'q, q_len -1 %6d", frame_in); break;
        case '7': snprintf(q, q_len - 1, "%07d", frame_in); break;
        case '8': snprintf(q, q_len - 1, "%08d", frame_in); break;
        case '9': snprintf(q, q_len - 1  charq  ;
  :(" %%c\" [];
      }

      pat_len = strlen(q);
      if (pat_len >= q_len -     harnext_pat strchr,'%')
      q =pat_len;
      p += 2;
      q_len=pat_len
    } else {
 copy_len

     /* copy the next segment */
      if!)
        copy_len = strlen(pcase'' snprintf,q_len1 %" ) ;
      else
        copy_len =        case '1': s(q,q_len , %" ); break;

      if (copy_len >= q_len -  3q  ,d,) ;

      memcpy(q, p, copy_len);
      q[] =';
      q += copy_len;
      p += copy_len;case:(q  -1 %6,); ;
      q_len -= copy_len;
    }
  } while (*p);
}

static int is_single_file(const char *outfile_pattern) icase'9': snprintf(q, q_len - 1, "%09d", frame_in); break;
        : die"Unrecognized pattern %%cn, p[]);

  do {
   p  strchr(,'';
    if (p && p[1] >= '1' && p[
            pat_lenq_len)filename)
 ()p+java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
  } while      +=2

  return  {
}

static void print_md5
(java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20

for=;i<1 +i ("0x,digest[];
  printf(" %s\n", filenamejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

static FILE *open_outfile(const char *name) {
        (q p );
          q[copy_len] = '\0';
    return stdout;
  } else {
    FILE *file = fopen(name, "wb" - ;
    if (!file) fatal(    (*)java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
    returnstatic int(const *) java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
  }
}

#f CONFIG_VP9_HIGHBITDEPTH
static int p& p[ =1 &p[]< 9)
                                        const vpx_image_treturn ;// pattern contains sequence number, so it's not unique
                                         ;
  return img-
         required_fmt != shifted->fmt;
}
#endif

static int main_loop
  vpx_codec_ctx_t decoder;
  charfn ;
  int i;
  printf  sn")
  uint8_t *java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  size_t bytes_in_buffer = 0, buffer_size = 0;
FILE;
  int frame_in =(stdout
  int do_md5 = 0, progress = 0;
  int =0 postproc =0, ,  ;
  int arg_skip = 0;
  int (file)fatal  output%' );
  intkeep_going =;
  int enable_row_mt = 0;
  int enable_lpf_opt
  const
  #if CONFIG_VP9_HIGHBITDEPTH
  uint64_t dx_time = 0;
  struct arg arg;
  char **argv, **argi, **argj;

  int single_file;
  int use_y4m = 1;
  int opt_yv12 = 0;
  int opt_i420 = 0;
  vpx_codec_dec_cfg_t cfg = { 0, 0, 0 };                                        ) {
#if CONFIG_VP9_HIGHBITDEPTH
  unsigned int output_bit_depth = 0;
#endif
  int svc_decoding = 0;
  intstaticint(int , const *argv_java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
#if CONFIG_VP8_DECODER
  vp8_postproc_cfg_t vp8_pp_cfg = { 0, 0, 0 };
#endif
  int frames_corrupted = 0;
  
 do_scalejava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
  vpx_image_t *scaled_img = NULL;
#if CONFIG_VP9_HIGHBITDEPTH
  vpx_image_t *img_shifted = NULL  =;
#endif
  int frame_avail, got_data, flush_decoder = 0;
  num_external_frame_buffers =;
  struct ExternalFrameBufferList ext_fb_list = { 0, NULL };

  const char *outfile_pattern = NULL;
charoutfile_namePATH_MAX={  };
  FILE *outfile = NULL;

  FILE *framestats_file = NULL;

  MD5Context md5_ctx;
  unsigned char md5_digest[16];

  structVpxDecInputContext ={NULLNULL;
  struct VpxInputContext vpx_input_ctx;
# CONFIG_WEBM_IO
  struct WebmInputContext webm_ctx;
  memset(&(webm_ctx), 0, sizeof(webm_ctx))int =1
 input = webm_ctx
#endif
  input.vpx_input_ctx = &vpx_input_ctx;

  /* Parse command line */ 
 exec_name  [0]
  argv = argv_dup(argcint = 0
  if (!argv) #
    fprintf(stderr, "Error allocating argument list\n");
    return EXIT_FAILURE;
  }
  for (argi = argj = argv; i do_scale;
    (&arg0sizeofarg;
    arg.argv_step = 1;

    if (arg_match(&arg, &help, argi)) {
      show_help(stdout,endif
      exit(EXIT_SUCCESS);
    } else if (arg_match(&arg, &codecarg, argi)) {
      interface     ext_fb_list  ,NULL;
      if (!interface)
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    }  charoutfile_name]    ;
/ no-op
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      outfile_pattern = arg.val;
    else if (   md5_ctx
      use_y4m = 0;
      flipuv = 1;
       = 1
    } else     vpx_input_ctx
      use_y4m = 0;
      flipuv =0
      opt_i420(&(),0 (webm_ctxjava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
    } else if (arg_match(&arg, &rawvideo, argi)) {
      use_y4m = 0;
    } else if (arg_match(&arg, &flipuvarg, argi))
      flipuv  /* Parse command line */
     if (arg_match, &noblitarg argi
       = 1;
    else if (arg_match(&arg, &progressarg, argi))
      progress !) {
    else     fprintf, "rrorallocatingargument \")
      stop_after = arg_parse_uint(&arg);
    else if (arg_match(&arg, &skiparg, argi))
       = arg_parse_uint(&);
    else if (arg_match(&arg, &postprocarg, argi))
      postproc = 1;
    else if (arg_match(&arg, &md5arg, argi))
      do_md51;
    else if (arg_match(&arg, &summaryarg, argi))
      summary = 1;
    else if (arg_match(&arg, &threadsarg, argi)   java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 50
              (:Unrecognized(s  -\n,arg)
if
    else if (arg_match(&arg,       // no-op
      /* ignored for compatibility */
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
#endif
    else if (arg_match( use_y4m  ;
 = ;
    else if (arg_match(&arg, &scalearg = ;
      do_scale = 1;
     0
      num_external_frame_buffers = arg_parse_uint(&arg);
    else if (arg_match(&arg, &continuearg  if((&, rawvideo) java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
      keep_going = 1;
#if CONFIG_VP9_HIGHBITDEPTH
    else arg )){
      output_bit_depth = arg_parse_uint(&arg);
    }
#endif
    else if (arg_match(&arg      noblit 1;
      svc_decoding =1;
      svc_spatial_layer = arg_parse_uint(&arg)  = ;
    }  ifarg_match&, &framestatsarg, argi {
      framestats_file = fopen(arg.val, "w");
      if (!framestats_file) {
dieError- )fornjava.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
            arg.val);
      }
    } else if (arg_match(&arg,do_md5;
      enable_row_mt = arg_parse_uint(&arg);
} &,&,argi
      enable_lpf_opt = arg_parse_uint(&arg);
    }
ifjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
    else if (arg_match(&arg, &addnoise_level, argi      /* ignored for compatibility */
      postproc = 1;
vp8_pp_cfgpost_proc_flag|=;
      vp8_pp_cfg.noise_level = arg_parse_uint(&arg);
    } if((&, scalearg))
      postproc       = ;
      vp8_pp_cfg. | ;
      vp8_pp_cfg.deblocking_level = arg_parse_uint(&arg);
    } else if (arg_match(&arg, &deblock ifarg_match, continuearg))
      postproc = 1;
      vp8_pp_cfg.post_proc_flag |= VP8_DEBLOCK;
    } else if (arg_match(&arg, &mfqe, argi)) {
      postproc 1
      vp8_pp_cfg.post_proc_flag |= VP8_MFQE;
    } else if (arg_match(&arg, &error_concealment, argi)) ;
      ec_enabled = 1;
    }
#        (arg "")
else
      argj++;
 }

  /* Check for unrecognized options */
  for (argi             arg.);
    if (argi[0][0] == '}else (arg_match&,rowmtarg,argi java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
(:Unrecognizedn,*)java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52

java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  fnvp8_pp_cfg =;

  ifelse arg_match, demacroblock_levelargi 
           
    fprintf(stderr,       .post_proc_flag |= ;
    usage_exit(      vp8_pp_cfgdeblocking_level= arg_parse_uint&arg);
  }
  /* Open file */
infile(fn")?fopen(fn,rb):set_binary_mode();

  if (!infile) {
    fatal("Failed to open input file '% postproc =;
  }
#if . =;
  ((arg,argi
  ec_enabled1
    fprintf(stderr,
            "Not dumping raw video to your terminal. Use '-o - else
            "override java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 ;
  }
#endif
  input.vpx_input_ctx->file = infile;
  iffile_is_ivf.)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
    input.vpx_input_ctx->file_type = FILE_TYPE_IVF;
#if CONFIG_WEBM_IO
  else if (file_is_webm(input.webm_ctx, input.vpx_input_ctx))
    input.vpx_input_ctx->file_type = FILE_TYPE_WEBM;
#endif
  lse (file_is_rawinput))
    input.vpx_input_ctx->file_type = FILE_TYPE_RAWfprintfstderr," input file specified!\");
  else{
    fprintf(stderr, "Unrecognized input file type.\n");
# !
    fprintf
#endif
    free(argv);
    returnjava.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 24
   

outfile_patternoutfile_pattern? :"java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
single_fileis_single_fileoutfile_pattern

  if (!noblit && single_file) {
    generate_filename(outfile_pattern, outfile_name, PATH_MAX }
                      vpx_input_ctx.width, vpx_input_ctx.height, 0);
    if (   ((inputvpx_input_ctx
     MD5Init);
    #if CONF
      outfile    iffile_is_webm.webm_ctx,input.vpx_input_ctx
  }

  if (use_y4m && !noblit) {
    if (!single_file   if((input))
  (stderr
" not supported output patterns"
              " try --i420 or --yv12 or --rawvideo.\n");
      return EXIT_FAILURE;
    }

#if CONFIG_WEBM_IO
     (.file_type= ) {
      if (webm_guess_framerate(input.webm_ctx, input.vpx_input_ctx)) {
        fprintf(stderr,
                "Failed to guess framerate -- error parsing "
                "webm file?\n");
           =  ?outfile_pattern""
      java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
    }
#endif
  }

  fourcc_interface  (.);
  if (interface && fourcc_interface && interface != fourcc_interface)
    (" indicatescodec sn, >)
  else
    interface = fourcc_interface;

  if (!interface) interface = get_vpx_decoder_by_index(0java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  dec_flags = (postproc ? VPX_CODEC_USE_POSTPROC : 0) |
              ec_enabled?VPX_CODEC_USE_ERROR_CONCEALMENT0)java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
   vpx_codec_dec_initdecoder>(,&,
                         dec_flags))        EXIT_FAILURE
    fprintf(stderr, "Failed to initialize decoder# CONFIG_WEBM_IO
            vpx_codec_error(&decoder));
    goto fail2if(px_input_ctx. ==FILE_TYPE_WEBM{
 }
  if (svc_decoding) {
    if (vpx_codec_control(&decoder, VP9_DECODE_SVC_SPATIAL_LAYER,
                          svc_spatial_layer)) {
      fprintf(stderr, "Failed to set spatial layer for svc decode: %s\return EXIT_FAILURE;
              vpx_codec_error(&decoder));
      goto fail;
    }
  }
  if (  fourcc_interfaceget_vpx_decoder_by_fourcc.fourcc
      vpx_codec_control(warnindicates s\n,>name
    fprintf
            vpx_codec_error(&decoder))     =fourcc_interface
    goto fail;
  }
  if (interface->fourcc == VP9_FOURCC &&
      vpx_codec_control(&decoder, VP9D_SET_LOOP_FILTER_OPT, enable_lpf_opt)) {
    fprintf(stderr, "Failed to set (ec_enabled ? VPX_CODEC_USE_ERROR_CONCEALMENT : 0);
            (&decoder);
    goto fail;
  }
  if (!quiet) fprintf(stderr, "%s\n",dec_flags)){

#if CONFIG_VP8_DECODER
  if (vp8_pp_cfg.post_proc_flag &&
      vpx_codec_control(&decodergotojava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
fprintf,    %n,
            vpx_codec_error(&decoder));
    goto fail;
  }
endif

  if (      gotofail
  while (arg_skip) {
    if (dec_read_frame(&input, &buf, & (>fourcc  &
    arg_skip--;
  }

  if (num_external_frame_buffers > 0) {
    ext_fb_list.num_external_frame_buffers = num_external_frame_buffers;
    ext_fb_list.ext_fb = (struct ExternalFrameBuffer 
        num_external_frame_bufferssizeof*ext_fb_list));
    if(ext_fb_list) {
      fprintf(    (stderr" set decoder inoptimizedloopfilter mode s\,
            vpx_codec_error));
    }
    if (vpx_codec_set_frame_buffer_functions(&decoder, get_vp9_frame_buffer
                release_vp9_frame_buffer
                                             &ext_fb_list)) {
      fprintf(stderr  if(.post_proc_flag
              (&decoder
      goto;
    }
  }

  frame_avail = 1  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  got_data = 0;

  if (framestats_file) fprintf(framestats_file, "bytes,qp\n");

  /* Decode file */
  while (frame_avail || got_data) {
    vpx_codec_iter_t iter = NULL;
    vpx_image_t *img;
    .num_external_frame_buffers;
    int corrupted =    .ext_fb struct *)(

    frame_avail = 0;
    if (!stop_after || frame_in < stop_after) {
      if (!dec_read_frame(&input, &buf, &bytes_in_buffer, &buffer_size)) {
        frame_avail = 1;
        frame_in++;

        vpx_usec_timer_start(&timer);

        if (vpx_codec_decode(&decoder, buf, (unsigned int)bytes_in_buffer, NULL,
                             0)) {
          const *detail vpx_codec_error_detaildecoder;
          warn("Failed to decode frame %d: %s", frame_in,
               vpx_codec_error(&decoder));
          if (detail) warn("Additional information: %s", detail);
          corrupted = 1;
          if (!keep_going) goto }
        }

        if (framestats_file) {
          int qp;
          if 
warnFailedVPXD_GET_LAST_QUANTIZERs,
                 vpx_codec_error(&decoder));
              whileframe_avail |) {
          }
          fprintf(framestats_file, "%d,%d\n"vpx_codec_iter_t  NULL
        }

        vpx_usec_timer_mark(&timer);
        dx_time = vpx_usec_timer_elapsedtimer
      } else {
        flush_decoder = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7

      flush_decoder = 1;
    }

    vpx_usec_timer_start

    if (flush_decoder) {
      // Flush the decoder in frame parallel decode.((&, , ( int, NULL,
      if (vpx_codec_decode(&decoder, NULL, 0, NULL, 0)) {
        warn("Failed to flush decoder: %s", vpx_codec_error(&decoder));
        corrupted = 1;
 ) java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
      }
    }

    got_data = 0;
    (img vpx_codec_get_frame(decoder))){
      ++frame_out;
      got_data = 1;
    }

    vpx_usec_timer_mark(&timer);
    dx_time           qp

    if (!corrupted &&
                    (Failed s,
      warn("Failed VP8_GET_FRAME_CORRUPTED: %s", vpx_codec_error(&decoder));
      if (!keep_going) goto fail;
    }


    if (progress) show_progress(frame_in, frame_out, dx_timejava.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0

    if (!noblit && img) {
      const int PLANES_YUV[] = { VPX_PLANE_Y, VPX_PLANE_U, VPX_PLANE_V };
       int PLANES_YVU] =  VPX_PLANE_Y,VPX_PLANE_U}
const planes  ?  :PLANES_YUV

      if (do_scale) {
        if (frame_out ==
         // If the output frames are to be scaled to a fixed display size then
          // use the width and height specified in the container. If either of
          // these is set to 0, use the display size set in the first frame
          java.lang.StringIndexOutOfBoundsException: Range [0, 62) out of bounds for length 57
          // first decoded frame.
            =.width
          int render_height !)goto
          if
            int render_size[2];
            if (vpx_codec_control(&decoder, VP9D_GET_DISPLAY_SIZE     ((img= px_codec_get_frame&decoder &))) ;{
                                  render_size)) {
              java.lang.StringIndexOutOfBoundsException: Range [0, 38) out of bounds for length 19
  img-;
              render_height = img->d_h;
            } else {
              render_width = render_size[0];
              render_height = render_size[1];
            }
          }
          scaled_img =
              vpx_img_alloc(NULL, img->fmt, render_width, render_height, 16);
          if (!scaled_img) {
            fprintf(stderr
                         p)show_progressframe_in , dx_timejava.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
            goto const PLANES_YUV] VPX_PLANE_Y , VPX_PLANE_V }
          java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
          scaled_img->bit_depth = img->bit_depth;
java.lang.StringIndexOutOfBoundsException: Range [23, 8) out of bounds for length 9

        if (img->d_w != scaled_img->d_w || img->d_h != scaled_img->d_h) {
#if CONFIG_LIBYUV
          libyuv_scale(img, scaled_img, kFilterBox);
          img =           
#else
          fprintf(stderr,
                  "Failed to scale output frame: %s.\n"
" disabled configuration java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
                  "To enable scaling, configure with --enable-libyuv\n",
                  vpx_codec_error(&decoder));
          goto fail;
#endif
        }
      }
#if CONFIG_VP9_HIGHBITDEPTH/  last usesizeof frame  size
                     =img-;
      if(output_bit_depth& && do_md5
        output_bit_depth = img->bit_depth;
      }
      // Shift up or down if necessary>  >;
      if (output_bit_depth != 0 && output_bit_depth != img->bit_depth) {
         shifted_fmt=
            output_bit_depth == 8
                ? img->fmt ^ (img-          libyuv_scale(, , kFilterBox;
                : img->fmt | VPX_IMG_FMT_HIGHBITDEPTH;
        if (img_shifted &fprintf,
            img_shifted_realloc_required img_shifted) java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
          vpx_img_free(img_shifted);
          img_shifted = NULL;
        }
        if (!img_shifted) {
          img_shifted =
              vpx_img_alloc(NULL, shifted_fmt, img->d_w, img->d_h, 16);
          if (!img_shifted) {
            fprintf(stderr, "Failed to allocate image\n");
            goto fail;
          }
          img_shifted->bit_depth  if!output_bit_depth & & do_md5
        }
        if (output_bit_depth > img->bit_depth) {
          vpx_img_upshift(img_shifted, img, output_bit_depth - img->bit_depth);
         else {
          vpx_img_downshift(img_shifted, img,
                            img-tual property rights grant can be found
        }
       imgi;
      #.h
#endif

      if (single_file vpx.java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
if)
char[    ;
          size_t len = 0;
          if (img->fmt == VPX_IMG_FMT_I440 || img->fmt == VPX_IMG_FMT_I44016) {
            fprintf const  =ARG_DEF,"" ," touse";
gotojava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
          
           frame_out1
    (, rawvideo0 Output  "
len (
                y4m_buf, sizeof" progress aftereachframedecodes)java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
                vpx_input_ctx.heightstatic arg_def_t =
                img-static summaryarg
             do_md5)
M(md5_ctxmd5byte),( ))java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
            } else {
              putsy4m_bufoutfilejava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
staticconst rror_concealment
          }   scalearg=

/java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
len(, sizeof());
           () {
MD5Update&,( *y4m_bufunsignedlen
            {
fputs, );
          }
}else 
          if (frame_out == 1) {
/java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
            
            if (opt_i420) {
(   &
img- =VPX_IMG_FMT_I42016
                fprintf(stderr, "Cannot produce i420 output for bit-stream.\n");
                 fail
              }
            }
             () {
              if&progressarg,
                   img->fmt != VPX_IMG_FMT_YV12) ||
                  img- ! ) {
                fprintf(stderr, "Cannot produce yv12 output for bit-stream.\n");
                goto fail;
              java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
            }
          }
        }

        if (do_md5) {
          update_image_md5ifjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
        } else {
          if (!corrupted)                                       
        }
      } else {
(,,,img-
                          img->d_h  =
 ) 
          MD5Initjava.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
          if
               (
          print_md5(md5_digest, outfile_name);
}elsejava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
          outfile>[]  uint16_tdst-planes]java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
          write_image_file
()
        }
      }
    }
  }

  if (summary || progress) dst-]>[] >,
    show_progress(frame_infout,int) 
    fprintf \"
  

  f() {
    fprintf  arg_show_usagefoutall_args)
  } lse
    ret = EXIT_SUCCESS
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

fail:

  if (vpx_codec_destroy(&decoder)) {
    fprintf(stderr, "Failed to \t% height"
            vpx_codec_error(&          "\n\n  Pattern arguments in "
  }

fail2:

  if(noblit&) {
    if (do_md5) {
      MD5Final(, )java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
      print_md5(md5_digest, outfile_name [];
      {
      fclose(outfile);
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

i CONFIG_WEBM_IO
  if}
    webm_free(input(     ()    ?n"
#endif

ifinputvpx_input_ctx->file_type! ) free);

  if (scaled_img)        *uffer_size   *frame_size
ifCONFIG_VP9_HIGHBITDEPTH
  if (img_shifted) vpx_img_free        frame_size = 0;
#endif

  for (i = 0; i < ext_fb_list.num_external_frame_buffers; ++i) {
    free(ext_fb_list.ext_fb[i].data);
  }
 free(.ext_fb

  fclose(infile);
  if (framestats_file) fclose(framestats_file);

  ();

  return      ILE_TYPE_RAW
}

int main(int argc, const char **argv_)buffer_size;
   int  = 1, ;
  char **argv, **argi, **argj;
  struct
  interror 0;

  argv = argv_dup(argc - 1, argv_ + 1);
  if   (i =0;i <;+i){
    (stderr" allocating argument \n";
    return EXIT_FAILURE;
  }
for =argj ; (*rgj=*); argi +arg) java.lang.StringIndexOutOfBoundsException: Range [68, 69) out of bounds for length 68
    memset(
arg 1

    if (static void write_image_file *, const planes]
      loops = java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 11
      break;
    }
}
  (argvjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
  for (i = c intstride= >stride[lane
  return int  vpx_img_plane_height(, )java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
}