1
    2
    3
    4
    5
    6
    7
    8
    9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68
   69
   70
   71
   72
   73
   74
   75
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93
   94
   95
   96
   97
   98
   99
  100
  101
  102
  103
  104
  105
  106
  107
  108
  109
  110
  111
  112
  113
  114
  115
  116
  117
  118


media / cdm / fuchsia / fuchsia_stream_decryptor.h [blame]

// Copyright 2019 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef MEDIA_CDM_FUCHSIA_FUCHSIA_STREAM_DECRYPTOR_H_
#define MEDIA_CDM_FUCHSIA_FUCHSIA_STREAM_DECRYPTOR_H_

#include <fuchsia/media/drm/cpp/fidl.h>

#include <memory>

#include "base/memory/raw_ptr.h"
#include "base/sequence_checker.h"
#include "media/base/decryptor.h"
#include "media/base/media_export.h"
#include "media/fuchsia/common/stream_processor_helper.h"
#include "media/fuchsia/common/sysmem_buffer_stream.h"
#include "media/fuchsia/common/sysmem_client.h"
#include "media/fuchsia/common/vmo_buffer_writer_queue.h"

namespace media {

// Stream decryptor used to decrypt protected media streams on Fuchsia. Must be
// created an used on the same thread.
class MEDIA_EXPORT FuchsiaStreamDecryptor
    : public SysmemBufferStream,
      public StreamProcessorHelper::Client {
 public:
  // Number of buffers that the decryptor allocates for input buffer
  // collection. Decryptors provided by fuchsia.media.drm API normally decrypt a
  // single buffer at a time. Second buffer is useful to allow reading/writing a
  // packet while the decryptor is working on another one.
  static constexpr size_t kInputBufferCount = 2;

  explicit FuchsiaStreamDecryptor(fuchsia::media::StreamProcessorPtr processor);
  ~FuchsiaStreamDecryptor() override;

  FuchsiaStreamDecryptor(const FuchsiaStreamDecryptor&) = delete;
  FuchsiaStreamDecryptor& operator=(const FuchsiaStreamDecryptor&) = delete;

  // Returns closure that should be called when the key changes. This class
  // uses this notification to handle NO_KEY errors. Note that this class can
  // queue multiple input buffers so it's also responsible for resubmitting
  // queued buffers after a new key is received. This is different from
  // FuchsiaClearStreamDecryptor and media::Decryptor: they report NO_KEY error
  // to the caller and expect the caller to resubmit same buffers again after
  // the key is updated.
  base::RepeatingClosure GetOnNewKeyClosure();

  // SysmemBufferStream implementation.
  void Initialize(Sink* sink,
                  size_t min_buffer_size,
                  size_t min_buffer_count) override;
  void EnqueueBuffer(scoped_refptr<DecoderBuffer> buffer) override;
  void Reset() override;

 private:
  // StreamProcessorHelper::Client overrides.
  void OnStreamProcessorAllocateOutputBuffers(
      const fuchsia::media::StreamBufferConstraints& stream_constraints) final;
  void OnStreamProcessorEndOfStream() final;
  void OnStreamProcessorOutputFormat(
      fuchsia::media::StreamOutputFormat format) final;
  void OnStreamProcessorOutputPacket(
      StreamProcessorHelper::IoPacket packet) final;
  void OnStreamProcessorNoKey() final;
  void OnStreamProcessorError() final;

  void OnError();

  void OnInputBuffersAcquired(
      std::vector<VmoBuffer> buffers,
      const fuchsia::sysmem2::SingleBufferSettings& buffer_settings);
  void SendInputPacket(const DecoderBuffer* buffer,
                       StreamProcessorHelper::IoPacket packet);
  void ProcessEndOfStream();

  // Callback returned by GetOnNewKeyClosure(). When waiting for a key this
  // method unpauses the stream to decrypt any pending buffers.
  void OnNewKey();

  StreamProcessorHelper processor_;

  SysmemAllocatorClient allocator_;

  raw_ptr<Sink> sink_ = nullptr;

  size_t min_buffer_size_ = 0;
  size_t min_buffer_count_ = 0;

  std::unique_ptr<SysmemCollectionClient> input_buffer_collection_;
  VmoBufferWriterQueue input_writer_queue_;

  std::unique_ptr<SysmemCollectionClient> output_buffer_collection_;

  // Key ID for which we received the last OnNewKey() event.
  std::string last_new_key_id_;

  // Set to true if some keys have been updated recently. New key notifications
  // are received from a LicenseSession, while DECRYPTOR_NO_KEY error is
  // received from StreamProcessor. These are separate FIDL connections that are
  // handled on different threads, so they are not synchronized. As result
  // OnNewKey() may be called before we get OnNoKey(). To handle this case
  // correctly OnNewKey() sets |retry_on_no_key_event_| and then OnNoKey() tries
  // to restart the stream immediately if this flag is set.
  bool retry_on_no_key_event_ = false;

  // Set to true if the stream is paused while we are waiting for new keys.
  bool waiting_for_key_ = false;

  SEQUENCE_CHECKER(sequence_checker_);

  base::WeakPtrFactory<FuchsiaStreamDecryptor> weak_factory_{this};
};

}  // namespace media

#endif  // MEDIA_CDM_FUCHSIA_FUCHSIA_STREAM_DECRYPTOR_H_