Add DecryptingAudioDecoder.

webkit/media/filter_helpers.cc

 // Copyright (c) 2012 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 "webkit/media/filter_helpers.h"
 
 #include "base/bind.h"
 #include "media/base/filter_collection.h"
 #include "media/base/message_loop_factory.h"
+#include "media/filters/decrypting_audio_decoder.h"
 #include "media/filters/decrypting_video_decoder.h"
 #include "media/filters/chunk_demuxer.h"
 #include "media/filters/dummy_demuxer.h"
 #include "media/filters/ffmpeg_audio_decoder.h"
 #include "media/filters/ffmpeg_demuxer.h"
 #include "media/filters/ffmpeg_video_decoder.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebURL.h"
 #include "webkit/media/crypto/proxy_decryptor.h"
 #include "webkit/media/media_stream_client.h"
 
 namespace webkit_media {
 
 // Constructs and adds the default audio/video decoders to |filter_collection|.
 // Note that decoders in the |filter_collection| are ordered. The first
 // audio/video decoder in the |filter_collection| that supports the input
 // audio/video stream will be selected as the audio/video decoder in the media
 // pipeline. This is done by trying to initialize the decoder with the input
 // stream. Some decoder may only accept certain types of streams. For example,
 // DecryptingVideoDecoder only supports encrypted video stream.
 static void AddDefaultDecodersToCollection(
     media::MessageLoopFactory* message_loop_factory,
     media::FilterCollection* filter_collection,
     ProxyDecryptor* proxy_decryptor) {
   scoped_refptr<media::FFmpegAudioDecoder> ffmpeg_audio_decoder =
       new media::FFmpegAudioDecoder(
           base::Bind(&media::MessageLoopFactory::GetMessageLoop,
                      base::Unretained(message_loop_factory),
                      media::MessageLoopFactory::kDecoder));
 
+  scoped_refptr<media::DecryptingAudioDecoder> decrypting_audio_decoder =
+      new media::DecryptingAudioDecoder(
+          base::Bind(&media::MessageLoopFactory::GetMessageLoop,
+                     base::Unretained(message_loop_factory),
+                     media::MessageLoopFactory::kDecoder),
+          base::Bind(&ProxyDecryptor::RequestDecryptorNotification,
+                     base::Unretained(proxy_decryptor)));
+
+  filter_collection->GetAudioDecoders()->push_back(ffmpeg_audio_decoder);
+  filter_collection->GetAudioDecoders()->push_back(decrypting_audio_decoder);

[scherkus (not reviewing), 2012/10/19 02:12:58]

here we have ffmpeg > decrypting for audio, but for video the order is reversed


intentional?

[xhwang, 2012/10/19 02:19:45]

Nothing happens by chance :) This is intentional.
Ideally I'd like decrypting decoders to be after normal decoders because in the
real world most videos will not be encrypted. But for video, FFVD can also do
decryption. If both decrypt-only and decrypt-and-decode are supported, we'd like
to choose decrypt-and-decode. That's why DVD comes before FFVD. WDYT?

[scherkus (not reviewing), 2012/10/19 02:23:05]

...but FFVD doing decryption is temporary, right?

[xhwang, 2012/10/19 02:40:35]

Yes. But if I move FFVD up now, then decrypt-and-decode (D&D) will not be
chosen. For decrypt-only, we don't have the mechanism to ask a CDM "if you
support decrypt-only". Decrypt-only can only succeed or fail. So it should
always be tried after the D&D path. We'll change the order here when we remove
decryption out of FFVD.

[scherkus (not reviewing), 2012/10/19 02:51:48]

Sounds good to me -- can you TODOify it w/ a comment?

[xhwang, 2012/10/19 07:28:28]

Done.

+
   scoped_refptr<media::DecryptingVideoDecoder> decrypting_video_decoder =
       new media::DecryptingVideoDecoder(
           base::Bind(&media::MessageLoopFactory::GetMessageLoop,
                      base::Unretained(message_loop_factory),
                      media::MessageLoopFactory::kDecoder),
           base::Bind(&ProxyDecryptor::RequestDecryptorNotification,
                      base::Unretained(proxy_decryptor)));
 
   scoped_refptr<media::FFmpegVideoDecoder> ffmpeg_video_decoder =
       new media::FFmpegVideoDecoder(
           base::Bind(&media::MessageLoopFactory::GetMessageLoop,
                      base::Unretained(message_loop_factory),
                      media::MessageLoopFactory::kDecoder),
           proxy_decryptor);
 
-  filter_collection->GetAudioDecoders()->push_back(ffmpeg_audio_decoder);
   filter_collection->GetVideoDecoders()->push_back(decrypting_video_decoder);
   filter_collection->GetVideoDecoders()->push_back(ffmpeg_video_decoder);
 }
 
 bool BuildMediaStreamCollection(const WebKit::WebURL& url,
                                 MediaStreamClient* client,
                                 media::MessageLoopFactory* message_loop_factory,
                                 media::FilterCollection* filter_collection) {
   if (!client)
     return false;
@@ skipping 39 matching lines @@
   filter_collection->SetDemuxer(new media::FFmpegDemuxer(
       message_loop_factory->GetMessageLoop(
           media::MessageLoopFactory::kPipeline),
       data_source));
 
   AddDefaultDecodersToCollection(message_loop_factory, filter_collection,
                                  proxy_decryptor);
 }
 
 }  // webkit_media