Mercurial > hg > orthanc

comparison OrthancFramework/Sources/Images/PngWriter.cpp @ 4642:69bbb4bd35cb

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
PngWriter recreates a new libpng context for each encoding
author Sebastien Jodogne <s.jodogne@gmail.com>
date Wed, 28 Apr 2021 11:22:39 +0200
parents d9473bd5ed43
children e8967149d87a
comparison
equal deleted inserted replaced
4641:b02dc8303cf6 4642:69bbb4bd35cb
60 //((PngWriter*) payload)->isError_ = true; 60 //((PngWriter*) payload)->isError_ = true;
61 } 61 }
62 62
63 static void WarningHandler(png_structp png, png_const_charp message) 63 static void WarningHandler(png_structp png, png_const_charp message)
64 { 64 {
65 printf("++ %d\n", (int)message); 65 printf("++ %d\n", (int)message);
66 }*/ 66 }*/
67 67
68 68
69 namespace Orthanc 69 namespace Orthanc
70 { 70 {
71 struct PngWriter::PImpl 71 /**
72 { 72 * The "png_" structure cannot be safely reused if the bpp changes
73 * between successive invocations. This can lead to "Invalid reads"
74 * reported by valgrind if writing a 16bpp image, then a 8bpp image
75 * using the same "PngWriter" object. Starting with Orthanc 1.9.3,
76 * we recreate a new "png_" context each time a PNG image must be
77 * written so as to prevent such invalid reads.
78 **/
79 class PngWriter::Context : public boost::noncopyable
80 {
81 private:
73 png_structp png_; 82 png_structp png_;
74 png_infop info_; 83 png_infop info_;
75 84
76 // Filled by Prepare() 85 // Filled by Prepare()
77 std::vector<uint8_t*> rows_; 86 std::vector<uint8_t*> rows_;
78 int bitDepth_; 87 int bitDepth_;
79 int colorType_; 88 int colorType_;
89
90 public:
91 Context() :
92 png_(NULL),
93 info_(NULL)
94 {
95 png_ = png_create_write_struct
96 (PNG_LIBPNG_VER_STRING, NULL, NULL, NULL); //this, ErrorHandler, WarningHandler);
97 if (!png_)
98 {
99 throw OrthancException(ErrorCode_NotEnoughMemory);
100 }
101
102 info_ = png_create_info_struct(png_);
103 if (!info_)
104 {
105 png_destroy_write_struct(&png_, NULL);
106 throw OrthancException(ErrorCode_NotEnoughMemory);
107 }
108 }
109
110
111 ~Context()
112 {
113 if (info_)
114 {
115 png_destroy_info_struct(png_, &info_);
116 }
117
118 if (png_)
119 {
120 png_destroy_write_struct(&png_, NULL);
121 }
122 }
123
124
125 png_structp GetObject() const
126 {
127 return png_;
128 }
129
130
131 void Prepare(unsigned int width,
132 unsigned int height,
133 unsigned int pitch,
134 PixelFormat format,
135 const void* buffer)
136 {
137 rows_.resize(height);
138 for (unsigned int y = 0; y < height; y++)
139 {
140 rows_[y] = const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(buffer)) + y * pitch;
141 }
142
143 switch (format)
144 {
145 case PixelFormat_RGB24:
146 bitDepth_ = 8;
147 colorType_ = PNG_COLOR_TYPE_RGB;
148 break;
149
150 case PixelFormat_RGBA32:
151 bitDepth_ = 8;
152 colorType_ = PNG_COLOR_TYPE_RGBA;
153 break;
154
155 case PixelFormat_Grayscale8:
156 bitDepth_ = 8;
157 colorType_ = PNG_COLOR_TYPE_GRAY;
158 break;
159
160 case PixelFormat_Grayscale16:
161 case PixelFormat_SignedGrayscale16:
162 bitDepth_ = 16;
163 colorType_ = PNG_COLOR_TYPE_GRAY;
164 break;
165
166 default:
167 throw OrthancException(ErrorCode_NotImplemented);
168 }
169 }
170
171
172 void Compress(unsigned int width,
173 unsigned int height,
174 unsigned int pitch,
175 PixelFormat format)
176 {
177 png_set_IHDR(png_, info_, width, height,
178 bitDepth_, colorType_, PNG_INTERLACE_NONE,
179 PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
180
181 png_write_info(png_, info_);
182
183 if (height > 0)
184 {
185 switch (format)
186 {
187 case PixelFormat_Grayscale16:
188 case PixelFormat_SignedGrayscale16:
189 {
190 int transforms = 0;
191 if (Toolbox::DetectEndianness() == Endianness_Little)
192 {
193 transforms = PNG_TRANSFORM_SWAP_ENDIAN;
194 }
195
196 png_set_rows(png_, info_, &rows_[0]);
197 png_write_png(png_, info_, transforms, NULL);
198
199 break;
200 }
201
202 default:
203 png_write_image(png_, &rows_[0]);
204 }
205 }
206
207 png_write_end(png_, NULL);
208 }
80 }; 209 };
81
82
83
84 PngWriter::PngWriter() : pimpl_(new PImpl)
85 {
86 pimpl_->png_ = NULL;
87 pimpl_->info_ = NULL;
88
89 pimpl_->png_ = png_create_write_struct
90 (PNG_LIBPNG_VER_STRING, NULL, NULL, NULL); //this, ErrorHandler, WarningHandler);
91 if (!pimpl_->png_)
92 {
93 throw OrthancException(ErrorCode_NotEnoughMemory);
94 }
95
96 pimpl_->info_ = png_create_info_struct(pimpl_->png_);
97 if (!pimpl_->info_)
98 {
99 png_destroy_write_struct(&pimpl_->png_, NULL);
100 throw OrthancException(ErrorCode_NotEnoughMemory);
101 }
102 }
103
104 PngWriter::~PngWriter()
105 {
106 if (pimpl_->info_)
107 {
108 png_destroy_info_struct(pimpl_->png_, &pimpl_->info_);
109 }
110
111 if (pimpl_->png_)
112 {
113 png_destroy_write_struct(&pimpl_->png_, NULL);
114 }
115 }
116
117
118
119 void PngWriter::Prepare(unsigned int width,
120 unsigned int height,
121 unsigned int pitch,
122 PixelFormat format,
123 const void* buffer)
124 {
125 pimpl_->rows_.resize(height);
126 for (unsigned int y = 0; y < height; y++)
127 {
128 pimpl_->rows_[y] = const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(buffer)) + y * pitch;
129 }
130
131 switch (format)
132 {
133 case PixelFormat_RGB24:
134 pimpl_->bitDepth_ = 8;
135 pimpl_->colorType_ = PNG_COLOR_TYPE_RGB;
136 break;
137
138 case PixelFormat_RGBA32:
139 pimpl_->bitDepth_ = 8;
140 pimpl_->colorType_ = PNG_COLOR_TYPE_RGBA;
141 break;
142
143 case PixelFormat_Grayscale8:
144 pimpl_->bitDepth_ = 8;
145 pimpl_->colorType_ = PNG_COLOR_TYPE_GRAY;
146 break;
147
148 case PixelFormat_Grayscale16:
149 case PixelFormat_SignedGrayscale16:
150 pimpl_->bitDepth_ = 16;
151 pimpl_->colorType_ = PNG_COLOR_TYPE_GRAY;
152 break;
153
154 default:
155 throw OrthancException(ErrorCode_NotImplemented);
156 }
157 }
158
159
160 void PngWriter::Compress(unsigned int width,
161 unsigned int height,
162 unsigned int pitch,
163 PixelFormat format)
164 {
165 png_set_IHDR(pimpl_->png_, pimpl_->info_, width, height,
166 pimpl_->bitDepth_, pimpl_->colorType_, PNG_INTERLACE_NONE,
167 PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
168
169 png_write_info(pimpl_->png_, pimpl_->info_);
170
171 if (height > 0)
172 {
173 switch (format)
174 {
175 case PixelFormat_Grayscale16:
176 case PixelFormat_SignedGrayscale16:
177 {
178 int transforms = 0;
179 if (Toolbox::DetectEndianness() == Endianness_Little)
180 {
181 transforms = PNG_TRANSFORM_SWAP_ENDIAN;
182 }
183
184 png_set_rows(pimpl_->png_, pimpl_->info_, &pimpl_->rows_[0]);
185 png_write_png(pimpl_->png_, pimpl_->info_, transforms, NULL);
186
187 break;
188 }
189
190 default:
191 png_write_image(pimpl_->png_, &pimpl_->rows_[0]);
192 }
193 }
194
195 png_write_end(pimpl_->png_, NULL);
196 }
197 210
198 211
199 #if ORTHANC_SANDBOXED == 0 212 #if ORTHANC_SANDBOXED == 0
200 void PngWriter::WriteToFileInternal(const std::string& filename, 213 void PngWriter::WriteToFileInternal(const std::string& filename,
201 unsigned int width, 214 unsigned int width,
202 unsigned int height, 215 unsigned int height,
203 unsigned int pitch, 216 unsigned int pitch,
204 PixelFormat format, 217 PixelFormat format,
205 const void* buffer) 218 const void* buffer)
206 { 219 {
207 Prepare(width, height, pitch, format, buffer); 220 Context context;
221
222 context.Prepare(width, height, pitch, format, buffer);
208 223
209 FILE* fp = SystemToolbox::OpenFile(filename, FileMode_WriteBinary); 224 FILE* fp = SystemToolbox::OpenFile(filename, FileMode_WriteBinary);
210 if (!fp) 225 if (!fp)
211 { 226 {
212 throw OrthancException(ErrorCode_CannotWriteFile); 227 throw OrthancException(ErrorCode_CannotWriteFile);
213 } 228 }
214 229
215 png_init_io(pimpl_->png_, fp); 230 png_init_io(context.GetObject(), fp);
216 231
217 if (setjmp(png_jmpbuf(pimpl_->png_))) 232 if (setjmp(png_jmpbuf(context.GetObject())))
218 { 233 {
219 // Error during writing PNG 234 // Error during writing PNG
220 throw OrthancException(ErrorCode_CannotWriteFile); 235 throw OrthancException(ErrorCode_CannotWriteFile);
221 } 236 }
222 237
223 Compress(width, height, pitch, format); 238 context.Compress(width, height, pitch, format);
224 239
225 fclose(fp); 240 fclose(fp);
226 } 241 }
227 #endif 242 #endif
228 243
232 png_size_t size) 247 png_size_t size)
233 { 248 {
234 ChunkedBuffer* buffer = reinterpret_cast<ChunkedBuffer*>(png_get_io_ptr(png_ptr)); 249 ChunkedBuffer* buffer = reinterpret_cast<ChunkedBuffer*>(png_get_io_ptr(png_ptr));
235 buffer->AddChunk(data, size); 250 buffer->AddChunk(data, size);
236 } 251 }
237
238 252
239 253
240 void PngWriter::WriteToMemoryInternal(std::string& png, 254 void PngWriter::WriteToMemoryInternal(std::string& png,
241 unsigned int width, 255 unsigned int width,
242 unsigned int height, 256 unsigned int height,
243 unsigned int pitch, 257 unsigned int pitch,
244 PixelFormat format, 258 PixelFormat format,
245 const void* buffer) 259 const void* buffer)
246 { 260 {
261 Context context;
262
247 ChunkedBuffer chunks; 263 ChunkedBuffer chunks;
248 264
249 Prepare(width, height, pitch, format, buffer); 265 context.Prepare(width, height, pitch, format, buffer);
250 266
251 if (setjmp(png_jmpbuf(pimpl_->png_))) 267 if (setjmp(png_jmpbuf(context.GetObject())))
252 { 268 {
253 // Error during writing PNG 269 // Error during writing PNG
254 throw OrthancException(ErrorCode_InternalError); 270 throw OrthancException(ErrorCode_InternalError);
255 } 271 }
256 272
257 png_set_write_fn(pimpl_->png_, &chunks, MemoryCallback, NULL); 273 png_set_write_fn(context.GetObject(), &chunks, MemoryCallback, NULL);
258 274
259 Compress(width, height, pitch, format); 275 context.Compress(width, height, pitch, format);
260 276
261 chunks.Flatten(png); 277 chunks.Flatten(png);
262 } 278 }
263 } 279 }