| // Copyright 2018 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_DRIVERS_AMLOGIC_DECODER_VP9_DECODER_H_ | |
| #define SRC_MEDIA_DRIVERS_AMLOGIC_DECODER_VP9_DECODER_H_ | |
| #include <lib/async-loop/cpp/loop.h> | |
| #include <lib/async/cpp/task.h> | |
| #include <cstdint> | |
| #include <string_view> | |
| #include <vector> | |
| #include "macros.h" | |
| #include "registers.h" | |
| #include "video_decoder.h" | |
| // From libvpx | |
| struct loop_filter_info_n; | |
| struct loopfilter; | |
| struct segmentation; | |
| namespace amlogic_decoder { | |
| // Used for friend declarations below | |
| namespace test { | |
| class Vp9UnitTest; | |
| class TestVP9; | |
| class TestFrameProvider; | |
| } // namespace test | |
| class Vp9Decoder : public VideoDecoder { | |
| public: | |
| enum class InputType { | |
| // A single stream is decoded at once | |
| kSingleStream, | |
| // Multiple streams are decoded at once. | |
| // | |
| // This mode is capable of interrupting re. frame headers and decoded frames until all frames | |
| // previously delivered via the ring buffer are exhausted at which point the FW will interrupt | |
| // re. out of input. This mode isn't very forgiving about delivering additional data that | |
| // doesn't contain at least the rest of a frame - the FW will hit the SW watchdog in that case. | |
| kMultiStream, | |
| // Multiple streams, each with input buffers divided on frame boundaries, | |
| // are decoded at once. | |
| // | |
| // This mode expects frames (originally separate or within a superframe) to be delivered | |
| // separately to the FW. If multiple frames are delivered together, the FW can respond to | |
| // DecodeSlice with the second frame's header, instead of decoding the first frame's header, | |
| // which may not be usable for decoding multiple frames delivered to the FW at once. See | |
| // kMultiStream for that purpose. | |
| kMultiFrameBased | |
| }; | |
| class FrameDataProvider { | |
| public: | |
| // Called with the decoder locked. | |
| virtual void ReadMoreInputData(Vp9Decoder* decoder) = 0; | |
| virtual void ReadMoreInputDataFromReschedule(Vp9Decoder* decoder) = 0; | |
| // Default behavior is for the benefit of test code; production implementation overrides all the | |
| // methods. | |
| virtual bool HasMoreInputData() { return true; } | |
| // CodecAdapterVp9 will fwd to CodecImpl which will async stop/start the stream (on | |
| // StreamControl thread) to continue decoding for the same stream, with the current input packet | |
| // skipped, if the stream hasn't been obsoleted by the time this request reaches the | |
| // StreamControl thread. | |
| virtual void AsyncResetStreamAfterCurrentFrame() { ZX_PANIC("not impemented"); } | |
| }; | |
| enum class DecoderState : uint32_t { | |
| // In these two states the decoder is stopped because UpdateDecodeSize needs to be called. The | |
| // difference between these two is how it needs to be restarted. | |
| kInitialWaitingForInput, | |
| kStoppedWaitingForInput, | |
| // A frame was produced and the hardware is waiting for permission to decode another frame. | |
| kFrameJustProduced, | |
| // The hardware is currently processing data. The watchdog should always be running while the | |
| // hardware's in this state. | |
| kRunning, | |
| // The hardware is waiting for reference frames and outputs to be initialized after decoding the | |
| // uncompressed header and before decoding the compressed data. | |
| kPausedAtHeader, | |
| // The hardware is waiting for references frames, but the special end-of-stream size was | |
| // reached. It can safely be swapped out now, because its state doesn't matter. | |
| kPausedAtEndOfStream, | |
| // The hardware's state doesn't reflect that of the Vp9Decoder. | |
| kSwappedOut, | |
| // Used during watchdog handling, to avoid processing interrupts that occur after watchdog. The | |
| // current decoder is deleted and a new decoder is created to take its place. | |
| kFailed, | |
| }; | |
| static const char* DecoderStateName(DecoderState state); | |
| Vp9Decoder(const Vp9Decoder&) = delete; | |
| void ForceStopDuringRemoveLocked() override; | |
| ~Vp9Decoder() override; | |
| __WARN_UNUSED_RESULT zx_status_t Initialize() override; | |
| __WARN_UNUSED_RESULT zx_status_t InitializeHardware() override; | |
| void HandleInterrupt() override; | |
| void ReturnFrame(std::shared_ptr<VideoFrame> frame) override; | |
| void CallErrorHandler() override { | |
| have_fatal_error_ = true; | |
| client_->OnError(); | |
| } | |
| void InitializedFrames(std::vector<CodecFrame> frames, uint32_t width, uint32_t height, | |
| uint32_t stride) override; | |
| __WARN_UNUSED_RESULT bool CanBeSwappedIn() override; | |
| __WARN_UNUSED_RESULT bool CanBeSwappedOut() const override { | |
| // We don't include kInitialWaitingForInput here, because we're only in that state if | |
| // CanBeSwappedIn(), which means we have some input data to give the HW, and we don't want to | |
| // be swapping back out before we've done that. | |
| return state_ == DecoderState::kFrameJustProduced || | |
| state_ == DecoderState::kStoppedWaitingForInput || | |
| state_ == DecoderState::kPausedAtEndOfStream; | |
| } | |
| // See also comment on on MustBeSwappedOut in video_decoder.h. For now, the vp9_decoder only swaps | |
| // out during kVp9CommandDecodingDataDone handling, and always saves context during this swap out. | |
| // This saving and swapping out when a frame has successfully decoded brings vp9_decoder closer to | |
| // the underlying driver <-> FW/HW protocol (vs. what we were doing before which broke when we got | |
| // a newer video_ucode.bin), but vp9_decoder doesn't yet ever swap out without saving, nor does | |
| // vp9_decoder yet have the decoder HW retry processing stream buffer data from the last save | |
| // point. Both of those would be required to achieve full "multi-stream" mode. Currently the | |
| // vp9_decoder is nominally using multi-stream mode as far as what vp9_decoder tells the HW, but | |
| // is really only able to use multi-stream mode for frame-at-a-time decoding, which at least so | |
| // far is all we really need for vp9. If we ever find that we really need to be able to split an | |
| // input frame across input packets, or do full stream-style input handling, we can improve | |
| // vp9_decoder to achieve that in a similar way as h264_multi_decoder (retry from save point with | |
| // more data in the stream buffer, until a frame shows up on output at which point make a new save | |
| // point, and so on). | |
| // | |
| // While it may be tempting to try to avoid/skip this swap out with context save (and the context | |
| // restore), keep in mind that skipping this swap out and context save would put | |
| // kVp9CommandDecodingDataDone handling in undefined territory wrt the driver <-> FW/HW protocol. | |
| __WARN_UNUSED_RESULT bool MustBeSwappedOut() const override { return true; } | |
| bool IsUtilizingHardware() const override { | |
| switch (static_cast<DecoderState>(state_)) { | |
| case DecoderState::kInitialWaitingForInput: | |
| case DecoderState::kRunning: | |
| case DecoderState::kPausedAtHeader: | |
| case DecoderState::kFailed: | |
| return true; | |
| case DecoderState::kStoppedWaitingForInput: | |
| case DecoderState::kFrameJustProduced: | |
| case DecoderState::kPausedAtEndOfStream: | |
| case DecoderState::kSwappedOut: | |
| return false; | |
| } | |
| } | |
| void SetSwappedOut() override { state_ = DecoderState::kSwappedOut; } | |
| void SwappedIn() override { frame_data_provider_->ReadMoreInputDataFromReschedule(this); } | |
| void OnSignaledWatchdog() override; | |
| zx_status_t SetupProtection() override; | |
| void SetFrameDataProvider(FrameDataProvider* provider) { frame_data_provider_ = provider; } | |
| void UpdateDecodeSize(uint32_t size); | |
| // The number of frames that have been emitted from the FW (not necessarily emitted downstream | |
| // however) since the most recent UpdateDecodeSize(). | |
| uint32_t FramesSinceUpdateDecodeSize(); | |
| __WARN_UNUSED_RESULT bool needs_more_input_data() const { | |
| return state_ == DecoderState::kStoppedWaitingForInput || | |
| state_ == DecoderState::kInitialWaitingForInput; | |
| } | |
| __WARN_UNUSED_RESULT bool swapped_out() const { return state_ == DecoderState::kSwappedOut; } | |
| void SetPausedAtEndOfStream(); | |
| void set_reallocate_buffers_next_frame_for_testing() { | |
| reallocate_buffers_next_frame_for_testing_ = true; | |
| } | |
| void InjectInitializationFault() { should_inject_initialization_fault_for_testing_ = true; } | |
| private: | |
| friend class test::Vp9UnitTest; | |
| friend class test::TestVP9; | |
| friend class test::TestFrameProvider; | |
| friend class CodecAdapterVp9; | |
| class WorkingBuffer; | |
| class BufferAllocator { | |
| public: | |
| void Register(WorkingBuffer* buffer); | |
| zx_status_t AllocateBuffers(VideoDecoder::Owner* decoder, bool is_secure); | |
| void CheckBuffers(); | |
| private: | |
| std::vector<WorkingBuffer*> buffers_; | |
| }; | |
| class WorkingBuffer { | |
| public: | |
| WorkingBuffer(BufferAllocator* allocator, size_t size, bool can_be_protected, const char* name); | |
| ~WorkingBuffer(); | |
| WorkingBuffer(const WorkingBuffer& to_copy) = delete; | |
| WorkingBuffer& operator=(const WorkingBuffer& to_copy) = delete; | |
| WorkingBuffer(WorkingBuffer&& to_move) = default; | |
| WorkingBuffer& operator=(WorkingBuffer&& to_move) = default; | |
| uint32_t addr32(); | |
| size_t size() const { return size_; } | |
| const char* name() const { return name_; } | |
| InternalBuffer& buffer() { return buffer_.value(); } | |
| bool has_buffer() { return buffer_.has_value(); } | |
| bool can_be_protected() const { return can_be_protected_; } | |
| void SetBuffer(InternalBuffer buffer) { buffer_.emplace(std::move(buffer)); } | |
| private: | |
| size_t size_; | |
| bool can_be_protected_; | |
| const char* name_; | |
| std::optional<InternalBuffer> buffer_; | |
| }; | |
| struct WorkingBuffers : public BufferAllocator { | |
| WorkingBuffers() {} | |
| WorkingBuffers(const WorkingBuffers& to_copy) = delete; | |
| WorkingBuffers& operator=(const WorkingBuffers& to_copy) = delete; | |
| WorkingBuffers(WorkingBuffers&& to_move) = default; | |
| WorkingBuffers& operator=(WorkingBuffers&& to_move) = default; | |
| // Sizes are large enough for 4096x2304. | |
| #define DEF_BUFFER(name, can_be_protected, size) \ | |
| WorkingBuffer name = WorkingBuffer(this, size, can_be_protected, #name) | |
| DEF_BUFFER(rpm, false, 0x400 * 2); | |
| DEF_BUFFER(short_term_rps, true, 0x800); | |
| DEF_BUFFER(picture_parameter_set, true, 0x2000); | |
| DEF_BUFFER(swap, true, 0x800); | |
| DEF_BUFFER(swap2, true, 0x800); | |
| DEF_BUFFER(local_memory_dump, false, 0x400 * 2); | |
| DEF_BUFFER(ipp_line_buffer, true, 0x4000); | |
| DEF_BUFFER(sao_up, true, 0x2800); | |
| DEF_BUFFER(scale_lut, true, 0x8000); | |
| // HW/firmware requires first parameters + deblock data to be adjacent in that order. | |
| static constexpr uint32_t kDeblockParametersSize = 0x80000; | |
| static constexpr uint32_t kDeblockDataSize = 0x80000; | |
| DEF_BUFFER(deblock_parameters, true, kDeblockParametersSize + kDeblockDataSize); | |
| DEF_BUFFER(deblock_parameters2, true, 0x80000); // Only used on G12a. | |
| DEF_BUFFER(segment_map, true, 0xd800); | |
| DEF_BUFFER(probability_buffer, false, 0x1000 * 5); | |
| DEF_BUFFER(count_buffer, false, 0x300 * 4 * 4); | |
| DEF_BUFFER(motion_prediction_above, true, 0x10000); | |
| DEF_BUFFER(mmu_vbh, true, 0x5000); | |
| DEF_BUFFER(frame_map_mmu, false, 0x1200 * 4); | |
| #undef DEF_BUFFER | |
| }; | |
| public: | |
| // We allow extracting internal buffers from an old instance and adding internal buffers to a new | |
| // instance, to reduce the cost of switching to a new Vp9Decoder instance without giving up | |
| // the advantages of fully re-initializing the new Vp9Decoder in every other way. In other | |
| // words, we don't want to have a Reset(), because runng the actual destructor then constructor is | |
| // much less brittle. | |
| // | |
| // Any buffers that are missing or not big enough will still be reallocated desipte transferring | |
| // InternalBuffers from an old instance to a new instance. | |
| class InternalBuffers { | |
| public: | |
| InternalBuffers() = default; | |
| InternalBuffers(InternalBuffers&& to_move) = default; | |
| InternalBuffers& operator=(InternalBuffers&& to_move) = default; | |
| InternalBuffers(const InternalBuffers& to_copy) = delete; | |
| InternalBuffers& operator=(const InternalBuffers& to_copy) = delete; | |
| private: | |
| friend class Vp9Decoder; | |
| std::optional<WorkingBuffers> working_buffers_; | |
| // per-frame compressed_headers | |
| std::vector<InternalBuffer> compressed_headers_; | |
| // all the MpredBuffer(s); no more than 2-3. | |
| std::vector<InternalBuffer> mpred_buffers_; | |
| }; | |
| InternalBuffers TakeInternalBuffers(); | |
| Vp9Decoder(Owner* owner, Client* client, InputType input_type, | |
| std::optional<InternalBuffers> internal_buffers, bool use_compressed_output, | |
| bool is_secure); | |
| private: | |
| void GiveInternalBuffers(InternalBuffers internal_buffers); | |
| struct Frame { | |
| Frame(Vp9Decoder* parent); | |
| ~Frame(); | |
| Vp9Decoder* parent = nullptr; | |
| // Index into frames_. | |
| uint32_t index = 0; | |
| // This is the count of references from reference_frame_map_, last_frame_, current_frame_, and | |
| // any buffers the ultimate consumers have outstanding. | |
| int32_t refcount = 0; | |
| // Each VideoFrame is managed via shared_ptr<> here and via weak_ptr<> in CodecBuffer. There is | |
| // a frame.reset() performed under video_decoder_lock_ that essentially signals to the | |
| // weak_ptr<> in CodecBuffer not to call ReturnFrame() any more for this frame. For this | |
| // reason, under normal operation (not self-test), it's important that FrameReadyNotifier and | |
| // weak_ptr<>::lock() not result in keeping any shared_ptr<> reference on VideoFrame that lasts | |
| // beyond the current video_decoder_lock_ interval, since that could allow calling ReturnFrame() | |
| // on a frame that the Vp9Decoder doesn't want to hear about any more. | |
| // | |
| // TODO(dustingreen): Mute ReturnFrame() a different way; maybe just explicitly. Ideally, we'd | |
| // use a way that's more similar between decoder self-test and "normal operation". | |
| // | |
| // This shared_ptr<> must not actually be shared outside of while video_decoder_lock_ is held. | |
| // See previous paragraphs. | |
| std::shared_ptr<VideoFrame> frame; | |
| // This is a frame that was received from sysmem and will next be decoded into. | |
| std::shared_ptr<VideoFrame> on_deck_frame; | |
| // With the MMU enabled the compressed frame header is stored separately from the data itself, | |
| // allowing the data to be allocated in noncontiguous memory. | |
| std::optional<InternalBuffer> compressed_header; | |
| io_buffer_t compressed_data = {}; | |
| // This is decoded_frame_count_ when this frame was decoded into. | |
| uint32_t decoded_index = 0xffffffff; | |
| // This is valid even after the VideoFrame is cleared out on resize. | |
| uint32_t hw_width = 0; | |
| uint32_t hw_height = 0; | |
| int32_t client_refcount = 0; | |
| // Redueces refcount and releases |frame| if it's not necessary anymore. | |
| void Deref(); | |
| // Releases |frame| if it's not currently being used as a reference frame. | |
| void ReleaseIfNonreference(); | |
| }; | |
| struct PictureData { | |
| bool keyframe = false; | |
| bool intra_only = false; | |
| uint32_t refresh_frame_flags = 0; | |
| bool show_frame; | |
| bool error_resilient_mode; | |
| bool has_pts = false; | |
| uint64_t pts = 0; | |
| }; | |
| union HardwareRenderParams; | |
| zx_status_t AllocateFrames(); | |
| void InitializeHardwarePictureList(); | |
| void InitializeParser(); | |
| bool FindNewFrameBuffer(HardwareRenderParams* params, bool params_checked_previously); | |
| void InitLoopFilter(); | |
| void UpdateLoopFilter(HardwareRenderParams* params); | |
| void ProcessCompletedFrames(); | |
| void ShowExistingFrame(HardwareRenderParams* params); | |
| void SkipFrameAfterFirmwareSlow(); | |
| void PrepareNewFrame(bool params_checked_previously); | |
| void ConfigureFrameOutput(bool bit_depth_8); | |
| void ConfigureMcrcc(); | |
| void UpdateLoopFilterThresholds(); | |
| void ConfigureMotionPrediction(); | |
| void ConfigureReferenceFrameHardware(); | |
| void SetRefFrames(HardwareRenderParams* params); | |
| bool AdaptProbabilityCoefficients(uint32_t adapt_prob_status); | |
| __WARN_UNUSED_RESULT zx_status_t InitializeBuffers(); | |
| void InitializeLoopFilterData(); | |
| static uint64_t GetMpredBufferSize(uint32_t width, uint32_t height); | |
| InputType input_type_; | |
| FrameDataProvider* frame_data_provider_ = nullptr; | |
| std::optional<WorkingBuffers> working_buffers_; | |
| DiagnosticStateWrapper<DecoderState> state_{[this]() { UpdateDiagnostics(); }, | |
| DecoderState::kSwappedOut, &DecoderStateName}; | |
| std::unique_ptr<PowerReference> power_ref_; | |
| // While frames_ always has size() == kMaxFrames, the actual number of valid frames that are fully | |
| // usable is valid_frames_count_. For now we don't remove any Frame from frames_ after | |
| // initialization, mostly for historical reasons at this point. | |
| // | |
| // TODO(dustingreen): Ensure we're getting all contig memory from sysmem, and/or always using | |
| // non-compressed reference frames / zero per-frame contig that isn't part of the buffer | |
| // collection, and if so, consider changing the size of frames_ instead of valid_frames_count_. | |
| uint32_t valid_frames_count_ = 0; | |
| std::vector<std::unique_ptr<Frame>> frames_; | |
| Frame* last_frame_ = nullptr; | |
| Frame* current_frame_ = nullptr; | |
| std::unique_ptr<loop_filter_info_n> loop_filter_info_; | |
| std::unique_ptr<loopfilter> loop_filter_; | |
| std::unique_ptr<segmentation> segmentation_; | |
| // Waiting for an available frame buffer (with reference count 0). | |
| bool waiting_for_empty_frames_ = false; | |
| // Waiting for an available output packet, to avoid show_existing_frame potentially allowing too | |
| // much queued output, as a show_existing_frame output frame doesn't use up a frame buffer - but | |
| // it does use up an output packet. We don't directly track the output packets in the | |
| // h264_decoder, but this bool corresponds to being out of output packets in codec_adapter_vp9. | |
| // We re-try PrepareNewFrame() during ReturnFrame() even if no refcount on any Frame has reached 0 | |
| bool waiting_for_output_ready_ = false; | |
| // Waiting for InitializedFrameBuffers to be called with a new size. | |
| bool waiting_for_new_frames_ = false; | |
| // This is the count of frames decoded since this object was created. | |
| uint32_t decoded_frame_count_ = 0; | |
| uint32_t frame_done_count_ = 0; | |
| // When we deliver a superframe containing multiple frames to the FW in one submit, the FW | |
| // _sometimes_ emits more than one frame per UpdateDecodeSize() + kVp9CommandNalDecodeDone. | |
| // Then later if we tell the FW to continue decoding with no more frames in the | |
| // previously-submitted data, the FW doesn't interrupt (not even with kVp9CommandNalDecodeDone) | |
| // and we hit the watchdog. So instead, if the FW delivers more than one frame after | |
| // UpdateDecodeSize before kVp9CommandNalDecodeDone, we notice and combine the two first entries | |
| // in queued_frame_sizes_ to essentially remove one future UpdateDecodeSize() that's no longer | |
| // needed. | |
| uint32_t frames_since_update_decode_size_ = 0; | |
| // This is used to force new buffers to be allocated without needing a test stream that | |
| // resizes. | |
| bool reallocate_buffers_next_frame_for_testing_ = false; | |
| // This forces the next InitializeHardware call to fail. | |
| bool should_inject_initialization_fault_for_testing_ = false; | |
| PictureData last_frame_data_; | |
| PictureData current_frame_data_; | |
| // This stores the motion vectors used to decode a frame for use in calculating motion vectors | |
| // for the next frame. | |
| // | |
| // The choice of unique_ptr<> vs std::optional<> here seems fine either way; it'd be moving a few | |
| // fields vs. currently chasing a couple extra pointers per frame. Unlikely to make any notable | |
| // performance difference either way. | |
| std::unique_ptr<InternalBuffer> last_mpred_buffer_; | |
| std::unique_ptr<InternalBuffer> current_mpred_buffer_; | |
| // Previously-used buffers kept around so a new buffer doesn't have to be allocated each frame. | |
| // This will hold no more than 3 buffers shortly after GiveInternalBuffers(), but up to 1 buffer | |
| // in the middle of a stream. | |
| // | |
| // The full properties of a buffer are checked before re-use since these can come from a previous | |
| // Vp9Decoder instance. | |
| std::vector<std::unique_ptr<InternalBuffer>> cached_mpred_buffers_; | |
| // The VP9 specification requires that 8 reference frames can be stored - they're saved in this | |
| // structure. | |
| static constexpr uint32_t kReferenceFrameCount = 8u; | |
| Frame* reference_frame_map_[kReferenceFrameCount] = {}; | |
| // Each frame that's being decoded can reference 3 of the frames that are in reference_frame_map_. | |
| static constexpr uint32_t kCurrentReferenceFrameCount = 3u; | |
| Frame* current_reference_frames_[kCurrentReferenceFrameCount] = {}; | |
| bool use_compressed_output_ = {}; | |
| bool have_fatal_error_ = false; | |
| bool already_got_watchdog_ = false; | |
| bool has_keyframe_ = false; | |
| // When present, these are InternalBuffer(s) that we can re-use if their properties are suitable. | |
| // | |
| // Also, since we move these into use, not all InternalBuffer(s) within are necessarily present() | |
| // (may have been moved out, but not fully deleted / cleared), so care is taken to check both | |
| // has_value() and present() before re-using an optional InternalBuffer within. While we could | |
| // potentially simplify this by making InternalBuffer be more like std::optional<> to avoid the | |
| // std::optional<> wrapping, that currently doesn't seem like it'd necessarily pay for itself. | |
| std::optional<InternalBuffers> on_deck_internal_buffers_; | |
| }; | |
| } // namespace amlogic_decoder | |
| #endif // SRC_MEDIA_DRIVERS_AMLOGIC_DECODER_VP9_DECODER_H_ |