Support for parsing encrypted WebM streams by src.

media/filters/ffmpeg_demuxer.h

 // 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.
 
 // Implements the Demuxer interface using FFmpeg's libavformat.  At this time
 // will support demuxing any audio/video format thrown at it.  The streams
 // output mime types audio/x-ffmpeg and video/x-ffmpeg and include an integer
 // key FFmpegCodecID which contains the CodecID enumeration value.  The CodecIDs
 // can be used to create and initialize the corresponding FFmpeg decoder.
 //
 // FFmpegDemuxer sets the duration of pipeline during initialization by using
 // the duration of the longest audio/video stream.
 //
 // NOTE: since FFmpegDemuxer reads packets sequentially without seeking, media
 // files with very large drift between audio/video streams may result in
 // excessive memory consumption.
 //
 // When stopped, FFmpegDemuxer and FFmpegDemuxerStream release all callbacks
 // and buffered packets.  Reads from a stopped FFmpegDemuxerStream will not be
 // replied to.
 
 #ifndef MEDIA_FILTERS_FFMPEG_DEMUXER_H_
 #define MEDIA_FILTERS_FFMPEG_DEMUXER_H_
 
 #include <deque>
+#include <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/gtest_prod_util.h"
 #include "base/synchronization/waitable_event.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/demuxer.h"
 #include "media/base/pipeline.h"
 #include "media/base/video_decoder_config.h"
 #include "media/filters/ffmpeg_glue.h"
 
 // FFmpeg forward declarations.
 struct AVFormatContext;
 struct AVPacket;
 struct AVRational;
 struct AVStream;
 
 namespace media {
 
+// A new potentially encrypted stream has been parsed.
+// First parameter - The initialization data associated with the stream.
+// Second parameter - Number of bytes of the initialization data.
+typedef base::Callback<bool(scoped_array<uint8>, int)> FFmpegNeedKeyCB;
+
 class FFmpegDemuxer;
 class FFmpegH264ToAnnexBBitstreamConverter;
 class ScopedPtrAVFreePacket;
 
 class FFmpegDemuxerStream : public DemuxerStream {
  public:
   // Keeps a copy of |demuxer| and initializes itself using information
   // inside |stream|.  Both parameters must outlive |this|.
   FFmpegDemuxerStream(FFmpegDemuxer* demuxer, AVStream* stream);
 
@@ skipping 29 matching lines @@
   virtual const AudioDecoderConfig& audio_decoder_config() OVERRIDE;
   virtual const VideoDecoderConfig& video_decoder_config() OVERRIDE;
 
   // Returns the range of buffered data in this stream.
   Ranges<base::TimeDelta> GetBufferedRanges() const;
 
   // Returns elapsed time based on the already queued packets.
   // Used to determine stream duration when it's not known ahead of time.
   base::TimeDelta GetElapsedTime() const;
 
+  void KeyAdded();
+
  protected:
   virtual ~FFmpegDemuxerStream();
 
  private:
   friend class FFmpegDemuxerTest;
 
   // Carries out enqueuing a pending read on the demuxer thread.
   void ReadTask(const ReadCB& read_cb);
 
   // Attempts to fulfill a single pending read by dequeueing a buffer and read
@@ skipping 16 matching lines @@
   Ranges<base::TimeDelta> buffered_ranges_;
 
   typedef std::deque<scoped_refptr<DecoderBuffer> > BufferQueue;
   BufferQueue buffer_queue_;
 
   typedef std::deque<ReadCB> ReadQueue;
   ReadQueue read_queue_;
 
   scoped_ptr<FFmpegH264ToAnnexBBitstreamConverter> bitstream_converter_;
 
+  bool need_decryption_key_;

[ddorwin, 2012/08/22 23:20:29]

Curious why the demuxer cares. It shouldn't be blocking.

[fgalligan1, 2012/08/23 02:39:11]

See the other comment. Also if we don't have the demuxer block I think we will
need to re-architect the demuxer decoder interface. I think the demuxer expects
the decoder will only have one buffer at a time.

[xhwang, 2012/08/23 19:04:53]

I am not quite sure what's the problem. But the DemuxerStream just give out a
buffer when Read() is called if it can, or hold the callback and try to get more
data until it can give a buffer out. It should not worry about if the decoder
can decrypt or not.

So in summary, when the demuxer found a key_id, it should fire NeedKey with the
key_id and forget it. Whenever Read() is called the demuxer should hand out a
frame (encrypted or not) and should not worry about if the decryptor can decrypt
it.

[fgalligan1, 2012/08/24 20:01:26]

Removed. With xhwang's change this will work now.

+  std::string enc_key_id_;

[ddorwin, 2012/08/22 23:20:29]

Why do we store the key ID as state? There can be multiple. This is specific to
WebM too. (I'm fine with only supporting WebM now, but we should try to name
appropriately from the start.)

[fgalligan1, 2012/08/23 02:39:11]

I'm using this to decide if to create a DecryptConfig. Renamed to
current_key_id_.

+
   // Used to synchronize access to |buffer_queue_|, |read_queue_|, and
   // |stopped_|. This is so other threads can get access to buffers that have
   // already been demuxed without having the demuxer thread sending the
   // buffers. |lock_| must be acquired before any access to |buffer_queue_|,
   // |read_queue_|, or |stopped_|.
   mutable base::Lock lock_;
 
   DISALLOW_COPY_AND_ASSIGN(FFmpegDemuxerStream);
 };
 
 class MEDIA_EXPORT FFmpegDemuxer : public Demuxer, public FFmpegURLProtocol {
  public:
   FFmpegDemuxer(const scoped_refptr<base::MessageLoopProxy>& message_loop,
-                const scoped_refptr<DataSource>& data_source);
+                const scoped_refptr<DataSource>& data_source,
+                const FFmpegNeedKeyCB& need_key_cb);
 
   // Posts a task to perform additional demuxing.
   virtual void PostDemuxTask();
 
   // Demuxer implementation.
   virtual void Initialize(DemuxerHost* host,
                           const PipelineStatusCB& status_cb) OVERRIDE;
   virtual void Stop(const base::Closure& callback) OVERRIDE;
   virtual void Seek(base::TimeDelta time, const PipelineStatusCB& cb) OVERRIDE;
   virtual void OnAudioRendererDisabled() OVERRIDE;
   virtual void SetPlaybackRate(float playback_rate) OVERRIDE;
   virtual scoped_refptr<DemuxerStream> GetStream(
       DemuxerStream::Type type) OVERRIDE;
   virtual base::TimeDelta GetStartTime() const OVERRIDE;
 
   // FFmpegURLProtocol implementation.
   virtual size_t Read(size_t size, uint8* data) OVERRIDE;
   virtual bool GetPosition(int64* position_out) OVERRIDE;
   virtual bool SetPosition(int64 position) OVERRIDE;
   virtual bool GetSize(int64* size_out) OVERRIDE;
   virtual bool IsStreaming() OVERRIDE;
 
   // Provide access to FFmpegDemuxerStream.
   scoped_refptr<base::MessageLoopProxy> message_loop();
 
+  virtual void KeyAdded() OVERRIDE;
+  void NeedKey(const std::string& key_id);

[ddorwin, 2012/08/22 23:20:29]

Should this be public?

[fgalligan1, 2012/08/23 02:39:11]

This is called from FFmpegDemuxerStream.

+
   // Allow FFmpegDemuxerStream to notify us when there is updated information
   // about what buffered data is available.
   void NotifyBufferingChanged();
 
  private:
   // To allow tests access to privates.
   friend class FFmpegDemuxerTest;
 
   virtual ~FFmpegDemuxer();
 
   // Carries out initialization on the demuxer thread.
   void InitializeTask(DemuxerHost* host, const PipelineStatusCB& status_cb);
 
   // Carries out a seek on the demuxer thread.
   void SeekTask(base::TimeDelta time, const PipelineStatusCB& cb);
 
   // Carries out demuxing and satisfying stream reads on the demuxer thread.
   void DemuxTask();
 
   // Carries out stopping the demuxer streams on the demuxer thread.
   void StopTask(const base::Closure& callback);
 
   // Carries out disabling the audio stream on the demuxer thread.
   void DisableAudioStreamTask();
 
+  void KeyAddedTask();
+
   // Returns true if any of the streams have pending reads.  Since we lazily
   // post a DemuxTask() for every read, we use this method to quickly terminate
   // the tasks if there is no work to do.
   //
   // Must be called on the demuxer thread.
   bool StreamsHavePendingReads();
 
   // Signal all FFmpegDemuxerStream that the stream has ended.
   //
   // Must be called on the demuxer thread.
@@ skipping 55 matching lines @@
   base::TimeDelta start_time_;
 
   // Whether audio has been disabled for this demuxer (in which case this class
   // drops packets destined for AUDIO demuxer streams on the floor).
   bool audio_disabled_;
 
   // Set if we know duration of the audio stream. Used when processing end of
   // stream -- at this moment we definitely know duration.
   bool duration_known_;
 
+  FFmpegNeedKeyCB need_key_cb_;

[ddorwin, 2012/08/22 23:20:29]

const

[fgalligan1, 2012/08/23 02:39:11]

Done.

+
   DISALLOW_COPY_AND_ASSIGN(FFmpegDemuxer);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_FILTERS_FFMPEG_DEMUXER_H_