#include <algorithm>
#include <memory>
+#include <tuple>
#include <utility>
#include <vector>
#include "content/renderer/media/tizen/elementary_media_stream_source/control_thread/track_dispatcher_client.h"
#include "content/renderer/media/tizen/elementary_media_stream_source/worker_thread/track_dispatcher_client.h"
#include "media/base/decoder_buffer.h"
-#include "media/base/decryptor.h"
#include "tizen/system_info.h"
TrackImpl::TrackImpl(TrackParams params)
: operations_client_(nullptr),
- decryptor_(nullptr),
dispatcher_(std::move(params.dispatcher)),
state_(std::move(params.state)),
track_mode_(params.track_mode) {
operations_client_.store(client);
}
-void TrackImpl::SetDecryptor(media::Decryptor* decryptor) {
- EMSS_DEBUG_TYPED();
-
- decryptor_ = decryptor;
-}
-
//////////////////// SourceClient ////////////////////
void TrackImpl::RegisterSessionIdChangeListener(
void TrackImpl::OnAppendPacketDone(
std::weak_ptr<TrackImpl> track_weak,
size_t data_size,
- bool is_encrypted,
base::OnceCallback<void(OperationResult)> append_cb,
OperationResult result) {
EMSS_VERBOSE_NO_INSTANCE();
std::move(append_cb).Run(result);
}
-// static
-void TrackImpl::OnDecryptDone(
- media::DemuxerStream::Type type,
- blink::WebElementaryMediaPacketMetadata&& packet_metadata,
- uint32_t session_id,
- base::OnceCallback<void(OperationResult)> append_cb,
- mojo::ScopedSharedBufferHandle&& shared_memory,
- size_t data_size,
- worker_thread::TrackDispatcherClient* worker_track,
- any_thread::TrackDispatcherClient* any_track,
- media::Decryptor::Status status,
- scoped_refptr<media::DecoderBuffer> buffer) {
- EMSS_VERBOSE_NO_INSTANCE();
-
- worker_track->OnPrepareDemuxedFrameDataDone(
- std::move(append_cb), status, Packet{std::move(buffer), session_id});
-}
-
OperationResult TrackImpl::PrepareDemuxedFrameData(
blink::WebElementaryMediaPacketMetadata&& packet_metadata,
base::span<const uint8_t>&& packet_data,
EMSS_VERBOSE_TYPED() << " pts = " << packet_metadata.pts
<< ", dts = " << packet_metadata.dts;
- auto [packet, result] = ([&]() {
- const auto duration = base::Seconds(packet_metadata.duration)
- .RoundToMultiple(base::Milliseconds(1));
- const auto dts = base::Seconds(packet_metadata.dts)
- .RoundToMultiple(base::Milliseconds(1));
- const auto pts = base::Seconds(packet_metadata.pts)
- .RoundToMultiple(base::Milliseconds(1));
- const auto is_key_frame = packet_metadata.is_key_frame.value_or(false);
-
- auto buffer =
- media::DecoderBuffer::CopyFrom(packet_data.data(), packet_data.size());
-
- buffer->set_is_key_frame(is_key_frame);
- buffer->set_duration(duration);
- buffer->set_timestamp(pts);
- buffer->set_dts(dts);
-
- return std::make_tuple(Packet{std::move(buffer), session_id},
- OperationResult::kOk);
- })();
+ auto [packet, result] =
+ PreparePacket(packet_metadata, std::move(packet_data), session_id);
if (result != OperationResult::kOk) {
EMSS_VERBOSE_TYPED() << result;
return result;
}
- append_cb = UpdateAppendCallback(packet_metadata, packet_data.size(),
- std::move(append_cb));
-
- if (auto dispatcher = dispatcher_.lock()) {
- if (dispatcher->DispatchTask(
- &worker_thread::TrackDispatcherClient::
- OnPrepareDemuxedFrameDataDone,
- AutoAbortedCallbackWrapper::WrapCallback(std::move(append_cb)),
- media::Decryptor::Status::kSuccess,
- std::move(packet)) == DispatchResult::kOk) {
- return OperationResult::kOk;
- }
- }
-
- EMSS_DEBUG();
-
- // If dispatch didn't happen after internal data was already updated with
- // packet stats, the update must be reverted. We cannot run append_cb
- // directly, because it might have been moved - however calling
- // OnAppendPacketDone() will revert the state for us.
- TrackImpl::OnAppendPacketDone(shared_from_this(), packet_data.size(),
- packet_metadata.is_encrypted, base::DoNothing(),
- OperationResult::kAborted);
- return OperationResult::kAborted;
+ return TransferPacketToWorkerThread(std::move(packet), std::move(append_cb));
}
OperationResult TrackImpl::PrepareDecryptionConfig(
return OperationResult::kVideoCodecParametersUnsupported;
}
- if (!decryptor_) {
- EMSS_LOG_TYPED(ERROR) << "No media key session registered!";
- return OperationResult::kNoMediaKeySession;
- }
-
- // FIXME(p.balut): Implement DRM support on Tizen 9.0
- return OperationResult::kBufferCreationFailed;
- /*
- media::Decryptor::StreamType decryptor_stream_type;
-
- switch (Type()) {
- case TrackType::kAudio:
- decryptor_stream_type = media::Decryptor::kAudio;
- break;
- case TrackType::kVideo:
- decryptor_stream_type = media::Decryptor::kVideo;
- break;
- default:
- EMSS_LOG_ASSERT(false) << "Unsupported stream type: " << Type();
- return OperationResult::kInvalidTrackState;
- }
-
std::unique_ptr<media::DecryptConfig> decrypt_config;
auto decryption_result =
PrepareDecryptionConfig(packet_metadata, &decrypt_config);
}
EMSS_VERBOSE_TYPED() << "Prepared decrypt config: " << *decrypt_config;
- using AccessMode = mojo::SharedBufferHandle::AccessMode;
- auto buffer = media::DecoderBuffer::FromSharedMemoryRegion(
- mojo::UnwrapUnsafeSharedMemoryRegion(
- shared_memory->Clone(AccessMode::READ_WRITE)),
- 0, packet_data.size());
+ auto [packet, result] = PreparePacket(packet_metadata, std::move(packet_data),
+ session_id, std::move(decrypt_config));
+ if (result != OperationResult::kOk) {
+ EMSS_VERBOSE_TYPED() << result;
+ return result;
+ }
+
+ return TransferPacketToWorkerThread(std::move(packet), std::move(append_cb));
+}
+std::tuple<Packet, OperationResult> TrackImpl::PreparePacket(
+ const blink::WebElementaryMediaPacketMetadata& packet_metadata,
+ base::span<const uint8_t>&& packet_data,
+ uint32_t session_id,
+ std::unique_ptr<media::DecryptConfig> maybe_decrypt_config) {
+ EMSS_VERBOSE();
+
+ const auto duration = base::Seconds(packet_metadata.duration)
+ .RoundToMultiple(base::Milliseconds(1));
+ const auto dts =
+ base::Seconds(packet_metadata.dts).RoundToMultiple(base::Milliseconds(1));
+ const auto pts =
+ base::Seconds(packet_metadata.pts).RoundToMultiple(base::Milliseconds(1));
+ const auto is_key_frame = packet_metadata.is_key_frame.value_or(false);
+
+ auto buffer =
+ media::DecoderBuffer::CopyFrom(packet_data.data(), packet_data.size());
if (!buffer) {
- EMSS_LOG_TYPED(ERROR) << "DecoderBuffer creation failed.";
- return OperationResult::kBufferCreationFailed;
+ EMSS_LOG_TYPED(ERROR) << "DecoderBuffer creation failed";
+ return {Packet{}, OperationResult::kBufferCreationFailed};
+ }
+
+ buffer->set_is_key_frame(is_key_frame);
+ buffer->set_duration(duration);
+ buffer->set_timestamp(pts);
+ buffer->set_dts(dts);
+
+ if (maybe_decrypt_config) {
+ buffer->set_decrypt_config(std::move(maybe_decrypt_config));
}
- buffer->set_decrypt_config(std::move(decrypt_config));
+ return {Packet{std::move(buffer), session_id}, OperationResult::kOk};
+}
+
+OperationResult TrackImpl::TransferPacketToWorkerThread(
+ Packet packet,
+ base::OnceCallback<void(OperationResult)> append_cb) {
+ EMSS_DEBUG() << packet;
+
+ append_cb = UpdateAppendCallback(packet, std::move(append_cb));
- append_cb = UpdateAppendCallback(packet_metadata, packet_data.size(),
- std::move(append_cb));
+ const auto data_size = packet.data_size();
if (auto dispatcher = dispatcher_.lock()) {
- auto decrypt_cb = base::BindOnce(
- &media::Decryptor::DecryptTizen, base::Unretained(decryptor_),
- decryptor_stream_type, std::move(std::move(buffer)));
-
- auto decrypt_done_cb = base::BindRepeating(
- OnDecryptDone,
- ToDemuxerStreamType(Type()), base::Passed(std::move(packet_metadata)),
- session_id,
- base::Passed(
- AutoAbortedCallbackWrapper::WrapCallback(std::move(append_cb))),
- base::Passed(std::move(shared_memory)), packet_data.size());
-
- dispatcher->DispatchAppendPacket(std::move(decrypt_cb),
- std::move(decrypt_done_cb));
- } else {
- return OperationResult::kAborted;
+ if (dispatcher->DispatchTask(
+ &worker_thread::TrackDispatcherClient::
+ OnPrepareDemuxedFrameDataDone,
+ AutoAbortedCallbackWrapper::WrapCallback(std::move(append_cb)),
+ std::move(packet)) == DispatchResult::kOk) {
+ return OperationResult::kOk;
+ }
}
- return OperationResult::kOk;
- */
+ EMSS_DEBUG();
+
+ // If dispatch didn't happen after internal data was already updated with
+ // packet stats, the update must be reverted. We cannot run append_cb
+ // directly, because it might have been moved - however calling
+ // OnAppendPacketDone() will revert the state for us.
+ TrackImpl::OnAppendPacketDone(shared_from_this(), data_size,
+ base::DoNothing(), OperationResult::kAborted);
+ return OperationResult::kAborted;
}
base::OnceCallback<void(OperationResult)> TrackImpl::UpdateAppendCallback(
- const blink::WebElementaryMediaPacketMetadata& packet_metadata,
- size_t packet_size,
+ const Packet& packet,
base::OnceCallback<void(OperationResult)>&& append_cb) {
{
auto shared_state = state_->GetLockedState();
shared_state->is_keyframe_required = false;
++shared_state->any_thread_data.pending_appends;
- shared_state->OnPacketAddedToBuffer(packet_size);
+ shared_state->OnPacketAddedToBuffer(packet.data_size());
// If append will fail, OnAppendPacketDone will free reserved
// buffer space and packets count.
shared_state->any_thread_data.last_packet_timestamp =
std::max(shared_state->any_thread_data.last_packet_timestamp,
- packet_metadata.pts);
+ packet.timestamp().InSecondsF());
}
return base::BindOnce(TrackImpl::OnAppendPacketDone, shared_from_this(),
- packet_size, packet_metadata.is_encrypted,
- std::move(append_cb));
+ packet.data_size(), std::move(append_cb));
}
OperationResult TrackImpl::VerifyAppendPreconditionsWhileLocked(
#define TIZEN_SRC_CHROMIUM_IMPL_CONTENT_RENDERER_MEDIA_TIZEN_ELEMENTARY_MEDIA_STREAM_SOURCE_ANY_THREAD_TRACK_IMPL_H_
#include <memory>
+#include <tuple>
#include <vector>
#include "base/functional/callback.h"
#include "content/renderer/media/tizen/elementary_media_stream_source/any_thread/track_dispatcher_client.h"
#include "content/renderer/media/tizen/elementary_media_stream_source/any_thread/track_params.h"
#include "content/renderer/media/tizen/elementary_media_stream_source/common/common.h"
+#include "content/renderer/media/tizen/elementary_media_stream_source/common/packet.h"
#include "media/base/decrypt_config.h"
#include "media/base/demuxer_stream.h"
#include "third_party/blink/renderer/platform/elementary_media_stream_source/web_elementary_media_track_operations.h"
PlayerMode GetPlayerMode() const override;
uint32_t GetSessionId() const override;
void RegisterClient(WebElementaryMediaTrackOperationsClient*) override;
- void SetDecryptor(media::Decryptor*) override;
// SourceClient
void RegisterSessionIdChangeListener(
static void OnAppendPacketDone(
std::weak_ptr<TrackImpl>,
size_t data_size,
- bool is_encrypted,
base::OnceCallback<void(OperationResult)> append_cb,
OperationResult result);
- static void OnDecryptDone(
- media::DemuxerStream::Type type,
- blink::WebElementaryMediaPacketMetadata&& packet_metadata,
- uint32_t session_id,
- base::OnceCallback<void(OperationResult)> append_cb,
- mojo::ScopedSharedBufferHandle&& shared_memory,
- size_t data_size,
- worker_thread::TrackDispatcherClient* worker_track,
- any_thread::TrackDispatcherClient* any_track,
- media::Decryptor::Status status,
- scoped_refptr<media::DecoderBuffer> buffer);
-
OperationResult PrepareDemuxedFrameData(
blink::WebElementaryMediaPacketMetadata&& packet_metadata,
base::span<const uint8_t>&& packet_data,
uint32_t session_id,
base::OnceCallback<void(OperationResult)> append_cb);
- base::OnceCallback<void(OperationResult)> UpdateAppendCallback(
+ std::tuple<Packet, OperationResult> PreparePacket(
const blink::WebElementaryMediaPacketMetadata& packet_metadata,
- size_t packet_size,
+ base::span<const uint8_t>&& packet_data,
+ uint32_t session_id,
+ std::unique_ptr<media::DecryptConfig> maybe_decrypt_config = {});
+
+ OperationResult TransferPacketToWorkerThread(
+ Packet packet,
+ base::OnceCallback<void(OperationResult)> append_cb);
+
+ base::OnceCallback<void(OperationResult)> UpdateAppendCallback(
+ const Packet& packet,
base::OnceCallback<void(OperationResult)>&& append_cb);
OperationResult VerifyAppendPreconditionsWhileLocked(
const blink::WebElementaryMediaPacketMetadata& packet_metadata,
const base::span<const uint8_t>& packet_data);
- media::Decryptor* decryptor_;
std::weak_ptr<TrackDispatcher> dispatcher_;
std::weak_ptr<SessionIdChangeListener> session_id_change_listener_;
std::shared_ptr<LockableTrackState> state_;
projects / platform / framework / web / chromium-efl.git / commitdiff