libvpx: Pull from upstream

source/libvpx/vpxdec.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.
  */
 
@@ skipping 151 matching lines @@
                    src->planes[VPX_PLANE_V], src->stride[VPX_PLANE_V],
                    src->d_w, src->d_h,
                    dst->planes[VPX_PLANE_Y], dst->stride[VPX_PLANE_Y],
                    dst->planes[VPX_PLANE_U], dst->stride[VPX_PLANE_U],
                    dst->planes[VPX_PLANE_V], dst->stride[VPX_PLANE_V],
                    dst->d_w, dst->d_h,
                    mode);
 }
 #endif
 
-void usage_exit() {
+void usage_exit(void) {
   int i;
 
   fprintf(stderr, "Usage: %s <options> filename\n\n"
           "Options:\n", exec_name);
   arg_show_usage(stderr, all_args);
 #if CONFIG_VP8_DECODER
   fprintf(stderr, "\nVP8 Postprocessing Options:\n");
   arg_show_usage(stderr, vp8_pp_args);
 #endif
   fprintf(stderr,
@@ skipping 122 matching lines @@
     const int w = vpx_img_plane_width(img, plane);
     const int h = vpx_img_plane_height(img, plane);
 
     for (y = 0; y < h; ++y) {
       fwrite(buf, bytes_per_sample, w, file);
       buf += stride;
     }
   }
 }
 
-int file_is_raw(struct VpxInputContext *input) {
+static int file_is_raw(struct VpxInputContext *input) {
   uint8_t buf[32];
   int is_raw = 0;
   vpx_codec_stream_info_t si;
 
   si.sz = sizeof(si);
 
   if (fread(buf, 1, 32, input->file) == 32) {
     int i;
 
     if (mem_get_le32(buf) < 256 * 1024 * 1024) {
@@ skipping 10 matching lines @@
           break;
         }
       }
     }
   }
 
   rewind(input->file);
   return is_raw;
 }
 
-void show_progress(int frame_in, int frame_out, uint64_t dx_time) {
+static void show_progress(int frame_in, int frame_out, uint64_t dx_time) {
   fprintf(stderr,
           "%d decoded frames/%d showed frames in %"PRId64" us (%.2f fps)\r",
           frame_in, frame_out, dx_time,
           (double)frame_out * 1000000.0 / (double)dx_time);
 }
 
 struct ExternalFrameBuffer {
   uint8_t* data;
   size_t size;
   int in_use;
 };
 
 struct ExternalFrameBufferList {
   int num_external_frame_buffers;
   struct ExternalFrameBuffer *ext_fb;
 };
 
 // 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.
-int get_vp9_frame_buffer(void *cb_priv, size_t min_size,
-                         vpx_codec_frame_buffer_t *fb) {
+static int get_vp9_frame_buffer(void *cb_priv, size_t min_size,
+                                vpx_codec_frame_buffer_t *fb) {
   int i;
   struct ExternalFrameBufferList *const ext_fb_list =
       (struct ExternalFrameBufferList *)cb_priv;
   if (ext_fb_list == NULL)
     return -1;
 
   // Find a free frame buffer.
   for (i = 0; i < ext_fb_list->num_external_frame_buffers; ++i) {
     if (!ext_fb_list->ext_fb[i].in_use)
       break;
@@ skipping 16 matching lines @@
   ext_fb_list->ext_fb[i].in_use = 1;
 
   // Set the frame buffer's private data to point at the external frame buffer.
   fb->priv = &ext_fb_list->ext_fb[i];
   return 0;
 }
 
 // Callback used by libvpx when there are no references to the frame buffer.
 // |cb_priv| user private data passed into the set function. |fb| pointer
 // to the frame buffer.
-int release_vp9_frame_buffer(void *cb_priv,
-                             vpx_codec_frame_buffer_t *fb) {
+static int release_vp9_frame_buffer(void *cb_priv,
+                                    vpx_codec_frame_buffer_t *fb) {
   struct ExternalFrameBuffer *const ext_fb =
       (struct ExternalFrameBuffer *)fb->priv;
   (void)cb_priv;
   ext_fb->in_use = 0;
   return 0;
 }
 
-void generate_filename(const char *pattern, char *out, size_t q_len,
-                       unsigned int d_w, unsigned int d_h,
-                       unsigned int frame_in) {
+static void generate_filename(const char *pattern, char *out, size_t q_len,
+                              unsigned int d_w, unsigned int d_h,
+                              unsigned int frame_in) {
   const char *p = pattern;
   char *q = out;
 
   do {
     char *next_pat = strchr(p, '%');
 
     if (p == next_pat) {
       size_t pat_len;
 
       /* parse the pattern */
@@ skipping 101 matching lines @@
 #if CONFIG_VP9 && CONFIG_VP9_HIGHBITDEPTH
 static int img_shifted_realloc_required(const vpx_image_t *img,
                                         const vpx_image_t *shifted,
                                         vpx_img_fmt_t required_fmt) {
   return img->d_w != shifted->d_w ||
          img->d_h != shifted->d_h ||
          required_fmt != shifted->fmt;
 }
 #endif
 
-int main_loop(int argc, const char **argv_) {
+static int main_loop(int argc, const char **argv_) {
   vpx_codec_ctx_t       decoder;
   char                  *fn = NULL;
   int                    i;
   uint8_t               *buf = NULL;
   size_t                 bytes_in_buffer = 0, buffer_size = 0;
   FILE                  *infile;
   int                    frame_in = 0, frame_out = 0, flipuv = 0, noblit = 0;
   int                    do_md5 = 0, progress = 0, frame_parallel = 0;
   int                    stop_after = 0, postproc = 0, summary = 0, quiet = 1;
   int                    arg_skip = 0;
@@ skipping 595 matching lines @@
     if (arg_match(&arg, &looparg, argi)) {
       loops = arg_parse_uint(&arg);
       break;
     }
   }
   free(argv);
   for (i = 0; !error && i < loops; i++)
     error = main_loop(argc, argv_);
   return error;
 }