70 lines
2.5 KiB
C++
70 lines
2.5 KiB
C++
// Copyright 2018 Google Inc. All rights reserved.
|
|
//
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file or at
|
|
// https://developers.google.com/open-source/licenses/bsd
|
|
|
|
#include <map>
|
|
#include <memory>
|
|
|
|
#include "packager/base/synchronization/condition_variable.h"
|
|
#include "packager/base/synchronization/lock.h"
|
|
#include "packager/media/public/ad_cue_generator_params.h"
|
|
|
|
namespace shaka {
|
|
namespace media {
|
|
|
|
struct CueEvent;
|
|
|
|
/// A synchronized queue for cue points.
|
|
class SyncPointQueue {
|
|
public:
|
|
explicit SyncPointQueue(const AdCueGeneratorParams& params);
|
|
~SyncPointQueue() = default;
|
|
|
|
/// Add a new thread. Each thread using this instance must call this method in
|
|
/// order to keep track of its clients.
|
|
void AddThread();
|
|
|
|
/// Cancel the queue and unblock all threads.
|
|
void Cancel();
|
|
|
|
/// @return A hint for when the next cue event would be. The returned hint is
|
|
/// not less than @a time_in_seconds. The actual time for the next cue
|
|
/// event will not be less than the returned hint, with the exact
|
|
/// value depends on promotion.
|
|
double GetHint(double time_in_seconds);
|
|
|
|
/// @return The next cue based on a previous hint. If a cue has been promoted
|
|
/// that comes after @a hint_in_seconds it is returned. If no cue
|
|
/// after @a hint_in_seconds has been promoted, this will block until
|
|
/// either a cue is promoted or all threads are blocked (in which
|
|
/// case, the unpromoted cue at @a hint_in_seconds will be
|
|
/// self-promoted and returned) or Cancel() is called.
|
|
std::shared_ptr<const CueEvent> GetNext(double hint_in_seconds);
|
|
|
|
/// Promote the first cue that is not greater than @a time_in_seconds. All
|
|
/// unpromoted cues before the cue will be discarded.
|
|
std::shared_ptr<const CueEvent> PromoteAt(double time_in_seconds);
|
|
|
|
private:
|
|
SyncPointQueue(const SyncPointQueue&) = delete;
|
|
SyncPointQueue& operator=(const SyncPointQueue&) = delete;
|
|
|
|
// PromoteAt() without locking. It is called by PromoteAt() and other
|
|
// functions that have locks.
|
|
std::shared_ptr<const CueEvent> PromoteAtNoLocking(double time_in_seconds);
|
|
|
|
base::Lock lock_;
|
|
base::ConditionVariable sync_condition_;
|
|
size_t thread_count_ = 0;
|
|
size_t waiting_thread_count_ = 0;
|
|
bool cancelled_ = false;
|
|
|
|
std::map<double, std::shared_ptr<CueEvent>> unpromoted_;
|
|
std::map<double, std::shared_ptr<CueEvent>> promoted_;
|
|
};
|
|
|
|
} // namespace media
|
|
} // namespace shaka
|