Motown: Implement MediaTimelineController and use it.
Implemented MediaTimelineController, which aggregates multiple
MediaTimelineControlSites, and changed MediaPlayerImpl to use the
controller.
R=kulakowski@chromium.org
Review URL: https://codereview.chromium.org/2009643002 .
diff --git a/examples/media_test/media_test.h b/examples/media_test/media_test.h
index fc17161..ca16de2 100644
--- a/examples/media_test/media_test.h
+++ b/examples/media_test/media_test.h
@@ -8,7 +8,6 @@
#include "base/macros.h"
#include "mojo/public/cpp/application/application_impl.h"
#include "mojo/services/media/common/cpp/timeline_function.h"
-#include "mojo/services/media/common/interfaces/rate_control.mojom.h"
#include "mojo/services/media/control/interfaces/media_factory.mojom.h"
#include "mojo/services/media/control/interfaces/media_player.mojom.h"
diff --git a/mojo/dart/packages/mojo_services/lib/mojo/media/media_factory.mojom.dart b/mojo/dart/packages/mojo_services/lib/mojo/media/media_factory.mojom.dart
index f729ebb..50b5f37 100644
--- a/mojo/dart/packages/mojo_services/lib/mojo/media/media_factory.mojom.dart
+++ b/mojo/dart/packages/mojo_services/lib/mojo/media/media_factory.mojom.dart
@@ -14,6 +14,7 @@
import 'package:mojo_services/mojo/media/media_type_converter.mojom.dart' as media_type_converter_mojom;
import 'package:mojo_services/mojo/media/media_types.mojom.dart' as media_types_mojom;
import 'package:mojo_services/mojo/media/seeking_reader.mojom.dart' as seeking_reader_mojom;
+import 'package:mojo_services/mojo/media/timeline_controller.mojom.dart' as timeline_controller_mojom;
@@ -566,12 +567,84 @@
}
}
+
+class _MediaFactoryCreateTimelineControllerParams extends bindings.Struct {
+ static const List<bindings.StructDataHeader> kVersions = const [
+ const bindings.StructDataHeader(16, 0)
+ ];
+ timeline_controller_mojom.MediaTimelineControllerInterfaceRequest timelineController = null;
+
+ _MediaFactoryCreateTimelineControllerParams() : super(kVersions.last.size);
+
+ static _MediaFactoryCreateTimelineControllerParams deserialize(bindings.Message message) {
+ var decoder = new bindings.Decoder(message);
+ var result = decode(decoder);
+ if (decoder.excessHandles != null) {
+ decoder.excessHandles.forEach((h) => h.close());
+ }
+ return result;
+ }
+
+ static _MediaFactoryCreateTimelineControllerParams decode(bindings.Decoder decoder0) {
+ if (decoder0 == null) {
+ return null;
+ }
+ _MediaFactoryCreateTimelineControllerParams result = new _MediaFactoryCreateTimelineControllerParams();
+
+ var mainDataHeader = decoder0.decodeStructDataHeader();
+ if (mainDataHeader.version <= kVersions.last.version) {
+ // Scan in reverse order to optimize for more recent versions.
+ for (int i = kVersions.length - 1; i >= 0; --i) {
+ if (mainDataHeader.version >= kVersions[i].version) {
+ if (mainDataHeader.size == kVersions[i].size) {
+ // Found a match.
+ break;
+ }
+ throw new bindings.MojoCodecError(
+ 'Header size doesn\'t correspond to known version size.');
+ }
+ }
+ } else if (mainDataHeader.size < kVersions.last.size) {
+ throw new bindings.MojoCodecError(
+ 'Message newer than the last known version cannot be shorter than '
+ 'required by the last known version.');
+ }
+ if (mainDataHeader.version >= 0) {
+
+ result.timelineController = decoder0.decodeInterfaceRequest(8, false, timeline_controller_mojom.MediaTimelineControllerStub.newFromEndpoint);
+ }
+ return result;
+ }
+
+ void encode(bindings.Encoder encoder) {
+ var encoder0 = encoder.getStructEncoderAtOffset(kVersions.last);
+ try {
+ encoder0.encodeInterfaceRequest(timelineController, 8, false);
+ } on bindings.MojoCodecError catch(e) {
+ e.message = "Error encountered while encoding field "
+ "timelineController of struct _MediaFactoryCreateTimelineControllerParams: $e";
+ rethrow;
+ }
+ }
+
+ String toString() {
+ return "_MediaFactoryCreateTimelineControllerParams("
+ "timelineController: $timelineController" ")";
+ }
+
+ Map toJson() {
+ throw new bindings.MojoCodecError(
+ 'Object containing handles cannot be encoded to JSON.');
+ }
+}
+
const int _mediaFactoryMethodCreatePlayerName = 0;
const int _mediaFactoryMethodCreateSourceName = 1;
const int _mediaFactoryMethodCreateSinkName = 2;
const int _mediaFactoryMethodCreateDemuxName = 3;
const int _mediaFactoryMethodCreateDecoderName = 4;
const int _mediaFactoryMethodCreateNetworkReaderName = 5;
+const int _mediaFactoryMethodCreateTimelineControllerName = 6;
class _MediaFactoryServiceDescription implements service_describer.ServiceDescription {
dynamic getTopLevelInterface([Function responseFactory]) =>
@@ -612,6 +685,7 @@
void createDemux(seeking_reader_mojom.SeekingReaderInterface reader, media_demux_mojom.MediaDemuxInterfaceRequest demux);
void createDecoder(media_types_mojom.MediaType inputMediaType, media_type_converter_mojom.MediaTypeConverterInterfaceRequest decoder);
void createNetworkReader(String url, seeking_reader_mojom.SeekingReaderInterfaceRequest reader);
+ void createTimelineController(timeline_controller_mojom.MediaTimelineControllerInterfaceRequest timelineController);
}
abstract class MediaFactoryInterface
@@ -756,6 +830,16 @@
ctrl.sendMessage(params,
_mediaFactoryMethodCreateNetworkReaderName);
}
+ void createTimelineController(timeline_controller_mojom.MediaTimelineControllerInterfaceRequest timelineController) {
+ if (!ctrl.isBound) {
+ ctrl.proxyError("The Proxy is closed.");
+ return;
+ }
+ var params = new _MediaFactoryCreateTimelineControllerParams();
+ params.timelineController = timelineController;
+ ctrl.sendMessage(params,
+ _mediaFactoryMethodCreateTimelineControllerName);
+ }
}
class _MediaFactoryStubControl
@@ -821,6 +905,11 @@
message.payload);
_impl.createNetworkReader(params.url, params.reader);
break;
+ case _mediaFactoryMethodCreateTimelineControllerName:
+ var params = _MediaFactoryCreateTimelineControllerParams.deserialize(
+ message.payload);
+ _impl.createTimelineController(params.timelineController);
+ break;
default:
throw new bindings.MojoCodecError("Unexpected message name");
break;
@@ -897,6 +986,9 @@
void createNetworkReader(String url, seeking_reader_mojom.SeekingReaderInterfaceRequest reader) {
return impl.createNetworkReader(url, reader);
}
+ void createTimelineController(timeline_controller_mojom.MediaTimelineControllerInterfaceRequest timelineController) {
+ return impl.createTimelineController(timelineController);
+ }
}
diff --git a/mojo/services/media/control/interfaces/media_factory.mojom b/mojo/services/media/control/interfaces/media_factory.mojom
index c171886..6ad372a 100644
--- a/mojo/services/media/control/interfaces/media_factory.mojom
+++ b/mojo/services/media/control/interfaces/media_factory.mojom
@@ -12,6 +12,7 @@
import "mojo/services/media/core/interfaces/media_demux.mojom";
import "mojo/services/media/core/interfaces/media_type_converter.mojom";
import "mojo/services/media/core/interfaces/seeking_reader.mojom";
+import "mojo/services/media/core/interfaces/timeline_controller.mojom";
// Exposed by the factory service to create media-related agents.
[ServiceName="mojo::media::MediaFactory"]
@@ -42,4 +43,7 @@
// Creates a network reader.
CreateNetworkReader(string url, SeekingReader& reader);
+
+ // Creates a timeline controller reader.
+ CreateTimelineController(MediaTimelineController& timeline_controller);
};
diff --git a/services/media/factory_service/BUILD.gn b/services/media/factory_service/BUILD.gn
index 12f60e1..a38ba0d 100644
--- a/services/media/factory_service/BUILD.gn
+++ b/services/media/factory_service/BUILD.gn
@@ -28,6 +28,8 @@
"media_sink_impl.h",
"media_source_impl.cc",
"media_source_impl.h",
+ "media_timeline_controller_impl.cc",
+ "media_timeline_controller_impl.h",
"network_reader_impl.cc",
"network_reader_impl.h",
]
diff --git a/services/media/factory_service/factory_service.cc b/services/media/factory_service/factory_service.cc
index 94b4c9b..5d87ad4 100644
--- a/services/media/factory_service/factory_service.cc
+++ b/services/media/factory_service/factory_service.cc
@@ -8,6 +8,7 @@
#include "services/media/factory_service/media_player_impl.h"
#include "services/media/factory_service/media_sink_impl.h"
#include "services/media/factory_service/media_source_impl.h"
+#include "services/media/factory_service/media_timeline_controller_impl.h"
#include "services/media/factory_service/network_reader_impl.h"
namespace mojo {
@@ -64,5 +65,11 @@
AddProduct(NetworkReaderImpl::Create(url, reader.Pass(), this));
}
+void MediaFactoryService::CreateTimelineController(
+ InterfaceRequest<MediaTimelineController> timeline_controller) {
+ AddProduct(
+ MediaTimelineControllerImpl::Create(timeline_controller.Pass(), this));
+}
+
} // namespace media
} // namespace mojo
diff --git a/services/media/factory_service/factory_service.h b/services/media/factory_service/factory_service.h
index 8b4f520..c87e271 100644
--- a/services/media/factory_service/factory_service.h
+++ b/services/media/factory_service/factory_service.h
@@ -46,6 +46,9 @@
void CreateNetworkReader(const String& url,
InterfaceRequest<SeekingReader> reader) override;
+ void CreateTimelineController(
+ InterfaceRequest<MediaTimelineController> timeline_controller) override;
+
private:
BindingSet<MediaFactory> bindings_;
};
diff --git a/services/media/factory_service/media_player_impl.cc b/services/media/factory_service/media_player_impl.cc
index a963299..dcaa5f6 100644
--- a/services/media/factory_service/media_player_impl.cc
+++ b/services/media/factory_service/media_player_impl.cc
@@ -31,7 +31,7 @@
uint64_t version) {
MediaPlayerStatusPtr status = MediaPlayerStatus::New();
status->timeline_transform = TimelineTransform::From(timeline_function_);
- status->end_of_stream = AllSinksAtEndOfStream();
+ status->end_of_stream = end_of_stream_;
status->metadata = metadata_.Clone();
callback.Run(version, status.Pass());
});
@@ -41,27 +41,29 @@
ConnectToService(app()->shell(), "mojo:media_factory", GetProxy(&factory_));
factory_->CreateDemux(reader.Pass(), GetProxy(&demux_));
-
HandleDemuxMetadataUpdates();
+ factory_->CreateTimelineController(GetProxy(&timeline_controller_));
+ timeline_controller_->GetControlSite(GetProxy(&timeline_control_site_));
+ timeline_control_site_->GetTimelineConsumer(GetProxy(&timeline_consumer_));
+ HandleTimelineControlSiteStatusUpdates();
+
demux_->Describe([this](mojo::Array<MediaTypePtr> stream_types) {
// Populate streams_ and enable the streams we want.
std::shared_ptr<CallbackJoiner> callback_joiner = CallbackJoiner::Create();
for (MediaTypePtr& stream_type : stream_types) {
- streams_.push_back(std::unique_ptr<Stream>(
- new Stream(streams_.size(), stream_type.Pass())));
+ streams_.push_back(std::unique_ptr<Stream>(new Stream()));
Stream& stream = *streams_.back();
- switch (stream.media_type_->medium) {
+ switch (stream_type->medium) {
case MediaTypeMedium::AUDIO:
- stream.enabled_ = true;
- PrepareStream(&stream, "mojo:audio_server",
- callback_joiner->NewCallback());
+ PrepareStream(&stream, streams_.size() - 1, stream_type,
+ "mojo:audio_server", callback_joiner->NewCallback());
break;
case MediaTypeMedium::VIDEO:
- stream.enabled_ = true;
// TODO(dalesat): Send video somewhere.
- PrepareStream(&stream, "nowhere", callback_joiner->NewCallback());
+ PrepareStream(&stream, streams_.size() - 1, stream_type, "nowhere",
+ callback_joiner->NewCallback());
break;
// TODO(dalesat): Enable other stream types.
default:
@@ -91,7 +93,7 @@
if (target_state_ == State::kPlaying) {
if (!flushed_) {
- SetSinkTimelineTransforms(1, 1);
+ SetTimelineTransform(1, 1);
state_ = State::kWaiting;
break;
}
@@ -99,7 +101,7 @@
flushed_ = false;
state_ = State::kWaiting;
demux_->Prime([this]() {
- SetSinkTimelineTransforms(1, 1);
+ SetTimelineTransform(1, 1);
state_ = State::kWaiting;
Update();
});
@@ -109,12 +111,12 @@
case State::kPlaying:
if (target_position_ != kUnspecifiedTime ||
target_state_ == State::kPaused) {
- SetSinkTimelineTransforms(1, 0);
+ SetTimelineTransform(1, 0);
state_ = State::kWaiting;
break;
}
- if (AllSinksAtEndOfStream()) {
+ if (end_of_stream_) {
target_state_ = State::kPaused;
state_ = State::kPaused;
break;
@@ -150,62 +152,22 @@
});
}
-void MediaPlayerImpl::SetSinkTimelineTransforms(uint32_t reference_delta,
- uint32_t subject_delta) {
- SetSinkTimelineTransforms(
+void MediaPlayerImpl::SetTimelineTransform(uint32_t reference_delta,
+ uint32_t subject_delta) {
+ timeline_consumer_->SetTimelineTransform(
transform_subject_time_, reference_delta, subject_delta,
- Timeline::local_now() + kMinimumLeadTime, kUnspecifiedTime);
-}
+ Timeline::local_now() + kMinimumLeadTime, kUnspecifiedTime,
+ [this, subject_delta](bool completed) {
+ RCHECK(state_ == State::kWaiting);
-void MediaPlayerImpl::SetSinkTimelineTransforms(
- int64_t subject_time,
- uint32_t reference_delta,
- uint32_t subject_delta,
- int64_t effective_reference_time,
- int64_t effective_subject_time) {
- std::shared_ptr<CallbackJoiner> callback_joiner = CallbackJoiner::Create();
+ if (subject_delta == 0) {
+ state_ = State::kPaused;
+ } else {
+ state_ = State::kPlaying;
+ }
- for (auto& stream : streams_) {
- if (stream->enabled_) {
- DCHECK(stream->timeline_consumer_);
- callback_joiner->Spawn();
- stream->timeline_consumer_->SetTimelineTransform(
- subject_time, reference_delta, subject_delta,
- effective_reference_time, effective_subject_time,
- [this, callback_joiner](bool completed) {
- callback_joiner->Complete();
- });
- }
- }
-
- transform_subject_time_ = kUnspecifiedTime;
-
- callback_joiner->WhenJoined([this, subject_delta]() {
- RCHECK(state_ == State::kWaiting);
-
- if (subject_delta == 0) {
- state_ = State::kPaused;
- } else {
- state_ = State::kPlaying;
- }
-
- Update();
- });
-}
-
-bool MediaPlayerImpl::AllSinksAtEndOfStream() {
- int result = false;
-
- for (auto& stream : streams_) {
- if (stream->enabled_) {
- result = stream->end_of_stream_;
- if (!result) {
- break;
- }
- }
- }
-
- return result;
+ Update();
+ });
}
void MediaPlayerImpl::GetStatus(uint64_t version_last_seen,
@@ -229,19 +191,21 @@
}
void MediaPlayerImpl::PrepareStream(Stream* stream,
+ size_t index,
+ const MediaTypePtr& input_media_type,
const String& url,
const std::function<void()>& callback) {
DCHECK(factory_);
- demux_->GetProducer(stream->index_, GetProxy(&stream->encoded_producer_));
+ demux_->GetProducer(index, GetProxy(&stream->encoded_producer_));
- if (stream->media_type_->encoding != MediaType::kAudioEncodingLpcm &&
- stream->media_type_->encoding != MediaType::kVideoEncodingUncompressed) {
+ if (input_media_type->encoding != MediaType::kAudioEncodingLpcm &&
+ input_media_type->encoding != MediaType::kVideoEncodingUncompressed) {
std::shared_ptr<CallbackJoiner> callback_joiner = CallbackJoiner::Create();
// Compressed media. Insert a decoder in front of the sink. The sink would
// add its own internal decoder, but we want to test the decoder.
- factory_->CreateDecoder(stream->media_type_.Clone(),
+ factory_->CreateDecoder(input_media_type.Clone(),
GetProxy(&stream->decoder_));
MediaConsumerPtr decoder_consumer;
@@ -268,7 +232,7 @@
// would work for compressed media as well (the sink would decode), but we
// want to test the decoder.
stream->decoded_producer_ = stream->encoded_producer_.Pass();
- CreateSink(stream, stream->media_type_, url, callback);
+ CreateSink(stream, input_media_type, url, callback);
}
}
@@ -281,13 +245,11 @@
DCHECK(factory_);
factory_->CreateSink(url, input_media_type.Clone(), GetProxy(&stream->sink_));
- stream->sink_->GetTimelineControlSite(
- GetProxy(&stream->timeline_control_site_));
- HandleTimelineControlSiteStatusUpdates(stream);
+ MediaTimelineControlSitePtr timeline_control_site;
+ stream->sink_->GetTimelineControlSite(GetProxy(&timeline_control_site));
- stream->timeline_control_site_->GetTimelineConsumer(
- GetProxy(&stream->timeline_consumer_));
+ timeline_controller_->AddControlSite(timeline_control_site.Pass());
MediaConsumerPtr consumer;
stream->sink_->GetConsumer(GetProxy(&consumer));
@@ -313,26 +275,23 @@
}
void MediaPlayerImpl::HandleTimelineControlSiteStatusUpdates(
- Stream* stream,
uint64_t version,
MediaTimelineControlSiteStatusPtr status) {
if (status) {
- // TODO(dalesat): Why does one sink determine timeline_function_?
timeline_function_ = status->timeline_transform.To<TimelineFunction>();
- stream->end_of_stream_ = status->end_of_stream;
+ end_of_stream_ = status->end_of_stream;
status_publisher_.SendUpdates();
Update();
}
- stream->timeline_control_site_->GetStatus(
- version, [this, stream](uint64_t version,
- MediaTimelineControlSiteStatusPtr status) {
- HandleTimelineControlSiteStatusUpdates(stream, version, status.Pass());
+ timeline_control_site_->GetStatus(
+ version,
+ [this](uint64_t version, MediaTimelineControlSiteStatusPtr status) {
+ HandleTimelineControlSiteStatusUpdates(version, status.Pass());
});
}
-MediaPlayerImpl::Stream::Stream(size_t index, MediaTypePtr media_type)
- : index_(index), media_type_(media_type.Pass()) {}
+MediaPlayerImpl::Stream::Stream() {}
MediaPlayerImpl::Stream::~Stream() {}
diff --git a/services/media/factory_service/media_player_impl.h b/services/media/factory_service/media_player_impl.h
index d9b5be8..6ee1061 100644
--- a/services/media/factory_service/media_player_impl.h
+++ b/services/media/factory_service/media_player_impl.h
@@ -15,6 +15,7 @@
#include "mojo/services/media/common/interfaces/media_transport.mojom.h"
#include "mojo/services/media/control/interfaces/media_factory.mojom.h"
#include "mojo/services/media/core/interfaces/seeking_reader.mojom.h"
+#include "mojo/services/media/core/interfaces/timeline_controller.mojom.h"
#include "services/media/common/mojo_publisher.h"
#include "services/media/factory_service/factory_service.h"
#include "services/media/framework/util/callback_joiner.h"
@@ -54,16 +55,13 @@
};
struct Stream {
- Stream(size_t index, MediaTypePtr media_type);
+ Stream();
~Stream();
- size_t index_;
- bool enabled_ = false;
- bool end_of_stream_ = false;
- MediaTypePtr media_type_;
+ // TODO(dalesat): Have the sink enlist the decoder.
MediaTypeConverterPtr decoder_;
MediaSinkPtr sink_;
- MediaTimelineControlSitePtr timeline_control_site_;
- TimelineConsumerPtr timeline_consumer_;
+ // The following fields are just temporaries used to solve lambda capture
+ // problems.
MediaProducerPtr encoded_producer_;
MediaProducerPtr decoded_producer_;
};
@@ -81,25 +79,15 @@
// Handles seeking in paused state with flushed pipeline.
void WhenFlushedAndSeeking();
- // Sets the timeline transforms on all the sinks. transform_subject_time_ is
- // used for the subject_time, and the effective_reference_time is now plus an
- // epsilon.
- void SetSinkTimelineTransforms(uint32_t reference_delta,
- uint32_t subject_delta);
-
- // Sets the timeline transforms on all the sinks.
- void SetSinkTimelineTransforms(int64_t subject_time,
- uint32_t reference_delta,
- uint32_t subject_delta,
- int64_t effective_reference_time,
- int64_t effective_subject_time);
-
- // Determines if all the enabled sinks have reached end-of-stream. Returns
- // false if there are no enabled streams.
- bool AllSinksAtEndOfStream();
+ // Sets the timeline transform. transform_subject_time_ is used for the
+ // subject_time, and the effective_reference_time is now plus
+ // kMinimumLeadTime.
+ void SetTimelineTransform(uint32_t reference_delta, uint32_t subject_delta);
// Prepares a stream.
void PrepareStream(Stream* stream,
+ size_t index,
+ const MediaTypePtr& input_media_type,
const String& url,
const std::function<void()>& callback);
@@ -115,19 +103,22 @@
uint64_t version = MediaDemux::kInitialMetadata,
MediaMetadataPtr metadata = nullptr);
- // Handles a status update from a control site. When called with the default
+ // Handles a status update from the control site. When called with the default
// argument values, initiates control site. status updates.
void HandleTimelineControlSiteStatusUpdates(
- Stream* stream,
uint64_t version = MediaTimelineControlSite::kInitialStatus,
MediaTimelineControlSiteStatusPtr status = nullptr);
MediaFactoryPtr factory_;
MediaDemuxPtr demux_;
+ MediaTimelineControllerPtr timeline_controller_;
+ MediaTimelineControlSitePtr timeline_control_site_;
+ TimelineConsumerPtr timeline_consumer_;
std::vector<std::unique_ptr<Stream>> streams_;
State state_ = State::kWaiting;
State target_state_ = State::kPaused;
bool flushed_ = true;
+ bool end_of_stream_ = false;
int64_t target_position_ = kUnspecifiedTime;
int64_t transform_subject_time_ = kUnspecifiedTime;
TimelineFunction timeline_function_;
diff --git a/services/media/factory_service/media_timeline_controller_impl.cc b/services/media/factory_service/media_timeline_controller_impl.cc
new file mode 100644
index 0000000..54bb564
--- /dev/null
+++ b/services/media/factory_service/media_timeline_controller_impl.cc
@@ -0,0 +1,264 @@
+// Copyright 2016 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.
+
+#include "base/logging.h"
+#include "mojo/services/media/common/cpp/timeline.h"
+#include "services/media/factory_service/media_timeline_controller_impl.h"
+#include "services/media/framework_mojo/mojo_type_conversions.h"
+
+namespace mojo {
+namespace media {
+
+// static
+std::shared_ptr<MediaTimelineControllerImpl>
+MediaTimelineControllerImpl::Create(
+ InterfaceRequest<MediaTimelineController> request,
+ MediaFactoryService* owner) {
+ return std::shared_ptr<MediaTimelineControllerImpl>(
+ new MediaTimelineControllerImpl(request.Pass(), owner));
+}
+
+MediaTimelineControllerImpl::MediaTimelineControllerImpl(
+ InterfaceRequest<MediaTimelineController> request,
+ MediaFactoryService* owner)
+ : MediaFactoryService::Product<MediaTimelineController>(this,
+ request.Pass(),
+ owner),
+ control_site_binding_(this),
+ consumer_binding_(this) {
+ status_publisher_.SetCallbackRunner(
+ [this](const GetStatusCallback& callback, uint64_t version) {
+ MediaTimelineControlSiteStatusPtr status =
+ MediaTimelineControlSiteStatus::New();
+ status->timeline_transform =
+ mojo::TimelineTransform::From(current_timeline_function_);
+ status->end_of_stream = end_of_stream_;
+ callback.Run(version, status.Pass());
+ });
+}
+
+MediaTimelineControllerImpl::~MediaTimelineControllerImpl() {
+ status_publisher_.SendUpdates();
+}
+
+void MediaTimelineControllerImpl::AddControlSite(
+ InterfaceHandle<MediaTimelineControlSite> control_site) {
+ site_states_.emplace_back(
+ this, MediaTimelineControlSitePtr::Create(std::move(control_site)));
+ site_states_.back().HandleStatusUpdates();
+}
+
+void MediaTimelineControllerImpl::GetControlSite(
+ InterfaceRequest<MediaTimelineControlSite> control_site) {
+ if (control_site_binding_.is_bound()) {
+ control_site_binding_.Close();
+ }
+
+ control_site_binding_.Bind(control_site.Pass());
+}
+
+void MediaTimelineControllerImpl::GetStatus(uint64_t version_last_seen,
+ const GetStatusCallback& callback) {
+ status_publisher_.Get(version_last_seen, callback);
+}
+
+void MediaTimelineControllerImpl::GetTimelineConsumer(
+ InterfaceRequest<TimelineConsumer> timeline_consumer) {
+ if (consumer_binding_.is_bound()) {
+ consumer_binding_.Close();
+ }
+
+ consumer_binding_.Bind(timeline_consumer.Pass());
+}
+
+void MediaTimelineControllerImpl::SetTimelineTransform(
+ int64_t subject_time,
+ uint32_t reference_delta,
+ uint32_t subject_delta,
+ int64_t effective_reference_time,
+ int64_t effective_subject_time,
+ const SetTimelineTransformCallback& callback) {
+ // At most one effective time may be specified.
+ RCHECK(effective_subject_time == kUnspecifiedTime ||
+ effective_reference_time == kUnspecifiedTime);
+ // effective_subject_time can only be specified if we're progressing.
+ RCHECK(effective_subject_time == kUnspecifiedTime ||
+ current_timeline_function_.subject_delta() != 0u);
+ RCHECK(reference_delta != 0);
+
+ // There can only be once SetTimelineTransform transition pending at any
+ // moment, so a new SetTimelineTransform call that arrives before a previous
+ // one completes cancels the previous one. This causes some problems for us,
+ // because some sites may complete the previous transition while other may
+ // not.
+ //
+ // We start by noticing that there's an incomplete previous transition, and
+ // we 'cancel' it, meaning we call its callback with a false complete
+ // parameter.
+ //
+ // If we're cancelling a previous transition, we need to take steps to make
+ // sure the sites will end up in the right state regardless of whether they
+ // completed the previous transition. We do two things:
+ //
+ // 1) If subject_time isn't specified, we infer it here and supply the
+ // inferred value to the sites, so there's no disagreement about its
+ // value.
+ // 2) If the effective_subject_time is specified rather than the
+ // effective_reference_time, we infer effective_reference_time and send
+ // it to the sites instead of effective_subject_time, so there's no
+ // disagreement about effective time and so that no sites reject the
+ // transition due to having a zero subject_delta.
+
+ std::shared_ptr<TimelineTransition> pending_transition =
+ pending_transition_.lock();
+ if (pending_transition) {
+ // A transition is pending - cancel it.
+ pending_transition->Cancel();
+ }
+
+ // These will be recorded as part of the new TimelineFunction.
+ int64_t new_reference_time;
+ int64_t new_subject_time;
+
+ if (effective_subject_time != kUnspecifiedTime) {
+ // Infer new_reference_time from effective_subject_time.
+ new_reference_time =
+ current_timeline_function_.ApplyInverse(effective_subject_time);
+
+ // Figure out what the subject_time will be after this transition.
+ if (subject_time == kUnspecifiedTime) {
+ new_subject_time = effective_subject_time;
+ } else {
+ new_subject_time = subject_time;
+ }
+ } else {
+ if (effective_reference_time == kUnspecifiedTime) {
+ // Neither effective time was specified. Effective time is now.
+ effective_reference_time = Timeline::local_now() + kDefaultLeadTime;
+ }
+
+ // new_reference_time is just effective_reference_time.
+ new_reference_time = effective_reference_time;
+
+ // Figure out what the subject_time will be after this transition.
+ if (subject_time == kUnspecifiedTime) {
+ new_subject_time = current_timeline_function_(effective_reference_time);
+ } else {
+ new_subject_time = subject_time;
+ }
+ }
+
+ if (pending_transition) {
+ // This transition cancels a previous one. Use effective_reference_time
+ // rather than effective_subject_time, because we can't be sure what
+ // effective_subject_time will mean to the sites.
+ effective_reference_time = new_reference_time;
+ effective_subject_time = kUnspecifiedTime;
+
+ // We don't want the sites to have to infer the subject_time, because we
+ // can't be sure what subject_time a site will infer.
+ subject_time = new_subject_time;
+ }
+
+ // Recording the new pending transition.
+ std::shared_ptr<TimelineTransition> transition =
+ std::shared_ptr<TimelineTransition>(
+ new TimelineTransition(new_reference_time, new_subject_time,
+ reference_delta, subject_delta, callback));
+
+ pending_transition_ = transition;
+
+ // Initiate the transition for each site.
+ for (const SiteState& site_state : site_states_) {
+ site_state.consumer_->SetTimelineTransform(
+ subject_time, reference_delta, subject_delta, effective_reference_time,
+ effective_subject_time, transition->NewCallback());
+ }
+
+ // If and when this transition is complete, adopt the new TimelineFunction
+ // and tell any status subscribers.
+ transition->WhenCompleted([this, transition]() {
+ current_timeline_function_ = transition->new_timeline_function();
+ status_publisher_.SendUpdates();
+ });
+}
+
+void MediaTimelineControllerImpl::HandleSiteEndOfStreamChange() {
+ bool end_of_stream = true;
+ for (const SiteState& site_state : site_states_) {
+ if (!site_state.end_of_stream_) {
+ end_of_stream = false;
+ break;
+ }
+ }
+
+ if (end_of_stream_ != end_of_stream) {
+ end_of_stream_ = end_of_stream;
+ status_publisher_.SendUpdates();
+ }
+}
+
+MediaTimelineControllerImpl::SiteState::SiteState(
+ MediaTimelineControllerImpl* parent,
+ MediaTimelineControlSitePtr site)
+ : parent_(parent), site_(site.Pass()) {
+ site_->GetTimelineConsumer(GetProxy(&consumer_));
+}
+
+MediaTimelineControllerImpl::SiteState::SiteState(SiteState&& other)
+ : parent_(other.parent_),
+ site_(other.site_.Pass()),
+ consumer_(other.consumer_.Pass()) {}
+
+MediaTimelineControllerImpl::SiteState::~SiteState() {}
+
+void MediaTimelineControllerImpl::SiteState::HandleStatusUpdates(
+ uint64_t version,
+ MediaTimelineControlSiteStatusPtr status) {
+ if (status) {
+ // Respond to any end-of-stream changes.
+ if (end_of_stream_ != status->end_of_stream) {
+ end_of_stream_ = status->end_of_stream;
+ parent_->HandleSiteEndOfStreamChange();
+ }
+ }
+
+ site_->GetStatus(version, [this](uint64_t version,
+ MediaTimelineControlSiteStatusPtr status) {
+ HandleStatusUpdates(version, status.Pass());
+ });
+}
+
+MediaTimelineControllerImpl::TimelineTransition::TimelineTransition(
+ int64_t reference_time,
+ int64_t subject_time,
+ uint32_t reference_delta,
+ uint32_t subject_delta,
+ const SetTimelineTransformCallback& callback)
+ : new_timeline_function_(reference_time,
+ subject_time,
+ reference_delta,
+ subject_delta),
+ callback_(callback) {
+ DCHECK(!callback_.is_null());
+ callback_joiner_.WhenJoined([this]() {
+ if (cancelled_) {
+ DCHECK(callback_.is_null());
+ return;
+ }
+
+ DCHECK(!callback_.is_null());
+ callback_.Run(true);
+ callback_.reset();
+ if (!completed_callback_.is_null()) {
+ completed_callback_.Run();
+ completed_callback_.reset();
+ }
+ });
+}
+
+MediaTimelineControllerImpl::TimelineTransition::~TimelineTransition() {}
+
+} // namespace media
+} // namespace mojo
diff --git a/services/media/factory_service/media_timeline_controller_impl.h b/services/media/factory_service/media_timeline_controller_impl.h
new file mode 100644
index 0000000..7dca89d
--- /dev/null
+++ b/services/media/factory_service/media_timeline_controller_impl.h
@@ -0,0 +1,161 @@
+// Copyright 2016 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 MOJO_SERVICES_MEDIA_FACTORY_TIMELINE_CONTROLLER_IMPL_H_
+#define MOJO_SERVICES_MEDIA_FACTORY_TIMELINE_CONTROLLER_IMPL_H_
+
+#include <memory>
+#include <vector>
+
+#include "mojo/public/cpp/bindings/binding.h"
+#include "mojo/services/media/common/cpp/local_time.h"
+#include "mojo/services/media/common/cpp/timeline.h"
+#include "mojo/services/media/common/cpp/timeline_function.h"
+#include "mojo/services/media/core/interfaces/timeline_controller.mojom.h"
+#include "services/media/common/mojo_publisher.h"
+#include "services/media/factory_service/factory_service.h"
+#include "services/media/framework/util/callback_joiner.h"
+
+namespace mojo {
+namespace media {
+
+// Mojo agent that controls timing in a graph.
+class MediaTimelineControllerImpl
+ : public MediaFactoryService::Product<MediaTimelineController>,
+ public MediaTimelineController,
+ public MediaTimelineControlSite,
+ public TimelineConsumer {
+ public:
+ static std::shared_ptr<MediaTimelineControllerImpl> Create(
+ InterfaceRequest<MediaTimelineController> request,
+ MediaFactoryService* owner);
+
+ ~MediaTimelineControllerImpl() override;
+
+ // MediaTimelineController implementation.
+ void AddControlSite(
+ InterfaceHandle<MediaTimelineControlSite> control_site) override;
+
+ void GetControlSite(
+ InterfaceRequest<MediaTimelineControlSite> control_site) override;
+
+ // MediaTimelineControlSite implementation.
+ void GetStatus(uint64_t version_last_seen,
+ const GetStatusCallback& callback) override;
+
+ void GetTimelineConsumer(
+ InterfaceRequest<TimelineConsumer> timeline_consumer) override;
+
+ // TimelineConsumer implementation.
+ void SetTimelineTransform(
+ int64_t subject_time,
+ uint32_t reference_delta,
+ uint32_t subject_delta,
+ int64_t effective_reference_time,
+ int64_t effective_subject_time,
+ const SetTimelineTransformCallback& callback) override;
+
+ private:
+ static constexpr int64_t kDefaultLeadTime = Timeline::ns_from_ms(30);
+
+ // Relationship to subordinate control site.
+ struct SiteState {
+ SiteState(MediaTimelineControllerImpl* parent,
+ MediaTimelineControlSitePtr site);
+
+ SiteState(SiteState&& other);
+
+ ~SiteState();
+
+ void HandleStatusUpdates(
+ uint64_t version = MediaTimelineControlSite::kInitialStatus,
+ MediaTimelineControlSiteStatusPtr status = nullptr);
+
+ MediaTimelineControllerImpl* parent_;
+ MediaTimelineControlSitePtr site_;
+ TimelineConsumerPtr consumer_;
+ bool end_of_stream_ = false;
+ };
+
+ class TimelineTransition
+ : public std::enable_shared_from_this<TimelineTransition> {
+ public:
+ TimelineTransition(int64_t reference_time,
+ int64_t subject_time,
+ uint32_t reference_delta,
+ uint32_t subject_delta,
+ const SetTimelineTransformCallback& callback);
+
+ ~TimelineTransition();
+
+ // Calls returns a new callback for a child (site) transition. THIS METHOD
+ // WILL ONLY WORK IF THERE IS ALREADY A SHARED POINTER TO THIS OBJECT.
+ std::function<void(bool)> NewCallback() {
+ callback_joiner_.Spawn();
+
+ std::shared_ptr<TimelineTransition> this_ptr = shared_from_this();
+ DCHECK(!this_ptr.unique());
+
+ return [this_ptr](bool completed) {
+ DCHECK(this_ptr);
+ if (!completed && !this_ptr->cancelled_) {
+ LOG(WARNING) << "A site transition was cancelled unexpectedly.";
+ }
+ this_ptr->callback_joiner_.Complete();
+ };
+ }
+
+ // Cancels this transition.
+ void Cancel() {
+ DCHECK(!cancelled_);
+ cancelled_ = true;
+ DCHECK(callback_.is_null());
+ callback_.Run(false);
+ callback_.reset();
+ completed_callback_.reset();
+ }
+
+ // Specifies a callback to be called if and when the transition is complete.
+ // The callback will never be called if the transition is cancelled.
+ void WhenCompleted(const mojo::Callback<void()>& completed_callback) {
+ DCHECK(completed_callback_.is_null());
+ if (callback_.is_null() && !cancelled_) {
+ completed_callback.Run();
+ } else {
+ completed_callback_ = completed_callback;
+ }
+ }
+
+ // Returns the TimelineFunction that will result from this transition.
+ const TimelineFunction& new_timeline_function() const {
+ return new_timeline_function_;
+ }
+
+ private:
+ TimelineFunction new_timeline_function_;
+ SetTimelineTransformCallback callback_;
+ CallbackJoiner callback_joiner_;
+ bool cancelled_ = false;
+ Callback<void()> completed_callback_;
+ };
+
+ MediaTimelineControllerImpl(InterfaceRequest<MediaTimelineController> request,
+ MediaFactoryService* owner);
+
+ // Takes action when a site changes its end-of-stream value.
+ void HandleSiteEndOfStreamChange();
+
+ Binding<MediaTimelineControlSite> control_site_binding_;
+ Binding<TimelineConsumer> consumer_binding_;
+ MojoPublisher<GetStatusCallback> status_publisher_;
+ std::vector<SiteState> site_states_;
+ TimelineFunction current_timeline_function_;
+ bool end_of_stream_;
+ std::weak_ptr<TimelineTransition> pending_transition_;
+};
+
+} // namespace media
+} // namespace mojo
+
+#endif // MOJO_SERVICES_MEDIA_FACTORY_TIMELINE_CONTROLLER_IMPL_H_
diff --git a/services/media/framework/util/callback_joiner.h b/services/media/framework/util/callback_joiner.h
index 0c035ba..35fb353 100644
--- a/services/media/framework/util/callback_joiner.h
+++ b/services/media/framework/util/callback_joiner.h
@@ -73,7 +73,7 @@
DCHECK(counter_ != 0);
--counter_;
if (counter_ == 0) {
- mojo::Callback<void()> join_callback;
+ Callback<void()> join_callback;
join_callback = join_callback_;
join_callback_.reset();
join_callback.Run();
@@ -97,7 +97,7 @@
// immediately. If child operations are pending, the callback is copied. The
// copy called later (and reset) when all child oeprations have completed.
// Only one callback at a time can be registered with WhenJoined.
- void WhenJoined(const mojo::Callback<void()>& join_callback) {
+ void WhenJoined(const Callback<void()>& join_callback) {
DCHECK(join_callback_.is_null());
if (counter_ == 0) {
join_callback.Run();
@@ -116,7 +116,7 @@
private:
size_t counter_ = 0;
- mojo::Callback<void()> join_callback_;
+ Callback<void()> join_callback_;
};
} // namespace media
diff --git a/services/media/framework_mojo/mojo_producer.h b/services/media/framework_mojo/mojo_producer.h
index fb8b12a..ed78add 100644
--- a/services/media/framework_mojo/mojo_producer.h
+++ b/services/media/framework_mojo/mojo_producer.h
@@ -8,7 +8,6 @@
#include "base/single_thread_task_runner.h"
#include "base/synchronization/lock.h"
#include "mojo/common/binding_set.h"
-#include "mojo/services/media/common/interfaces/media_state.mojom.h"
#include "mojo/services/media/common/interfaces/media_transport.mojom.h"
#include "services/media/framework/models/active_sink.h"
#include "services/media/framework_mojo/mojo_allocator.h"
diff --git a/services/media/framework_mojo/mojo_pull_mode_producer.cc b/services/media/framework_mojo/mojo_pull_mode_producer.cc
index f953aa5..f0101b9 100644
--- a/services/media/framework_mojo/mojo_pull_mode_producer.cc
+++ b/services/media/framework_mojo/mojo_pull_mode_producer.cc
@@ -9,8 +9,7 @@
namespace media {
MojoPullModeProducer::MojoPullModeProducer()
- : state_(MediaState::UNPREPARED),
- demand_(Demand::kNegative),
+ : demand_(Demand::kNegative),
pts_(0),
cached_packet_(nullptr) {}
@@ -28,13 +27,6 @@
mojo_allocator_.InitNew(256 * 1024); // TODO(dalesat): Made up!
}
- {
- base::AutoLock lock(lock_);
- if (state_ == MediaState::UNPREPARED) {
- state_ = MediaState::PAUSED;
- }
- }
-
callback.Run(mojo_allocator_.GetDuplicateHandle());
DCHECK(!cached_packet_);
@@ -52,11 +44,11 @@
{
base::AutoLock lock(lock_);
- if (state_ == MediaState::UNPREPARED) {
+ //if (state_ == MediaState::UNPREPARED) {
// The consumer has yet to call GetBuffer. This request will have to wait.
- pending_pulls_.push_back(callback);
- return;
- }
+ // pending_pulls_.push_back(callback);
+ // return;
+ //}
DCHECK(mojo_allocator_.initialized());
@@ -111,7 +103,6 @@
Demand MojoPullModeProducer::SupplyPacket(PacketPtr packet) {
base::AutoLock lock(lock_);
DCHECK(demand_ != Demand::kNegative) << "packet pushed with negative demand";
- DCHECK(state_ != MediaState::ENDED) << "packet pushed after end-of-stream";
DCHECK(!cached_packet_);
@@ -119,7 +110,6 @@
// happen if a pull client disconnects unexpectedly.
if (bindings_.size() == 0) {
demand_ = Demand::kNegative;
- state_ = MediaState::UNPREPARED;
// TODO(dalesat): More shutdown?
return demand_;
}
@@ -152,11 +142,11 @@
DCHECK(!callback.is_null());
lock_.AssertAcquired();
- if (state_ == MediaState::ENDED) {
+ //if (state_ == MediaState::ENDED) {
// At end-of-stream. Respond with empty end-of-stream packet.
- HandlePullWithPacketUnsafe(callback, Packet::CreateEndOfStream(pts_));
- return true;
- }
+ // HandlePullWithPacketUnsafe(callback, Packet::CreateEndOfStream(pts_));
+ // return true;
+ //}
if (!cached_packet_) {
// Waiting for packet or end-of-stream indication.
diff --git a/services/media/framework_mojo/mojo_pull_mode_producer.h b/services/media/framework_mojo/mojo_pull_mode_producer.h
index 0d27a74..741458c 100644
--- a/services/media/framework_mojo/mojo_pull_mode_producer.h
+++ b/services/media/framework_mojo/mojo_pull_mode_producer.h
@@ -9,7 +9,6 @@
#include "base/synchronization/lock.h"
#include "mojo/common/binding_set.h"
-#include "mojo/services/media/common/interfaces/media_state.mojom.h"
#include "mojo/services/media/common/interfaces/media_transport.mojom.h"
#include "services/media/framework/models/active_sink.h"
#include "services/media/framework_mojo/mojo_allocator.h"
@@ -72,7 +71,6 @@
mutable base::Lock lock_;
// THE FIELDS BELOW SHOULD ONLY BE ACCESSED WITH lock_ TAKEN.
- MediaState state_;
Demand demand_;
int64_t pts_;
