Add a simple, safe gain PostProcessor.

chromecast/media/cma/backend/alsa/post_processing_pipeline_impl.cc

 // Copyright 2017 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chromecast/media/cma/backend/alsa/post_processing_pipeline_impl.h"
 
 #include <cmath>
 #include <string>
 
 #include "base/files/file_path.h"
 #include "base/memory/ptr_util.h"
 #include "base/scoped_native_library.h"
 #include "base/values.h"
 #include "chromecast/base/serializers.h"
 #include "chromecast/public/media/audio_post_processor_shlib.h"
 #include "chromecast/public/volume_control.h"
 
 namespace chromecast {
 namespace media {
 
 namespace {
 
 const int kNoSampleRate = -1;
-const char kSoCreateFunction[] = "AudioPostProcessorShlib_Create";
 const char kProcessorKey[] = "processor";
 const char kNameKey[] = "name";
 }  // namespace
 
-using CreatePostProcessor = AudioPostProcessor* (*)(const std::string&, int);
-
 std::unique_ptr<PostProcessingPipeline> PostProcessingPipeline::Create(
     const std::string& name,
     const base::ListValue* filter_description_list,
     int num_channels) {
   return base::MakeUnique<PostProcessingPipelineImpl>(
       name, filter_description_list, num_channels);
 }
 
 PostProcessingPipelineImpl::PostProcessingPipelineImpl(
     const std::string& name,
@@ skipping 19 matching lines @@
         << "Duplicate postprocessor name " << processor_name;
     std::string library_path;
     CHECK(processor_description_dict->GetString(kProcessorKey, &library_path));
     if (library_path == "null" || library_path == "none") {
       continue;
     }
 
     const base::Value* processor_config_val;
     CHECK(processor_description_dict->Get("config", &processor_config_val));
     CHECK(processor_config_val->is_dict() || processor_config_val->is_string());
-    auto processor_config_string = SerializeToJson(*processor_config_val);
+    std::unique_ptr<std::string> processor_config_string =
+        SerializeToJson(*processor_config_val);
 
     LOG(INFO) << "Creating an instance of " << library_path << "("
               << *processor_config_string << ")";
-    libraries_.push_back(base::MakeUnique<base::ScopedNativeLibrary>(
-        base::FilePath(library_path)));
-    CHECK(libraries_.back()->is_valid())
-        << "Could not open post processing library " << library_path;
-    CreatePostProcessor create = reinterpret_cast<CreatePostProcessor>(
-        libraries_.back()->GetFunctionPointer(kSoCreateFunction));
 
-    CHECK(create) << "Could not find " << kSoCreateFunction << "() in "
-                  << library_path;
-    processors_.emplace_back(PostProcessorInfo{
-        base::WrapUnique(create(*processor_config_string, channels)),
-        processor_name});
+    processors_.emplace_back(
+        PostProcessorInfo{factory_.CreatePostProcessor(
+                              library_path, *processor_config_string, channels),
+                          processor_name});
   }
 }
 
 PostProcessingPipelineImpl::~PostProcessingPipelineImpl() = default;
 
 int PostProcessingPipelineImpl::ProcessFrames(float* data,
                                               int num_frames,
                                               float current_multiplier,
                                               bool is_silence) {
   DCHECK_NE(sample_rate_, kNoSampleRate);
@@ skipping 61 matching lines @@
               [&name](PostProcessorInfo& p) { return p.name == name; });
   if (it != processors_.end()) {
     it->ptr->UpdateParameters(config);
     LOG(INFO) << "Config string:\n"
               << config << "\nwas delivered to postprocessor " << name;
   }
 }
 
 }  // namespace media
 }  // namespace chromecast