Debian Codegraph @

lib/jxl/modular/modular_image.h

raw
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_MODULAR_MODULAR_IMAGE_H_
7 #define LIB_JXL_MODULAR_MODULAR_IMAGE_H_
8
9 #include <jxl/memory_manager.h>
10
11 #include <cstddef>
12 #include <cstdint>
13 #include <cstring>
14 #include <string>
15 #include <utility>
16 #include <vector>
17
18 #include "lib/jxl/base/compiler_specific.h"
19 #include "lib/jxl/base/data_parallel.h"
20 #include "lib/jxl/base/status.h"
21 #include "lib/jxl/image.h"
22
23 namespace jxl {
24
25 typedef int32_t pixel_type; // can use int16_t if it's only for 8-bit images.
26 // Need some wiggle room for YCoCg / Squeeze etc
27
28 typedef int64_t pixel_type_w;
29
30 namespace weighted {
31 struct Header;
32 }
33
34 class Channel {
35 public:
36 jxl::Plane<pixel_type> plane;
37 size_t w, h;
38 int hshift, vshift; // w ~= image.w >> hshift; h ~= image.h >> vshift
39 Channel(const Channel& other) = delete;
40 Channel& operator=(const Channel& other) = delete;
41
42 static StatusOr<Channel> Create(JxlMemoryManager* memory_manager, size_t iw,
43 size_t ih, int hsh = 0, int vsh = 0) {
44 JXL_ASSIGN_OR_RETURN(Plane<pixel_type> plane,
45 Plane<pixel_type>::Create(memory_manager, iw, ih));
46 return Channel(std::move(plane), iw, ih, hsh, vsh);
47 }
48
49 // Move assignment
50 Channel& operator=(Channel&& other) noexcept {
51 w = other.w;
52 h = other.h;
53 hshift = other.hshift;
54 vshift = other.vshift;
55 plane = std::move(other.plane);
56 return *this;
57 }
58
59 // Move constructor
60 Channel(Channel&& other) noexcept = default;
61
62 JxlMemoryManager* memory_manager() const { return plane.memory_manager(); };
63
64 Status shrink() {
65 if (plane.xsize() == w && plane.ysize() == h) return true;
66 JXL_ASSIGN_OR_RETURN(plane,
67 Plane<pixel_type>::Create(memory_manager(), w, h));
68 return true;
69 }
70 Status shrink(int nw, int nh) {
71 w = nw;
72 h = nh;
73 return shrink();
74 }
75
76 JXL_INLINE pixel_type* Row(const size_t y) { return plane.Row(y); }
77 JXL_INLINE const pixel_type* Row(const size_t y) const {
78 return plane.Row(y);
79 }
80
81 private:
82 Channel(jxl::Plane<pixel_type>&& p, size_t iw, size_t ih, int hsh, int vsh)
83 : plane(std::move(p)), w(iw), h(ih), hshift(hsh), vshift(vsh) {}
84 };
85
86 class Transform;
87
88 class Image {
89 public:
90 // image data, transforms can dramatically change the number of channels and
91 // their semantics
92 std::vector<Channel> channel;
93 // transforms that have been applied (and that have to be undone)
94 std::vector<Transform> transform;
95
96 // image dimensions (channels may have different dimensions due to transforms)
97 size_t w, h;
98 int bitdepth;
99 size_t nb_meta_channels; // first few channels might contain palette(s)
100 bool error; // true if a fatal error occurred, false otherwise
101
102 explicit Image(JxlMemoryManager* memory_manager);
103
104 Image(const Image& other) = delete;
105 Image& operator=(const Image& other) = delete;
106
107 Image& operator=(Image&& other) noexcept;
108 Image(Image&& other) noexcept = default;
109
110 static StatusOr<Image> Create(JxlMemoryManager* memory_manager, size_t iw,
111 size_t ih, int bitdepth, int nb_chans);
112
113 JxlMemoryManager* memory_manager() const { return memory_manager_; }
114
115 bool empty() const {
116 for (const auto& ch : channel) {
117 if (ch.w && ch.h) return false;
118 }
119 return true;
120 }
121
122 static StatusOr<Image> Clone(const Image& that);
123
124 void undo_transforms(const weighted::Header& wp_header,
125 jxl::ThreadPool* pool = nullptr);
126
127 std::string DebugString() const;
128
129 private:
130 Image(JxlMemoryManager* memory_manager, size_t iw, size_t ih, int bitdepth);
131 JxlMemoryManager* memory_manager_;
132 };
133
134 } // namespace jxl
135
136 #endif // LIB_JXL_MODULAR_MODULAR_IMAGE_H_