Motown: Remove LPCM optimizations, fix prepare, add flush, add ActiveMultistreamSink model/stage

services/media/framework/conversion_pipeline_builder.cc

 // Copyright 2016 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 "services/media/framework/conversion_pipeline_builder.h"
 #include "services/media/framework/formatting.h"
 #include "services/media/framework/parts/decoder.h"
 #include "services/media/framework/parts/lpcm_reformatter.h"
 
 namespace mojo {
@@ skipping 55 matching lines @@
     // Very much prefer not to resample.
     score += 50;
   } else {
     return 0; // TODO(dalesat): Remove when we have resamplers.
   }
 
   return score;
 }
 
 // Finds the media type set that best matches in_type.
-const StreamTypeSetPtr* FindBestLpcm(
+const std::unique_ptr<StreamTypeSet>* FindBestLpcm(
     const LpcmStreamType& in_type,
-    const StreamTypeSetsPtr& out_type_sets) {
-  const StreamTypeSetPtr* best = nullptr;
+    const std::unique_ptr<std::vector<std::unique_ptr<StreamTypeSet>>>&
+        out_type_sets) {
+  const std::unique_ptr<StreamTypeSet>* best = nullptr;
   int best_score = 0;
-  for (const StreamTypeSetPtr& out_type_set : *out_type_sets) {
+  for (const std::unique_ptr<StreamTypeSet>& out_type_set : *out_type_sets) {
     switch (out_type_set->scheme()) {
       case StreamType::Scheme::kAnyElementary:
       case StreamType::Scheme::kAnyAudio:
       case StreamType::Scheme::kAny:
         // Wildcard scheme allows any type without conversion.
         return &out_type_set;
       case StreamType::Scheme::kLpcm: {
         int score = Score(in_type, *out_type_set->lpcm());
         if (best_score < score) {
           best_score = score;
           best = &out_type_set;
         }
         break;
       }
       default:
         break;
     }
   }
   return best;
 }
 
 // Attempts to add transforms to the pipeline given an input compressed audio
 // stream type with (in_type) and the set of output types we need to convert to
 // (out_type_sets). If the call succeeds, *out_type is set to the new output
 // type. Otherwise, *out_type is set to nullptr.
 AddResult AddTransformsForCompressedAudio(
     const CompressedAudioStreamType& in_type,
-    const StreamTypePtr& in_type_ptr,
-    const StreamTypeSetsPtr& out_type_sets,
-    Engine* engine,
-    Engine::Output* output,
-    StreamTypePtr* out_type) {
+    const std::unique_ptr<StreamType>& in_type_ptr,
+    const std::unique_ptr<std::vector<std::unique_ptr<StreamTypeSet>>>&
+        out_type_sets,
+    Graph* graph,
+    OutputRef* output,
+    std::unique_ptr<StreamType>* out_type) {
   DCHECK(out_type);
-  DCHECK(engine);
+  DCHECK(graph);
 
   // See if we have a matching COMPRESSED_AUDIO type.
-  for (const StreamTypeSetPtr& out_type_set : *out_type_sets) {
+  for (const std::unique_ptr<StreamTypeSet>& out_type_set : *out_type_sets) {
     switch (out_type_set->scheme()) {
       case StreamType::Scheme::kAnyElementary:
       case StreamType::Scheme::kAnyAudio:
       case StreamType::Scheme::kAny:
         // Wildcard scheme allows any type without conversion.
         *out_type = in_type.Clone();
         return AddResult::kFinished;
       case StreamType::Scheme::kCompressedAudio: {
         if (out_type_set->compressed_audio()->contains(in_type)) {
           // No transform needed.
           *out_type = in_type.Clone();
           return AddResult::kFinished;
         }
         break;
       }
       default:
         break;
     }
     // TODO(dalesat): Support a different compressed output type by transcoding.
   }
 
   // Find the best LPCM output type.
-  const StreamTypeSetPtr* best = FindBestLpcm(in_type, out_type_sets);
+  const std::unique_ptr<StreamTypeSet>* best =
+      FindBestLpcm(in_type, out_type_sets);
   if (best == nullptr) {
     // No candidates found.
     *out_type = nullptr;
     return AddResult::kFailed;
   }
 
   DCHECK_EQ((*best)->scheme(), StreamType::Scheme::kLpcm);
 
   // Need to decode. Create a decoder and go from there.
-  DecoderPtr decoder;
+  std::shared_ptr<Decoder> decoder;
   Result result = Decoder::Create(in_type_ptr, &decoder);
   if (result !=  Result::kOk) {
     // No decoder found.
     *out_type = nullptr;
     return AddResult::kFailed;
   }
 
-  *output = engine->ConnectOutputToPart(*output, engine->Add(decoder)).output();
+  *output = graph->ConnectOutputToPart(*output, graph->Add(decoder)).output();
   *out_type = decoder->output_stream_type();
 
   return AddResult::kProgressed;
 }
 
 // Attempts to add transforms to the pipeline given an input LPCM stream type
 // (in_type) and the output lpcm stream type set for the type we need to convert
 // to (out_type_set). If the call succeeds, *out_type is set to the new output
 // type. Otherwise, *out_type is set to nullptr.
 AddResult AddTransformsForLpcm(
     const LpcmStreamType& in_type,
     const LpcmStreamTypeSet& out_type_set,
-    Engine* engine,
-    Engine::Output* output,
-    StreamTypePtr* out_type) {
-  DCHECK(engine);
+    Graph* graph,
+    OutputRef* output,
+    std::unique_ptr<StreamType>* out_type) {
+  DCHECK(graph);
   DCHECK(out_type);
 
   // TODO(dalesat): Room for more intelligence here wrt transform ordering and
   // transforms that handle more than one conversion.
   if (in_type.sample_format() != out_type_set.sample_format() &&
       out_type_set.sample_format() != LpcmStreamType::SampleFormat::kAny) {
     // The reformatter will fix interleave conversion.
-    *output = engine->ConnectOutputToPart(
+    *output = graph->ConnectOutputToPart(
         *output,
-        engine->Add(LpcmReformatter::Create(in_type, out_type_set))).output();
+        graph->Add(LpcmReformatter::Create(in_type, out_type_set))).output();
   }
 
   if (!out_type_set.channels().contains(in_type.channels())) {
     // TODO(dalesat): Insert mixdown/up transform.
     NOTREACHED() << "conversion requires mixdown/up - not supported";
     *out_type = nullptr;
     return AddResult::kFailed;
   }
 
   if (!out_type_set.frames_per_second().contains(in_type.frames_per_second())) {
@@ skipping 13 matching lines @@
 
   return AddResult::kFinished;
 }
 
 // Attempts to add transforms to the pipeline given an input media type with
 // scheme LPCM (in_type) and the set of output types we need to convert to
 // (out_type_sets). If the call succeeds, *out_type is set to the new output
 // type. Otherwise, *out_type is set to nullptr.
 AddResult AddTransformsForLpcm(
     const LpcmStreamType& in_type,
-    const StreamTypeSetsPtr& out_type_sets,
-    Engine* engine,
-    Engine::Output* output,
-    StreamTypePtr* out_type) {
-  DCHECK(engine);
+    const std::unique_ptr<std::vector<std::unique_ptr<StreamTypeSet>>>&
+        out_type_sets,
+    Graph* graph,
+    OutputRef* output,
+    std::unique_ptr<StreamType>* out_type) {
+  DCHECK(graph);
   DCHECK(out_type);
 
-  const StreamTypeSetPtr* best = FindBestLpcm(in_type, out_type_sets);
+  const std::unique_ptr<StreamTypeSet>* best =
+      FindBestLpcm(in_type, out_type_sets);
   if (best == nullptr) {
     // TODO(dalesat): Support a compressed output type by encoding.
     NOTREACHED() << "conversion using encoder not supported";
     *out_type = nullptr;
     return AddResult::kFailed;
   }
 
   switch ((*best)->scheme()) {
     case StreamType::Scheme::kAnyElementary:
     case StreamType::Scheme::kAnyAudio:
     case StreamType::Scheme::kAny:
       // Wildcard scheme allows any type without conversion.
       *out_type = in_type.Clone();
       return AddResult::kFinished;
     case StreamType::Scheme::kLpcm:
       return AddTransformsForLpcm(
           in_type,
           *(*best)->lpcm(),
-          engine,
+          graph,
           output,
           out_type);
     default:
       NOTREACHED() << "FindBestLpcm produced unexpected type set scheme"
           << (*best)->scheme();
       return AddResult::kFailed;
   }
 }
 
 // Attempts to add transforms to the pipeline given an input media type of any
 // scheme (in_type) and the set of output types we need to convert to
 // (out_type_sets). If the call succeeds, *out_type is set to the new output
 // type. Otherwise, *out_type is set to nullptr.
 AddResult AddTransforms(
-    const StreamTypePtr& in_type,
-    const StreamTypeSetsPtr& out_type_sets,
-    Engine* engine,
-    Engine::Output* output,
-    StreamTypePtr* out_type) {
+    const std::unique_ptr<StreamType>& in_type,
+    const std::unique_ptr<std::vector<std::unique_ptr<StreamTypeSet>>>&
+        out_type_sets,
+    Graph* graph,
+    OutputRef* output,
+    std::unique_ptr<StreamType>* out_type) {
   DCHECK(in_type);
-  DCHECK(engine);
+  DCHECK(graph);
   DCHECK(out_type);
 
   switch (in_type->scheme()) {
     case StreamType::Scheme::kLpcm:
       return AddTransformsForLpcm(
           *in_type->lpcm(),
           out_type_sets,
-          engine,
+          graph,
           output,
           out_type);
     case StreamType::Scheme::kCompressedAudio:
       return AddTransformsForCompressedAudio(
           *in_type->compressed_audio(),
           in_type,
           out_type_sets,
-          engine,
+          graph,
           output,
           out_type);
     default:
       NOTREACHED() << "conversion not supported for scheme"
           << in_type->scheme();
       *out_type = nullptr;
       return AddResult::kFailed;
   }
 }
 
 }  // namespace
 
 bool BuildConversionPipeline(
-    const StreamTypePtr& in_type,
-    const StreamTypeSetsPtr& out_type_sets,
-    Engine* engine,
-    Engine::Output* output,
-    StreamTypePtr* out_type) {
+    const std::unique_ptr<StreamType>& in_type,
+    const std::unique_ptr<std::vector<std::unique_ptr<StreamTypeSet>>>&
+        out_type_sets,
+    Graph* graph,
+    OutputRef* output,
+    std::unique_ptr<StreamType>* out_type) {
   DCHECK(in_type);
   DCHECK(out_type_sets);
-  DCHECK(engine);
+  DCHECK(graph);
   DCHECK(output);
   DCHECK(out_type);
 
-  Engine::Output out = *output;
+  OutputRef out = *output;
 
-  const StreamTypePtr* type_to_convert = &in_type;
-  StreamTypePtr next_in_type;
+  const std::unique_ptr<StreamType>* type_to_convert = &in_type;
+  std::unique_ptr<StreamType> next_in_type;
   while (true) {
-    StreamTypePtr converted_type;
+    std::unique_ptr<StreamType> converted_type;
     switch (AddTransforms(
         *type_to_convert,
         out_type_sets,
-        engine,
+        graph,
         &out,
         &converted_type)) {
       case AddResult::kFailed:
         // Failed to find a suitable conversion. Return the pipeline to its
         // original state.
-        engine->RemovePartsConnectedToOutput(*output);
+        graph->RemovePartsConnectedToOutput(*output);
         *out_type = nullptr;
         return false;
       case AddResult::kProgressed:
         // Made progress. Continue.
         break;
       case AddResult::kFinished:
         // No further conversion required.
         *output = out;
         *out_type = std::move(converted_type);
         return true;
     }
 
     next_in_type = std::move(converted_type);
     type_to_convert = &next_in_type;
   }
 }
 
 }  // namespace media
 }  // namespace mojo