| // Copyright 2019 The Fuchsia 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 SRC_MEDIA_CODEC_EXAMPLES_USE_MEDIA_DECODER_IN_STREAM_H_ | |
| #define SRC_MEDIA_CODEC_EXAMPLES_USE_MEDIA_DECODER_IN_STREAM_H_ | |
| #include <lib/async-loop/cpp/loop.h> | |
| #include <lib/async-loop/default.h> | |
| #include <lib/sys/cpp/component_context.h> | |
| #include <fbl/mutex.h> | |
| // Abstract base class which permits reading from a stream of input data. | |
| // | |
| // Sub-classes: | |
| // * InStreamFile can stream in from a file. | |
| // * InStreamHttp can stream in using http. | |
| // | |
| // Re. threading, this class is meant to be called from a single ordering | |
| // domain / thread that isn't the fidl_thread. None of the public methods are | |
| // safe to call from the fidl_thread; also not the destructor. | |
| // | |
| // All methods including the destructor may rely on fidl_thread to make | |
| // progress. | |
| // | |
| // Calls to ReadBytes() will block until there's at least 1 byte or the read | |
| // times out. | |
| // | |
| // It is only safe to delete the instance from a thread that is not the | |
| // fidl_thread. | |
| class InStream { | |
| public: | |
| // All sub-classes must retain the property that it's safe to delete this | |
| // instance from any thread. | |
| // | |
| // Sub-classes may wish to use FencePostSerial() at the start of their | |
| // destructor to ensure that any lambdas previously posted with PostSerial() | |
| // are done before any sub-class member vars are destructed. | |
| virtual ~InStream(); | |
| // The cursor_position() is the byte offset of the current location in the | |
| // input data. This starts at 0. | |
| // | |
| // Every successful ReadBytes() advances cursor_position(). | |
| // | |
| // This method is not meant to be overridden by sub-classes. | |
| uint64_t cursor_position() const; | |
| // Once this starts returning true it'll continue returning true. At the | |
| // latest, this will start returning true when ReadBytesComplete() reads less | |
| // than the requested amount. | |
| bool eos_position_known(); | |
| // Requires eos_position_known(). | |
| uint64_t eos_position(); | |
| // Returns ZX_OK with *bytes_read_out == 0 if the end of input data has been | |
| // reached. | |
| // | |
| // If the end of input data has not yet been reached, this blocks until at | |
| // least 1 bytes of input data is available, and then returns ZX_OK indicating | |
| // at least 1 byte was read. The caller must not expect that the # of bytes | |
| // actaully read is necessarily max_bytes_to_read. Especially as the end of | |
| // input data is reached, the *bytes_read_out will sometimes be less than | |
| // max_bytes_to_read. | |
| // | |
| // When deadline is non-infinite, and the deadline is reached, timeout will | |
| // occur before 1 byte is available and ZX_ERR_TIMED_OUT is returned. | |
| // | |
| // buffer_out must be at least max_bytes_to_read in length. | |
| // | |
| // The cursor_position is advanced by *bytes_read_out. | |
| // | |
| // Sub-classes should override ReadBytesInternal, not ReadBytes. | |
| zx_status_t ReadBytesShort(uint32_t max_bytes_to_read, uint32_t* bytes_read_out, | |
| uint8_t* buffer_out, | |
| zx::time just_fail_deadline = zx::time::infinite()); | |
| zx_status_t ReadBytesComplete(uint32_t max_bytes_to_read, uint32_t* bytes_read_out, | |
| uint8_t* buffer_out, | |
| zx::time just_fail_deadline = zx::time::infinite()); | |
| // Normally a reset like this isn't necessarily optimal vs. just creating a new instance, but in | |
| // tests we want the reset to be fast, so we allow instance reset. | |
| // | |
| // This either succeeds with ZX_OK and sets cursor_position() back to 0, or fails with an error. | |
| // If the error is ZX_ERR_NOT_SUPPORTED, a sub-class doesn't support ResetToStart(), and any | |
| // wrapper InStream wasn't able to avoid calling ResetToStart() on the sub-class. | |
| zx_status_t ResetToStart(zx::time just_fail_deadline = zx::time::infinite()); | |
| protected: | |
| InStream(async::Loop* fidl_loop, thrd_t fidl_thread, sys::ComponentContext* component_context); | |
| void PostToFidlSerial(fit::closure to_run); | |
| void FencePostToFidlSerial(); | |
| // Sub-classes override ReadBytesInternal() to actually read data. The | |
| // sub-class doesn't need to update cursor_position_ since ReadBytes() handles | |
| // that. | |
| virtual zx_status_t ReadBytesInternal(uint32_t max_bytes_to_read, uint32_t* bytes_read_out, | |
| uint8_t* buffer_out, zx::time just_fail_deadline) = 0; | |
| virtual zx_status_t ResetToStartInternal(zx::time just_fail_deadline); | |
| async::Loop* const fidl_loop_ = nullptr; | |
| async_dispatcher_t* const fidl_dispatcher_ = nullptr; | |
| const thrd_t fidl_thread_{}; | |
| sys::ComponentContext* const component_context_; | |
| // TODO(liyl): Need to change to std::mutex. | |
| fbl::Mutex lock_; | |
| uint64_t cursor_position_ = 0; | |
| bool failure_seen_ = false; | |
| bool eos_position_known_ = false; | |
| uint64_t eos_position_ = 0; | |
| }; | |
| #endif // SRC_MEDIA_CODEC_EXAMPLES_USE_MEDIA_DECODER_IN_STREAM_H_ |