| // Copyright 2020 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_H264_MULTI_DECODER_H_ | |
| #define SRC_MEDIA_DRIVERS_AMLOGIC_DECODER_H264_MULTI_DECODER_H_ | |
| #include <lib/fit/defer.h> | |
| #include <cstdint> | |
| #include <list> | |
| #include <map> | |
| #include <string_view> | |
| #include <vector> | |
| #include "macros.h" | |
| #include "magic.h" | |
| #include "registers.h" | |
| #include "src/media/third_party/chromium_media/media/parsers/h264_parser.h" | |
| #include "src/media/third_party/chromium_media/media/parsers/h264_poc.h" | |
| #include "video_decoder.h" | |
| class MultiAccelerator; | |
| namespace media { | |
| class H264Decoder; | |
| class H264DPB; | |
| struct H264PPS; | |
| class H264Picture; | |
| struct H264SPS; | |
| class DecoderBuffer; | |
| } // namespace media | |
| namespace amlogic_decoder { | |
| // An H264 decoder that can be context-switched in and out. | |
| class H264MultiDecoder : public VideoDecoder { | |
| public: | |
| static constexpr uint32_t kStrideAlignment = 32; | |
| struct ReferenceFrame { | |
| bool in_use = false; | |
| bool in_internal_use = false; | |
| bool is_for_output = false; | |
| uint32_t index; | |
| std::shared_ptr<VideoFrame> frame; | |
| std::unique_ptr<CanvasEntry> y_canvas; | |
| std::unique_ptr<CanvasEntry> uv_canvas; | |
| // TODO(use one per reference frame, rather than one per DPB frame) | |
| InternalBuffer reference_mv_buffer; | |
| uint32_t info0{}; | |
| uint32_t info1{}; | |
| uint32_t info2{}; | |
| bool is_long_term_reference{}; | |
| }; | |
| struct SliceData { | |
| media::H264SPS sps; | |
| media::H264PPS pps; | |
| media::H264SliceHeader header; | |
| std::shared_ptr<media::H264Picture> pic; | |
| std::vector<std::shared_ptr<media::H264Picture>> ref_pic_list0; | |
| std::vector<std::shared_ptr<media::H264Picture>> ref_pic_list1; | |
| }; | |
| struct DataInput { | |
| bool is_eos = false; | |
| // If input is in protected buffers, then data.empty(), but codec_buffer won't be nullptr in | |
| // that case. | |
| std::vector<uint8_t> data; | |
| size_t length = 0; | |
| std::optional<uint64_t> pts; | |
| const CodecBuffer* codec_buffer = nullptr; | |
| // Offset within codec_buffer at which data starts. This is the offset above | |
| // codec_buffer->base() or codec_buffer->physical_base(). | |
| uint32_t buffer_start_offset = 0; | |
| fit::deferred_callback return_input_packet; | |
| }; | |
| class FrameDataProvider { | |
| public: | |
| // Called with the video_decoder_lock held. | |
| virtual std::optional<DataInput> ReadMoreInputData() = 0; | |
| virtual bool HasMoreInputData() = 0; | |
| virtual void AsyncPumpDecoder() = 0; | |
| virtual void AsyncResetStreamAfterCurrentFrame() = 0; | |
| }; | |
| // 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 H264MultiDecoder instance without giving up | |
| // the advantages of fully re-initializing the new H264MultiDecoder 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 H264MultiDecoder; | |
| std::optional<InternalBuffer> firmware_; | |
| std::optional<InternalBuffer> secondary_firmware_; | |
| std::optional<InternalBuffer> codec_data_; | |
| std::optional<InternalBuffer> aux_buf_; | |
| std::optional<InternalBuffer> lmem_; | |
| // The std::optional<> is so we can avoid moving out of an InternalBuffer and then back in, | |
| // which InternalBuffer doesn't currently support. This way we can just run the destructor and | |
| // constructor of InternalBuffer instead. | |
| std::vector<std::optional<InternalBuffer>> reference_mv_buffers_; | |
| }; | |
| enum class DecoderState : uint32_t { | |
| // The hardware's state doesn't reflect that of the H264MultiDecoder. | |
| kSwappedOut, | |
| // Any stoppage waiting for input data or output surfaces. | |
| kWaitingForInputOrOutput, | |
| // After config change interrupt, waiting for new buffers. | |
| kWaitingForConfigChange, | |
| kRunning, | |
| }; | |
| static const char* DecoderStateName(DecoderState state); | |
| H264MultiDecoder(Owner* owner, Client* client, FrameDataProvider* frame_data_provider, | |
| std::optional<InternalBuffers> internal_buffers, bool is_secure); | |
| H264MultiDecoder(const H264MultiDecoder&) = delete; | |
| void ForceStopDuringRemoveLocked() override; | |
| ~H264MultiDecoder() override; | |
| [[nodiscard]] zx_status_t Initialize() override; | |
| [[nodiscard]] zx_status_t InitializeHardware() override; | |
| void HandleInterrupt() override; | |
| void ReturnFrame(std::shared_ptr<VideoFrame> frame) override; | |
| void CallErrorHandler() override; | |
| // PumpOrReschedule must be called after InitializedFrames to get the decoder to continue. | |
| void InitializedFrames(std::vector<CodecFrame> frames, uint32_t width, uint32_t height, | |
| uint32_t stride) override; | |
| [[nodiscard]] bool IsUtilizingHardware() const override; | |
| [[nodiscard]] bool CanBeSwappedIn() override; | |
| [[nodiscard]] bool CanBeSwappedOut() const override; | |
| [[nodiscard]] bool MustBeSwappedOut() const override; | |
| [[nodiscard]] bool ShouldSaveInputContext() const override; | |
| void SetSwappedOut() override; | |
| void SwappedIn() override; | |
| void OnSignaledWatchdog() override; | |
| zx_status_t SetupProtection() override; | |
| zx_status_t InitializeBuffers(); | |
| // Signal that a the end of a stream has been reached. This will flush all frames after decoding | |
| // all existing frames. | |
| void QueueInputEos(); | |
| void ReceivedNewInput(); | |
| // not currently used: | |
| void FlushFrames(); | |
| uint32_t GetApproximateConsumedBytes(); | |
| void DumpStatus(); | |
| // Try to pump the decoder, rescheduling it if it isn't currently scheduled in. | |
| void PumpOrReschedule(); | |
| void SubmitDataToHardware(const uint8_t* data, size_t length, const CodecBuffer* codec_buffer, | |
| uint32_t buffer_start_offset); | |
| // For use by MultiAccelerator. | |
| void SubmitSliceData(SliceData data); | |
| void SubmitFrameMetadata(ReferenceFrame* reference_frame, const media::H264SPS* sps, | |
| const media::H264PPS* pps, const media::H264DPB& dpb); | |
| void OutputFrame(ReferenceFrame* reference_frame, uint32_t pts_id); | |
| void StartFrameDecode(); | |
| bool IsUnusedReferenceFrameAvailable(); | |
| std::shared_ptr<ReferenceFrame> GetUnusedReferenceFrame(bool is_for_output); | |
| bool is_hw_active() { return is_hw_active_; } | |
| bool is_decoder_started() { return is_decoder_started_; } | |
| void* SecondaryFirmwareVirtualAddressForTesting() { return secondary_firmware_->virt_base(); } | |
| void set_use_parser(bool use_parser) { use_parser_ = use_parser; } | |
| InternalBuffers TakeInternalBuffers(); | |
| private: | |
| // This struct contains parameters for the current frame that are dumped from | |
| // lmem | |
| struct HardwareRenderParams { | |
| uint16_t data[0x400]; | |
| static constexpr uint32_t kOffsetDelimiterLo = 0x2f; | |
| static constexpr uint32_t kOffsetDelimiterHi = 0x30; | |
| static constexpr uint32_t kCroppingLeftRight = 0x6a; | |
| static constexpr uint32_t kCroppingTopBottom = 0x6b; | |
| // Only newer versions of the firmware put max_num_reorder_frames here. The current version of | |
| // the FW has 0 here. | |
| static constexpr uint32_t kMaxNumReorderFramesNewerFirmware = 0x6d; | |
| // jbauman points out that this may be max_dec_frame_buffering, based on how new versions of | |
| // the firmware put max_num_reorder_frames at 0x6d, and the two being adjacent in VUI | |
| // parameters. | |
| // | |
| // We've seen one test stream where this is 0 while kMaxReferenceFrameNum is 2, so probably this | |
| // isn't max_num_ref_frames, but it's unclear whether that stream is fully compliant or not; | |
| // max_dec_frame_buffering is supposed to be >= max_num_ref_frames. | |
| static constexpr uint32_t kMaxBufferFrame = 0x6e; | |
| static constexpr uint32_t kSkipPicCount = 0x74; | |
| static constexpr uint32_t kNewPictureStructure = 0x7c; | |
| static constexpr uint16_t kNewPictureStructureTopField = 0x1; | |
| static constexpr uint16_t kNewPictureStructureBottomField = 0x2; | |
| static constexpr uint16_t kNewPictureStructureFrame = 0x3; | |
| static constexpr uint32_t kNewIdrPicId = 0x7e; | |
| static constexpr uint32_t kIdrPicId = 0x7f; | |
| static constexpr uint32_t kNalUnitType = 0x80; | |
| static constexpr uint32_t kNalRefIdc = 0x81; | |
| static constexpr uint32_t kSliceType = 0x82; | |
| static constexpr uint32_t kLog2MaxFrameNum = 0x83; | |
| static constexpr uint32_t kFrameMbsOnlyFlag = 0x84; | |
| static constexpr uint32_t kPicOrderCntType = 0x85; | |
| static constexpr uint32_t kLog2MaxPicOrderCntLsb = 0x86; | |
| static constexpr uint32_t kRedundantPicCntPresentFlag = 0x88; | |
| static constexpr uint32_t kPicInitQpMinus26 = 0x89; | |
| static constexpr uint32_t kDeblockingFilterControlPresentFlag = 0x8a; | |
| static constexpr uint32_t kNumSliceGroupsMinus1 = 0x8b; | |
| static constexpr uint32_t kMode8x8Flags = 0x8c; | |
| static constexpr uint32_t kEntropyCodingModeFlag = 0x8d; | |
| static constexpr uint32_t kTotalMbHeight = 0x8f; | |
| static constexpr uint32_t kWeightedPredFlag = 0xa3; | |
| static constexpr uint32_t kWeightedBipredIdc = 0xa4; | |
| // bits 3..2 picture_structure | |
| // bit 1 mb_adaptive_frame_field_flag | |
| // bit 0 frame_mbs_only_flag | |
| static constexpr uint32_t kMbffInfo = 0xa5; | |
| static constexpr uint32_t kMbXNum = 0xb0; | |
| static constexpr uint32_t kMbWidth = 0xb1; | |
| static constexpr uint32_t kMbHeight = 0xb2; | |
| static constexpr uint32_t kMbX = 0xb3; | |
| static constexpr uint32_t kTotalMbY = 0xb4; | |
| // value is int16_t, not uint16_t | |
| static constexpr uint32_t kOffsetForNonRefPic = 0xe0; | |
| // value is int16_t, not uint16_t | |
| static constexpr uint32_t kOffsetForTopToBottomField = 0xe2; | |
| static constexpr uint32_t kMaxReferenceFrameNum = 0xe4; | |
| static constexpr uint32_t kFrameNumGapAllowed = 0xe5; | |
| static constexpr uint32_t kNumRefFramesInPicOrderCntCycle = 0xe6; | |
| static constexpr uint32_t kProfileIdcMmco = 0xe7; | |
| static constexpr uint32_t kLevelIdcMmco = 0xe8; | |
| static constexpr uint32_t kPpsNumRefIdxL0ActiveMinus1 = 0xeb; | |
| static constexpr uint32_t kPpsNumRefIdxL1ActiveMinus1 = 0xec; | |
| static constexpr uint32_t kCurrentSpsId = 0xed; | |
| static constexpr uint32_t kCurrentPpsId = 0xee; | |
| static constexpr uint32_t kDeltaPicOrderAlwaysZeroFlag = 0xea; | |
| static constexpr uint32_t kFirstMbInSlice = 0xf0; | |
| static constexpr uint32_t kVuiStatus = 0xf4; | |
| // kVuiStatus bits: | |
| static constexpr uint16_t kVuiStatusMaskAspectRatioInfoPresentFlag = 0x1; | |
| static constexpr uint16_t kVuiStatusMaskTimingInfoPresentFlag = 0x2; | |
| static constexpr uint16_t kVuiStatusMaskNalHrdParametersPresentFlag = 0x4; | |
| static constexpr uint16_t kVuiStatusMaskVclHrdParametersPresentFlag = 0x8; | |
| static constexpr uint16_t kVuiStatusMaskPicStructPresentFlag = 0x10; | |
| static constexpr uint16_t kVuiStatusMaskBitstreamRestrictionFlag = 0x20; | |
| static constexpr uint16_t kVuiStatusMaskAll = 0x3F; | |
| static constexpr uint32_t kAspectRatioIdc = 0xf5; | |
| static constexpr uint32_t kAspectRatioSarWidth = 0xf6; | |
| static constexpr uint32_t kAspectRatioSarHeight = 0xf7; | |
| // Observed to be zero regardless of low-latency stream or stream with frame reordering. | |
| static constexpr uint32_t kDpbBufferInfo = 0xfd; | |
| // offset to dpb_max_buffer_frame. | |
| static constexpr uint32_t kDpbStructStart = 0x100 + 24 * 8; | |
| // Observed to be zero regardless of low-latency stream or stream with frame reordering. | |
| static constexpr uint32_t kDpbMaxBufferFrame = kDpbStructStart + 0; | |
| // Observed to be zero regardless of low-latency stream or stream with frame reordering. | |
| static constexpr uint32_t kActualDpbSize = kDpbStructStart + 1; | |
| static constexpr uint32_t kPictureStructureMmco = kDpbStructStart + 12; | |
| static constexpr uint16_t kPictureStructureMmcoTopField = 0x0; | |
| static constexpr uint16_t kPictureStructureMmcoBottomField = 0x1; | |
| static constexpr uint16_t kPictureStructureMmcoFrame = 0x2; | |
| static constexpr uint16_t kPictureStructureMmcoMbaffFrame = 0x3; | |
| static constexpr uint32_t kFrameNum = kDpbStructStart + 13; | |
| static constexpr uint32_t kPicOrderCntLsb = kDpbStructStart + 14; | |
| static constexpr uint32_t kNumRefIdxL0ActiveMinus1 = kDpbStructStart + 15; | |
| static constexpr uint32_t kNumRefIdxL1ActiveMinus1 = kDpbStructStart + 16; | |
| // low uin16_t | |
| static constexpr uint32_t kDeltaPicOrderCntBottom_0 = kDpbStructStart + 19; | |
| // high uint16_t | |
| static constexpr uint32_t kDeltaPicOrderCntBottom_1 = kDpbStructStart + 20; | |
| // low uin16_t | |
| static constexpr uint32_t kDeltaPicOrderCnt0_0 = kDpbStructStart + 21; | |
| // high uint16_t | |
| static constexpr uint32_t kDeltaPicOrderCnt0_1 = kDpbStructStart + 22; | |
| // low uin16_t | |
| static constexpr uint32_t kDeltaPicOrderCnt1_0 = kDpbStructStart + 23; | |
| // high uint16_t | |
| static constexpr uint32_t kDeltaPicOrderCnt1_1 = kDpbStructStart + 24; | |
| // There are 128 int16_t offset_for_ref_frame values starting here, not 255, | |
| // not 256. These are signed values despite data being an array of uint16_t. | |
| static constexpr uint32_t kOffsetForRefFrameBase = 0x200; | |
| static constexpr uint32_t kOffsetforRefFrameCount = 128; | |
| static constexpr uint32_t kMaxNumRefFramesInPicOrderCntCycle = kOffsetforRefFrameCount; | |
| static constexpr uint32_t kReferenceBase = kOffsetForRefFrameBase + kOffsetforRefFrameCount; | |
| static constexpr uint32_t kReferenceCount = 128; | |
| static constexpr uint32_t kL0ReorderCmdBase = kReferenceBase + kReferenceCount; | |
| static constexpr uint32_t kLxReorderCmdCount = 66; | |
| static constexpr uint32_t kL0ReorderCmdCount = kLxReorderCmdCount; | |
| static constexpr uint32_t kL1ReorderCmdBase = kL0ReorderCmdBase + kL0ReorderCmdCount; | |
| static constexpr uint32_t kL1ReorderCmdCount = kLxReorderCmdCount; | |
| static constexpr uint32_t kMmcoCmd = kL1ReorderCmdBase + kL1ReorderCmdCount; | |
| static constexpr uint32_t kMmcoCmdCount = 44; | |
| static constexpr uint32_t kL0Base = kMmcoCmd + kMmcoCmdCount; | |
| static constexpr uint32_t kLxCount = 40; | |
| static constexpr uint32_t kL0Count = kLxCount; | |
| static constexpr uint32_t kL1Base = kL0Base + kL0Count; | |
| static constexpr uint32_t kL1Count = kLxCount; | |
| // Read a pair of entries starting at |offset| as a 32-bit number. | |
| uint32_t Read32(uint32_t offset) { | |
| // Little endian. | |
| return data[offset] | (static_cast<uint32_t>(data[offset + 1]) << 16); | |
| } | |
| void ReadFromLmem(InternalBuffer* lmem) { | |
| lmem->CacheFlushInvalidate(0, sizeof(data)); | |
| uint16_t* input_params = reinterpret_cast<uint16_t*>(lmem->virt_base()); | |
| // Convert from middle-endian. | |
| for (uint32_t i = 0; i < std::size(data); i += 4) { | |
| for (uint32_t j = 0; j < 4; j++) { | |
| data[i + j] = input_params[i + (3 - j)]; | |
| } | |
| } | |
| } | |
| }; | |
| zx_status_t LoadSecondaryFirmware(const uint8_t* data, uint32_t firmware_size); | |
| void ResetHardware(); | |
| void ConfigureDpb(); | |
| void HandleSliceHeadDone(); | |
| void HandlePicDataDone(); | |
| void HandleBufEmpty(); | |
| void OnFatalError(); | |
| void PumpDecoder(); | |
| bool InitializeRefPics(const std::vector<std::shared_ptr<media::H264Picture>>& ref_pic_list, | |
| uint32_t reg_offset); | |
| // Output all the frames in frames_to_output. | |
| void OutputReadyFrames(); | |
| void PropagatePotentialEos(); | |
| void HandleHardwareError(); | |
| // This method should be called when the decoder detects an error with the input stream and | |
| // requires that the decoder is torn down and recreated before continuing. The method will try to | |
| // reschedule, since the decoder can't do any more work. | |
| void RequestStreamReset(); | |
| uint32_t GetStreamBufferSize(); | |
| void GiveInternalBuffers(InternalBuffers internal_buffers); | |
| FrameDataProvider* frame_data_provider_; | |
| bool fatal_error_ = false; | |
| bool input_eos_queued_ = false; | |
| bool sent_output_eos_to_client_ = false; | |
| bool use_parser_ = false; | |
| std::unique_ptr<PowerReference> power_ref_; | |
| std::unique_ptr<media::H264Decoder> media_decoder_; | |
| std::optional<InternalBuffer> firmware_; | |
| std::optional<InternalBuffer> secondary_firmware_; | |
| std::optional<InternalBuffer> codec_data_; | |
| std::optional<InternalBuffer> aux_buf_; | |
| std::optional<InternalBuffer> lmem_; | |
| // Once InitializedFrames() has run, some of on_dec_internal_buffers_.reference_mv_buffers_ can be | |
| // !present(). The overall ordering of MV buffers is logically the MV buffers in frames_ followed | |
| // by the remaining present() MV buffers in on_deck_internal_buffers_.reference_mv_buffers_. | |
| // Essentially the !present() MV buffers here are in frames_ instead. | |
| std::optional<InternalBuffers> on_deck_internal_buffers_; | |
| // HW state. We separately track some similar SW state with bool values such as | |
| // waiting_for_input_. | |
| DiagnosticStateWrapper<DecoderState> state_{ | |
| [this]() { UpdateDiagnostics(); }, DecoderState::kSwappedOut, | |
| [](DecoderState state) { return DecoderStateName(state); }}; | |
| // The client doesn't round-trip these so stash them here: | |
| uint32_t pending_display_width_ = 0; | |
| uint32_t pending_display_height_ = 0; | |
| // How the HW has been configured (not counting swap out/in): | |
| uint32_t hw_coded_width_ = 0; | |
| uint32_t hw_coded_height_ = 0; | |
| uint32_t hw_stride_ = 0; | |
| // We pretend like these are also configured in the HW even though they're not really. | |
| uint32_t hw_display_width_ = 0; | |
| uint32_t hw_display_height_ = 0; | |
| uint32_t hw_level_idc_ = 0; | |
| uint32_t next_max_reference_size_ = 0u; | |
| bool waiting_for_surfaces_ = false; | |
| bool waiting_for_input_ = false; | |
| // We sometimes need to hold on to current_data_input_ from one PumpDecoder() to the next if | |
| // current_data_input_ doesn't fit in the stream buffer immediately. | |
| std::optional<DataInput> current_data_input_; | |
| // This becomes true on StartDecoding(), and becomes false on StopDecoding(). | |
| // | |
| // Invariant: decoder_started_ || !hw_active_. | |
| bool is_decoder_started_ = false; | |
| // This tracks whether the FW is actively doing any decoding. | |
| // | |
| // It's possible for decoder_started_ to remain true while hw_active_ becomes false for a while, | |
| // then for hw_active_ to become true again without needing to StartDecoding(). For hw_active_ | |
| // to be true, decoder_started_ must also be true. | |
| // | |
| // Invariant: decoder_started_ || !hw_active_. | |
| // Invariant: is_hw_active_ == watchdog is running | |
| bool is_hw_active_ = false; | |
| bool in_pump_decoder_ = false; | |
| bool is_async_pump_pending_ = false; | |
| std::vector<std::shared_ptr<ReferenceFrame>> video_frames_; | |
| ReferenceFrame* current_frame_ = nullptr; | |
| ReferenceFrame* current_metadata_frame_ = nullptr; | |
| std::list<uint32_t> frames_to_output_; | |
| // by first_mb_in_slice | |
| std::map<int, SliceData> slice_data_map_; | |
| media::H264POC poc_; | |
| bool have_initialized_ = false; | |
| uint32_t seq_info2_{}; | |
| HardwareRenderParams params_; | |
| std::optional<media::H264SPS> current_sps_; | |
| std::optional<media::H264PPS> current_pps_; | |
| // This tracks which slice headers we've seen since starting from a saved state. If we restore | |
| // from the same saved state later, this prevents us from telling H264Decoder about the same slice | |
| // more than once. | |
| int per_frame_seen_first_mb_in_slice_ = -1; | |
| int per_frame_decoded_first_mb_in_slice_ = -1; | |
| int per_frame_attempt_seen_first_mb_in_slice_ = -1; | |
| // Not restricted to being a power of 2, but at least for now we do restrict to being a multiple | |
| // of system page size. | |
| uint32_t stream_buffer_size_ = 0; | |
| // If we fail to fully decode a frame, we'll force "swap out" but with should_save_input_context_ | |
| // false to achieve a re-load of the old state when swapping back in. If we succeed at fully | |
| // decoding a frame, we'll force_swap_out_ true in order to checkpoint the useful progress so far, | |
| // to persist a saved state from which we can repeatedly start from if decoding the next frame | |
| // doesn't work the first time due to insufficient input data so far. | |
| bool force_swap_out_ = false; | |
| // This is only true if we've made useful progress. If we haven't made useful progress then we'll | |
| // restore a previous state and try to decode starting at the same read position again, with more | |
| // data appended at the end, and repeatedly do that until we get a picture fully decoded. | |
| bool should_save_input_context_ = false; | |
| // When we restore from a saved state we've previously started from, we want to restore everything | |
| // except the write pointer, since we want to keep the data written to the stream buffer last time | |
| // so we can re-decode all that data. | |
| uint64_t unwrapped_write_stream_offset_ = 0; | |
| // When we're adding data to the stream buffer we want to know what to avoid overwriting. We only | |
| // move this forward based on the HW read pointer when we're restoring from a saved state, else | |
| // we may need to restore from the current saved state again which can cause the HW read offset | |
| // to be restored to a logically lower value. Immediately after restoring from a saved state is | |
| // also when the read pointer won't reflect bytes consumed into the FIFO yet - those bytes may or | |
| // may not be saved along with the saved state, so we assume they aren't. Similar to the HW read | |
| // pointer, this will be 512 byte aligned, only moving forward when it's safe for the parser to | |
| // write into bytes before this offset again. | |
| uint64_t unwrapped_saved_read_stream_offset_ = 0; | |
| // This is used to determine how many PTS values we have stored beyond the last detected slice | |
| // header. We don't want to put so many packets into the stream buffer that it causes PtsManager | |
| // to lose track of PTS offsets within the stream buffer. | |
| uint64_t unwrapped_first_slice_header_of_frame_detected_stream_offset_ = 0; | |
| // These are used to determine if we're making progress when we're about to tell the HW to attempt | |
| // searching for a frame and decoding it. If we're not making progress either adding more input | |
| // data or decoding a frame from input data provided so far, then we've gotten caught in a | |
| // pathological case involving broken input data or more PTS values from the client than makes any | |
| // sense. In such cases we fail the stream (at least for now). | |
| uint64_t unwrapped_first_slice_header_of_frame_decoded_stream_offset_ = 0; | |
| uint64_t unwrapped_write_stream_offset_decode_tried_ = 0; | |
| uint64_t unwrapped_first_slice_header_of_frame_decoded_stream_offset_decode_tried_ = 0; | |
| media::H264SliceHeader stashed_latest_slice_header_; | |
| // Stashed during ConfigureDpb(), since not robustly available during HandleSliceHeader(). | |
| uint32_t chroma_format_idc_ = 0; | |
| // The frame_num we've seen a slice header for, but not yet a pic data done. We use this to | |
| // detect a missing pic data done between slices of two different frames. | |
| std::optional<int> frame_num_; | |
| std::optional<uint32_t> saved_iqidct_ctrl_; | |
| std::optional<uint32_t> saved_vcop_ctrl_; | |
| std::optional<uint32_t> saved_vld_decode_ctrl_; | |
| bool configure_dpb_seen_ = false; | |
| }; | |
| } // namespace amlogic_decoder | |
| #endif // SRC_MEDIA_DRIVERS_AMLOGIC_DECODER_H264_MULTI_DECODER_H_ |