Motown: Define MediaRenderer and make it the way we identify renderers.

services/media/framework/util/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/parts/decoder.h"
 #include "services/media/framework/parts/lpcm_reformatter.h"
 #include "services/media/framework/util/conversion_pipeline_builder.h"
 #include "services/media/framework/util/formatting.h"
 
 namespace mojo {
@@ skipping 126 matching lines @@
     *out_type = nullptr;
     return AddResult::kFailed;
   }
 
   *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 compressed video
+// 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 AddTransformsForCompressedVideo(
+    const VideoStreamType& in_type,
+    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);
+
+  // TODO(dalesat): See if we already have a matching video type.
+
+  // Need to decode. Create a decoder and go from there.
+  std::shared_ptr<Decoder> 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;
+}
+
 // 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 AudioStreamType& in_type,
                                const AudioStreamTypeSet& out_type_set,
                                Graph* graph,
                                OutputRef* output,
                                std::unique_ptr<StreamType>* out_type) {
   DCHECK(graph);
@@ skipping 78 matching lines @@
 
   switch (in_type.medium()) {
     case StreamType::Medium::kAudio:
       if (in_type.encoding() == StreamType::kAudioEncodingLpcm) {
         return AddTransformsForLpcm(*in_type.audio(), out_type_sets, graph,
                                     output, out_type);
       } else {
         return AddTransformsForCompressedAudio(*in_type.audio(), out_type_sets,
                                                graph, output, out_type);
       }
+    case StreamType::Medium::kVideo:
+      if (in_type.encoding() == StreamType::kVideoEncodingUncompressed) {
+        *out_type = in_type.Clone();
+        return AddResult::kFinished;
+      } else {
+        return AddTransformsForCompressedVideo(*in_type.video(), out_type_sets,
+                                               graph, output, out_type);
+      }
     default:
       NOTREACHED() << "conversion not supported for medium" << in_type.medium();
       *out_type = nullptr;
       return AddResult::kFailed;
   }
 }
 
 }  // namespace
 
 bool BuildConversionPipeline(
@@ skipping 27 matching lines @@
         *out_type = std::move(converted_type);
         return true;
     }
 
     type_to_convert = converted_type.get();
   }
 }
 
 }  // namespace media
 }  // namespace mojo