MediaCodecPlayer implementation - stage 7 (DRM)

media/base/android/media_codec_decoder.h

 // Copyright 2015 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.
 
 #ifndef MEDIA_BASE_ANDROID_MEDIA_CODEC_DECODER_H_
 #define MEDIA_BASE_ANDROID_MEDIA_CODEC_DECODER_H_
 
 #include "base/android/scoped_java_ref.h"
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread.h"
 #include "base/time/time.h"
 #include "media/base/android/access_unit_queue.h"
 #include "media/base/android/demuxer_stream_player_params.h"
+#include "media/base/android/media_drm_bridge.h"
 
 namespace media {
 
 class MediaCodecBridge;
 
 // The decoder for MediaCodecPlayer.
 // This class accepts the incoming data into AccessUnitQueue and works with
 // MediaCodecBridge for decoding and rendering the frames. The MediaCodecPlayer
 // has two decoder objects: audio and video.
 //
@@ skipping 82 matching lines @@
 //
 // (**) VideoSurface is a precondition to video decoder Configure(), can be set
 //      any time before Configure().
 
 class MediaCodecDecoder {
  public:
   // The result of MediaCodec configuration, used by MediaCodecPlayer.
   enum ConfigStatus {
     kConfigFailure = 0,
     kConfigOk,
+    kConfigNoCrypto,
     kConfigKeyFrameRequired,
   };
 
   // The decoder reports current playback time to the MediaCodecPlayer.
   // For audio, the parameters designate the beginning and end of a time
   // interval. The beginning is the estimated time that is playing right now.
   // The end is the playback time of the last buffered data. During normal
   // playback the subsequent intervals overlap.
   // For video both values are PTS of the corresponding frame, i.e. the interval
   // has zero width.
@@ skipping 24 matching lines @@
   //     Called when a MediaCodec error occurred. If this happens, a player has
   //     to either call ReleaseDecoderResources() or destroy the decoder object.
   //   decoder_thread_name:
   //     The thread name to be passed to decoder thread constructor.
   MediaCodecDecoder(
       const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
       const base::Closure& external_request_data_cb,
       const base::Closure& starvation_cb,
       const base::Closure& decoder_drained_cb,
       const base::Closure& stop_done_cb,
+      const base::Closure& key_required_cb,
       const base::Closure& error_cb,
       const char* decoder_thread_name);
   virtual ~MediaCodecDecoder();
 
   virtual const char* class_name() const;
 
   // MediaCodecDecoder exists through the whole lifetime of the player
   // to support dynamic addition and removal of the streams.
   // This method returns true if the current stream (audio or video)
   // is currently active.
   virtual bool HasStream() const = 0;
 
   // Stores configuration for the use of upcoming Configure()
   virtual void SetDemuxerConfigs(const DemuxerConfigs& configs) = 0;
 
+  // Returns true if the DemuxerConfigs announce that content is encrypted and
+  // that MediaCrypto is required for configuration.
+  virtual bool IsContentEncrypted() const = 0;
+
   // Stops decoder thread, releases the MediaCodecBridge and other resources.
   virtual void ReleaseDecoderResources() = 0;
 
   // Flushes the MediaCodec, after that resets the AccessUnitQueue and blocks
   // the input. Decoder thread should not be running.
   virtual void Flush();
 
   // Releases MediaCodecBridge and any related buffers or references.
   virtual void ReleaseMediaCodec();
 
   // Returns corresponding conditions.
   bool IsPrefetchingOrPlaying() const;
   bool IsStopped() const;
   bool IsCompleted() const;
   bool NotCompletedAndNeedsPreroll() const;
 
   // Sets preroll timestamp and requests preroll.
   void SetPrerollTimestamp(base::TimeDelta preroll_ts);
 
-  base::android::ScopedJavaLocalRef<jobject> GetMediaCrypto();
+  // Sets the DRM bridge pointer.
+  void SetDrmBridge(MediaDrmBridge* drm_bridge);
 
   // Starts prefetching: accumulates enough data in AccessUnitQueue.
   // Decoder thread is not running.
   void Prefetch(const base::Closure& prefetch_done_cb);
 
   // Configures MediaCodec.
-  ConfigStatus Configure();
+  ConfigStatus Configure(jobject media_crypto);
 
   // Starts the decoder for prerolling. This method starts the decoder thread.
   bool Preroll(const base::Closure& preroll_done_cb);
 
   // Starts the decoder after preroll is not needed, starting decoder thread
   // if it has not started yet.
   bool Start(base::TimeDelta start_timestamp);
 
   // Stops the playback process synchronously. This method stops the decoder
   // thread synchronously, and then releases all MediaCodec buffers.
@@ skipping 30 matching lines @@
     kRenderAfterPreroll,
     kRenderNow,
   };
 
   // Returns true if the new DemuxerConfigs requires MediaCodec
   // reconfiguration.
   virtual bool IsCodecReconfigureNeeded(const DemuxerConfigs& next) const = 0;
 
   // Does the part of MediaCodecBridge configuration that is specific
   // to audio or video.
-  virtual ConfigStatus ConfigureInternal() = 0;
+  virtual ConfigStatus ConfigureInternal(jobject media_crypto) = 0;
 
   // Associates PTS with device time so we can calculate delays.
   // We use delays for video decoder only.
   virtual void AssociateCurrentTimeWithPTS(base::TimeDelta current_time) {}
 
   // Invalidate delay calculation. We use delays for video decoder only.
   virtual void DissociatePTSFromTime() {}
 
   // Processes the change of the output format, varies by stream.
   virtual void OnOutputFormatChanged() = 0;
@@ skipping 39 matching lines @@
   // Controls Android MediaCodec
   scoped_ptr<MediaCodecBridge> media_codec_bridge_;
 
   // We call MediaCodecBridge on this thread for both
   // input and output buffers.
   base::Thread decoder_thread_;
 
   // The queue of access units.
   AccessUnitQueue au_queue_;
 
+  // Pointer to a DRM object that will be used for encrypted streams.
+  MediaDrmBridge* drm_bridge_;
+
   // Flag forces reconfiguration even if |media_codec_bridge_| exists. Currently
   // is set by video decoder when the video surface changes.
   bool needs_reconfigure_;
 
   // Flag forces to drain decoder in the process of dynamic reconfiguration.
   bool drain_decoder_;
 
   // For tests only. Forces to always reconfigure for |kConfigChanged| unit.
   bool always_reconfigure_for_tests_;
 
@@ skipping 54 matching lines @@
 
   // External data request callback that is passed to decoder.
   base::Closure external_request_data_cb_;
 
   // These notifications are called on corresponding conditions.
   base::Closure prefetch_done_cb_;
   base::Closure starvation_cb_;
   base::Closure preroll_done_cb_;
   base::Closure decoder_drained_cb_;
   base::Closure stop_done_cb_;
+  base::Closure key_required_cb_;
   base::Closure error_cb_;
 
   // Data request callback that is posted by decoder internally.
   base::Closure request_data_cb_;
 
   // Callback used to post OnCodecError method.
   base::Closure internal_error_cb_;
 
   // Callback for posting OnPrerollDone method.
   base::Closure internal_preroll_done_cb_;
 
   // Internal state.
   DecoderState state_;
   mutable base::Lock state_lock_;
 
   // Preroll timestamp is set if we need preroll and cleared after we done it.
   base::TimeDelta preroll_timestamp_;
 
   // Set to true when MediaCodec internal buffers are filled up.
   bool is_prepared_;
 
   // Flag is set when the EOS is enqueued into MediaCodec. Reset by Flush.
   bool eos_enqueued_;
 
+  // Flag is set when NO_KEY error is received from QueueSecureInputBuffer.
+  // Reset after we stop.
+  bool key_request_posted_;
+
   // Flag is set when the EOS is received in MediaCodec output. Reset by Flush.
   bool completed_;
 
   // Flag to ensure we post last frame notification once.
   bool last_frame_posted_;
 
   // Indicates whether the data request is in progress.
   bool is_data_request_in_progress_;
 
   // Indicates whether the incoming data should be ignored.
   bool is_incoming_data_invalid_;
 
 #ifndef NDEBUG
   // When set, we check that the following video frame is the key frame.
   bool verify_next_frame_is_key_;
 #endif
 
   // NOTE: Weak pointers must be invalidated before all other member variables.
   base::WeakPtrFactory<MediaCodecDecoder> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaCodecDecoder);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BASE_ANDROID_MEDIA_CODEC_DECODER_H_