diff --git a/dom/media/MemoryBlockCache.cpp b/dom/media/MemoryBlockCache.cpp new file mode 100644 index 000000000000..ff73d1ea10bb --- /dev/null +++ b/dom/media/MemoryBlockCache.cpp @@ -0,0 +1,127 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "MemoryBlockCache.h" + +#include "mozilla/Logging.h" + +namespace mozilla { + +#undef LOG +LazyLogModule gMemoryBlockCacheLog("MemoryBlockCache"); +#define LOG(x, ...) \ + MOZ_LOG(gMemoryBlockCacheLog, LogLevel::Debug, ("%p " x, this, ##__VA_ARGS__)) + +MemoryBlockCache::MemoryBlockCache(int64_t aContentLength) + // Buffer whole blocks. + : mInitialContentLength((aContentLength >= 0) ? size_t(aContentLength) : 0) + , mMutex("MemoryBlockCache") +{ +} + +MemoryBlockCache::~MemoryBlockCache() +{ + MOZ_ASSERT(mBuffer.IsEmpty()); +} + +bool +MemoryBlockCache::EnsureBufferCanContain(size_t aContentLength) +{ + mMutex.AssertCurrentThreadOwns(); + if (aContentLength == 0) { + return true; + } + size_t desiredLength = ((aContentLength - 1) / BLOCK_SIZE + 1) * BLOCK_SIZE; + if (mBuffer.Length() >= desiredLength) { + // Already large enough. + return true; + } + // Need larger buffer, attempt to re-allocate. + return mBuffer.SetLength(desiredLength, mozilla::fallible); +} + +nsresult +MemoryBlockCache::Init() +{ + LOG("@%p Init()", this); + MutexAutoLock lock(mMutex); + // Attempt to pre-allocate buffer for expected content length. + return EnsureBufferCanContain(mInitialContentLength) ? NS_OK + : NS_ERROR_FAILURE; +} + +void +MemoryBlockCache::Close() +{ + LOG("@%p Close()", this); + MutexAutoLock lock(mMutex); + mBuffer.SetLength(0); +} + +nsresult +MemoryBlockCache::WriteBlock(uint32_t aBlockIndex, + Span aData1, + Span aData2) +{ + MutexAutoLock lock(mMutex); + + size_t offset = BlockIndexToOffset(aBlockIndex); + if (!EnsureBufferCanContain(offset + aData1.Length() + aData2.Length())) { + return NS_ERROR_FAILURE; + } + + memcpy(mBuffer.Elements() + offset, aData1.Elements(), aData1.Length()); + if (aData2.Length() > 0) { + memcpy(mBuffer.Elements() + offset + aData1.Length(), + aData2.Elements(), + aData2.Length()); + } + + return NS_OK; +} + +nsresult +MemoryBlockCache::Read(int64_t aOffset, + uint8_t* aData, + int32_t aLength, + int32_t* aBytes) +{ + MutexAutoLock lock(mMutex); + + MOZ_ASSERT(aOffset >= 0); + if (aOffset + aLength > int64_t(mBuffer.Length())) { + return NS_ERROR_FAILURE; + } + + memcpy(aData, mBuffer.Elements() + aOffset, aLength); + *aBytes = aLength; + + return NS_OK; +} + +nsresult +MemoryBlockCache::MoveBlock(int32_t aSourceBlockIndex, int32_t aDestBlockIndex) +{ + MutexAutoLock lock(mMutex); + + size_t sourceOffset = BlockIndexToOffset(aSourceBlockIndex); + size_t destOffset = BlockIndexToOffset(aDestBlockIndex); + if (sourceOffset + BLOCK_SIZE > mBuffer.Length() || + !EnsureBufferCanContain(destOffset + BLOCK_SIZE)) { + return NS_ERROR_FAILURE; + } + + memcpy(mBuffer.Elements() + destOffset, + mBuffer.Elements() + sourceOffset, + BLOCK_SIZE); + + return NS_OK; +} + +} // End namespace mozilla. + +// avoid redefined macro in unified build +#undef LOG diff --git a/dom/media/MemoryBlockCache.h b/dom/media/MemoryBlockCache.h new file mode 100644 index 000000000000..6ce10de6365d --- /dev/null +++ b/dom/media/MemoryBlockCache.h @@ -0,0 +1,84 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef MEMORY_BLOCK_CACHE_H_ +#define MEMORY_BLOCK_CACHE_H_ + +#include "MediaBlockCacheBase.h" +#include "mozilla/Mutex.h" + +namespace mozilla { + +// Manages block management for the media cache. Data comes in over the network +// via callbacks on the main thread, however we don't want to write the +// incoming data to the media cache on the main thread, as this could block +// causing UI jank. +// +// So MediaBlockCacheBase provides an abstraction for a temporary memory buffer +// as an array of blocks, which supports a block move operation, and +// allows synchronous reading and writing from any thread. +// +// Writes and cache block moves (which require reading) may be deferred to +// their own non-main thread. This object also ensures that data which has +// been scheduled to be written, but hasn't actually *been* written, is read +// as if it had, i.e. pending writes are cached in readable memory until +// they're flushed to file. +// +// To improve efficiency, writes can only be done at block granularity, +// whereas reads can be done with byte granularity. +class MemoryBlockCache : public MediaBlockCacheBase +{ +public: + explicit MemoryBlockCache(int64_t aContentLength); + +protected: + virtual ~MemoryBlockCache(); + +public: + // Allocate initial buffer. + virtual nsresult Init() override; + + // Empty buffer. + virtual void Close() override; + + // Can be called on any thread. + virtual nsresult WriteBlock(uint32_t aBlockIndex, + Span aData1, + Span aData2) override; + + // Synchronously reads data from buffer. + virtual nsresult Read(int64_t aOffset, + uint8_t* aData, + int32_t aLength, + int32_t* aBytes) override; + + // Moves a block. Can be called on any thread. + virtual nsresult MoveBlock(int32_t aSourceBlockIndex, + int32_t aDestBlockIndex) override; + +private: + static size_t BlockIndexToOffset(uint32_t aBlockIndex) + { + return static_cast(aBlockIndex) * BLOCK_SIZE; + } + + // Ensure the buffer has at least a multiple of BLOCK_SIZE that can contain + // aContentLength bytes. Buffer size can only grow. + // Returns false if allocation failed. + bool EnsureBufferCanContain(size_t aContentLength); + + // Initial content length. + const size_t mInitialContentLength; + + // Mutex which controls access to all members below. + Mutex mMutex; + + nsTArray mBuffer; +}; + +} // End namespace mozilla. + +#endif /* MEMORY_BLOCK_CACHE_H_ */ diff --git a/dom/media/moz.build b/dom/media/moz.build index 31366aea33f8..567e7465444d 100644 --- a/dom/media/moz.build +++ b/dom/media/moz.build @@ -135,6 +135,7 @@ EXPORTS += [ 'MediaTimer.h', 'MediaTrack.h', 'MediaTrackList.h', + 'MemoryBlockCache.h', 'MP3Decoder.h', 'MP3Demuxer.h', 'MP3FrameParser.h', @@ -242,6 +243,7 @@ UNIFIED_SOURCES += [ 'MediaTimer.cpp', 'MediaTrack.cpp', 'MediaTrackList.cpp', + 'MemoryBlockCache.cpp', 'MP3Decoder.cpp', 'MP3Demuxer.cpp', 'MP3FrameParser.cpp',