NS_IMETHOD Run()
{
NS_ASSERTION(NS_IsMainThread(), "Should be on main thread.");
NotifyDataArrived();
return NS_OK;
}
void BaseSearchMgr::SetSection(DVBSection *pSection)
{
AutoLockT lock_it(m_dequeMutex);
if(NULL != pSection)
{
m_dequePacket.push_back(pSection);
NotifyDataArrived();
}
}
ULONG TVSearchMgr::Cancel()
{
NotifyDataArrived();
if(m_pTVSearchMgrThread != NULL )
{
m_pTVSearchMgrThread->stop();
}
return 0 ;
}
void
MediaDecoderReader::DoThrottledNotify()
{
MOZ_ASSERT(OnTaskQueue());
mLastThrottledNotify = TimeStamp::Now();
mThrottledNotify.DisconnectIfExists();
Interval<int64_t> interval = mThrottledInterval.ref();
mThrottledInterval.reset();
NotifyDataArrived(interval);
}
void
MediaSourceDecoder::Ended(bool aEnded)
{
MOZ_ASSERT(NS_IsMainThread());
static_cast<MediaSourceResource*>(GetResource())->SetEnded(aEnded);
if (aEnded) {
// We want the MediaSourceReader to refresh its buffered range as it may
// have been modified (end lined up).
NotifyDataArrived();
}
mEnded = aEnded;
}
void WebMBufferedState::UpdateIndex(const MediaByteRangeSet& aRanges, MediaResource* aResource)
{
for (uint32_t index = 0; index < aRanges.Length(); index++) {
const MediaByteRange& range = aRanges[index];
int64_t offset = range.mStart;
uint32_t length = range.mEnd - range.mStart;
uint32_t idx = mRangeParsers.IndexOfFirstElementGt(offset - 1);
if (!idx || !(mRangeParsers[idx-1] == offset)) {
// If the incoming data overlaps an already parsed range, adjust the
// buffer so that we only reparse the new data. It's also possible to
// have an overlap where the end of the incoming data is within an
// already parsed range, but we don't bother handling that other than by
// avoiding storing duplicate timecodes when the parser runs.
if (idx != mRangeParsers.Length() && mRangeParsers[idx].mStartOffset <= offset) {
// Complete overlap, skip parsing.
if (offset + length <= mRangeParsers[idx].mCurrentOffset) {
continue;
}
// Partial overlap, adjust the buffer to parse only the new data.
int64_t adjust = mRangeParsers[idx].mCurrentOffset - offset;
NS_ASSERTION(adjust >= 0, "Overlap detection bug.");
offset += adjust;
length -= uint32_t(adjust);
} else {
mRangeParsers.InsertElementAt(idx, WebMBufferedParser(offset));
if (idx) {
mRangeParsers[idx].SetTimecodeScale(mRangeParsers[0].GetTimecodeScale());
}
}
}
MediaResourceIndex res(aResource);
while (length > 0) {
static const uint32_t BLOCK_SIZE = 1048576;
uint32_t block = std::min(length, BLOCK_SIZE);
RefPtr<MediaByteBuffer> bytes = res.CachedMediaReadAt(offset, block);
if (!bytes) {
break;
}
NotifyDataArrived(bytes->Elements(), bytes->Length(), offset);
length -= bytes->Length();
offset += bytes->Length();
}
}
}
MP4TrackDemuxer::MP4TrackDemuxer(MP4Demuxer* aParent,
TrackInfo::TrackType aType,
uint32_t aTrackNumber)
: mParent(aParent)
, mStream(new mp4_demuxer::ResourceStream(mParent->mResource))
, mMonitor("MP4TrackDemuxer")
{
mInfo = mParent->mMetadata->GetTrackInfo(aType, aTrackNumber);
MOZ_ASSERT(mInfo);
nsTArray<mp4_demuxer::Index::Indice> indices;
if (!mParent->mMetadata->ReadTrackIndex(indices, mInfo->mTrackId)) {
MOZ_ASSERT(false);
}
mIndex = new mp4_demuxer::Index(indices,
mStream,
mInfo->mTrackId,
mInfo->IsAudio(),
&mMonitor);
mIterator = MakeUnique<mp4_demuxer::SampleIterator>(mIndex);
NotifyDataArrived(); // Force update of index
}
NS_IMETHOD Run()
{
MOZ_ASSERT(mOmxReader->OnTaskQueue());
NotifyDataArrived();
return NS_OK;
}
