dec_modular.h (5817B)
1 // Copyright (c) the JPEG XL Project Authors. All rights reserved. 2 // 3 // Use of this source code is governed by a BSD-style 4 // license that can be found in the LICENSE file. 5 6 #ifndef LIB_JXL_DEC_MODULAR_H_ 7 #define LIB_JXL_DEC_MODULAR_H_ 8 9 #include <jxl/memory_manager.h> 10 11 #include <cstddef> 12 #include <cstdint> 13 #include <string> 14 #include <vector> 15 16 #include "lib/jxl/base/data_parallel.h" 17 #include "lib/jxl/base/rect.h" 18 #include "lib/jxl/base/status.h" 19 #include "lib/jxl/dec_bit_reader.h" 20 #include "lib/jxl/dec_cache.h" 21 #include "lib/jxl/frame_dimensions.h" 22 #include "lib/jxl/frame_header.h" 23 #include "lib/jxl/modular/encoding/dec_ma.h" 24 #include "lib/jxl/modular/encoding/encoding.h" 25 #include "lib/jxl/modular/modular_image.h" 26 #include "lib/jxl/quant_weights.h" 27 #include "lib/jxl/render_pipeline/render_pipeline.h" 28 29 namespace jxl { 30 31 struct ModularStreamId { 32 enum class Kind { 33 GlobalData, 34 VarDCTDC, 35 ModularDC, 36 ACMetadata, 37 QuantTable, 38 ModularAC 39 }; 40 Kind kind; 41 size_t quant_table_id; 42 size_t group_id; // DC or AC group id. 43 size_t pass_id; // Only for kModularAC. 44 size_t ID(const FrameDimensions& frame_dim) const { 45 size_t id = 0; 46 switch (kind) { 47 case Kind::GlobalData: 48 id = 0; 49 break; 50 case Kind::VarDCTDC: 51 id = 1 + group_id; 52 break; 53 case Kind::ModularDC: 54 id = 1 + frame_dim.num_dc_groups + group_id; 55 break; 56 case Kind::ACMetadata: 57 id = 1 + 2 * frame_dim.num_dc_groups + group_id; 58 break; 59 case Kind::QuantTable: 60 id = 1 + 3 * frame_dim.num_dc_groups + quant_table_id; 61 break; 62 case Kind::ModularAC: 63 id = 1 + 3 * frame_dim.num_dc_groups + kNumQuantTables + 64 frame_dim.num_groups * pass_id + group_id; 65 break; 66 }; 67 return id; 68 } 69 static ModularStreamId Global() { 70 return ModularStreamId{Kind::GlobalData, 0, 0, 0}; 71 } 72 static ModularStreamId VarDCTDC(size_t group_id) { 73 return ModularStreamId{Kind::VarDCTDC, 0, group_id, 0}; 74 } 75 static ModularStreamId ModularDC(size_t group_id) { 76 return ModularStreamId{Kind::ModularDC, 0, group_id, 0}; 77 } 78 static ModularStreamId ACMetadata(size_t group_id) { 79 return ModularStreamId{Kind::ACMetadata, 0, group_id, 0}; 80 } 81 static StatusOr<ModularStreamId> QuantTable(size_t quant_table_id) { 82 JXL_ENSURE(quant_table_id < kNumQuantTables); 83 return ModularStreamId{Kind::QuantTable, quant_table_id, 0, 0}; 84 } 85 static ModularStreamId ModularAC(size_t group_id, size_t pass_id) { 86 return ModularStreamId{Kind::ModularAC, 0, group_id, pass_id}; 87 } 88 static size_t Num(const FrameDimensions& frame_dim, size_t passes) { 89 return ModularAC(0, passes).ID(frame_dim); 90 } 91 std::string DebugString() const; 92 }; 93 94 class ModularFrameDecoder { 95 public: 96 explicit ModularFrameDecoder(JxlMemoryManager* memory_manager) 97 : memory_manager_(memory_manager), full_image(memory_manager) {} 98 void Init(const FrameDimensions& frame_dim) { this->frame_dim = frame_dim; } 99 Status DecodeGlobalInfo(BitReader* reader, const FrameHeader& frame_header, 100 bool allow_truncated_group); 101 Status DecodeGroup(const FrameHeader& frame_header, const Rect& rect, 102 BitReader* reader, int minShift, int maxShift, 103 const ModularStreamId& stream, bool zerofill, 104 PassesDecoderState* dec_state, 105 RenderPipelineInput* render_pipeline_input, 106 bool allow_truncated, bool* should_run_pipeline = nullptr); 107 // Decodes a VarDCT DC group (`group_id`) from the given `reader`. 108 Status DecodeVarDCTDC(const FrameHeader& frame_header, size_t group_id, 109 BitReader* reader, PassesDecoderState* dec_state); 110 // Decodes a VarDCT AC Metadata group (`group_id`) from the given `reader`. 111 Status DecodeAcMetadata(const FrameHeader& frame_header, size_t group_id, 112 BitReader* reader, PassesDecoderState* dec_state); 113 // Decodes a RAW quant table from `br` into the given `encoding`, of size 114 // `required_size_x x required_size_y`. If `modular_frame_decoder` is passed, 115 // its global tree is used, otherwise no global tree is used. 116 static Status DecodeQuantTable(JxlMemoryManager* memory_manager, 117 size_t required_size_x, size_t required_size_y, 118 BitReader* br, QuantEncoding* encoding, 119 size_t idx, 120 ModularFrameDecoder* modular_frame_decoder); 121 // if inplace is true, this can only be called once 122 // if it is false, it can be called multiple times (e.g. for progressive 123 // steps) 124 Status FinalizeDecoding(const FrameHeader& frame_header, 125 PassesDecoderState* dec_state, jxl::ThreadPool* pool, 126 bool inplace); 127 bool have_dc() const { return have_something; } 128 void MaybeDropFullImage(); 129 bool UsesFullImage() const { return use_full_image; } 130 JxlMemoryManager* memory_manager() const { return memory_manager_; } 131 132 private: 133 Status ModularImageToDecodedRect(const FrameHeader& frame_header, Image& gi, 134 PassesDecoderState* dec_state, 135 jxl::ThreadPool* pool, 136 RenderPipelineInput& render_pipeline_input, 137 Rect modular_rect) const; 138 JxlMemoryManager* memory_manager_; 139 Image full_image; 140 std::vector<Transform> global_transform; 141 FrameDimensions frame_dim; 142 bool do_color; 143 bool have_something; 144 bool use_full_image = true; 145 bool all_same_shift; 146 Tree tree; 147 ANSCode code; 148 std::vector<uint8_t> context_map; 149 GroupHeader global_header; 150 }; 151 152 } // namespace jxl 153 154 #endif // LIB_JXL_DEC_MODULAR_H_