Description:

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 12 matching lines @@
 #include "vpx/vpx_decoder.h"
 #include "vpx_ports/vpx_timer.h"
 #if CONFIG_VP8_DECODER || CONFIG_VP9_DECODER
 #include "vpx/vp8dx.h"
 #endif
 #if CONFIG_MD5
 #include "md5_utils.h"
 #endif
 #include "tools_common.h"
 #include "nestegg/include/nestegg/nestegg.h"
+#include "third_party/libyuv/include/libyuv/scale.h"
 
 #if CONFIG_OS_SUPPORT
 #if defined(_MSC_VER)
 #include <io.h>
 #define snprintf _snprintf
 #define isatty   _isatty
 #define fileno   _fileno
 #else
 #include <unistd.h>
 #endif
@@ skipping 43 matching lines @@
 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");
+static const arg_def_t scalearg = ARG_DEF("S", "scale", 0,
+                                            "Scale output frames uniformly");
 
 
 #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, &skiparg, &postprocarg, &summaryarg, &outputfile,
-  &threadsarg, &verbosearg,
+  &threadsarg, &verbosearg, &scalearg,
 #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");
@@ skipping 585 matching lines @@
 #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;
+  int                     do_scale = 0;
+  int                     stream_w = 0, stream_h = 0;
+  vpx_image_t             *scaled_img = NULL;
 
   /* 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;
 
     if (arg_match(&arg, &codecarg, argi)) {
@@ skipping 29 matching lines @@
     else if (arg_match(&arg, &postprocarg, argi))
       postproc = 1;
     else if (arg_match(&arg, &md5arg, argi))
       do_md5 = 1;
     else if (arg_match(&arg, &summaryarg, argi))
       summary = 1;
     else if (arg_match(&arg, &threadsarg, argi))
       cfg.threads = arg_parse_uint(&arg);
     else if (arg_match(&arg, &verbosearg, argi))
       quiet = 0;
+    else if (arg_match(&arg, &scalearg, argi))
+      do_scale = 1;
 
 #if CONFIG_VP8_DECODER
     else if (arg_match(&arg, &addnoise_level, argi)) {
       postproc = 1;
       vp8_pp_cfg.post_proc_flag |= VP8_ADDNOISE;
       vp8_pp_cfg.noise_level = arg_parse_uint(&arg);
     } else if (arg_match(&arg, &demacroblock_level, argi)) {
       postproc = 1;
       vp8_pp_cfg.post_proc_flag |= VP8_DEMACROBLOCK;
       vp8_pp_cfg.deblocking_level = arg_parse_uint(&arg);
@@ skipping 238 matching lines @@
     if ((img = vpx_codec_get_frame(&decoder, &iter)))
       ++frame_out;
 
     vpx_usec_timer_mark(&timer);
     dx_time += (unsigned int)vpx_usec_timer_elapsed(&timer);
 
     if (progress)
       show_progress(frame_in, frame_out, dx_time);
 
     if (!noblit) {
+      if (do_scale) {
+        if (img && frame_out == 1) {
+          stream_w = img->d_w;
+          stream_h = img->d_h;
+          scaled_img = vpx_img_alloc(NULL, VPX_IMG_FMT_I420,
+                                     stream_w, stream_h, 16);
+        }
+        if (img && (img->d_w != stream_w || img->d_h != stream_h)) {
+          I420Scale(img->planes[VPX_PLANE_Y], img->stride[VPX_PLANE_Y],
+                    img->planes[VPX_PLANE_U], img->stride[VPX_PLANE_U],
+                    img->planes[VPX_PLANE_V], img->stride[VPX_PLANE_V],
+                    img->d_w, img->d_h,
+                    scaled_img->planes[VPX_PLANE_Y],
+                    scaled_img->stride[VPX_PLANE_Y],
+                    scaled_img->planes[VPX_PLANE_U],
+                    scaled_img->stride[VPX_PLANE_U],
+                    scaled_img->planes[VPX_PLANE_V],
+                    scaled_img->stride[VPX_PLANE_V],
+                    stream_w, stream_h,
+                    kFilterBox);
+          img = scaled_img;
+        }
+      }
+
       if (img) {
         unsigned int y;
         char out_fn[PATH_MAX];
         uint8_t *buf;
 
         if (!single_file) {
           size_t len = sizeof(out_fn) - 1;
 
           out_fn[len] = '\0';
           generate_filename(outfile_pattern, out_fn, len - 1,
@@ skipping 52 matching lines @@
 
   if (input.nestegg_ctx)
     nestegg_destroy(input.nestegg_ctx);
   if (input.kind != WEBM_FILE)
     free(buf);
   fclose(infile);
   free(argv);
 
   return frames_corrupted ? EXIT_FAILURE : EXIT_SUCCESS;
 }