Mercurial > hgrepos > Python2 > PyMuPDF

comparison mupdf-source/platform/java/jni/pixmap.c @ 2:b50eed0cc0ef upstream

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
ADD: MuPDF v1.26.7: the MuPDF source as downloaded by a default build of PyMuPDF 1.26.4. The directory name has changed: no version number in the expanded directory now.
author Franz Glasner <fzglas.hg@dom66.de>
date Mon, 15 Sep 2025 11:43:07 +0200
parents
children
comparison
equal deleted inserted replaced
1:1d09e1dec1d9 2:b50eed0cc0ef
1 // Copyright (C) 2004-2025 Artifex Software, Inc.
2 //
3 // This file is part of MuPDF.
4 //
5 // MuPDF is free software: you can redistribute it and/or modify it under the
6 // terms of the GNU Affero General Public License as published by the Free
7 // Software Foundation, either version 3 of the License, or (at your option)
8 // any later version.
9 //
10 // MuPDF is distributed in the hope that it will be useful, but WITHOUT ANY
11 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
12 // FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
13 // details.
14 //
15 // You should have received a copy of the GNU Affero General Public License
16 // along with MuPDF. If not, see <https://www.gnu.org/licenses/agpl-3.0.en.html>
17 //
18 // Alternative licensing terms are available from the licensor.
19 // For commercial licensing, see <https://www.artifex.com/> or contact
20 // Artifex Software, Inc., 39 Mesa Street, Suite 108A, San Francisco,
21 // CA 94129, USA, for further information.
22
23 /* Pixmap interface */
24
25 JNIEXPORT void JNICALL
26 FUN(Pixmap_finalize)(JNIEnv *env, jobject self)
27 {
28 fz_context *ctx = get_context(env);
29 fz_pixmap *pixmap = from_Pixmap_safe(env, self);
30 if (!ctx || !pixmap) return;
31 (*env)->SetLongField(env, self, fid_Pixmap_pointer, 0);
32 fz_drop_pixmap(ctx, pixmap);
33 }
34
35 JNIEXPORT jlong JNICALL
36 FUN(Pixmap_newNative)(JNIEnv *env, jobject self, jobject jcs, jint x, jint y, jint w, jint h, jboolean alpha)
37 {
38 fz_context *ctx = get_context(env);
39 fz_colorspace *cs = from_ColorSpace(env, jcs);
40 fz_pixmap *pixmap = NULL;
41
42 if (!ctx || !cs) return 0;
43
44 fz_try(ctx)
45 {
46 pixmap = fz_new_pixmap(ctx, cs, w, h, NULL, alpha);
47 pixmap->x = x;
48 pixmap->y = y;
49 }
50 fz_catch(ctx)
51 jni_rethrow(env, ctx);
52
53 return jlong_cast(pixmap);
54 }
55
56 JNIEXPORT jlong JNICALL
57 FUN(Pixmap_newNativeFromColorAndMask)(JNIEnv *env, jobject self, jobject jcolor, jobject jmask)
58 {
59 fz_context *ctx = get_context(env);
60 fz_pixmap *color = from_Pixmap_safe(env, jcolor);
61 fz_pixmap *mask = from_Pixmap_safe(env, jmask);
62 fz_pixmap *pixmap = NULL;
63
64 if (!ctx) return 0;
65 if (!jcolor) jni_throw_arg(env, "color must not be null");
66 if (!jmask) jni_throw_arg(env, "mask must not be null");
67
68 fz_try(ctx)
69 pixmap = fz_new_pixmap_from_color_and_mask(ctx, color, mask);
70 fz_catch(ctx)
71 jni_rethrow(env, ctx);
72
73 return jlong_cast(pixmap);
74 }
75
76 JNIEXPORT void JNICALL
77 FUN(Pixmap_clear)(JNIEnv *env, jobject self)
78 {
79 fz_context *ctx = get_context(env);
80 fz_pixmap *pixmap = from_Pixmap(env, self);
81
82 if (!ctx || !pixmap) return;
83
84 fz_try(ctx)
85 fz_clear_pixmap(ctx, pixmap);
86 fz_catch(ctx)
87 jni_rethrow_void(env, ctx);
88 }
89
90 JNIEXPORT void JNICALL
91 FUN(Pixmap_clearWithValue)(JNIEnv *env, jobject self, jint value)
92 {
93 fz_context *ctx = get_context(env);
94 fz_pixmap *pixmap = from_Pixmap(env, self);
95
96 if (!ctx || !pixmap) return;
97
98 fz_try(ctx)
99 fz_clear_pixmap_with_value(ctx, pixmap, value);
100 fz_catch(ctx)
101 jni_rethrow_void(env, ctx);
102 }
103
104 JNIEXPORT jobject JNICALL
105 FUN(Pixmap_asPNG)(JNIEnv *env, jobject self)
106 {
107 fz_context *ctx = get_context(env);
108 fz_pixmap *pixmap = from_Pixmap(env, self);
109 fz_buffer *buf = NULL;
110
111 if (!ctx || !pixmap) return NULL;
112
113 fz_try(ctx)
114 buf = fz_new_buffer_from_pixmap_as_png(ctx, pixmap, fz_default_color_params);
115 fz_catch(ctx)
116 jni_rethrow(env, ctx);
117
118 return to_Buffer_safe_own(ctx, env, buf);
119 }
120
121 JNIEXPORT jobject JNICALL
122 FUN(Pixmap_asJPEG)(JNIEnv *env, jobject self, jint quality, jboolean invert_cmyk)
123 {
124 fz_context *ctx = get_context(env);
125 fz_pixmap *pixmap = from_Pixmap(env, self);
126 fz_buffer *buf = NULL;
127
128 if (!ctx || !pixmap) return NULL;
129
130 fz_try(ctx)
131 buf = fz_new_buffer_from_pixmap_as_jpeg(ctx, pixmap, fz_default_color_params, quality, invert_cmyk);
132 fz_catch(ctx)
133 jni_rethrow(env, ctx);
134
135 return to_Buffer_safe_own(ctx, env, buf);
136 }
137
138 JNIEXPORT jobject JNICALL
139 FUN(Pixmap_asPAM)(JNIEnv *env, jobject self)
140 {
141 fz_context *ctx = get_context(env);
142 fz_pixmap *pixmap = from_Pixmap(env, self);
143 fz_buffer *buf = NULL;
144
145 if (!ctx || !pixmap) return NULL;
146
147 fz_try(ctx)
148 buf = fz_new_buffer_from_pixmap_as_pam(ctx, pixmap, fz_default_color_params);
149 fz_catch(ctx)
150 jni_rethrow(env, ctx);
151
152 return to_Buffer_safe_own(ctx, env, buf);
153 }
154
155 JNIEXPORT jobject JNICALL
156 FUN(Pixmap_asPNM)(JNIEnv *env, jobject self)
157 {
158 fz_context *ctx = get_context(env);
159 fz_pixmap *pixmap = from_Pixmap(env, self);
160 fz_buffer *buf = NULL;
161
162 if (!ctx || !pixmap) return NULL;
163
164 fz_try(ctx)
165 buf = fz_new_buffer_from_pixmap_as_pnm(ctx, pixmap, fz_default_color_params);
166 fz_catch(ctx)
167 jni_rethrow(env, ctx);
168
169 return to_Buffer_safe_own(ctx, env, buf);
170 }
171
172 JNIEXPORT jobject JNICALL
173 FUN(Pixmap_asPBM)(JNIEnv *env, jobject self)
174 {
175 fz_context *ctx = get_context(env);
176 fz_pixmap *pixmap = from_Pixmap(env, self);
177 fz_buffer *buf = NULL;
178
179 if (!ctx || !pixmap) return NULL;
180
181 fz_try(ctx)
182 buf = fz_new_buffer_from_pixmap_as_pbm(ctx, pixmap, fz_default_color_params);
183 fz_catch(ctx)
184 jni_rethrow(env, ctx);
185
186 return to_Buffer_safe_own(ctx, env, buf);
187 }
188
189 JNIEXPORT jobject JNICALL
190 FUN(Pixmap_asPKM)(JNIEnv *env, jobject self)
191 {
192 fz_context *ctx = get_context(env);
193 fz_pixmap *pixmap = from_Pixmap(env, self);
194 fz_buffer *buf = NULL;
195
196 if (!ctx || !pixmap) return NULL;
197
198 fz_try(ctx)
199 buf = fz_new_buffer_from_pixmap_as_pkm(ctx, pixmap, fz_default_color_params);
200 fz_catch(ctx)
201 jni_rethrow(env, ctx);
202
203 return to_Buffer_safe_own(ctx, env, buf);
204 }
205
206 JNIEXPORT jobject JNICALL
207 FUN(Pixmap_asJPX)(JNIEnv *env, jobject self, jint quality)
208 {
209 fz_context *ctx = get_context(env);
210 fz_pixmap *pixmap = from_Pixmap(env, self);
211 fz_buffer *buf = NULL;
212
213 if (!ctx || !pixmap) return NULL;
214
215 fz_try(ctx)
216 buf = fz_new_buffer_from_pixmap_as_jpx(ctx, pixmap, fz_default_color_params, quality);
217 fz_catch(ctx)
218 jni_rethrow(env, ctx);
219
220 return to_Buffer_safe_own(ctx, env, buf);
221 }
222
223 JNIEXPORT void JNICALL
224 FUN(Pixmap_saveAsPNG)(JNIEnv *env, jobject self, jstring jfilename)
225 {
226 fz_context *ctx = get_context(env);
227 fz_pixmap *pixmap = from_Pixmap(env, self);
228 const char *filename = "null";
229
230 if (!ctx || !pixmap) return;
231 if (!jfilename) jni_throw_arg_void(env, "filename must not be null");
232
233 filename = (*env)->GetStringUTFChars(env, jfilename, NULL);
234 if (!filename) return;
235
236 fz_try(ctx)
237 fz_save_pixmap_as_png(ctx, pixmap, filename);
238 fz_always(ctx)
239 (*env)->ReleaseStringUTFChars(env, jfilename, filename);
240 fz_catch(ctx)
241 jni_rethrow_void(env, ctx);
242 }
243
244 JNIEXPORT void JNICALL
245 FUN(Pixmap_saveAsJPEG)(JNIEnv *env, jobject self, jstring jfilename, jint quality)
246 {
247 fz_context *ctx = get_context(env);
248 fz_pixmap *pixmap = from_Pixmap(env, self);
249 const char *filename = "null";
250
251 if (!ctx || !pixmap) return;
252 if (!jfilename) jni_throw_arg_void(env, "filename must not be null");
253
254 filename = (*env)->GetStringUTFChars(env, jfilename, NULL);
255 if (!filename) return;
256
257 fz_try(ctx)
258 fz_save_pixmap_as_jpeg(ctx, pixmap, filename, quality);
259 fz_always(ctx)
260 (*env)->ReleaseStringUTFChars(env, jfilename, filename);
261 fz_catch(ctx)
262 jni_rethrow_void(env, ctx);
263 }
264
265 JNIEXPORT void JNICALL
266 FUN(Pixmap_saveAsPAM)(JNIEnv *env, jobject self, jstring jfilename)
267 {
268 fz_context *ctx = get_context(env);
269 fz_pixmap *pixmap = from_Pixmap(env, self);
270 const char *filename = "null";
271
272 if (!ctx || !pixmap) return;
273 if (!jfilename) jni_throw_arg_void(env, "filename must not be null");
274
275 filename = (*env)->GetStringUTFChars(env, jfilename, NULL);
276 if (!filename) return;
277
278 fz_try(ctx)
279 fz_save_pixmap_as_pam(ctx, pixmap, filename);
280 fz_always(ctx)
281 (*env)->ReleaseStringUTFChars(env, jfilename, filename);
282 fz_catch(ctx)
283 jni_rethrow_void(env, ctx);
284 }
285
286 JNIEXPORT void JNICALL
287 FUN(Pixmap_saveAsPNM)(JNIEnv *env, jobject self, jstring jfilename)
288 {
289 fz_context *ctx = get_context(env);
290 fz_pixmap *pixmap = from_Pixmap(env, self);
291 const char *filename = "null";
292
293 if (!ctx || !pixmap) return;
294 if (!jfilename) jni_throw_arg_void(env, "filename must not be null");
295
296 filename = (*env)->GetStringUTFChars(env, jfilename, NULL);
297 if (!filename) return;
298
299 fz_try(ctx)
300 fz_save_pixmap_as_pnm(ctx, pixmap, filename);
301 fz_always(ctx)
302 (*env)->ReleaseStringUTFChars(env, jfilename, filename);
303 fz_catch(ctx)
304 jni_rethrow_void(env, ctx);
305 }
306
307 JNIEXPORT void JNICALL
308 FUN(Pixmap_saveAsPBM)(JNIEnv *env, jobject self, jstring jfilename)
309 {
310 fz_context *ctx = get_context(env);
311 fz_pixmap *pixmap = from_Pixmap(env, self);
312 const char *filename = "null";
313
314 if (!ctx || !pixmap) return;
315 if (!jfilename) jni_throw_arg_void(env, "filename must not be null");
316
317 filename = (*env)->GetStringUTFChars(env, jfilename, NULL);
318 if (!filename) return;
319
320 fz_try(ctx)
321 fz_save_pixmap_as_pbm(ctx, pixmap, filename);
322 fz_always(ctx)
323 (*env)->ReleaseStringUTFChars(env, jfilename, filename);
324 fz_catch(ctx)
325 jni_rethrow_void(env, ctx);
326 }
327
328 JNIEXPORT void JNICALL
329 FUN(Pixmap_saveAsPKM)(JNIEnv *env, jobject self, jstring jfilename)
330 {
331 fz_context *ctx = get_context(env);
332 fz_pixmap *pixmap = from_Pixmap(env, self);
333 const char *filename = "null";
334
335 if (!ctx || !pixmap) return;
336 if (!jfilename) jni_throw_arg_void(env, "filename must not be null");
337
338 filename = (*env)->GetStringUTFChars(env, jfilename, NULL);
339 if (!filename) return;
340
341 fz_try(ctx)
342 fz_save_pixmap_as_pkm(ctx, pixmap, filename);
343 fz_always(ctx)
344 (*env)->ReleaseStringUTFChars(env, jfilename, filename);
345 fz_catch(ctx)
346 jni_rethrow_void(env, ctx);
347 }
348
349 JNIEXPORT void JNICALL
350 FUN(Pixmap_saveAsJPX)(JNIEnv *env, jobject self, jstring jfilename, jint quality)
351 {
352 fz_context *ctx = get_context(env);
353 fz_pixmap *pixmap = from_Pixmap(env, self);
354 const char *filename = "null";
355
356 if (!ctx || !pixmap) return;
357 if (!jfilename) jni_throw_arg_void(env, "filename must not be null");
358
359 filename = (*env)->GetStringUTFChars(env, jfilename, NULL);
360 if (!filename) return;
361
362 fz_try(ctx)
363 fz_save_pixmap_as_jpx(ctx, pixmap, filename, quality);
364 fz_always(ctx)
365 (*env)->ReleaseStringUTFChars(env, jfilename, filename);
366 fz_catch(ctx)
367 jni_rethrow_void(env, ctx);
368 }
369
370 JNIEXPORT jint JNICALL
371 FUN(Pixmap_getX)(JNIEnv *env, jobject self)
372 {
373 fz_pixmap *pixmap = from_Pixmap(env, self);
374 return pixmap ? pixmap->x : 0;
375 }
376
377 JNIEXPORT jint JNICALL
378 FUN(Pixmap_getY)(JNIEnv *env, jobject self)
379 {
380 fz_pixmap *pixmap = from_Pixmap(env, self);
381 return pixmap ? pixmap->y : 0;
382 }
383
384 JNIEXPORT jint JNICALL
385 FUN(Pixmap_getWidth)(JNIEnv *env, jobject self)
386 {
387 fz_pixmap *pixmap = from_Pixmap(env, self);
388 return pixmap ? pixmap->w : 0;
389 }
390
391 JNIEXPORT jint JNICALL
392 FUN(Pixmap_getHeight)(JNIEnv *env, jobject self)
393 {
394 fz_pixmap *pixmap = from_Pixmap(env, self);
395 return pixmap ? pixmap->h : 0;
396 }
397
398 JNIEXPORT jint JNICALL
399 FUN(Pixmap_getNumberOfComponents)(JNIEnv *env, jobject self)
400 {
401 fz_pixmap *pixmap = from_Pixmap(env, self);
402 return pixmap ? pixmap->n : 0;
403 }
404
405 JNIEXPORT jboolean JNICALL
406 FUN(Pixmap_getAlpha)(JNIEnv *env, jobject self)
407 {
408 fz_pixmap *pixmap = from_Pixmap(env, self);
409 return pixmap && pixmap->alpha ? JNI_TRUE : JNI_FALSE;
410 }
411
412 JNIEXPORT jint JNICALL
413 FUN(Pixmap_getStride)(JNIEnv *env, jobject self)
414 {
415 fz_pixmap *pixmap = from_Pixmap(env, self);
416 return pixmap ? pixmap->stride : 0;
417 }
418
419 JNIEXPORT jobject JNICALL
420 FUN(Pixmap_getColorSpace)(JNIEnv *env, jobject self)
421 {
422 fz_context *ctx = get_context(env);
423 fz_pixmap *pixmap = from_Pixmap(env, self);
424 fz_colorspace *cs;
425
426 if (!ctx | !pixmap) return NULL;
427
428 fz_try(ctx)
429 cs = fz_pixmap_colorspace(ctx, pixmap);
430 fz_catch(ctx)
431 jni_rethrow(env, ctx);
432
433 return to_ColorSpace_safe(ctx, env, cs);
434 }
435
436 JNIEXPORT jbyteArray JNICALL
437 FUN(Pixmap_getSamples)(JNIEnv *env, jobject self)
438 {
439 fz_context *ctx = get_context(env);
440 fz_pixmap *pixmap = from_Pixmap(env, self);
441 int size = pixmap->h * pixmap->stride;
442 jbyteArray arr;
443
444 if (!ctx | !pixmap) return NULL;
445
446 arr = (*env)->NewByteArray(env, size);
447 if (!arr || (*env)->ExceptionCheck(env)) jni_throw_run(env, "cannot create byte array");
448
449 (*env)->SetByteArrayRegion(env, arr, 0, size, (const jbyte *)pixmap->samples);
450 if ((*env)->ExceptionCheck(env)) return NULL;
451
452 return arr;
453 }
454
455 JNIEXPORT jbyte JNICALL
456 FUN(Pixmap_getSample)(JNIEnv *env, jobject self, jint x, jint y, jint k)
457 {
458 fz_context *ctx = get_context(env);
459 fz_pixmap *pixmap = from_Pixmap(env, self);
460
461 if (!ctx | !pixmap) return 0;
462
463 if (x < 0 || x >= pixmap->w) jni_throw_oob(env, "x out of range");
464 if (y < 0 || y >= pixmap->h) jni_throw_oob(env, "y out of range");
465 if (k < 0 || k >= pixmap->n) jni_throw_oob(env, "k out of range");
466
467 return pixmap->samples[(x + y * pixmap->w) * pixmap->n + k];
468 }
469
470 JNIEXPORT jintArray JNICALL
471 FUN(Pixmap_getPixels)(JNIEnv *env, jobject self)
472 {
473 fz_context *ctx = get_context(env);
474 fz_pixmap *pixmap = from_Pixmap(env, self);
475 int size = pixmap->w * pixmap->h;
476 jintArray arr;
477
478 if (!ctx | !pixmap) return NULL;
479
480 if (pixmap->n != 4 || !pixmap->alpha)
481 jni_throw_run(env, "invalid colorspace for getPixels (must be RGB/BGR with alpha)");
482 if (size * 4 != pixmap->h * pixmap->stride)
483 jni_throw_run(env, "invalid stride for getPixels");
484
485 arr = (*env)->NewIntArray(env, size);
486 if (!arr || (*env)->ExceptionCheck(env)) return NULL;
487
488 (*env)->SetIntArrayRegion(env, arr, 0, size, (const jint *)pixmap->samples);
489 if ((*env)->ExceptionCheck(env)) return NULL;
490
491 return arr;
492 }
493
494 JNIEXPORT jint JNICALL
495 FUN(Pixmap_getXResolution)(JNIEnv *env, jobject self)
496 {
497 fz_pixmap *pixmap = from_Pixmap(env, self);
498 return pixmap ? pixmap->xres : 0;
499 }
500
501 JNIEXPORT jint JNICALL
502 FUN(Pixmap_getYResolution)(JNIEnv *env, jobject self)
503 {
504 fz_pixmap *pixmap = from_Pixmap(env, self);
505 return pixmap ? pixmap->yres : 0;
506 }
507
508 JNIEXPORT void JNICALL
509 FUN(Pixmap_invert)(JNIEnv *env, jobject self)
510 {
511 fz_context *ctx = get_context(env);
512 fz_pixmap *pixmap = from_Pixmap(env, self);
513
514 if (!ctx || !pixmap) return;
515
516 fz_try(ctx)
517 fz_invert_pixmap(ctx, pixmap);
518 fz_catch(ctx)
519 jni_rethrow_void(env, ctx);
520 }
521
522 JNIEXPORT void JNICALL
523 FUN(Pixmap_invertLuminance)(JNIEnv *env, jobject self)
524 {
525 fz_context *ctx = get_context(env);
526 fz_pixmap *pixmap = from_Pixmap(env, self);
527
528 if (!ctx || !pixmap) return;
529
530 fz_try(ctx)
531 fz_invert_pixmap_luminance(ctx, pixmap);
532 fz_catch(ctx)
533 jni_rethrow_void(env, ctx);
534 }
535
536 JNIEXPORT void JNICALL
537 FUN(Pixmap_gamma)(JNIEnv *env, jobject self, jfloat gamma)
538 {
539 fz_context *ctx = get_context(env);
540 fz_pixmap *pixmap = from_Pixmap(env, self);
541
542 if (!ctx || !pixmap) return;
543
544 fz_try(ctx)
545 fz_gamma_pixmap(ctx, pixmap, gamma);
546 fz_catch(ctx)
547 jni_rethrow_void(env, ctx);
548 }
549
550 JNIEXPORT void JNICALL
551 FUN(Pixmap_tint)(JNIEnv *env, jobject self, jint black, jint white)
552 {
553 fz_context *ctx = get_context(env);
554 fz_pixmap *pixmap = from_Pixmap(env, self);
555
556 if (!ctx || !pixmap) return;
557
558 fz_try(ctx)
559 fz_tint_pixmap(ctx, pixmap, black, white);
560 fz_catch(ctx)
561 jni_rethrow_void(env, ctx);
562 }
563
564 JNIEXPORT void JNICALL
565 FUN(Pixmap_setResolution)(JNIEnv *env, jobject self, jint xres, jint yres)
566 {
567 fz_context *ctx = get_context(env);
568 fz_pixmap *pixmap = from_Pixmap(env, self);
569
570 if (!ctx || !pixmap) return;
571
572 fz_try(ctx)
573 fz_set_pixmap_resolution(ctx, pixmap, xres, yres);
574 fz_catch(ctx)
575 jni_rethrow_void(env, ctx);
576 }
577
578 JNIEXPORT jobject JNICALL
579 FUN(Pixmap_convertToColorSpace)(JNIEnv *env, jobject self, jobject jcs, jobject jproof, jobject jdefaultcs, jint jcolorparams, jboolean keep_alpha)
580 {
581 fz_context *ctx = get_context(env);
582 fz_pixmap *pixmap = from_Pixmap(env, self);
583 fz_colorspace *cs = from_ColorSpace(env, jcs);
584 fz_colorspace *proof = from_ColorSpace(env, jproof);
585 fz_default_colorspaces *default_cs = from_DefaultColorSpaces(env, jdefaultcs);
586 fz_color_params color_params = from_ColorParams_safe(env, jcolorparams);
587 fz_pixmap *dst = NULL;
588
589 if (!ctx || !pixmap) return NULL;
590 if (!cs) jni_throw_arg(env, "destination colorspace must not be null");
591
592 fz_try(ctx)
593 dst = fz_convert_pixmap(ctx, pixmap, cs, proof, default_cs, color_params, keep_alpha);
594 fz_catch(ctx)
595 jni_rethrow(env, ctx);
596
597 return to_Pixmap_safe_own(ctx, env, dst);
598 }
599
600 JNIEXPORT jobject JNICALL
601 FUN(Pixmap_computeMD5)(JNIEnv *env, jobject self)
602 {
603 fz_context *ctx = get_context(env);
604 fz_pixmap *pixmap = from_Pixmap(env, self);
605 unsigned char digest[16] = { 0 };
606 jbyteArray arr;
607
608 if (!ctx || !pixmap) return NULL;
609
610 fz_try(ctx)
611 fz_md5_pixmap(ctx, pixmap, digest);
612 fz_catch(ctx)
613 jni_rethrow(env, ctx);
614
615 arr = (*env)->NewByteArray(env, 16);
616 if (!arr || (*env)->ExceptionCheck(env)) jni_throw_run(env, "cannot create byte array");
617
618 (*env)->SetByteArrayRegion(env, arr, 0, 16, (const jbyte *)digest);
619 if ((*env)->ExceptionCheck(env)) return NULL;
620
621 return arr;
622 }
623
624 JNIEXPORT jlong JNICALL
625 FUN(Pixmap_newNativeDeskew)(JNIEnv *env, jobject self, jfloat ang, jint border)
626 {
627 fz_context *ctx = get_context(env);
628 fz_pixmap *pixmap = from_Pixmap(env, self);
629 fz_pixmap *dest;
630
631 if (!ctx || !pixmap) return 0;
632
633 fz_try(ctx)
634 dest = fz_deskew_pixmap(ctx, pixmap, ang, border);
635 fz_catch(ctx)
636 jni_rethrow(env, ctx);
637
638 return jlong_cast(dest);
639 }
640
641 JNIEXPORT jfloat JNICALL
642 FUN(Pixmap_detectSkew)(JNIEnv *env, jobject self)
643 {
644 fz_context *ctx = get_context(env);
645 fz_pixmap *pixmap = from_Pixmap(env, self);
646 float ang;
647
648 if (!ctx || !pixmap) return 0;
649
650 fz_try(ctx)
651 ang = fz_detect_skew(ctx, pixmap);
652 fz_catch(ctx)
653 jni_rethrow(env, ctx);
654
655 return (jfloat)ang;
656 }
657
658 JNIEXPORT jfloatArray JNICALL
659 FUN(Pixmap_detectDocument)(JNIEnv *env, jobject self)
660 {
661 fz_context *ctx = get_context(env);
662 fz_pixmap *pixmap = from_Pixmap(env, self);
663 fz_quad points = { 0 };
664 int found = 0;
665
666 if (!ctx || !pixmap) return NULL;
667
668 fz_try(ctx)
669 found = fz_detect_document(ctx, &points, pixmap);
670 fz_catch(ctx)
671 jni_rethrow(env, ctx);
672
673 if (!found)
674 return NULL;
675
676 return to_Quad_safe(ctx, env, points);
677 }
678
679 JNIEXPORT jobject JNICALL
680 FUN(Pixmap_warp)(JNIEnv *env, jobject self, jobject jpoints, jint width, jint height)
681 {
682 fz_context *ctx = get_context(env);
683 fz_pixmap *pixmap = from_Pixmap(env, self);
684 fz_quad points = from_Quad(env, jpoints);
685 fz_pixmap *dest = NULL;
686
687 if (!ctx || !pixmap) return NULL;
688 if (!jpoints) jni_throw_arg(env, "points not be null");
689
690 fz_try(ctx)
691 dest = fz_warp_pixmap(ctx, pixmap, points, width, height);
692 fz_catch(ctx)
693 jni_rethrow(env, ctx);
694
695 return to_Pixmap_safe_own(ctx, env, dest);
696 }
697
698 JNIEXPORT jobject JNICALL
699 FUN(Pixmap_autowarp)(JNIEnv *env, jobject self, jobject jpoints)
700 {
701 fz_context *ctx = get_context(env);
702 fz_pixmap *pixmap = from_Pixmap(env, self);
703 fz_quad points = from_Quad(env, jpoints);
704 fz_pixmap *dest = NULL;
705
706 if (!ctx || !pixmap) return NULL;
707 if (!jpoints) jni_throw_arg(env, "points not be null");
708
709 fz_try(ctx)
710 dest = fz_autowarp_pixmap(ctx, pixmap, points);
711 fz_catch(ctx)
712 jni_rethrow(env, ctx);
713
714 return to_Pixmap_safe_own(ctx, env, dest);
715 }
716
717 JNIEXPORT jobject JNICALL
718 FUN(Pixmap_decodeBarcode)(JNIEnv *env, jobject self, jfloat rotate)
719 {
720 fz_context *ctx = get_context(env);
721 fz_pixmap *pixmap = from_Pixmap(env, self);
722 fz_barcode_type type = FZ_BARCODE_NONE;
723 char *contents = NULL;
724 jobject jcontents;
725 jobject jbarcodeinfo;
726
727 if (!ctx || !pixmap)
728 return NULL;
729
730 fz_try(ctx)
731 contents = fz_decode_barcode_from_pixmap(ctx, &type, pixmap, rotate);
732 fz_catch(ctx)
733 jni_rethrow(env, ctx);
734
735 jcontents = (*env)->NewStringUTF(env, contents);
736 fz_free(ctx, contents);
737 if (!jcontents || (*env)->ExceptionCheck(env))
738 return NULL;
739
740 jbarcodeinfo = (*env)->NewObject(env, cls_BarcodeInfo, mid_BarcodeInfo_init, type, jcontents);
741 if (!jbarcodeinfo || (*env)->ExceptionCheck(env))
742 return NULL;
743
744 return jbarcodeinfo;
745 }
746
747 JNIEXPORT jobject JNICALL
748 FUN(Pixmap_encodeBarcode)(JNIEnv *env, jobject self, jint barcode_type, jstring jcontents, jint size, jint ec, jboolean quiet, jboolean hrt)
749 {
750 fz_context *ctx = get_context(env);
751 const char *contents = NULL;
752 fz_pixmap *pix = NULL;
753
754 if (!ctx)
755 return NULL;
756
757 contents = (*env)->GetStringUTFChars(env, jcontents, NULL);
758 if (!contents) jni_throw_run(env, "cannot get characters in contents string");
759
760 fz_try(ctx)
761 pix = fz_new_barcode_pixmap(ctx, barcode_type, contents, size, ec, quiet, hrt);
762 fz_always(ctx)
763 if (contents)
764 (*env)->ReleaseStringUTFChars(env, jcontents, contents);
765 fz_catch(ctx)
766 jni_rethrow(env, ctx);
767
768 return to_Pixmap_safe_own(ctx, env, pix);
769 }