blob: 5ce63413ae4296ce3b04ccd4c0673fc3c90ea28e [file] [log] [blame]
// 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/callback.h"
#include "base/macros.h"
#include "base/memory/weak_ptr.h"
#include "base/threading/thread_checker.h"
#include "base/time/time.h"
#include "media/base/media_export.h"
#include "media/base/pipeline.h"
#include "media/base/renderer.h"
namespace media {
class Demuxer;
// PipelineController wraps a Pipeline to expose the one-at-a-time operations
// (Seek(), Suspend(), and Resume()) with a simpler API. Internally it tracks
// pending operations and dispatches them when possible. Duplicate requests
// (such as seeking twice to the same time) may be elided.
// TODO(sandersd):
// - Expose an operation that restarts via suspend+resume.
// - Block invalid calls after an error occurs.
class MEDIA_EXPORT PipelineController {
enum class State {
using RendererFactoryCB = base::Callback<std::unique_ptr<Renderer>(void)>;
using SeekedCB = base::Callback<void(bool time_updated)>;
using SuspendedCB = base::Callback<void()>;
using BeforeResumeCB = base::Callback<void()>;
using ResumedCB = base::Callback<void()>;
// Construct a PipelineController wrapping |pipeline_|. |pipeline_| must
// outlive the resulting PipelineController. The callbacks are:
// - |renderer_factory_cb| is called by PipelineController to create new
// renderers when starting and resuming.
// - |seeked_cb| is called upon reaching a stable state if a seek occured.
// - |suspended_cb| is called immediately after suspending.
// - |before_resume_cb| is called immediately before resuming.
// - |resumed_cb| is called immediately after resuming.
// - |error_cb| is called if any operation on |pipeline_| does not result
// in PIPELINE_OK or its error callback is called.
PipelineController(Pipeline* pipeline,
const RendererFactoryCB& renderer_factory_cb,
const SeekedCB& seeked_cb,
const SuspendedCB& suspended_cb,
const BeforeResumeCB& before_resume_cb,
const ResumedCB& resumed_cb,
const PipelineStatusCB& error_cb);
// Start |pipeline_|. |demuxer| will be retained and StartWaitingForSeek()/
// CancelPendingSeek() will be issued to it as necessary.
// When |is_streaming| is true, Resume() will always start at the
// beginning of the stream, rather than attempting to seek to the current
// time.
// When |is_static| is true, seeks to the current time may be elided.
// Otherwise it is assumed that the media data may have changed.
// The remaining parameters are just passed directly to pipeline_.Start().
void Start(Demuxer* demuxer,
Pipeline::Client* client,
bool is_streaming,
bool is_static);
// Request a seek to |time|. If |time_updated| is true, then the eventual
// |seeked_cb| callback will also have |time_updated| set to true; it
// indicates that the seek was requested by Blink and a time update is
// expected so that Blink can fire the seeked event.
void Seek(base::TimeDelta time, bool time_updated);
// Request that |pipeline_| be suspended. This is a no-op if |pipeline_| has
// been suspended.
void Suspend();
// Request that |pipeline_| be resumed. This is a no-op if |pipeline_| has not
// been suspended.
void Resume();
// Returns true if the current state is stable. This means that |state_| is
// PLAYING and there are no pending operations. Requests are processed
// immediately when the state is stable, otherwise they are queued.
// Exceptions to the above:
// - Start() is processed immediately while in the CREATED state.
// - Resume() is processed immediately while in the SUSPENDED state.
bool IsStable();
// Returns true if the current target state is suspended.
bool IsSuspended();
// Returns true if |pipeline_| is suspended.
bool IsPipelineSuspended();
// Attempts to make progress from the current state to the target state.
void Dispatch();
// PipelineStaus callback that also carries the target state.
void OnPipelineStatus(State state, PipelineStatus pipeline_status);
// The Pipeline we are managing state for.
Pipeline* pipeline_ = nullptr;
// Factory for Renderers, used for Start() and Resume().
RendererFactoryCB renderer_factory_cb_;
// Called after seeks (which includes Start()) upon reaching a stable state.
// Multiple seeks result in only one callback if no stable state occurs
// between them.
SeekedCB seeked_cb_;
// Called immediately when |pipeline_| completes a suspend operation.
SuspendedCB suspended_cb_;
// Called immediately before |pipeline_| starts a resume operation.
ResumedCB before_resume_cb_;
// Called immediately when |pipeline_| completes a resume operation.
ResumedCB resumed_cb_;
// Called immediately when any operation on |pipeline_| results in an error.
PipelineStatusCB error_cb_;
// State for handling StartWaitingForSeek()/CancelPendingSeek().
Demuxer* demuxer_ = nullptr;
bool waiting_for_seek_ = false;
// When true, Resume() will start at time zero instead of seeking to the
// current time.
bool is_streaming_ = false;
// When true, seeking to the current time may be elided.
bool is_static_ = true;
// Tracks the current state of |pipeline_|.
State state_ = State::CREATED;
// Indicates that a seek has occurred. When set, a seeked callback will be
// issued at the next stable state.
bool pending_seeked_cb_ = false;
// Indicates that time has been changed by a seek, which will be reported at
// the next seeked callback.
bool pending_time_updated_ = false;
// The target time of the active seek; valid while SEEKING or RESUMING.
base::TimeDelta seek_time_;
// Target state which we will work to achieve. |pending_seek_time_| is only
// valid when |pending_seek_| is true.
bool pending_seek_ = false;
base::TimeDelta pending_seek_time_;
bool pending_suspend_ = false;
bool pending_resume_ = false;
base::ThreadChecker thread_checker_;
base::WeakPtrFactory<PipelineController> weak_factory_;
} // namespace media