| // Copyright 2015 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 MEDIA_BLINK_MULTIBUFFER_READER_H_ |
| #define MEDIA_BLINK_MULTIBUFFER_READER_H_ |
| |
| #include <stdint.h> |
| |
| #include <limits> |
| #include <map> |
| #include <set> |
| |
| #include "base/callback.h" |
| #include "base/memory/weak_ptr.h" |
| #include "media/blink/media_blink_export.h" |
| #include "media/blink/multibuffer.h" |
| |
| namespace media { |
| |
| // Wrapper for MultiBuffer that offers a simple byte-reading |
| // interface with prefetch. |
| class MEDIA_BLINK_EXPORT MultiBufferReader |
| : NON_EXPORTED_BASE(public MultiBuffer::Reader) { |
| public: |
| // Note that |progress_callback| is guaranteed to be called if |
| // a redirect happens and the url_data is updated. Otherwise |
| // origin checks will become insecure. |
| // Users probably want to call SetMaxBuffer & SetPreload after |
| // creating the a MultiBufferReader. |
| // The progress callback will be called when the "available range" |
| // changes. (The number of bytes available for reading before and |
| // after the current position.) The arguments for the progress |
| // callback is the first byte available (from beginning of file) |
| // and the last byte available + 1. Note that there may be other |
| // regions of available data in the cache as well. |
| // If |end| is not known, use -1. |
| MultiBufferReader( |
| MultiBuffer* multibuffer, |
| int64_t start, |
| int64_t end, |
| const base::Callback<void(int64_t, int64_t)>& progress_callback); |
| |
| ~MultiBufferReader() override; |
| |
| // Returns number of bytes available for reading. When the rest of the file |
| // is available, the number returned will be greater than the number |
| // or readable bytes. If an error occurs, -1 is returned. |
| int64_t Available() const; |
| |
| // Seek to a different position. |
| // If there is a pending Wait(), it will be cancelled. |
| void Seek(int64_t pos); |
| |
| // Returns the current position. |
| int64_t Tell() const { return pos_; } |
| |
| // Tries to read |len| bytes and advance position. |
| // Returns number of bytes read. |
| // If there is a pending Wait(), it will be cancelled. |
| int64_t TryRead(uint8_t* data, int64_t len); |
| |
| // Wait until |len| bytes are available for reading. |
| // Returns net::OK if |len| bytes are already available, otherwise it will |
| // return net::ERR_IO_PENDING and call |cb| at some point later. |
| // |len| must be smaller or equal to max_buffer_forward. |
| int Wait(int64_t len, const base::Closure& cb); |
| |
| // Set how much data we try to preload into the cache ahead of our current |
| // location. Normally, we preload until we have preload_high bytes, then |
| // stop until we fall below preload_low bytes. Note that preload can be |
| // set higher than max_buffer_forward, but the result is usually that |
| // some blocks will be freed between the current position and the preload |
| // position. |
| void SetPreload(int64_t preload_high, int64_t preload_low); |
| |
| // Change how much data we pin to the cache. |
| // The range [current_position - backward ... current_position + forward) |
| // will be locked in the cache. Calling Wait() or TryRead() with values |
| // larger than |forward| is not supported. |
| void SetMaxBuffer(int64_t backward, int64_t forward); |
| |
| // Returns true if we are currently loading data. |
| bool IsLoading() const; |
| |
| // Reader implementation. |
| void NotifyAvailableRange(const Interval<MultiBufferBlockId>& range) override; |
| |
| // Getters |
| int64_t preload_high() const { return preload_high_; } |
| int64_t preload_low() const { return preload_low_; } |
| |
| private: |
| // Returns the block for a particular byte position. |
| MultiBufferBlockId block(int64_t byte_pos) const { |
| return byte_pos >> multibuffer_->block_size_shift(); |
| } |
| |
| // Returns the block for a particular byte position, rounding up. |
| MultiBufferBlockId block_ceil(int64_t byte_pos) const { |
| return block(byte_pos + (1LL << multibuffer_->block_size_shift()) - 1); |
| } |
| |
| // Check if wait operation can complete now. |
| void CheckWait(); |
| |
| // Recalculate preload_pos_ and update our entry in the multibuffer |
| // reader index. Also call CheckWait(). This function is basically |
| // called anything changes, like when we get more data or seek to |
| // a new position. |
| void UpdateInternalState(); |
| |
| // Indirection function used to call callbacks. When we post a callback |
| // we indirect it through a weak_ptr and this function to make sure we |
| // don't call any callbacks after this object has been destroyed. |
| void Call(const base::Closure& cb) const; |
| |
| // The multibuffer we're wrapping, not owned. |
| MultiBuffer* multibuffer_; |
| |
| // We're not interested in reading past this position. |
| int64_t end_; |
| |
| // Defer reading once we have this much data. |
| int64_t preload_high_; |
| // Stop deferring once we have this much data. |
| int64_t preload_low_; |
| |
| // Pin this much data in the cache from the current position. |
| int64_t max_buffer_forward_; |
| int64_t max_buffer_backward_; |
| |
| // Current position in bytes. |
| int64_t pos_; |
| |
| // [block(pos_)..preload_pos_) are known to be in the cache. |
| // preload_pos_ is only allowed to point to a filled |
| // cache position if it is equal to end_ or pos_+preload_. |
| // This is a pointer to a slot in the cache, so the unit is |
| // blocks. |
| MultiBufferBlockId preload_pos_; |
| |
| // True if we've requested data from the cache by calling WaitFor(). |
| bool loading_; |
| |
| // When Available() > current_wait_size_ we call cb_. |
| int64_t current_wait_size_; |
| base::Closure cb_; |
| |
| // Progress callback. |
| base::Callback<void(int64_t, int64_t)> progress_callback_; |
| |
| base::WeakPtrFactory<MultiBufferReader> weak_factory_; |
| }; |
| |
| } // namespace media |
| |
| #endif // MEDIA_BLINK_MULTIBUFFER_READER_H_ |