[qcms] Disable advisory asserts when running in libfuzzer

third_party/qcms/src/transform.c

 /* vim: set ts=8 sw=8 noexpandtab: */
 //  qcms
 //  Copyright (C) 2009 Mozilla Corporation
 //  Copyright (C) 1998-2007 Marti Maria
 //
 // Permission is hereby granted, free of charge, to any person obtaining 
 // a copy of this software and associated documentation files (the "Software"), 
 // to deal in the Software without restriction, including without limitation 
 // the rights to use, copy, modify, merge, publish, distribute, sublicense, 
 // and/or sell copies of the Software, and to permit persons to whom the Software 
@@ skipping 13 matching lines @@
 #include <stdlib.h>
 #include <math.h>
 #include <assert.h>
 #include <string.h> //memcpy
 #include "qcmsint.h"
 #include "chain.h"
 #include "halffloat.h"
 #include "matrix.h"
 #include "transform_util.h"
 
+#ifdef USE_LIBFUZZER
+#define ASSERT(x)
+#else
+#define ASSERT(x) assert(x)
+#endif
+
 /* for MSVC, GCC, Intel, and Sun compilers */
 #if defined(_M_IX86) || defined(__i386__) || defined(__i386) || defined(_M_AMD64) || defined(__x86_64__) || defined(__x86_64)
 #define X86
 #endif /* _M_IX86 || __i386__ || __i386 || _M_AMD64 || __x86_64__ || __x86_64 */
 
 // Build a White point, primary chromas transfer matrix from RGB to CIE XYZ
 // This is just an approximation, I am not handling all the non-linear
 // aspects of the RGB to XYZ process, and assumming that the gamma correction
 // has transitive property in the tranformation chain.
 //
@@ skipping 1245 matching lines @@
         qcms_transform *transform = NULL;
         bool precache = false;
         int i, j;
 
         transform = transform_alloc();
         if (!transform) {
                 return NULL;
         }
 
         if (out_type != QCMS_DATA_RGB_8 && out_type != QCMS_DATA_RGBA_8) {
-                assert(0 && "output type");
+                ASSERT(0 && "output type");
                 qcms_transform_release(transform);
                 return NULL;
         }
 
         transform->transform_flags = 0;
 
         if (out->output_table_r && out->output_table_g && out->output_table_b) {
                 precache = true;
         }
 
         if (qcms_supports_iccv4 && (in->A2B0 || out->B2A0 || in->mAB || out->mAB)) {
                 // Precache the transformation to a CLUT 33x33x33 in size.
                 // 33 is used by many profiles and works well in practice.
                 // This evenly divides 256 into blocks of 8x8x8.
                 // TODO For transforming small data sets of about 200x200 or less
                 // precaching should be avoided.
                 qcms_transform *result = qcms_transform_precacheLUT_float(transform, in, out, 33, in_type);
                 if (!result) {
-                        assert(0 && "precacheLUT failed");
+                        ASSERT(0 && "precacheLUT failed");
                         qcms_transform_release(transform);
                         return NULL;
                 }
                 return result;
         }
 
         /* A matrix-based transform will be selected: check that the PCS
            of the input/output profiles are the same, crbug.com/5120682 */
         if (in->pcs != out->pcs) {
                 qcms_transform_release(transform);
@@ skipping 17 matching lines @@
                 if (!transform->output_gamma_lut_r || !transform->output_gamma_lut_g || !transform->output_gamma_lut_b) {
                         qcms_transform_release(transform);
                         return NO_MEM_TRANSFORM;
                 }
         }
 
         if (in->color_space == RGB_SIGNATURE) {
                 struct matrix in_matrix, out_matrix, result;
 
                 if (in_type != QCMS_DATA_RGB_8 && in_type != QCMS_DATA_RGBA_8) {
-                        assert(0 && "input type");
+                        ASSERT(0 && "input type");
                         qcms_transform_release(transform);
                         return NULL;
                 }
 
                 if (precache) {
 #if defined(SSE2_ENABLE)
                         if (sse_version_available() >= 2) {
                                 if (in_type == QCMS_DATA_RGB_8)
                                         transform->transform_fn = qcms_transform_data_rgb_out_lut_sse2;
                                 else
@@ skipping 54 matching lines @@
                 transform->matrix[2][1] = result.m[1][2];
                 transform->matrix[0][2] = result.m[2][0];
                 transform->matrix[1][2] = result.m[2][1];
                 transform->matrix[2][2] = result.m[2][2];
 
                 /* Flag transform as matrix. */
                 transform->transform_flags |= TRANSFORM_FLAG_MATRIX;
 
         } else if (in->color_space == GRAY_SIGNATURE) {
                 if (in_type != QCMS_DATA_GRAY_8 && in_type != QCMS_DATA_GRAYA_8) {
-                        assert(0 && "input type");
+                        ASSERT(0 && "input type");
                         qcms_transform_release(transform);
                         return NULL;
                 }
 
                 transform->input_gamma_table_gray = build_input_gamma_table(in->grayTRC);
 
                 if (!transform->input_gamma_table_gray) {
                         qcms_transform_release(transform);
                         return NO_MEM_TRANSFORM;
                 }
 
                 if (precache) {
                         if (in_type == QCMS_DATA_GRAY_8) {
                                 transform->transform_fn = qcms_transform_data_gray_out_precache;
                         } else {
                                 transform->transform_fn = qcms_transform_data_graya_out_precache;
                         }
                 } else {
                         if (in_type == QCMS_DATA_GRAY_8) {
                                 transform->transform_fn = qcms_transform_data_gray_out_lut;
                         } else {
                                 transform->transform_fn = qcms_transform_data_graya_out_lut;
                         }
                 }
         } else {
-                assert(0 && "unexpected colorspace");
+                ASSERT(0 && "unexpected colorspace");
                 qcms_transform_release(transform);
                 return NULL;
         }
 
         return transform;
 }
 
 /* __force_align_arg_pointer__ is an x86-only attribute, and gcc/clang warns on unused
  * attributes. Don't use this on ARM or AMD64. __has_attribute can detect the presence
  * of the attribute but is currently only supported by clang */
@@ skipping 92 matching lines @@
                 case QCMS_TRC_USHORT:
                         for (i = 0; i < size; ++i) {
                                 *data++ = roundf(t->input_gamma_table_r[i] * 65535.0); // r
                                 *data++ = roundf(t->input_gamma_table_g[i] * 65535.0); // g
                                 *data++ = roundf(t->input_gamma_table_b[i] * 65535.0); // b
                                 *data++ = 65535;                                       // a
                         }
                         break;
                 default:
                         /* should not be reached */
-                        assert(0);
+                        ASSERT(0);
         }
 
         return size;
 }
 
 const float inverse65535 = (float) (1.0 / 65535.0);
 
 size_t qcms_transform_get_output_trc_rgba(qcms_transform *t, qcms_profile *out, qcms_trc_type type, unsigned short *data)
 {
         size_t size, i;
@@ skipping 46 matching lines @@
                 case QCMS_TRC_USHORT:
                         for (i = 0; i < size; ++i) {
                                 *data++ = t->output_gamma_lut_r[i]; // r
                                 *data++ = t->output_gamma_lut_g[i]; // g
                                 *data++ = t->output_gamma_lut_b[i]; // b
                                 *data++ = 65535;                    // a
                         }
                         break;
                 default:
                         /* should not be reached */
-                        assert(0);
+                        ASSERT(0);
         }
 
         return size;
 }