Motown: ffmpeg implementations of framework 'parts'

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 57 matching lines @@
   } else {
     return 0; // TODO(dalesat): Remove when we have resamplers.
   }
 
   return score;
 }
 
 // Finds the media type set that best matches in_type.
 const std::unique_ptr<StreamTypeSet>* FindBestLpcm(
     const LpcmStreamType& in_type,
-    const std::unique_ptr<std::vector<std::unique_ptr<StreamTypeSet>>>&
-        out_type_sets) {
+    const std::vector<std::unique_ptr<StreamTypeSet>>& out_type_sets) {
   const std::unique_ptr<StreamTypeSet>* best = nullptr;
   int best_score = 0;
-  for (const std::unique_ptr<StreamTypeSet>& 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 std::unique_ptr<StreamType>& in_type_ptr,
-    const std::unique_ptr<std::vector<std::unique_ptr<StreamTypeSet>>>&
-        out_type_sets,
+    const std::vector<std::unique_ptr<StreamTypeSet>>& out_type_sets,
     Graph* graph,
     OutputRef* output,
     std::unique_ptr<StreamType>* out_type) {
   DCHECK(out_type);
   DCHECK(graph);
 
   // See if we have a matching COMPRESSED_AUDIO type.
-  for (const std::unique_ptr<StreamTypeSet>& 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.
@@ skipping 14 matching lines @@
   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.
   std::shared_ptr<Decoder> decoder;
-  Result result = Decoder::Create(in_type_ptr, &decoder);
+  Result result = Decoder::Create(in_type, &decoder);
   if (result !=  Result::kOk) {
     // No decoder found.
     *out_type = nullptr;
     return AddResult::kFailed;
   }
 
   *output = graph->ConnectOutputToPart(*output, graph->Add(decoder)).output();
   *out_type = decoder->output_stream_type();
 
   return AddResult::kProgressed;
@@ skipping 46 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 std::unique_ptr<std::vector<std::unique_ptr<StreamTypeSet>>>&
-        out_type_sets,
+    const 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 std::unique_ptr<StreamTypeSet>* best =
       FindBestLpcm(in_type, out_type_sets);
   if (best == nullptr) {
     // TODO(dalesat): Support a compressed output type by encoding.
@@ skipping 21 matching lines @@
           << (*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 std::unique_ptr<StreamType>& in_type,
-    const std::unique_ptr<std::vector<std::unique_ptr<StreamTypeSet>>>&
-        out_type_sets,
+    const StreamType& in_type,
+    const std::vector<std::unique_ptr<StreamTypeSet>>& out_type_sets,
     Graph* graph,
     OutputRef* output,
     std::unique_ptr<StreamType>* out_type) {
-  DCHECK(in_type);
   DCHECK(graph);
   DCHECK(out_type);
 
-  switch (in_type->scheme()) {
+  switch (in_type.scheme()) {
     case StreamType::Scheme::kLpcm:
       return AddTransformsForLpcm(
-          *in_type->lpcm(),
+          *in_type.lpcm(),
           out_type_sets,
           graph,
           output,
           out_type);
     case StreamType::Scheme::kCompressedAudio:
       return AddTransformsForCompressedAudio(
-          *in_type->compressed_audio(),
-          in_type,
+          *in_type.compressed_audio(),
           out_type_sets,
           graph,
           output,
           out_type);
     default:
       NOTREACHED() << "conversion not supported for scheme"
-          << in_type->scheme();
+          << in_type.scheme();
       *out_type = nullptr;
       return AddResult::kFailed;
   }
 }
 
 }  // namespace
 
 bool BuildConversionPipeline(
-    const std::unique_ptr<StreamType>& in_type,
-    const std::unique_ptr<std::vector<std::unique_ptr<StreamTypeSet>>>&
-        out_type_sets,
+    const StreamType& in_type,
+    const 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(graph);
   DCHECK(output);
   DCHECK(out_type);
 
   OutputRef out = *output;
-
-  const std::unique_ptr<StreamType>* type_to_convert = &in_type;
-  std::unique_ptr<StreamType> next_in_type;
+  const StreamType* type_to_convert = &in_type;
+  std::unique_ptr<StreamType> converted_type;
   while (true) {
-    std::unique_ptr<StreamType> converted_type;
     switch (AddTransforms(
         *type_to_convert,
         out_type_sets,
         graph,
         &out,
         &converted_type)) {
       case AddResult::kFailed:
         // Failed to find a suitable conversion. Return the pipeline to its
         // original state.
         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;
+    type_to_convert = converted_type.get();
   }
 }
 
 }  // namespace media
 }  // namespace mojo