Update libvpx snapshot to v0.9.7-p1 (Cayuga).

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 69 matching lines @@
 static const arg_def_t postprocarg = ARG_DEF(NULL, "postproc", 0,
                                      "Postprocess decoded frames");
 static const arg_def_t summaryarg = ARG_DEF(NULL, "summary", 0,
                                     "Show timing summary");
 static const arg_def_t outputfile = ARG_DEF("o", "output", 1,
                                     "Output file name pattern (see below)");
 static const arg_def_t threadsarg = ARG_DEF("t", "threads", 1,
                                     "Max threads to use");
 static const arg_def_t verbosearg = ARG_DEF("v", "verbose", 0,
                                   "Show version string");
+static const arg_def_t error_concealment = ARG_DEF(NULL, "error-concealment", 0,
+                                       "Enable decoder error-concealment");
+
 
 #if CONFIG_MD5
 static const arg_def_t md5arg = ARG_DEF(NULL, "md5", 0,
                                         "Compute the MD5 sum of the decoded frame");
 #endif
 static const arg_def_t *all_args[] =
 {
     &codecarg, &use_yv12, &use_i420, &flipuvarg, &noblitarg,
     &progressarg, &limitarg, &postprocarg, &summaryarg, &outputfile,
     &threadsarg, &verbosearg,
 #if CONFIG_MD5
     &md5arg,
 #endif
+    &error_concealment,
     NULL
 };
 
 #if CONFIG_VP8_DECODER
 static const arg_def_t addnoise_level = ARG_DEF(NULL, "noise-level", 1,
                                         "Enable VP8 postproc add noise");
 static const arg_def_t deblock = ARG_DEF(NULL, "deblock", 0,
                                  "Enable VP8 deblocking");
 static const arg_def_t demacroblock_level = ARG_DEF(NULL, "demacroblock-level", 1,
         "Enable VP8 demacroblocking, w/ level");
@@ skipping 453 matching lines @@
 static int
 file_is_webm(struct input_ctx *input,
              unsigned int     *fourcc,
              unsigned int     *width,
              unsigned int     *height,
              unsigned int     *fps_den,
              unsigned int     *fps_num)
 {
     unsigned int i, n;
     int          track_type = -1;
-    uint64_t     tstamp=0;
 
     nestegg_io io = {nestegg_read_cb, nestegg_seek_cb, nestegg_tell_cb,
                      input->infile};
     nestegg_video_params params;
-    nestegg_packet * pkt;
 
     if(nestegg_init(&input->nestegg_ctx, io, NULL))
         goto fail;
 
     if(nestegg_track_count(input->nestegg_ctx, &n))
         goto fail;
 
     for(i=0; i<n; i++)
     {
         track_type = nestegg_track_type(input->nestegg_ctx, i);
@@ skipping 103 matching lines @@
 int main(int argc, const char **argv_)
 {
     vpx_codec_ctx_t          decoder;
     char                  *fn = NULL;
     int                    i;
     uint8_t               *buf = NULL;
     size_t                 buf_sz = 0, buf_alloc_sz = 0;
     FILE                  *infile;
     int                    frame_in = 0, frame_out = 0, flipuv = 0, noblit = 0, do_md5 = 0, progress = 0;
     int                    stop_after = 0, postproc = 0, summary = 0, quiet = 1;
+    int                    ec_enabled = 0;
     vpx_codec_iface_t       *iface = NULL;
     unsigned int           fourcc;
     unsigned long          dx_time = 0;
     struct arg               arg;
     char                   **argv, **argi, **argj;
     const char             *outfile_pattern = 0;
     char                    outfile[PATH_MAX];
     int                     single_file;
     int                     use_y4m = 1;
     unsigned int            width;
     unsigned int            height;
     unsigned int            fps_den;
     unsigned int            fps_num;
     void                   *out = NULL;
     vpx_codec_dec_cfg_t     cfg = {0};
 #if CONFIG_VP8_DECODER
     vp8_postproc_cfg_t      vp8_pp_cfg = {0};
     int                     vp8_dbg_color_ref_frame = 0;
     int                     vp8_dbg_color_mb_modes = 0;
     int                     vp8_dbg_color_b_modes = 0;
     int                     vp8_dbg_display_mv = 0;
 #endif
     struct input_ctx        input = {0};
+    int                     frames_corrupted = 0;
+    int                     dec_flags = 0;
 
     /* Parse command line */
     exec_name = argv_[0];
     argv = argv_dup(argc - 1, argv_ + 1);
 
     for (argi = argj = argv; (*argj = *argi); argi += arg.argv_step)
     {
         memset(&arg, 0, sizeof(arg));
         arg.argv_step = 1;
 
@@ skipping 99 matching lines @@
         }
         else if (arg_match(&arg, &pp_disp_mvs, argi))
         {
             unsigned int flags = arg_parse_int(&arg);
             if (flags)
             {
                 postproc = 1;
                 vp8_dbg_display_mv = flags;
             }
         }
+        else if (arg_match(&arg, &error_concealment, argi))
+        {
+            ec_enabled = 1;
+        }
 
 #endif
         else
             argj++;
     }
 
     /* Check for unrecognized options */
     for (argi = argv; *argi; argi++)
         if (argi[0][0] == '-' && strlen(argi[0]) > 1)
             die("Error: Unrecognized option %s\n", *argi);
@@ skipping 100 matching lines @@
 
             if (iface && iface != ivf_iface)
                 fprintf(stderr, "Notice -- IVF header indicates codec: %s\n",
                         ifaces[i].name);
             else
                 iface = ivf_iface;
 
             break;
         }
 
+    dec_flags = (postproc ? VPX_CODEC_USE_POSTPROC : 0) |
+                (ec_enabled ? VPX_CODEC_USE_ERROR_CONCEALMENT : 0);
     if (vpx_codec_dec_init(&decoder, iface ? iface :  ifaces[0].iface, &cfg,
-                           postproc ? VPX_CODEC_USE_POSTPROC : 0))
+                           dec_flags))
     {
         fprintf(stderr, "Failed to initialize decoder: %s\n", vpx_codec_error(&decoder));
         return EXIT_FAILURE;
     }
 
     if (!quiet)
         fprintf(stderr, "%s\n", decoder.name);
 
 #if CONFIG_VP8_DECODER
 
