1 /* 2 * Copyright (C)2011-2013, 2017-2018 D. R. Commander. All Rights Reserved. 3 * Copyright (C)2015 Viktor Szathmáry. All Rights Reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions are met: 7 * 8 * - Redistributions of source code must retain the above copyright notice, 9 * this list of conditions and the following disclaimer. 10 * - Redistributions in binary form must reproduce the above copyright notice, 11 * this list of conditions and the following disclaimer in the documentation 12 * and/or other materials provided with the distribution. 13 * - Neither the name of the libjpeg-turbo Project nor the names of its 14 * contributors may be used to endorse or promote products derived from this 15 * software without specific prior written permission. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS", 18 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE 21 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 22 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 23 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 24 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 25 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 26 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 27 * POSSIBILITY OF SUCH DAMAGE. 28 */ 29 30 package org.libjpegturbo.turbojpeg; 31 32 /** 33 * TurboJPEG utility class (cannot be instantiated) 34 */ 35 public final class TJ { 36 TJ()37 private TJ() {} 38 39 /** 40 * The number of chrominance subsampling options 41 */ 42 public static final int NUMSAMP = 6; 43 /** 44 * 4:4:4 chrominance subsampling (no chrominance subsampling). The JPEG 45 * or YUV image will contain one chrominance component for every pixel in the 46 * source image. 47 */ 48 public static final int SAMP_444 = 0; 49 /** 50 * 4:2:2 chrominance subsampling. The JPEG or YUV image will contain one 51 * chrominance component for every 2x1 block of pixels in the source image. 52 */ 53 public static final int SAMP_422 = 1; 54 /** 55 * 4:2:0 chrominance subsampling. The JPEG or YUV image will contain one 56 * chrominance component for every 2x2 block of pixels in the source image. 57 */ 58 public static final int SAMP_420 = 2; 59 /** 60 * Grayscale. The JPEG or YUV image will contain no chrominance components. 61 */ 62 public static final int SAMP_GRAY = 3; 63 /** 64 * 4:4:0 chrominance subsampling. The JPEG or YUV image will contain one 65 * chrominance component for every 1x2 block of pixels in the source image. 66 * Note that 4:4:0 subsampling is not fully accelerated in libjpeg-turbo. 67 */ 68 public static final int SAMP_440 = 4; 69 /** 70 * 4:1:1 chrominance subsampling. The JPEG or YUV image will contain one 71 * chrominance component for every 4x1 block of pixels in the source image. 72 * JPEG images compressed with 4:1:1 subsampling will be almost exactly the 73 * same size as those compressed with 4:2:0 subsampling, and in the 74 * aggregate, both subsampling methods produce approximately the same 75 * perceptual quality. However, 4:1:1 is better able to reproduce sharp 76 * horizontal features. Note that 4:1:1 subsampling is not fully accelerated 77 * in libjpeg-turbo. 78 */ 79 public static final int SAMP_411 = 5; 80 81 82 /** 83 * Returns the MCU block width for the given level of chrominance 84 * subsampling. 85 * 86 * @param subsamp the level of chrominance subsampling (one of 87 * <code>SAMP_*</code>) 88 * 89 * @return the MCU block width for the given level of chrominance 90 * subsampling. 91 */ getMCUWidth(int subsamp)92 public static int getMCUWidth(int subsamp) { 93 checkSubsampling(subsamp); 94 return MCU_WIDTH[subsamp]; 95 } 96 97 private static final int[] MCU_WIDTH = { 98 8, 16, 16, 8, 8, 32 99 }; 100 101 102 /** 103 * Returns the MCU block height for the given level of chrominance 104 * subsampling. 105 * 106 * @param subsamp the level of chrominance subsampling (one of 107 * <code>SAMP_*</code>) 108 * 109 * @return the MCU block height for the given level of chrominance 110 * subsampling. 111 */ getMCUHeight(int subsamp)112 public static int getMCUHeight(int subsamp) { 113 checkSubsampling(subsamp); 114 return MCU_HEIGHT[subsamp]; 115 } 116 117 private static final int[] MCU_HEIGHT = { 118 8, 8, 16, 8, 16, 8 119 }; 120 121 122 /** 123 * The number of pixel formats 124 */ 125 public static final int NUMPF = 12; 126 /** 127 * RGB pixel format. The red, green, and blue components in the image are 128 * stored in 3-byte pixels in the order R, G, B from lowest to highest byte 129 * address within each pixel. 130 */ 131 public static final int PF_RGB = 0; 132 /** 133 * BGR pixel format. The red, green, and blue components in the image are 134 * stored in 3-byte pixels in the order B, G, R from lowest to highest byte 135 * address within each pixel. 136 */ 137 public static final int PF_BGR = 1; 138 /** 139 * RGBX pixel format. The red, green, and blue components in the image are 140 * stored in 4-byte pixels in the order R, G, B from lowest to highest byte 141 * address within each pixel. The X component is ignored when compressing 142 * and undefined when decompressing. 143 */ 144 public static final int PF_RGBX = 2; 145 /** 146 * BGRX pixel format. The red, green, and blue components in the image are 147 * stored in 4-byte pixels in the order B, G, R from lowest to highest byte 148 * address within each pixel. The X component is ignored when compressing 149 * and undefined when decompressing. 150 */ 151 public static final int PF_BGRX = 3; 152 /** 153 * XBGR pixel format. The red, green, and blue components in the image are 154 * stored in 4-byte pixels in the order R, G, B from highest to lowest byte 155 * address within each pixel. The X component is ignored when compressing 156 * and undefined when decompressing. 157 */ 158 public static final int PF_XBGR = 4; 159 /** 160 * XRGB pixel format. The red, green, and blue components in the image are 161 * stored in 4-byte pixels in the order B, G, R from highest to lowest byte 162 * address within each pixel. The X component is ignored when compressing 163 * and undefined when decompressing. 164 */ 165 public static final int PF_XRGB = 5; 166 /** 167 * Grayscale pixel format. Each 1-byte pixel represents a luminance 168 * (brightness) level from 0 to 255. 169 */ 170 public static final int PF_GRAY = 6; 171 /** 172 * RGBA pixel format. This is the same as {@link #PF_RGBX}, except that when 173 * decompressing, the X byte is guaranteed to be 0xFF, which can be 174 * interpreted as an opaque alpha channel. 175 */ 176 public static final int PF_RGBA = 7; 177 /** 178 * BGRA pixel format. This is the same as {@link #PF_BGRX}, except that when 179 * decompressing, the X byte is guaranteed to be 0xFF, which can be 180 * interpreted as an opaque alpha channel. 181 */ 182 public static final int PF_BGRA = 8; 183 /** 184 * ABGR pixel format. This is the same as {@link #PF_XBGR}, except that when 185 * decompressing, the X byte is guaranteed to be 0xFF, which can be 186 * interpreted as an opaque alpha channel. 187 */ 188 public static final int PF_ABGR = 9; 189 /** 190 * ARGB pixel format. This is the same as {@link #PF_XRGB}, except that when 191 * decompressing, the X byte is guaranteed to be 0xFF, which can be 192 * interpreted as an opaque alpha channel. 193 */ 194 public static final int PF_ARGB = 10; 195 /** 196 * CMYK pixel format. Unlike RGB, which is an additive color model used 197 * primarily for display, CMYK (Cyan/Magenta/Yellow/Key) is a subtractive 198 * color model used primarily for printing. In the CMYK color model, the 199 * value of each color component typically corresponds to an amount of cyan, 200 * magenta, yellow, or black ink that is applied to a white background. In 201 * order to convert between CMYK and RGB, it is necessary to use a color 202 * management system (CMS.) A CMS will attempt to map colors within the 203 * printer's gamut to perceptually similar colors in the display's gamut and 204 * vice versa, but the mapping is typically not 1:1 or reversible, nor can it 205 * be defined with a simple formula. Thus, such a conversion is out of scope 206 * for a codec library. However, the TurboJPEG API allows for compressing 207 * CMYK pixels into a YCCK JPEG image (see {@link #CS_YCCK}) and 208 * decompressing YCCK JPEG images into CMYK pixels. 209 */ 210 public static final int PF_CMYK = 11; 211 212 213 /** 214 * Returns the pixel size (in bytes) for the given pixel format. 215 * 216 * @param pixelFormat the pixel format (one of <code>PF_*</code>) 217 * 218 * @return the pixel size (in bytes) for the given pixel format. 219 */ getPixelSize(int pixelFormat)220 public static int getPixelSize(int pixelFormat) { 221 checkPixelFormat(pixelFormat); 222 return PIXEL_SIZE[pixelFormat]; 223 } 224 225 private static final int[] PIXEL_SIZE = { 226 3, 3, 4, 4, 4, 4, 1, 4, 4, 4, 4, 4 227 }; 228 229 230 /** 231 * For the given pixel format, returns the number of bytes that the red 232 * component is offset from the start of the pixel. For instance, if a pixel 233 * of format <code>TJ.PF_BGRX</code> is stored in <code>char pixel[]</code>, 234 * then the red component will be 235 * <code>pixel[TJ.getRedOffset(TJ.PF_BGRX)]</code>. 236 * 237 * @param pixelFormat the pixel format (one of <code>PF_*</code>) 238 * 239 * @return the red offset for the given pixel format, or -1 if the pixel 240 * format does not have a red component. 241 */ getRedOffset(int pixelFormat)242 public static int getRedOffset(int pixelFormat) { 243 checkPixelFormat(pixelFormat); 244 return RED_OFFSET[pixelFormat]; 245 } 246 247 private static final int[] RED_OFFSET = { 248 0, 2, 0, 2, 3, 1, -1, 0, 2, 3, 1, -1 249 }; 250 251 252 /** 253 * For the given pixel format, returns the number of bytes that the green 254 * component is offset from the start of the pixel. For instance, if a pixel 255 * of format <code>TJ.PF_BGRX</code> is stored in <code>char pixel[]</code>, 256 * then the green component will be 257 * <code>pixel[TJ.getGreenOffset(TJ.PF_BGRX)]</code>. 258 * 259 * @param pixelFormat the pixel format (one of <code>PF_*</code>) 260 * 261 * @return the green offset for the given pixel format, or -1 if the pixel 262 * format does not have a green component. 263 */ getGreenOffset(int pixelFormat)264 public static int getGreenOffset(int pixelFormat) { 265 checkPixelFormat(pixelFormat); 266 return GREEN_OFFSET[pixelFormat]; 267 } 268 269 private static final int[] GREEN_OFFSET = { 270 1, 1, 1, 1, 2, 2, -1, 1, 1, 2, 2, -1 271 }; 272 273 274 /** 275 * For the given pixel format, returns the number of bytes that the blue 276 * component is offset from the start of the pixel. For instance, if a pixel 277 * of format <code>TJ.PF_BGRX</code> is stored in <code>char pixel[]</code>, 278 * then the blue component will be 279 * <code>pixel[TJ.getBlueOffset(TJ.PF_BGRX)]</code>. 280 * 281 * @param pixelFormat the pixel format (one of <code>PF_*</code>) 282 * 283 * @return the blue offset for the given pixel format, or -1 if the pixel 284 * format does not have a blue component. 285 */ getBlueOffset(int pixelFormat)286 public static int getBlueOffset(int pixelFormat) { 287 checkPixelFormat(pixelFormat); 288 return BLUE_OFFSET[pixelFormat]; 289 } 290 291 private static final int[] BLUE_OFFSET = { 292 2, 0, 2, 0, 1, 3, -1, 2, 0, 1, 3, -1 293 }; 294 295 296 /** 297 * For the given pixel format, returns the number of bytes that the alpha 298 * component is offset from the start of the pixel. For instance, if a pixel 299 * of format <code>TJ.PF_BGRA</code> is stored in <code>char pixel[]</code>, 300 * then the alpha component will be 301 * <code>pixel[TJ.getAlphaOffset(TJ.PF_BGRA)]</code>. 302 * 303 * @param pixelFormat the pixel format (one of <code>PF_*</code>) 304 * 305 * @return the alpha offset for the given pixel format, or -1 if the pixel 306 * format does not have a alpha component. 307 */ getAlphaOffset(int pixelFormat)308 public static int getAlphaOffset(int pixelFormat) { 309 checkPixelFormat(pixelFormat); 310 return ALPHA_OFFSET[pixelFormat]; 311 } 312 313 private static final int[] ALPHA_OFFSET = { 314 -1, -1, -1, -1, -1, -1, -1, 3, 3, 0, 0, -1 315 }; 316 317 318 /** 319 * The number of JPEG colorspaces 320 */ 321 public static final int NUMCS = 5; 322 /** 323 * RGB colorspace. When compressing the JPEG image, the R, G, and B 324 * components in the source image are reordered into image planes, but no 325 * colorspace conversion or subsampling is performed. RGB JPEG images can be 326 * decompressed to any of the extended RGB pixel formats or grayscale, but 327 * they cannot be decompressed to YUV images. 328 */ 329 public static final int CS_RGB = 0; 330 /** 331 * YCbCr colorspace. YCbCr is not an absolute colorspace but rather a 332 * mathematical transformation of RGB designed solely for storage and 333 * transmission. YCbCr images must be converted to RGB before they can 334 * actually be displayed. In the YCbCr colorspace, the Y (luminance) 335 * component represents the black & white portion of the original image, and 336 * the Cb and Cr (chrominance) components represent the color portion of the 337 * original image. Originally, the analog equivalent of this transformation 338 * allowed the same signal to drive both black & white and color televisions, 339 * but JPEG images use YCbCr primarily because it allows the color data to be 340 * optionally subsampled for the purposes of reducing bandwidth or disk 341 * space. YCbCr is the most common JPEG colorspace, and YCbCr JPEG images 342 * can be compressed from and decompressed to any of the extended RGB pixel 343 * formats or grayscale, or they can be decompressed to YUV planar images. 344 */ 345 @SuppressWarnings("checkstyle:ConstantName") 346 public static final int CS_YCbCr = 1; 347 /** 348 * Grayscale colorspace. The JPEG image retains only the luminance data (Y 349 * component), and any color data from the source image is discarded. 350 * Grayscale JPEG images can be compressed from and decompressed to any of 351 * the extended RGB pixel formats or grayscale, or they can be decompressed 352 * to YUV planar images. 353 */ 354 public static final int CS_GRAY = 2; 355 /** 356 * CMYK colorspace. When compressing the JPEG image, the C, M, Y, and K 357 * components in the source image are reordered into image planes, but no 358 * colorspace conversion or subsampling is performed. CMYK JPEG images can 359 * only be decompressed to CMYK pixels. 360 */ 361 public static final int CS_CMYK = 3; 362 /** 363 * YCCK colorspace. YCCK (AKA "YCbCrK") is not an absolute colorspace but 364 * rather a mathematical transformation of CMYK designed solely for storage 365 * and transmission. It is to CMYK as YCbCr is to RGB. CMYK pixels can be 366 * reversibly transformed into YCCK, and as with YCbCr, the chrominance 367 * components in the YCCK pixels can be subsampled without incurring major 368 * perceptual loss. YCCK JPEG images can only be compressed from and 369 * decompressed to CMYK pixels. 370 */ 371 public static final int CS_YCCK = 4; 372 373 374 /** 375 * The uncompressed source/destination image is stored in bottom-up (Windows, 376 * OpenGL) order, not top-down (X11) order. 377 */ 378 public static final int FLAG_BOTTOMUP = 2; 379 380 @SuppressWarnings("checkstyle:JavadocVariable") 381 @Deprecated 382 public static final int FLAG_FORCEMMX = 8; 383 @SuppressWarnings("checkstyle:JavadocVariable") 384 @Deprecated 385 public static final int FLAG_FORCESSE = 16; 386 @SuppressWarnings("checkstyle:JavadocVariable") 387 @Deprecated 388 public static final int FLAG_FORCESSE2 = 32; 389 @SuppressWarnings("checkstyle:JavadocVariable") 390 @Deprecated 391 public static final int FLAG_FORCESSE3 = 128; 392 393 /** 394 * When decompressing an image that was compressed using chrominance 395 * subsampling, use the fastest chrominance upsampling algorithm available in 396 * the underlying codec. The default is to use smooth upsampling, which 397 * creates a smooth transition between neighboring chrominance components in 398 * order to reduce upsampling artifacts in the decompressed image. 399 */ 400 public static final int FLAG_FASTUPSAMPLE = 256; 401 /** 402 * Use the fastest DCT/IDCT algorithm available in the underlying codec. The 403 * default if this flag is not specified is implementation-specific. For 404 * example, the implementation of TurboJPEG for libjpeg[-turbo] uses the fast 405 * algorithm by default when compressing, because this has been shown to have 406 * only a very slight effect on accuracy, but it uses the accurate algorithm 407 * when decompressing, because this has been shown to have a larger effect. 408 */ 409 public static final int FLAG_FASTDCT = 2048; 410 /** 411 * Use the most accurate DCT/IDCT algorithm available in the underlying 412 * codec. The default if this flag is not specified is 413 * implementation-specific. For example, the implementation of TurboJPEG for 414 * libjpeg[-turbo] uses the fast algorithm by default when compressing, 415 * because this has been shown to have only a very slight effect on accuracy, 416 * but it uses the accurate algorithm when decompressing, because this has 417 * been shown to have a larger effect. 418 */ 419 public static final int FLAG_ACCURATEDCT = 4096; 420 /** 421 * Immediately discontinue the current compression/decompression/transform 422 * operation if the underlying codec throws a warning (non-fatal error). The 423 * default behavior is to allow the operation to complete unless a fatal 424 * error is encountered. 425 * <p> 426 * NOTE: due to the design of the TurboJPEG Java API, only certain methods 427 * (specifically, {@link TJDecompressor TJDecompressor.decompress*()} methods 428 * with a void return type) will complete and leave the output image in a 429 * fully recoverable state after a non-fatal error occurs. 430 */ 431 public static final int FLAG_STOPONWARNING = 8192; 432 /** 433 * Use progressive entropy coding in JPEG images generated by compression and 434 * transform operations. Progressive entropy coding will generally improve 435 * compression relative to baseline entropy coding (the default), but it will 436 * reduce compression and decompression performance considerably. 437 */ 438 public static final int FLAG_PROGRESSIVE = 16384; 439 440 441 /** 442 * The number of error codes 443 */ 444 public static final int NUMERR = 2; 445 /** 446 * The error was non-fatal and recoverable, but the image may still be 447 * corrupt. 448 * <p> 449 * NOTE: due to the design of the TurboJPEG Java API, only certain methods 450 * (specifically, {@link TJDecompressor TJDecompressor.decompress*()} methods 451 * with a void return type) will complete and leave the output image in a 452 * fully recoverable state after a non-fatal error occurs. 453 */ 454 public static final int ERR_WARNING = 0; 455 /** 456 * The error was fatal and non-recoverable. 457 */ 458 public static final int ERR_FATAL = 1; 459 460 461 /** 462 * Returns the maximum size of the buffer (in bytes) required to hold a JPEG 463 * image with the given width, height, and level of chrominance subsampling. 464 * 465 * @param width the width (in pixels) of the JPEG image 466 * 467 * @param height the height (in pixels) of the JPEG image 468 * 469 * @param jpegSubsamp the level of chrominance subsampling to be used when 470 * generating the JPEG image (one of {@link TJ TJ.SAMP_*}) 471 * 472 * @return the maximum size of the buffer (in bytes) required to hold a JPEG 473 * image with the given width, height, and level of chrominance subsampling. 474 */ bufSize(int width, int height, int jpegSubsamp)475 public static native int bufSize(int width, int height, int jpegSubsamp); 476 477 /** 478 * Returns the size of the buffer (in bytes) required to hold a YUV planar 479 * image with the given width, height, and level of chrominance subsampling. 480 * 481 * @param width the width (in pixels) of the YUV image 482 * 483 * @param pad the width of each line in each plane of the image is padded to 484 * the nearest multiple of this number of bytes (must be a power of 2.) 485 * 486 * @param height the height (in pixels) of the YUV image 487 * 488 * @param subsamp the level of chrominance subsampling used in the YUV 489 * image (one of {@link TJ TJ.SAMP_*}) 490 * 491 * @return the size of the buffer (in bytes) required to hold a YUV planar 492 * image with the given width, height, and level of chrominance subsampling. 493 */ bufSizeYUV(int width, int pad, int height, int subsamp)494 public static native int bufSizeYUV(int width, int pad, int height, 495 int subsamp); 496 497 /** 498 * @deprecated Use {@link #bufSizeYUV(int, int, int, int)} instead. 499 */ 500 @SuppressWarnings("checkstyle:JavadocMethod") 501 @Deprecated bufSizeYUV(int width, int height, int subsamp)502 public static native int bufSizeYUV(int width, int height, int subsamp); 503 504 /** 505 * Returns the size of the buffer (in bytes) required to hold a YUV image 506 * plane with the given parameters. 507 * 508 * @param componentID ID number of the image plane (0 = Y, 1 = U/Cb, 509 * 2 = V/Cr) 510 * 511 * @param width width (in pixels) of the YUV image. NOTE: this is the width 512 * of the whole image, not the plane width. 513 * 514 * @param stride bytes per line in the image plane. 515 * 516 * @param height height (in pixels) of the YUV image. NOTE: this is the 517 * height of the whole image, not the plane height. 518 * 519 * @param subsamp the level of chrominance subsampling used in the YUV 520 * image (one of {@link TJ TJ.SAMP_*}) 521 * 522 * @return the size of the buffer (in bytes) required to hold a YUV planar 523 * image with the given parameters. 524 */ planeSizeYUV(int componentID, int width, int stride, int height, int subsamp)525 public static native int planeSizeYUV(int componentID, int width, int stride, 526 int height, int subsamp); 527 528 /** 529 * Returns the plane width of a YUV image plane with the given parameters. 530 * Refer to {@link YUVImage YUVImage} for a description of plane width. 531 * 532 * @param componentID ID number of the image plane (0 = Y, 1 = U/Cb, 533 * 2 = V/Cr) 534 * 535 * @param width width (in pixels) of the YUV image 536 * 537 * @param subsamp the level of chrominance subsampling used in the YUV image 538 * (one of {@link TJ TJ.SAMP_*}) 539 * 540 * @return the plane width of a YUV image plane with the given parameters. 541 */ planeWidth(int componentID, int width, int subsamp)542 public static native int planeWidth(int componentID, int width, int subsamp); 543 544 /** 545 * Returns the plane height of a YUV image plane with the given parameters. 546 * Refer to {@link YUVImage YUVImage} for a description of plane height. 547 * 548 * @param componentID ID number of the image plane (0 = Y, 1 = U/Cb, 549 * 2 = V/Cr) 550 * 551 * @param height height (in pixels) of the YUV image 552 * 553 * @param subsamp the level of chrominance subsampling used in the YUV image 554 * (one of {@link TJ TJ.SAMP_*}) 555 * 556 * @return the plane height of a YUV image plane with the given parameters. 557 */ planeHeight(int componentID, int height, int subsamp)558 public static native int planeHeight(int componentID, int height, 559 int subsamp); 560 561 /** 562 * Returns a list of fractional scaling factors that the JPEG decompressor in 563 * this implementation of TurboJPEG supports. 564 * 565 * @return a list of fractional scaling factors that the JPEG decompressor in 566 * this implementation of TurboJPEG supports. 567 */ getScalingFactors()568 public static native TJScalingFactor[] getScalingFactors(); 569 570 static { TJLoader.load()571 TJLoader.load(); 572 } 573 checkPixelFormat(int pixelFormat)574 private static void checkPixelFormat(int pixelFormat) { 575 if (pixelFormat < 0 || pixelFormat >= NUMPF) 576 throw new IllegalArgumentException("Invalid pixel format"); 577 } 578 checkSubsampling(int subsamp)579 private static void checkSubsampling(int subsamp) { 580 if (subsamp < 0 || subsamp >= NUMSAMP) 581 throw new IllegalArgumentException("Invalid subsampling type"); 582 } 583 584 } 585