video_encoder_fallback.cc 5.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184
  1. // Copyright 2021 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "media/video/video_encoder_fallback.h"
  5. #include "base/logging.h"
  6. #include "base/memory/ref_counted.h"
  7. #include "base/sequence_checker.h"
  8. #include "media/base/video_frame.h"
  9. namespace media {
  10. VideoEncoderFallback::VideoEncoderFallback(
  11. std::unique_ptr<VideoEncoder> main_encoder,
  12. CreateFallbackCB create_fallback_cb)
  13. : encoder_(std::move(main_encoder)),
  14. create_fallback_cb_(std::move(create_fallback_cb)) {
  15. DCHECK(encoder_);
  16. DCHECK(!create_fallback_cb_.is_null());
  17. }
  18. VideoEncoderFallback::~VideoEncoderFallback() = default;
  19. void VideoEncoderFallback::Initialize(VideoCodecProfile profile,
  20. const Options& options,
  21. OutputCB output_cb,
  22. EncoderStatusCB done_cb) {
  23. DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  24. init_done_cb_ = std::move(done_cb);
  25. output_cb_ = std::move(output_cb);
  26. profile_ = profile;
  27. options_ = options;
  28. auto done_callback = [](base::WeakPtr<VideoEncoderFallback> self,
  29. EncoderStatus status) {
  30. if (!self)
  31. return;
  32. if (status.is_ok()) {
  33. std::move(self->init_done_cb_).Run(std::move(status));
  34. return;
  35. }
  36. self->FallbackInitialize();
  37. };
  38. encoder_->Initialize(
  39. profile, options,
  40. base::BindRepeating(&VideoEncoderFallback::CallOutput,
  41. weak_factory_.GetWeakPtr()),
  42. base::BindOnce(done_callback, weak_factory_.GetWeakPtr()));
  43. }
  44. VideoEncoder::PendingEncode VideoEncoderFallback::MakePendingEncode(
  45. scoped_refptr<VideoFrame> frame,
  46. bool key_frame,
  47. EncoderStatusCB done_cb) {
  48. PendingEncode result;
  49. result.done_callback = std::move(done_cb);
  50. result.frame = std::move(frame);
  51. result.key_frame = key_frame;
  52. return result;
  53. }
  54. void VideoEncoderFallback::Encode(scoped_refptr<VideoFrame> frame,
  55. bool key_frame,
  56. EncoderStatusCB done_cb) {
  57. DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  58. DCHECK(!init_done_cb_);
  59. if (use_fallback_) {
  60. if (fallback_initialized_) {
  61. encoder_->Encode(std::move(frame), key_frame, std::move(done_cb));
  62. } else {
  63. encodes_to_retry_.push_back(std::make_unique<PendingEncode>(
  64. MakePendingEncode(std::move(frame), key_frame, std::move(done_cb))));
  65. }
  66. return;
  67. }
  68. auto done_callback = [](base::WeakPtr<VideoEncoderFallback> self,
  69. PendingEncode args, EncoderStatus status) {
  70. if (!self)
  71. return;
  72. DCHECK(self->encoder_);
  73. if (status.is_ok()) {
  74. std::move(args.done_callback).Run(std::move(status));
  75. return;
  76. }
  77. self->FallbackEncode(std::move(args));
  78. };
  79. encoder_->Encode(
  80. frame, key_frame,
  81. base::BindOnce(done_callback, weak_factory_.GetWeakPtr(),
  82. MakePendingEncode(frame, key_frame, std::move(done_cb))));
  83. }
  84. void VideoEncoderFallback::ChangeOptions(const Options& options,
  85. OutputCB output_cb,
  86. EncoderStatusCB done_cb) {
  87. DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  88. options_ = options;
  89. if (encoder_)
  90. encoder_->ChangeOptions(options, std::move(output_cb), std::move(done_cb));
  91. }
  92. void VideoEncoderFallback::Flush(EncoderStatusCB done_cb) {
  93. DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  94. if (encoder_)
  95. encoder_->Flush(std::move(done_cb));
  96. }
  97. void VideoEncoderFallback::FallbackInitCompleted(EncoderStatus status) {
  98. DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  99. DCHECK(encoder_);
  100. if (init_done_cb_)
  101. std::move(init_done_cb_).Run(status);
  102. fallback_initialized_ = true;
  103. if (status.is_ok()) {
  104. for (auto& encode : encodes_to_retry_) {
  105. encoder_->Encode(std::move(encode->frame), encode->key_frame,
  106. std::move(encode->done_callback));
  107. }
  108. } else {
  109. for (auto& encode : encodes_to_retry_)
  110. std::move(encode->done_callback).Run(status);
  111. }
  112. encodes_to_retry_.clear();
  113. }
  114. void VideoEncoderFallback::FallbackInitialize() {
  115. DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  116. use_fallback_ = true;
  117. encoder_ = std::move(create_fallback_cb_).Run();
  118. if (!encoder_) {
  119. std::move(init_done_cb_)
  120. .Run(EncoderStatus::Codes::kEncoderInitializationError);
  121. FallbackInitCompleted(EncoderStatus::Codes::kEncoderInitializationError);
  122. return;
  123. }
  124. encoder_->Initialize(
  125. profile_, options_,
  126. base::BindRepeating(&VideoEncoderFallback::CallOutput,
  127. weak_factory_.GetWeakPtr()),
  128. base::BindOnce(&VideoEncoderFallback::FallbackInitCompleted,
  129. weak_factory_.GetWeakPtr()));
  130. }
  131. void VideoEncoderFallback::FallbackEncode(PendingEncode args) {
  132. DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  133. if (!use_fallback_) {
  134. use_fallback_ = true;
  135. encoder_ = std::move(create_fallback_cb_).Run();
  136. if (!encoder_) {
  137. std::move(args.done_callback)
  138. .Run(EncoderStatus::Codes::kEncoderInitializationError);
  139. return;
  140. }
  141. encoder_->Initialize(
  142. profile_, options_,
  143. base::BindRepeating(&VideoEncoderFallback::CallOutput,
  144. weak_factory_.GetWeakPtr()),
  145. base::BindOnce(&VideoEncoderFallback::FallbackInitCompleted,
  146. weak_factory_.GetWeakPtr()));
  147. }
  148. if (fallback_initialized_) {
  149. encoder_->Encode(std::move(args.frame), args.key_frame,
  150. std::move(args.done_callback));
  151. } else {
  152. encodes_to_retry_.push_back(
  153. std::make_unique<PendingEncode>(std::move(args)));
  154. }
  155. }
  156. void VideoEncoderFallback::CallOutput(VideoEncoderOutput output,
  157. absl::optional<CodecDescription> desc) {
  158. output_cb_.Run(std::move(output), std::move(desc));
  159. }
  160. } // namespace media