Move ownership of webrtc::VideoCodec into TestConfig.

webrtc/modules/video_coding/codecs/tools/video_quality_measurement.cc

 /*
  *  Copyright (c) 2012 The WebRTC 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 187 matching lines @@
             config->output_filename.c_str());
     return 4;
   }
   fclose(test_file);
 
   // Check single core flag.
   config->use_single_core = FLAGS_use_single_core;
 
   // Get codec specific configuration.
   webrtc::VideoCodingModule::Codec(webrtc::kVideoCodecVP8,
-                                   config->codec_settings);
+                                   &config->codec_settings);
 
   // Check the temporal layers.
   if (FLAGS_temporal_layers < 0 ||
       FLAGS_temporal_layers > webrtc::kMaxTemporalStreams) {
     fprintf(stderr, "Temporal layers number must be 0-4, was: %d\n",
             FLAGS_temporal_layers);
     return 13;
   }
-  config->codec_settings->VP8()->numberOfTemporalLayers = FLAGS_temporal_layers;
+  config->codec_settings.VP8()->numberOfTemporalLayers = FLAGS_temporal_layers;
 
   // Check the bit rate.
   if (FLAGS_bitrate <= 0) {
     fprintf(stderr, "Bit rate must be >0 kbps, was: %d\n", FLAGS_bitrate);
     return 5;
   }
-  config->codec_settings->startBitrate = FLAGS_bitrate;
+  config->codec_settings.startBitrate = FLAGS_bitrate;
 
   // Check the keyframe interval.
   if (FLAGS_keyframe_interval < 0) {
     fprintf(stderr, "Keyframe interval must be >=0, was: %d\n",
             FLAGS_keyframe_interval);
     return 6;
   }
   config->keyframe_interval = FLAGS_keyframe_interval;
 
   // Check packet size and max payload size.
@@ skipping 11 matching lines @@
     return 8;
   }
   config->networking_config.max_payload_size_in_bytes =
       static_cast<size_t>(FLAGS_max_payload_size);
 
   // Check the width and height
   if (FLAGS_width <= 0 || FLAGS_height <= 0) {
     fprintf(stderr, "Width and height must be >0.");
     return 9;
   }
-  config->codec_settings->width = FLAGS_width;
-  config->codec_settings->height = FLAGS_height;
-  config->codec_settings->maxFramerate = FLAGS_framerate;
+  config->codec_settings.width = FLAGS_width;
+  config->codec_settings.height = FLAGS_height;
+  config->codec_settings.maxFramerate = FLAGS_framerate;
 
   // Calculate the size of each frame to read (according to YUV spec).
   config->frame_length_in_bytes =
-      3 * config->codec_settings->width * config->codec_settings->height / 2;
+      3 * config->codec_settings.width * config->codec_settings.height / 2;
 
   // Check packet loss settings
   if (FLAGS_packet_loss_mode != "uniform" &&
       FLAGS_packet_loss_mode != "burst") {
     fprintf(stderr,
             "Unsupported packet loss mode, must be 'uniform' or "
             "'burst'\n.");
     return 10;
   }
   config->networking_config.packet_loss_mode = webrtc::test::kUniform;
@@ skipping 23 matching lines @@
       FLAGS_packet_loss_burst_length;
   config->verbose = FLAGS_verbose;
   return 0;
 }
 
 void CalculateSsimVideoMetrics(webrtc::test::TestConfig* config,
                                webrtc::test::QualityMetricsResult* result) {
   Log("Calculating SSIM...\n");
   I420SSIMFromFiles(
       config->input_filename.c_str(), config->output_filename.c_str(),
-      config->codec_settings->width, config->codec_settings->height, result);
+      config->codec_settings.width, config->codec_settings.height, result);
   Log("  Average: %3.2f\n", result->average);
   Log("  Min    : %3.2f (frame %d)\n", result->min, result->min_frame_number);
   Log("  Max    : %3.2f (frame %d)\n", result->max, result->max_frame_number);
 }
 
 void CalculatePsnrVideoMetrics(webrtc::test::TestConfig* config,
                                webrtc::test::QualityMetricsResult* result) {
   Log("Calculating PSNR...\n");
   I420PSNRFromFiles(
       config->input_filename.c_str(), config->output_filename.c_str(),
-      config->codec_settings->width, config->codec_settings->height, result);
+      config->codec_settings.width, config->codec_settings.height, result);
   Log("  Average: %3.2f\n", result->average);
   Log("  Min    : %3.2f (frame %d)\n", result->min, result->min_frame_number);
   Log("  Max    : %3.2f (frame %d)\n", result->max, result->max_frame_number);
 }
 
 void PrintConfigurationSummary(const webrtc::test::TestConfig& config) {
   Log("Quality test with parameters:\n");
   Log("  Test name        : %s\n", config.name.c_str());
   Log("  Description      : %s\n", config.description.c_str());
   Log("  Input filename   : %s\n", config.input_filename.c_str());
@@ skipping 76 matching lines @@
       config.name.c_str(), config.description.c_str(), config.test_number,
       config.input_filename.c_str(), config.output_filename.c_str(),
       config.output_dir.c_str(), config.networking_config.packet_size_in_bytes,
       config.networking_config.max_payload_size_in_bytes,
       PacketLossModeToStr(config.networking_config.packet_loss_mode),
       config.networking_config.packet_loss_probability,
       config.networking_config.packet_loss_burst_length,
       ExcludeFrameTypesToStr(config.exclude_frame_types),
       config.frame_length_in_bytes, config.use_single_core ? "True " : "False",
       config.keyframe_interval,
-      CodecTypeToPayloadName(config.codec_settings->codecType)
+      CodecTypeToPayloadName(config.codec_settings.codecType)
           .value_or("Unknown"),
-      config.codec_settings->width, config.codec_settings->height,
-      config.codec_settings->startBitrate);
+      config.codec_settings.width, config.codec_settings.height,
+      config.codec_settings.startBitrate);
   printf(
       "frame_data_types = {"
       "'frame_number': ('number', 'Frame number'),\n"
       "'encoding_successful': ('boolean', 'Encoding successful?'),\n"
       "'decoding_successful': ('boolean', 'Decoding successful?'),\n"
       "'encode_time': ('number', 'Encode time (us)'),\n"
       "'decode_time': ('number', 'Decode time (us)'),\n"
       "'encode_return_code': ('number', 'Encode return code'),\n"
       "'decode_return_code': ('number', 'Decode return code'),\n"
       "'bit_rate': ('number', 'Bit rate (kbps)'),\n"
@@ skipping 38 matching lines @@
       "Run " +
       program_name +
       " --helpshort for usage.\n"
       "Example usage:\n" +
       program_name +
       " --input_filename=filename.yuv --width=352 --height=288\n";
   google::SetUsageMessage(usage);
 
   google::ParseCommandLineFlags(&argc, &argv, true);
 
-  // Create TestConfig and codec settings struct.
+  // Create TestConfig.
   webrtc::test::TestConfig config;
-  webrtc::VideoCodec codec_settings;
-  config.codec_settings = &codec_settings;
 
   int return_code = HandleCommandLineFlags(&config);
   // Exit if an invalid argument is supplied.
   if (return_code != 0) {
     return return_code;
   }
 
   PrintConfigurationSummary(config);
 
   webrtc::VP8Encoder* encoder = webrtc::VP8Encoder::Create();
   webrtc::VP8Decoder* decoder = webrtc::VP8Decoder::Create();
   webrtc::test::Stats stats;
   webrtc::test::YuvFrameReaderImpl frame_reader(config.input_filename,
-                                                config.codec_settings->width,
-                                                config.codec_settings->height);
+                                                config.codec_settings.width,
+                                                config.codec_settings.height);
   webrtc::test::YuvFrameWriterImpl frame_writer(config.output_filename,
-                                                config.codec_settings->width,
-                                                config.codec_settings->height);
+                                                config.codec_settings.width,
+                                                config.codec_settings.height);
   frame_reader.Init();
   frame_writer.Init();
   webrtc::test::PacketReader packet_reader;
 
   webrtc::test::PacketManipulatorImpl packet_manipulator(
       &packet_reader, config.networking_config, config.verbose);
   // By default the packet manipulator is seeded with a fixed random.
   // If disabled we must generate a new seed.
   if (FLAGS_disable_fixed_random_seed) {
     packet_manipulator.InitializeRandomSeed(time(NULL));
@@ skipping 38 matching lines @@
   }
   if (FLAGS_python) {
     PrintPythonOutput(config, stats, ssim_result, psnr_result);
   }
   delete processor;
   delete encoder;
   delete decoder;
   Log("Quality test finished!");
   return 0;
 }