@@ skipping 32 matching lines @@
         return EXIT_FAILURE;
     }
 #endif
 
     /* Decode file */
     while (!read_frame(&input, &buf, &buf_sz, &buf_alloc_sz))
     {
         vpx_codec_iter_t  iter = NULL;
         vpx_image_t    *img;
         struct vpx_usec_timer timer;
+        int                   corrupted;
 
         vpx_usec_timer_start(&timer);
 
         if (vpx_codec_decode(&decoder, buf, buf_sz, NULL, 0))
         {
             const char *detail = vpx_codec_error_detail(&decoder);
             fprintf(stderr, "Failed to decode frame: %s\n", vpx_codec_error(&decoder));
 
             if (detail)
                 fprintf(stderr, "  Additional information: %s\n", detail);
 
             goto fail;
         }
 
         vpx_usec_timer_mark(&timer);
         dx_time += vpx_usec_timer_elapsed(&timer);
 
         ++frame_in;
 
+        if (vpx_codec_control(&decoder, VP8D_GET_FRAME_CORRUPTED, &corrupted))
+        {
+            fprintf(stderr, "Failed VP8_GET_FRAME_CORRUPTED: %s\n",
+                    vpx_codec_error(&decoder));
+            goto fail;
+        }
+        frames_corrupted += corrupted;
+
         if ((img = vpx_codec_get_frame(&decoder, &iter)))
             ++frame_out;
 
         if (progress)
             show_progress(frame_in, frame_out, dx_time);
 
         if (!noblit)
         {
             if (img)
             {
@@ skipping 45 matching lines @@
         if (stop_after && frame_in >= stop_after)
             break;
     }
 
     if (summary || progress)
     {
         show_progress(frame_in, frame_out, dx_time);
         fprintf(stderr, "\n");
     }
 
+    if (frames_corrupted)
+        fprintf(stderr, "WARNING: %d frames corrupted.\n",frames_corrupted);
+
 fail:
 
     if (vpx_codec_destroy(&decoder))
     {
         fprintf(stderr, "Failed to destroy decoder: %s\n", vpx_codec_error(&decoder));
         return EXIT_FAILURE;
     }
 
     if (single_file && !noblit)
         out_close(out, outfile, do_md5);
 
     if(input.nestegg_ctx)
         nestegg_destroy(input.nestegg_ctx);
     if(input.kind != WEBM_FILE)
         free(buf);
     fclose(infile);
     free(argv);
 
-    return EXIT_SUCCESS;
+    return frames_corrupted ? EXIT_FAILURE : EXIT_SUCCESS;
 }