diff --git a/CMake/FindCPPCHECK.cmake b/CMake/FindCPPCHECK.cmake new file mode 100644 index 00000000..6e11bf73 --- /dev/null +++ b/CMake/FindCPPCHECK.cmake @@ -0,0 +1,16 @@ +# cppcheck +# +# Copyright (c) 2011 Mathieu Malaterre +# +# Redistribution and use is allowed according to the terms of the New +# BSD license. +# For details see the accompanying COPYING-CMAKE-SCRIPTS file. +# + +find_program(CPPCHECK_EXECUTABLE + cppcheck + ) + +mark_as_advanced( + CPPCHECK_EXECUTABLE + ) diff --git a/CMake/FindJPYLYZER.cmake b/CMake/FindJPYLYZER.cmake new file mode 100644 index 00000000..4fbbaa85 --- /dev/null +++ b/CMake/FindJPYLYZER.cmake @@ -0,0 +1,12 @@ +# +# this module looks for JPYLYZER +# http://jpylyzer.openpreservation.org +# + +find_program(JPYLYZER_EXECUTABLE + jpylyzer + ) + +mark_as_advanced( + JPYLYZER_EXECUTABLE + ) diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index fa7747e5..af4fbcef 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -1,5 +1,5 @@ # Tests -INCLUDE_DIRECTORIES( +include_directories( ${OPENJPEG_SOURCE_DIR}/libopenjpeg ${OPENJPEG_SOURCE_DIR}/applications/codec ${OPENJPEG_SOURCE_DIR}/applications/common @@ -9,50 +9,51 @@ INCLUDE_DIRECTORIES( ) # First thing define the common source: -SET(comparePGXimages_SRCS comparePGXimages.c +set(compare_images_SRCS compare_images.c ${OPENJPEG_SOURCE_DIR}/applications/codec/convert.c +# ${OPENJPEG_SOURCE_DIR}/applications/codec/converttif.c + ${OPENJPEG_SOURCE_DIR}/applications/common/opj_getopt.c ) -SET(compare_dump_files_SRCS compare_dump_files.c) -SET(compareRAWimages_SRCS compareRAWimages.c) -if(NOT USE_SYSTEM_GETOPT) - list(APPEND comparePGXimages_SRCS ${OPENJPEG_SOURCE_DIR}/applications/common/opj_getopt.c) - list(APPEND compare_dump_files_SRCS ${OPENJPEG_SOURCE_DIR}/applications/common/opj_getopt.c) - list(APPEND compareRAWimages_SRCS ${OPENJPEG_SOURCE_DIR}/applications/common/opj_getopt.c) -endif() +set(compare_dump_files_SRCS compare_dump_files.c + ${OPENJPEG_SOURCE_DIR}/applications/common/opj_getopt.c) -ADD_EXECUTABLE(comparePGXimages ${comparePGXimages_SRCS}) -TARGET_LINK_LIBRARIES(comparePGXimages +set(compare_raw_files_SRCS compare_raw_files.c + ${OPENJPEG_SOURCE_DIR}/applications/common/opj_getopt.c) + +add_executable(compare_images ${compare_images_SRCS}) +target_link_libraries(compare_images ${OPENJPEG_LIBRARY_NAME} ${PNG_LIBNAME} ${TIFF_LIBNAME} ) # To support universal exe: -IF(ZLIB_FOUND AND APPLE) - TARGET_LINK_LIBRARIES(comparePGXimages z) -ELSe(ZLIB_FOUND AND APPLE) - TARGET_LINK_LIBRARIES(comparePGXimages ${Z_LIBNAME}) -ENDIF(ZLIB_FOUND AND APPLE) +if(ZLIB_FOUND AND APPLE) + target_link_libraries(compare_images z) +else(ZLIB_FOUND AND APPLE) + target_link_libraries(compare_images ${Z_LIBNAME}) +endif() -ADD_EXECUTABLE(compare_dump_files ${compare_dump_files_SRCS}) - -ADD_EXECUTABLE(compareRAWimages ${compareRAWimages_SRCS}) +add_executable(compare_dump_files ${compare_dump_files_SRCS}) # No image send to the dashboard if lib PNG is not available. -IF(NOT HAVE_LIBPNG) - MESSAGE(WARNING "Lib PNG seems to be not available: if you want run the non-regression tests with images reported to the dashboard, you need it (try BUILD_THIRDPARTY)") -ENDIF(NOT HAVE_LIBPNG) +if(NOT OPJ_HAVE_LIBPNG) + message(WARNING "Lib PNG seems to be not available: if you want run the non-regression tests with images reported to the dashboard, you need it (try BUILD_THIRDPARTY)") +endif() -ADD_SUBDIRECTORY(conformance) -ADD_SUBDIRECTORY(nonregression) -ADD_SUBDIRECTORY(unit) +add_subdirectory(conformance) +#add_subdirectory(nonregression) +add_subdirectory(unit) -IF(BUILD_JPIP) - IF(JPIP_SERVER) - #SET(s "http://jpip.example.com/myFCGI?target=16.jp2&fsiz=170,170&cnew=http&type=jpp-stream") - SET(s "${JPIP_SERVER}?target=16.jp2&fsiz=170,170&cnew=http&type=jpp-stream") - SET(p "${CMAKE_CURRENT_BINARY_DIR}/jpip.dat") - SET(md5 "62b00c620fb0a600c5ffd413cada4674") - ADD_TEST(NAME TestJPIP1 COMMAND ${CMAKE_COMMAND} -DD_URL:STRING=${s} -DD_FILE:PATH=${p} - -DEXPECTED_MD5=${md5} -P ${PROJECT_SOURCE_DIR}/CMake/JPIPTestDriver.cmake) - ENDIF(JPIP_SERVER) -ENDIF(BUILD_JPIP) +if(BUILD_JPIP) + if(JPIP_SERVER) + #set(s "http://jpip.example.com/myFCGI?target=16.jp2&fsiz=170,170&cnew=http&type=jpp-stream") + set(s "${JPIP_SERVER}?target=16.jp2&fsiz=170,170&cnew=http&type=jpp-stream") + set(p "${CMAKE_CURRENT_BINARY_DIR}/jpip.dat") + set(md5 "d41d8cd98f00b204e9800998ecf8427e") + add_test(NAME TestJPIP1 COMMAND ${CMAKE_COMMAND} -DD_URL:STRING=${s} -DD_FILE:PATH=${p} + -DEXPECTED_MD5=${md5} -P ${PROJECT_SOURCE_DIR}/cmake/JPIPTestDriver.cmake) + endif() +endif() + +add_executable(ppm2rgb3 ppm2rgb3.c) +#add_executable(pdf2jp2 pdf2jp2.c) diff --git a/tests/compareRAWimages.c b/tests/compareRAWimages.c deleted file mode 100644 index 0421bebf..00000000 --- a/tests/compareRAWimages.c +++ /dev/null @@ -1,236 +0,0 @@ -/* - * Copyright (c) 2011, Mickael Savinaud, Communications & Systemes - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS' - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - -/* - * compareRAWimages.c - * - * Created on: 31 August 2011 - * Author: mickael - */ - -#include -#include -#include -#include - -#include "opj_getopt.h" - -void compareRAWimages_help_display(void); - -typedef struct test_cmp_parameters -{ - /** */ - char* base_filename; - /** */ - char* test_filename; -} test_cmp_parameters; - -/******************************************************************************* - * Command line help function - *******************************************************************************/ -void compareRAWimages_help_display(void) { - fprintf(stdout,"\nList of parameters for the comparePGX function \n"); - fprintf(stdout,"\n"); - fprintf(stdout," -b \t REQUIRED \t filename to the reference/baseline RAW image \n"); - fprintf(stdout," -t \t REQUIRED \t filename to the test RAW image\n"); - fprintf(stdout,"\n"); -} - -/******************************************************************************* - * Parse command line - *******************************************************************************/ -int parse_cmdline_cmp(int argc, char **argv, test_cmp_parameters* param) -{ - int sizemembasefile, sizememtestfile; - int index; - const char optlist[] = "b:t:"; - int c; - - /* Init parameters*/ - param->base_filename = NULL; - param->test_filename = NULL; - - opj_opterr = 0; - while ((c = opj_getopt(argc, argv, optlist)) != -1) - switch (c) - { - case 'b': - sizemembasefile = (int)strlen(opj_optarg)+1; - param->base_filename = (char*) malloc(sizemembasefile); - param->base_filename[0] = '\0'; - strncpy(param->base_filename, opj_optarg, strlen(opj_optarg)); - param->base_filename[strlen(opj_optarg)] = '\0'; - /*printf("param->base_filename = %s [%d / %d]\n", param->base_filename, strlen(param->base_filename), sizemembasefile );*/ - break; - case 't': - sizememtestfile = (int) strlen(opj_optarg) + 1; - param->test_filename = (char*) malloc(sizememtestfile); - param->test_filename[0] = '\0'; - strncpy(param->test_filename, opj_optarg, strlen(opj_optarg)); - param->test_filename[strlen(opj_optarg)] = '\0'; - /*printf("param->test_filename = %s [%d / %d]\n", param->test_filename, strlen(param->test_filename), sizememtestfile);*/ - break; - case '?': - if ((opj_optopt == 'b') || (opj_optopt == 't')) - fprintf(stderr, "Option -%c requires an argument.\n", opj_optopt); - else - if (isprint(opj_optopt)) fprintf(stderr, "Unknown option `-%c'.\n", opj_optopt); - else fprintf(stderr, "Unknown option character `\\x%x'.\n", opj_optopt); - return 1; - default: - fprintf(stderr, "WARNING -> this option is not valid \"-%c %s\"\n", c, opj_optarg); - break; - } - - if (opj_optind != argc) { - for (index = opj_optind; index < argc; index++) - fprintf(stderr,"Non-option argument %s\n", argv[index]); - return EXIT_FAILURE; - } - - return EXIT_SUCCESS; -} - -/******************************************************************************* - * MAIN - *******************************************************************************/ -int main(int argc, char **argv) -{ - test_cmp_parameters inParam; - FILE *file_test=NULL, *file_base=NULL; - unsigned char equal = 1; - - /* Get parameters from command line*/ - if (parse_cmdline_cmp(argc, argv, &inParam) == EXIT_FAILURE) - { - compareRAWimages_help_display(); - - /* Free Memory */ - if (inParam.base_filename){ - free(inParam.base_filename); - inParam.base_filename = NULL; - } - if (inParam.test_filename){ - free(inParam.test_filename); - inParam.test_filename = NULL; - } - - return EXIT_FAILURE; - } - - file_test = fopen(inParam.test_filename, "rb"); - if (!file_test) { - fprintf(stderr, "Failed to open %s for reading !!\n", inParam.test_filename); - - /* Free Memory */ - if (inParam.base_filename){ - free(inParam.base_filename); - inParam.base_filename = NULL; - } - if (inParam.test_filename){ - free(inParam.test_filename); - inParam.test_filename = NULL; - } - - return EXIT_FAILURE; - } - - file_base = fopen(inParam.base_filename, "rb"); - if (!file_base) { - fprintf(stderr, "Failed to open %s for reading !!\n", inParam.base_filename); - - /* Free Memory */ - if (inParam.base_filename){ - free(inParam.base_filename); - inParam.base_filename = NULL; - } - if (inParam.test_filename){ - free(inParam.test_filename); - inParam.test_filename = NULL; - } - - fclose(file_test); - return EXIT_FAILURE; - } - - /* Read simultaneously the two files*/ - while (equal) - { - unsigned char value_test = 0; - unsigned char eof_test = 0; - unsigned char value_base = 0; - unsigned char eof_base = 0; - - /* Read one byte*/ - if (!fread(&value_test, 1, 1, file_test)) { - eof_test = 1; - } - - /* Read one byte*/ - if (!fread(&value_base, 1, 1, file_base)) { - eof_base = 1;; - } - - /* End of file reached by the two files?*/ - if (eof_test && eof_base) - break; - - /* End of file reached only by one file?*/ - if (eof_test || eof_base) - { - fprintf(stdout,"Files have different sizes.\n"); - equal = 0; - } - - /* Binary values are equal?*/ - if (value_test != value_base) - { - fprintf(stdout,"Binary values read in the file are different.\n"); - equal = 0; - } - } - - /* Free Memory */ - if (inParam.base_filename){ - free(inParam.base_filename); - inParam.base_filename = NULL; - } - if (inParam.test_filename){ - free(inParam.test_filename); - inParam.test_filename = NULL; - } - - fclose(file_test); - fclose(file_base); - - if (equal) - { - fprintf(stdout,"---- TEST SUCCEED: Files are equal ----\n"); - return EXIT_SUCCESS; - } - else - return EXIT_FAILURE; -} diff --git a/tests/compare_dump_files.c b/tests/compare_dump_files.c index e503d120..946c92a5 100644 --- a/tests/compare_dump_files.c +++ b/tests/compare_dump_files.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2011, Mickael Savinaud, Communications & Systemes + * Copyright (c) 2011-2012, Centre National d'Etudes Spatiales (CNES), France * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -29,13 +29,13 @@ * * Created on: 25 juil. 2011 * Author: mickael - * BASELINE MUST BE GENERATED BY UNIX PLATFORM REGARDING TO THE CRLF PROBLEM */ #include #include #include #include +#include #include "opj_getopt.h" @@ -50,7 +50,7 @@ typedef struct test_cmp_parameters /******************************************************************************* * Command line help function *******************************************************************************/ -void compare_dump_files_help_display(void) { +static void compare_dump_files_help_display(void) { fprintf(stdout,"\nList of parameters for the compare_dump_files function \n"); fprintf(stdout,"\n"); fprintf(stdout," -b \t REQUIRED \t filename to the reference/baseline dump file \n"); @@ -60,9 +60,9 @@ void compare_dump_files_help_display(void) { /******************************************************************************* * Parse command line *******************************************************************************/ -int parse_cmdline_cmp(int argc, char **argv, test_cmp_parameters* param) +static int parse_cmdline_cmp(int argc, char **argv, test_cmp_parameters* param) { - int sizemembasefile, sizememtestfile; + size_t sizemembasefile, sizememtestfile; int index; const char optlist[] = "b:t:"; int c; @@ -76,43 +76,40 @@ int parse_cmdline_cmp(int argc, char **argv, test_cmp_parameters* param) while ((c = opj_getopt(argc, argv, optlist)) != -1) switch (c) { - case 'b': - sizemembasefile = (int)strlen(opj_optarg)+1; - param->base_filename = (char*) malloc(sizemembasefile); - param->base_filename[0] = '\0'; - strncpy(param->base_filename, opj_optarg, strlen(opj_optarg)); - param->base_filename[strlen(opj_optarg)] = '\0'; - /*printf("param->base_filename = %s [%d / %d]\n", param->base_filename, strlen(param->base_filename), sizemembasefile );*/ - break; - case 't': - sizememtestfile = (int) strlen(opj_optarg) + 1; - param->test_filename = (char*) malloc(sizememtestfile); - param->test_filename[0] = '\0'; - strncpy(param->test_filename, opj_optarg, strlen(opj_optarg)); - param->test_filename[strlen(opj_optarg)] = '\0'; - /*printf("param->test_filename = %s [%d / %d]\n", param->test_filename, strlen(param->test_filename), sizememtestfile);*/ - break; - case '?': - if ( (opj_optopt == 'b') || (opj_optopt == 't') ) - fprintf(stderr, "Option -%c requires an argument.\n", opj_optopt); - else - if (isprint(opj_optopt)) fprintf(stderr, "Unknown option `-%c'.\n", opj_optopt); - else fprintf(stderr, "Unknown option character `\\x%x'.\n", opj_optopt); - return 1; - default: - fprintf(stderr, "WARNING -> this option is not valid \"-%c %s\"\n", c, opj_optarg); - break; + case 'b': + sizemembasefile = strlen(opj_optarg) + 1; + param->base_filename = (char*) malloc(sizemembasefile); + strcpy(param->base_filename, opj_optarg); + /*printf("param->base_filename = %s [%d / %d]\n", param->base_filename, strlen(param->base_filename), sizemembasefile );*/ + break; + case 't': + sizememtestfile = strlen(opj_optarg) + 1; + param->test_filename = (char*) malloc(sizememtestfile); + strcpy(param->test_filename, opj_optarg); + /*printf("param->test_filename = %s [%d / %d]\n", param->test_filename, strlen(param->test_filename), sizememtestfile);*/ + break; + case '?': + if ( (opj_optopt == 'b') || (opj_optopt == 't') ) + fprintf(stderr, "Option -%c requires an argument.\n", opj_optopt); + else + if (isprint(opj_optopt)) fprintf(stderr, "Unknown option `-%c'.\n", opj_optopt); + else fprintf(stderr, "Unknown option character `\\x%x'.\n", opj_optopt); + return 1; + default: + fprintf(stderr, "WARNING -> this option is not valid \"-%c %s\"\n", c, opj_optarg); + break; } if (opj_optind != argc) { for (index = opj_optind; index < argc; index++) fprintf(stderr,"Non-option argument %s\n", argv[index]); - return EXIT_FAILURE; + return 1; } - return EXIT_SUCCESS; + return 0; } + /******************************************************************************* * MAIN *******************************************************************************/ @@ -120,33 +117,30 @@ int main(int argc, char **argv) { test_cmp_parameters inParam; FILE *fbase=NULL, *ftest=NULL; - int chbase, chtest; - int same = 1; - unsigned long l=1, pos; + int same = 0; + char lbase[256]; + char strbase[256]; + char ltest[256]; + char strtest[256]; - if( parse_cmdline_cmp(argc, argv, &inParam) == EXIT_FAILURE ) + if( parse_cmdline_cmp(argc, argv, &inParam) == 1 ) { compare_dump_files_help_display(); - if (!inParam.base_filename) free(inParam.base_filename); - if (!inParam.test_filename) free(inParam.test_filename); - return EXIT_FAILURE; + goto cleanup; } /* Display Parameters*/ printf("******Parameters********* \n"); printf(" base_filename = %s\n" - " test_filename = %s\n", - inParam.base_filename, inParam.test_filename); + " test_filename = %s\n", + inParam.base_filename, inParam.test_filename); printf("************************* \n"); /* open base file */ printf("Try to open: %s for reading ... ", inParam.base_filename); if((fbase = fopen(inParam.base_filename, "rb"))==NULL) { - printf("Failed.\n"); - free(inParam.base_filename); - free(inParam.test_filename); - return EXIT_FAILURE; + goto cleanup; } printf("Ok.\n"); @@ -154,105 +148,37 @@ int main(int argc, char **argv) printf("Try to open: %s for reading ... ", inParam.test_filename); if((ftest = fopen(inParam.test_filename, "rb"))==NULL) { - printf("Failed.\n"); - fclose(fbase); - free(inParam.base_filename); - free(inParam.test_filename); - return EXIT_FAILURE; + goto cleanup; } printf("Ok.\n"); - pos=ftell(fbase); - - while(!feof(fbase)) + while (fgets(lbase, sizeof(lbase), fbase) && fgets(ltest,sizeof(ltest),ftest)) { - chbase = fgetc(fbase); - if(ferror(fbase)) + int nbase = sscanf(lbase, "%255[^\r\n]", strbase); + int ntest = sscanf(ltest, "%255[^\r\n]", strtest); + assert( nbase != 255 && ntest != 255 ); + if( nbase != 1 || ntest != 1 ) { - printf("Error reading base file.\n"); - return EXIT_FAILURE; + fprintf(stderr, "could not parse line from files\n" ); + goto cleanup; } - - chtest = fgetc(ftest); - if(ferror(ftest)) + if( strcmp( strbase, strtest ) != 0 ) { - printf("Error reading test file.\n"); - return EXIT_FAILURE; - } - - /* CRLF problem (Baseline must be always generated by unix platform)*/ - if (chbase == '\n' && chtest == '\r') - if (fgetc(ftest) == '\n') - chtest = '\n'; - - if(chbase != chtest) - { - size_t nbytes = 2048; - int CRLF_shift=1; - char *strbase, *strtest, *strbase_d, *strtest_d; - - printf("Files differ at line %lu:\n", l); - fseek(fbase,pos,SEEK_SET); - - /* Take into account CRLF characters when we write \n into - // dump file when we used WIN platform*/ -#ifdef _WIN32 - CRLF_shift = 2; - fseek(ftest,pos + l - 1,SEEK_SET); -#else - fseek(ftest,pos,SEEK_SET); -#endif - - strbase = (char *) malloc(nbytes + 1); - strtest = (char *) malloc(nbytes + 1); - - if (fgets(strbase, nbytes, fbase) == NULL) - fprintf(stderr,"\nWARNING: fgets return a NULL value"); - else - { - if (fgets(strtest, nbytes, ftest) == NULL) - fprintf(stderr,"\nWARNING: fgets return a NULL value"); - else - { - strbase_d = (char *) malloc(strlen(strbase)+1); - strtest_d = (char *) malloc(strlen(strtest)+1); - strncpy(strbase_d, strbase, strlen(strbase)-1); - strncpy(strtest_d, strtest, strlen(strtest)-CRLF_shift); - strbase_d[strlen(strbase)-1] = '\0'; - strtest_d[strlen(strtest)-CRLF_shift] = '\0'; - printf("<%s> vs. <%s>\n", strbase_d, strtest_d); - free(strbase_d);free(strtest_d); - } - } - - free(strbase);free(strtest); - - same = 0; - - break; - } - else - { - if (chbase == '\n') - { - l++; - pos = ftell(fbase); - } + fprintf(stderr,"<%s> vs. <%s>\n", strbase, strtest); + goto cleanup; } } + same = 1; + printf("\n***** TEST SUCCEED: Files are the same. *****\n"); +cleanup: /*Close File*/ - fclose(fbase); - fclose(ftest); + if(fbase) fclose(fbase); + if(ftest) fclose(ftest); /* Free memory*/ free(inParam.base_filename); free(inParam.test_filename); - if(same) - { - printf("\n***** TEST SUCCEED: Files are the same. *****\n"); - return EXIT_SUCCESS; - } - else return EXIT_FAILURE; + return same ? EXIT_SUCCESS : EXIT_FAILURE; } diff --git a/tests/comparePGXimages.c b/tests/compare_images.c similarity index 56% rename from tests/comparePGXimages.c rename to tests/compare_images.c index 38b8e6f3..ce61b3b5 100644 --- a/tests/comparePGXimages.c +++ b/tests/compare_images.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2011, Mickael Savinaud, Communications & Systemes + * Copyright (c) 2011-2012, Centre National d'Etudes Spatiales (CNES), France * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -25,7 +25,7 @@ */ /* - * comparePGXimages.c + * compare_images.c * * Created on: 8 juil. 2011 * Author: mickael @@ -36,6 +36,7 @@ #include #include #include +#include #include "opj_config.h" #include "opj_getopt.h" @@ -44,11 +45,359 @@ #include "format_defs.h" #include "convert.h" -double* parseToleranceValues( char* inArg, const int nbcomp); -void comparePGXimages_help_display(void); -opj_image_t* readImageFromFilePGX(char* filename, int nbFilenamePGX, char *separator); -#ifdef HAVE_LIBPNG -int imageToPNG(const opj_image_t* image, const char* filename, int num_comp_select); +#ifdef HAVE_LIBTIFF +#include /* TIFFSetWarningHandler */ +#endif /* HAVE_LIBTIFF */ + +/******************************************************************************* + * Parse MSE and PEAK input values ( + * separator = ":" + *******************************************************************************/ +static double* parseToleranceValues( char* inArg, const int nbcomp) +{ + double* outArgs= malloc((size_t)nbcomp * sizeof(double)); + int it_comp = 0; + const char delims[] = ":"; + char *result = strtok( inArg, delims ); + + while( (result != NULL) && (it_comp < nbcomp )) + { + outArgs[it_comp] = atof(result); + result = strtok( NULL, delims ); + it_comp++; + } + + if (it_comp != nbcomp) + { + free(outArgs); + return NULL; + } + /* else */ + return outArgs; +} + +/******************************************************************************* + * Command line help function + *******************************************************************************/ +static void compare_images_help_display(void) +{ + fprintf(stdout,"\nList of parameters for the compare_images function \n"); + fprintf(stdout,"\n"); + fprintf(stdout," -b \t REQUIRED \t filename to the reference/baseline PGX/TIF/PNM image \n"); + fprintf(stdout," -t \t REQUIRED \t filename to the test PGX/TIF/PNM image\n"); + fprintf(stdout," -n \t REQUIRED \t number of component of the image (used to generate correct filename, not used when both input files are TIF)\n"); + fprintf(stdout," -m \t OPTIONAL \t list of MSE tolerances, separated by : (size must correspond to the number of component) of \n"); + fprintf(stdout," -p \t OPTIONAL \t list of PEAK tolerances, separated by : (size must correspond to the number of component) \n"); + fprintf(stdout," -s \t OPTIONAL \t 1 or 2 filename separator to take into account PGX/PNM image with different components, " + "please indicate b or t before separator to indicate respectively the separator " + "for ref/base file and for test file. \n"); + fprintf(stdout," -d \t OPTIONAL \t indicate if you want to run this function as conformance test or as non regression test\n"); + fprintf(stdout,"\n"); +} + +static int get_decod_format_from_string(const char *filename) +{ + const int dot = '.'; + char * ext = strrchr(filename, dot); + if( strcmp(ext,".pgx") == 0 ) return PGX_DFMT; + if( strcmp(ext,".tif") == 0 ) return TIF_DFMT; + if( strcmp(ext,".ppm") == 0 ) return PXM_DFMT; + return -1; +} + + +/******************************************************************************* + * Create filenames from a filename using separator and nb components + * (begin from 0) + *******************************************************************************/ +static char* createMultiComponentsFilename(const char* inFilename, const int indexF, const char* separator) +{ + char s[255]; + char *outFilename, *ptr; + const char token = '.'; + size_t posToken = 0; + int decod_format; + + /*printf("inFilename = %s\n", inFilename);*/ + if ((ptr = strrchr(inFilename, token)) != NULL) + { + posToken = strlen(inFilename) - strlen(ptr); + /*printf("Position of %c character inside inFilename = %d\n", token, posToken);*/ + } + else + { + /*printf("Token %c not found\n", token);*/ + outFilename = (char*)malloc(1); + outFilename[0] = '\0'; + return outFilename; + } + + outFilename = (char*)malloc((posToken + 7) * sizeof(char)); /*6*/ + + strncpy(outFilename, inFilename, posToken); + outFilename[posToken] = '\0'; + strcat(outFilename, separator); + sprintf(s, "%i", indexF); + strcat(outFilename, s); + + decod_format = get_decod_format_from_string(inFilename); + if( decod_format == PGX_DFMT ) + { + strcat(outFilename, ".pgx"); + } + else if( decod_format == PXM_DFMT ) + { + strcat(outFilename, ".pgm"); + } + + /*printf("outfilename: %s\n", outFilename);*/ + return outFilename; +} + +/******************************************************************************* + * + *******************************************************************************/ +static opj_image_t* readImageFromFilePPM(const char* filename, int nbFilenamePGX, const char *separator) +{ + int it_file; + opj_image_t* image_read = NULL; + opj_image_t* image = NULL; + opj_cparameters_t parameters; + opj_image_cmptparm_t* param_image_read; + int** data; + + /* If separator is empty => nb file to read is equal to one*/ + if ( strlen(separator) == 0 ) + nbFilenamePGX = 1; + + /* set encoding parameters to default values */ + opj_set_default_encoder_parameters(¶meters); + parameters.decod_format = PXM_DFMT; + strcpy(parameters.infile, filename); + + /* Allocate memory*/ + param_image_read = malloc((size_t)nbFilenamePGX * sizeof(opj_image_cmptparm_t)); + data = malloc((size_t)nbFilenamePGX * sizeof(*data)); + + for (it_file = 0; it_file < nbFilenamePGX; it_file++) + { + /* Create the right filename*/ + char *filenameComponentPGX; + if (strlen(separator) == 0) + { + filenameComponentPGX = malloc((strlen(filename) + 1) * sizeof(*filenameComponentPGX)); + strcpy(filenameComponentPGX, filename); + } + else + filenameComponentPGX = createMultiComponentsFilename(filename, it_file, separator); + + /* Read the tif file corresponding to the component */ + image_read = pnmtoimage(filenameComponentPGX, ¶meters); + if (!image_read) + { + int it_free_data; + fprintf(stderr, "Unable to load ppm file: %s\n", filenameComponentPGX); + + free(param_image_read); + + for (it_free_data = 0; it_free_data < it_file; it_free_data++) { + free(data[it_free_data]); + } + free(data); + + free(filenameComponentPGX); + + return NULL; + } + + /* Set the image_read parameters*/ + param_image_read[it_file].x0 = 0; + param_image_read[it_file].y0 = 0; + param_image_read[it_file].dx = 0; + param_image_read[it_file].dy = 0; + param_image_read[it_file].h = image_read->comps->h; + param_image_read[it_file].w = image_read->comps->w; + param_image_read[it_file].bpp = image_read->comps->bpp; + param_image_read[it_file].prec = image_read->comps->prec; + param_image_read[it_file].sgnd = image_read->comps->sgnd; + + /* Copy data*/ + data[it_file] = malloc(param_image_read[it_file].h * param_image_read[it_file].w * sizeof(int)); + memcpy(data[it_file], image_read->comps->data, image_read->comps->h * image_read->comps->w * sizeof(int)); + + /* Free memory*/ + opj_image_destroy(image_read); + free(filenameComponentPGX); + } + + image = opj_image_create((unsigned int)nbFilenamePGX, param_image_read, CLRSPC_UNSPECIFIED); + for (it_file = 0; it_file < nbFilenamePGX; it_file++) + { + /* Copy data into output image and free memory*/ + memcpy(image->comps[it_file].data, data[it_file], image->comps[it_file].h * image->comps[it_file].w * sizeof(int)); + free(data[it_file]); + } + + /* Free memory*/ + free(param_image_read); + free(data); + + return image; +} + +static opj_image_t* readImageFromFileTIF(const char* filename, int nbFilenamePGX, const char *separator) +{ + opj_image_t* image_read = NULL; + opj_cparameters_t parameters; + (void)nbFilenamePGX; + (void)separator; + + /* conformance test suite produce annoying warning/error: + * TIFFReadDirectory: Warning, /.../data/baseline/conformance/jp2_1.tif: unknown field with tag 37724 (0x935c) encountered. + * TIFFOpen: /.../data/baseline/nonregression/opj_jp2_1.tif: Cannot open. + * On Win32 this open a message box by default, so remove it from the test suite: + */ +#ifdef HAVE_LIBTIFF + TIFFSetWarningHandler(NULL); + TIFFSetErrorHandler(NULL); +#endif + + if ( strlen(separator) != 0 ) return NULL; + + /* set encoding parameters to default values */ + opj_set_default_encoder_parameters(¶meters); + parameters.decod_format = TIF_DFMT; + strcpy(parameters.infile, filename); + + /* Read the tif file corresponding to the component */ +#ifdef HAVE_LIBTIFF + image_read = tiftoimage(filename, ¶meters); +#endif + if (!image_read) + { + fprintf(stderr, "Unable to load TIF file\n"); + return NULL; + } + + return image_read; +} + +static opj_image_t* readImageFromFilePGX(const char* filename, int nbFilenamePGX, const char *separator) +{ + int it_file; + opj_image_t* image_read = NULL; + opj_image_t* image = NULL; + opj_cparameters_t parameters; + opj_image_cmptparm_t* param_image_read; + int** data; + + /* If separator is empty => nb file to read is equal to one*/ + if ( strlen(separator) == 0 ) + nbFilenamePGX = 1; + + /* set encoding parameters to default values */ + opj_set_default_encoder_parameters(¶meters); + parameters.decod_format = PGX_DFMT; + strcpy(parameters.infile, filename); + + /* Allocate memory*/ + param_image_read = malloc((size_t)nbFilenamePGX * sizeof(opj_image_cmptparm_t)); + data = malloc((size_t)nbFilenamePGX * sizeof(*data)); + + for (it_file = 0; it_file < nbFilenamePGX; it_file++) + { + /* Create the right filename*/ + char *filenameComponentPGX; + if (strlen(separator) == 0) + { + filenameComponentPGX = malloc((strlen(filename) + 1) * sizeof(*filenameComponentPGX)); + strcpy(filenameComponentPGX, filename); + } + else + filenameComponentPGX = createMultiComponentsFilename(filename, it_file, separator); + + /* Read the pgx file corresponding to the component */ + image_read = pgxtoimage(filenameComponentPGX, ¶meters); + if (!image_read) + { + int it_free_data; + fprintf(stderr, "Unable to load pgx file\n"); + + free(param_image_read); + + for (it_free_data = 0; it_free_data < it_file; it_free_data++) { + free(data[it_free_data]); + } + free(data); + + free(filenameComponentPGX); + + return NULL; + } + + /* Set the image_read parameters*/ + param_image_read[it_file].x0 = 0; + param_image_read[it_file].y0 = 0; + param_image_read[it_file].dx = 0; + param_image_read[it_file].dy = 0; + param_image_read[it_file].h = image_read->comps->h; + param_image_read[it_file].w = image_read->comps->w; + param_image_read[it_file].bpp = image_read->comps->bpp; + param_image_read[it_file].prec = image_read->comps->prec; + param_image_read[it_file].sgnd = image_read->comps->sgnd; + + /* Copy data*/ + data[it_file] = malloc(param_image_read[it_file].h * param_image_read[it_file].w * sizeof(int)); + memcpy(data[it_file], image_read->comps->data, image_read->comps->h * image_read->comps->w * sizeof(int)); + + /* Free memory*/ + opj_image_destroy(image_read); + free(filenameComponentPGX); + } + + image = opj_image_create((unsigned int)nbFilenamePGX, param_image_read, CLRSPC_UNSPECIFIED); + for (it_file = 0; it_file < nbFilenamePGX; it_file++) + { + /* Copy data into output image and free memory*/ + memcpy(image->comps[it_file].data, data[it_file], image->comps[it_file].h * image->comps[it_file].w * sizeof(int)); + free(data[it_file]); + } + + /* Free memory*/ + free(param_image_read); + free(data); + + return image; +} + +#if defined(HAVE_LIBPNG) && 0 /* remove for now */ +/******************************************************************************* + * + *******************************************************************************/ +static int imageToPNG(const opj_image_t* image, const char* filename, int num_comp_select) +{ + opj_image_cmptparm_t param_image_write; + opj_image_t* image_write = NULL; + + param_image_write.x0 = 0; + param_image_write.y0 = 0; + param_image_write.dx = 0; + param_image_write.dy = 0; + param_image_write.h = image->comps[num_comp_select].h; + param_image_write.w = image->comps[num_comp_select].w; + param_image_write.bpp = image->comps[num_comp_select].bpp; + param_image_write.prec = image->comps[num_comp_select].prec; + param_image_write.sgnd = image->comps[num_comp_select].sgnd; + + image_write = opj_image_create(1u, ¶m_image_write, OPJ_CLRSPC_GRAY); + memcpy(image_write->comps->data, image->comps[num_comp_select].data, param_image_write.h * param_image_write.w * sizeof(int)); + + imagetopng(image_write, filename); + + opj_image_destroy(image_write); + + return EXIT_SUCCESS; +} #endif typedef struct test_cmp_parameters @@ -72,32 +421,24 @@ typedef struct test_cmp_parameters } test_cmp_parameters; -/******************************************************************************* - * Command line help function - *******************************************************************************/ -void comparePGXimages_help_display(void) { - fprintf(stdout,"\nList of parameters for the comparePGX function \n"); - fprintf(stdout,"\n"); - fprintf(stdout," -b \t REQUIRED \t filename to the reference/baseline PGX image \n"); - fprintf(stdout," -t \t REQUIRED \t filename to the test PGX image\n"); - fprintf(stdout," -n \t REQUIRED \t number of component of the image (used to generate correct filename)\n"); - fprintf(stdout," -m \t OPTIONAL \t list of MSE tolerances, separated by : (size must correspond to the number of component) of \n"); - fprintf(stdout," -p \t OPTIONAL \t list of PEAK tolerances, separated by : (size must correspond to the number of component) \n"); - fprintf(stdout," -s \t OPTIONAL \t 1 or 2 filename separator to take into account PGX image with different components, " - "please indicate b or t before separator to indicate respectively the separator " - "for ref/base file and for test file. \n"); - fprintf(stdout," -r \t OPTIONAL \t indicate if you want to run this function as conformance test or as non regression test\n"); - fprintf(stdout,"\n"); +/* return decode format PGX / TIF / PPM , return -1 on error */ +static int get_decod_format(test_cmp_parameters* param) +{ + int base_format = get_decod_format_from_string( param->base_filename ); + int test_format = get_decod_format_from_string( param->test_filename ); + if( base_format != test_format ) return -1; + /* handle case -1: */ + return base_format; } /******************************************************************************* * Parse command line *******************************************************************************/ -int parse_cmdline_cmp(int argc, char **argv, test_cmp_parameters* param) +static int parse_cmdline_cmp(int argc, char **argv, test_cmp_parameters* param) { char *MSElistvalues = NULL; char *PEAKlistvalues= NULL; char *separatorList = NULL; - int sizemembasefile, sizememtestfile; + size_t sizemembasefile, sizememtestfile; int index, flagM=0, flagP=0; const char optlist[] = "b:t:n:m:p:s:d"; int c; @@ -109,6 +450,8 @@ int parse_cmdline_cmp(int argc, char **argv, test_cmp_parameters* param) param->tabMSEvalues = NULL; param->tabPEAKvalues = NULL; param->nr_flag = 0; + param->separator_base[0] = 0; + param->separator_test[0] = 0; opj_opterr = 0; @@ -116,19 +459,15 @@ int parse_cmdline_cmp(int argc, char **argv, test_cmp_parameters* param) switch (c) { case 'b': - sizemembasefile = (int)strlen(opj_optarg)+1; + sizemembasefile = strlen(opj_optarg) + 1; param->base_filename = (char*) malloc(sizemembasefile); - param->base_filename[0] = '\0'; - strncpy(param->base_filename, opj_optarg, strlen(opj_optarg)); - param->base_filename[strlen(opj_optarg)] = '\0'; + strcpy(param->base_filename, opj_optarg); /*printf("param->base_filename = %s [%d / %d]\n", param->base_filename, strlen(param->base_filename), sizemembasefile );*/ break; case 't': - sizememtestfile = (int) strlen(opj_optarg) + 1; + sizememtestfile = strlen(opj_optarg) + 1; param->test_filename = (char*) malloc(sizememtestfile); - param->test_filename[0] = '\0'; - strncpy(param->test_filename, opj_optarg, strlen(opj_optarg)); - param->test_filename[strlen(opj_optarg)] = '\0'; + strcpy(param->test_filename, opj_optarg); /*printf("param->test_filename = %s [%d / %d]\n", param->test_filename, strlen(param->test_filename), sizememtestfile);*/ break; case 'n': @@ -165,30 +504,24 @@ int parse_cmdline_cmp(int argc, char **argv, test_cmp_parameters* param) { for (index = opj_optind; index < argc; index++) fprintf(stderr,"Non-option argument %s\n", argv[index]); - return EXIT_FAILURE; + return 1; } if (param->nbcomp == 0) { fprintf(stderr,"Need to indicate the number of components !\n"); - return EXIT_FAILURE; + return 1; } - else + /* else */ + if ( flagM && flagP ) { - if ( flagM && flagP ) + param->tabMSEvalues = parseToleranceValues( MSElistvalues, param->nbcomp); + param->tabPEAKvalues = parseToleranceValues( PEAKlistvalues, param->nbcomp); + if ( (param->tabMSEvalues == NULL) || (param->tabPEAKvalues == NULL)) { - param->tabMSEvalues = parseToleranceValues( MSElistvalues, param->nbcomp); - param->tabPEAKvalues = parseToleranceValues( PEAKlistvalues, param->nbcomp); - if ( (param->tabMSEvalues == NULL) || (param->tabPEAKvalues == NULL)) - { - fprintf(stderr,"MSE and PEAK values are not correct (respectively need %d values)\n",param->nbcomp); - return EXIT_FAILURE; - } + fprintf(stderr,"MSE and PEAK values are not correct (respectively need %d values)\n",param->nbcomp); + return 1; } - /*else - { - - }*/ } /* Get separators after corresponding letter (b or t)*/ @@ -197,11 +530,9 @@ int parse_cmdline_cmp(int argc, char **argv, test_cmp_parameters* param) if( (strlen(separatorList) ==2) || (strlen(separatorList) ==4) ) { /* keep original string*/ - int sizeseplist = (int)strlen(separatorList)+1; + size_t sizeseplist = strlen(separatorList)+1; char* separatorList2 = (char*)malloc( sizeseplist ); - separatorList2[0] = '\0'; - strncpy(separatorList2, separatorList, strlen(separatorList)); - separatorList2[strlen(separatorList)] = '\0'; + strcpy(separatorList2, separatorList); /*printf("separatorList2 = %s [%d / %d]\n", separatorList2, strlen(separatorList2), sizeseplist);*/ if (strlen(separatorList) == 2) /* one separator behind b or t*/ @@ -214,19 +545,21 @@ int parse_cmdline_cmp(int argc, char **argv, test_cmp_parameters* param) resultB = strtok(resultT, "b"); if (strlen(resultB) == 1) { - param->separator_base[0] = separatorList[1];param->separator_base[1] = '\0'; - param->separator_test[0] ='\0'; + param->separator_base[0] = separatorList[1]; + param->separator_base[1] = 0; + param->separator_test[0] = 0; } else /* not found b*/ { free(separatorList2); - return EXIT_FAILURE; + return 1; } } else /* found t*/ { - param->separator_base[0] ='\0'; - param->separator_test[0] = separatorList[1];param->separator_test[1] = '\0'; + param->separator_base[0] = 0; + param->separator_test[0] = separatorList[1]; + param->separator_test[1] = 0; } /*printf("sep b = %s [%d] and sep t = %s [%d]\n",param->separator_base, strlen(param->separator_base), param->separator_test, strlen(param->separator_test) );*/ } @@ -240,13 +573,15 @@ int parse_cmdline_cmp(int argc, char **argv, test_cmp_parameters* param) resultB = strtok(resultT, "b"); if (strlen(resultB) == 1) /* found b after t*/ { - param->separator_test[0] = separatorList[1];param->separator_test[1] = '\0'; - param->separator_base[0] = separatorList[3];param->separator_base[1] = '\0'; + param->separator_test[0] = separatorList[1]; + param->separator_test[1] = 0; + param->separator_base[0] = separatorList[3]; + param->separator_base[1] = 0; } else /* didn't find b after t*/ { free(separatorList2); - return EXIT_FAILURE; + return 1; } } else /* == 2, didn't find t in first place*/ @@ -255,13 +590,15 @@ int parse_cmdline_cmp(int argc, char **argv, test_cmp_parameters* param) resultB = strtok(resultT, "b"); if (strlen(resultB) == 1) /* found b in first place*/ { - param->separator_base[0] = separatorList[1]; param->separator_base[1] = '\0'; - param->separator_test[0] = separatorList[3]; param->separator_test[1] = '\0'; + param->separator_base[0] = separatorList[1]; + param->separator_base[1] = 0; + param->separator_test[0] = separatorList[3]; + param->separator_test[1] = 0; } else /* didn't found b in first place => problem*/ { free(separatorList2); - return EXIT_FAILURE; + return 1; } } } @@ -269,20 +606,20 @@ int parse_cmdline_cmp(int argc, char **argv, test_cmp_parameters* param) } else /* wrong number of argument after -s*/ { - return EXIT_FAILURE; + return 1; } } else { if (param->nbcomp == 1) { - param->separator_base[0] = '\0'; - param->separator_test[0] = '\0'; + assert( param->separator_base[0] == 0 ); + assert( param->separator_test[0] == 0 ); } else { fprintf(stderr,"If number of component is > 1, we need separator\n"); - return EXIT_FAILURE; + return 1; } } @@ -290,233 +627,41 @@ int parse_cmdline_cmp(int argc, char **argv, test_cmp_parameters* param) if ( (param->nr_flag) && (flagP || flagM) ) { fprintf(stderr,"Wrong input parameters list: it is non-regression test or tolerance comparison\n"); - return EXIT_FAILURE; + return 1; } if ( (!param->nr_flag) && (!flagP || !flagM) ) { fprintf(stderr,"Wrong input parameters list: it is non-regression test or tolerance comparison\n"); - return EXIT_FAILURE; + return 1; } - return EXIT_SUCCESS; + return 0; } -/******************************************************************************* - * Parse MSE and PEAK input values ( - * separator = ":" - *******************************************************************************/ -double* parseToleranceValues( char* inArg, const int nbcomp) -{ - double* outArgs= malloc(nbcomp * sizeof(double)); - int it_comp = 0; - char delims[] = ":"; - char *result = NULL; - result = strtok( inArg, delims ); - - while( (result != NULL) && (it_comp < nbcomp )) - { - outArgs[it_comp] = atof(result); - result = strtok( NULL, delims ); - it_comp++; - } - - if (it_comp != nbcomp) - { - free(outArgs); - return NULL; - } - else - return outArgs; -} -/******************************************************************************* - * Create filenames from a filename by used separator and nb components - * (begin to 0) - *******************************************************************************/ -char* createMultiComponentsFilename(const char* inFilename, const int indexF, const char* separator) -{ - char s[255]; - char *outFilename, *ptr; - char token = '.'; - int posToken = 0; - - /*printf("inFilename = %s\n", inFilename);*/ - if ((ptr = strrchr(inFilename, token)) != NULL) - { - posToken = (int) (strlen(inFilename) - strlen(ptr)); - /*printf("Position of %c character inside inFilename = %d\n", token, posToken);*/ - } - else - { - /*printf("Token %c not found\n", token);*/ - outFilename = (char*)malloc(1); - outFilename[0] = '\0'; - return outFilename; - } - - outFilename = (char*)malloc((posToken + 7) * sizeof(char)); /*6*/ - - strncpy(outFilename, inFilename, posToken); - - outFilename[posToken] = '\0'; - - strcat(outFilename, separator); - - sprintf(s, "%i", indexF); - strcat(outFilename, s); - - strcat(outFilename, ".pgx"); - - /*printf("outfilename: %s\n", outFilename);*/ - return outFilename; -} -/******************************************************************************* - * - *******************************************************************************/ -opj_image_t* readImageFromFilePGX(char* filename, int nbFilenamePGX, char *separator) -{ - int it_file; - opj_image_t* image_read = NULL; - opj_image_t* image = NULL; - opj_cparameters_t parameters; - opj_image_cmptparm_t* param_image_read; - int** data; - - /* If separator is empty => nb file to read is equal to one*/ - if ( strlen(separator) == 0 ) - nbFilenamePGX = 1; - - /* set encoding parameters to default values */ - opj_set_default_encoder_parameters(¶meters); - parameters.decod_format = PGX_DFMT; - strncpy(parameters.infile, filename, sizeof(parameters.infile)-1); - - /* Allocate memory*/ - param_image_read = malloc(nbFilenamePGX * sizeof(opj_image_cmptparm_t)); - data = malloc(nbFilenamePGX * sizeof(*data)); - - it_file = 0; - for (it_file = 0; it_file < nbFilenamePGX; it_file++) - { - /* Create the right filename*/ - char *filenameComponentPGX; - if (strlen(separator) == 0) - { - filenameComponentPGX = malloc((strlen(filename) + 1) * sizeof(*filenameComponentPGX)); - strcpy(filenameComponentPGX, filename); - } - else - filenameComponentPGX = createMultiComponentsFilename(filename, it_file, separator); - - /* Read the pgx file corresponding to the component */ - image_read = pgxtoimage(filenameComponentPGX, ¶meters); - if (!image_read) - { - int it_free_data; - fprintf(stderr, "Unable to load pgx file\n"); - - free(param_image_read); - - for (it_free_data = 0; it_free_data < it_file; it_free_data++) { - free(data[it_free_data]); - } - free(data); - - free(filenameComponentPGX); - - return NULL; - } - - /* Set the image_read parameters*/ - param_image_read[it_file].x0 = 0; - param_image_read[it_file].y0 = 0; - param_image_read[it_file].dx = 0; - param_image_read[it_file].dy = 0; - param_image_read[it_file].h = image_read->comps->h; - param_image_read[it_file].w = image_read->comps->w; - param_image_read[it_file].bpp = image_read->comps->bpp; - param_image_read[it_file].prec = image_read->comps->prec; - param_image_read[it_file].sgnd = image_read->comps->sgnd; - - /* Copy data*/ - data[it_file] = malloc(param_image_read[it_file].h * param_image_read[it_file].w * sizeof(int)); - memcpy(data[it_file], image_read->comps->data, image_read->comps->h * image_read->comps->w * sizeof(int)); - - /* Free memory*/ - opj_image_destroy(image_read); - free(filenameComponentPGX); - } - - image = opj_image_create(nbFilenamePGX, param_image_read, CLRSPC_UNSPECIFIED); - for (it_file = 0; it_file < nbFilenamePGX; it_file++) - { - /* Copy data into output image and free memory*/ - memcpy(image->comps[it_file].data, data[it_file], image->comps[it_file].h * image->comps[it_file].w * sizeof(int)); - free(data[it_file]); - } - - /* Free memory*/ - free(param_image_read); - free(data); - - return image; -} - -/******************************************************************************* - * - *******************************************************************************/ -#ifdef HAVE_LIBPNG -int imageToPNG(const opj_image_t* image, const char* filename, int num_comp_select) -{ - opj_image_cmptparm_t param_image_write; - opj_image_t* image_write = NULL; - - param_image_write.x0 = 0; - param_image_write.y0 = 0; - param_image_write.dx = 0; - param_image_write.dy = 0; - param_image_write.h = image->comps[num_comp_select].h; - param_image_write.w = image->comps[num_comp_select].w; - param_image_write.bpp = image->comps[num_comp_select].bpp; - param_image_write.prec = image->comps[num_comp_select].prec; - param_image_write.sgnd = image->comps[num_comp_select].sgnd; - - image_write = opj_image_create(1, ¶m_image_write, CLRSPC_GRAY); - memcpy(image_write->comps->data, image->comps[num_comp_select].data, param_image_write.h * param_image_write.w * sizeof(int)); - - imagetopng(image_write, filename); - - opj_image_destroy(image_write); - - return EXIT_SUCCESS; -} -#endif - /******************************************************************************* * MAIN *******************************************************************************/ int main(int argc, char **argv) { test_cmp_parameters inParam; - int it_comp, itpxl; - int failed = 0; - int nbFilenamePGXbase, nbFilenamePGXtest; + unsigned int it_comp, itpxl; + int failed = 1; + int nbFilenamePGXbase = 0, nbFilenamePGXtest = 0; char *filenamePNGtest= NULL, *filenamePNGbase = NULL, *filenamePNGdiff = NULL; - int memsizebasefilename, memsizetestfilename, memsizedifffilename; + size_t memsizebasefilename, memsizetestfilename; + size_t memsizedifffilename; int valueDiff = 0, nbPixelDiff = 0; double sumDiff = 0.0; /* Structures to store image parameters and data*/ opj_image_t *imageBase = NULL, *imageTest = NULL, *imageDiff = NULL; - opj_image_cmptparm_t* param_image_diff; + opj_image_cmptparm_t* param_image_diff = NULL; + int decod_format; /* Get parameters from command line*/ - if( parse_cmdline_cmp(argc, argv, &inParam) == EXIT_FAILURE ) + if( parse_cmdline_cmp(argc, argv, &inParam) ) { - comparePGXimages_help_display(); - if (inParam.tabMSEvalues) free(inParam.tabMSEvalues); - if (inParam.tabPEAKvalues) free(inParam.tabPEAKvalues); - if (inParam.base_filename) free(inParam.base_filename); - if (inParam.test_filename) free(inParam.test_filename); - return EXIT_FAILURE; + compare_images_help_display(); + goto cleanup; } /* Display Parameters*/ @@ -531,26 +676,23 @@ int main(int argc, char **argv) inParam.nr_flag, inParam.separator_base, inParam.separator_test); if ( (inParam.tabMSEvalues != NULL) && (inParam.tabPEAKvalues != NULL)) - { + { + int it_comp2; printf(" MSE values = ["); - for (it_comp = 0; it_comp < inParam.nbcomp; it_comp++) - printf(" %f ", inParam.tabMSEvalues[it_comp]); + for (it_comp2 = 0; it_comp2 < inParam.nbcomp; it_comp2++) + printf(" %f ", inParam.tabMSEvalues[it_comp2]); printf("]\n"); printf(" PEAK values = ["); - for (it_comp = 0; it_comp < inParam.nbcomp; it_comp++) - printf(" %f ", inParam.tabPEAKvalues[it_comp]); + for (it_comp2 = 0; it_comp2 < inParam.nbcomp; it_comp2++) + printf(" %f ", inParam.tabPEAKvalues[it_comp2]); printf("]\n"); printf(" Non-regression test = %d\n", inParam.nr_flag); } - if (strlen(inParam.separator_base) == 0) - nbFilenamePGXbase = 0; - else + if (strlen(inParam.separator_base) != 0) nbFilenamePGXbase = inParam.nbcomp; - if (strlen(inParam.separator_test) == 0) - nbFilenamePGXtest = 0; - else + if (strlen(inParam.separator_test) != 0) nbFilenamePGXtest = inParam.nbcomp; printf(" NbFilename to generate from base filename = %d\n", nbFilenamePGXbase); @@ -558,50 +700,66 @@ int main(int argc, char **argv) printf("************************* \n"); /*----------BASELINE IMAGE--------*/ - memsizebasefilename = (int)strlen(inParam.test_filename) + 1 + 5 + 2 + 4; - memsizetestfilename = (int)strlen(inParam.test_filename) + 1 + 5 + 2 + 4; + memsizebasefilename = strlen(inParam.test_filename) + 1 + 5 + 2 + 4; + memsizetestfilename = strlen(inParam.test_filename) + 1 + 5 + 2 + 4; - imageBase = readImageFromFilePGX( inParam.base_filename, nbFilenamePGXbase, inParam.separator_base); - if ( imageBase != NULL) + decod_format = get_decod_format(&inParam); + if( decod_format == -1 ) { - filenamePNGbase = (char*) malloc(memsizebasefilename); - filenamePNGbase[0] = '\0'; - strncpy(filenamePNGbase, inParam.test_filename, strlen(inParam.test_filename)); - filenamePNGbase[strlen(inParam.test_filename)] = '\0'; - strcat(filenamePNGbase, ".base"); - /*printf("filenamePNGbase = %s [%d / %d octets]\n",filenamePNGbase, strlen(filenamePNGbase),memsizebasefilename );*/ + fprintf( stderr, "Unhandled file format\n" ); + goto cleanup; } - else + assert( decod_format == PGX_DFMT || decod_format == TIF_DFMT || decod_format == PXM_DFMT ); + + if( decod_format == PGX_DFMT ) { - if (inParam.tabMSEvalues) free(inParam.tabMSEvalues); - if (inParam.tabPEAKvalues) free(inParam.tabPEAKvalues); - if (inParam.base_filename) free(inParam.base_filename); - if (inParam.test_filename) free(inParam.test_filename); - return EXIT_FAILURE; + imageBase = readImageFromFilePGX( inParam.base_filename, nbFilenamePGXbase, inParam.separator_base); + if ( imageBase == NULL ) + goto cleanup; } + else if( decod_format == TIF_DFMT ) + { + imageBase = readImageFromFileTIF( inParam.base_filename, nbFilenamePGXbase, ""); + if ( imageBase == NULL ) + goto cleanup; + } + else if( decod_format == PXM_DFMT ) + { + imageBase = readImageFromFilePPM( inParam.base_filename, nbFilenamePGXbase, inParam.separator_base); + if ( imageBase == NULL ) + goto cleanup; + } + + filenamePNGbase = (char*) malloc(memsizebasefilename); + strcpy(filenamePNGbase, inParam.test_filename); + strcat(filenamePNGbase, ".base"); + /*printf("filenamePNGbase = %s [%d / %d octets]\n",filenamePNGbase, strlen(filenamePNGbase),memsizebasefilename );*/ /*----------TEST IMAGE--------*/ - imageTest = readImageFromFilePGX(inParam.test_filename, nbFilenamePGXtest, inParam.separator_test); - if ( imageTest != NULL) + if( decod_format == PGX_DFMT ) { - filenamePNGtest = (char*) malloc(memsizetestfilename); - filenamePNGtest[0] = '\0'; - strncpy(filenamePNGtest, inParam.test_filename, strlen(inParam.test_filename)); - filenamePNGtest[strlen(inParam.test_filename)] = '\0'; - strcat(filenamePNGtest, ".test"); - /*printf("filenamePNGtest = %s [%d / %d octets]\n",filenamePNGtest, strlen(filenamePNGtest),memsizetestfilename );*/ + imageTest = readImageFromFilePGX(inParam.test_filename, nbFilenamePGXtest, inParam.separator_test); + if ( imageTest == NULL ) + goto cleanup; } - else + else if( decod_format == TIF_DFMT ) { - if (imageBase) opj_image_destroy(imageBase); - if (inParam.tabMSEvalues) free(inParam.tabMSEvalues); - if (inParam.tabPEAKvalues) free(inParam.tabPEAKvalues); - if (inParam.base_filename) free(inParam.base_filename); - if (inParam.test_filename) free(inParam.test_filename); - free(filenamePNGbase); - return EXIT_FAILURE; + imageTest = readImageFromFileTIF(inParam.test_filename, nbFilenamePGXtest, ""); + if ( imageTest == NULL ) + goto cleanup; } + else if( decod_format == PXM_DFMT ) + { + imageTest = readImageFromFilePPM(inParam.test_filename, nbFilenamePGXtest, inParam.separator_test); + if ( imageTest == NULL ) + goto cleanup; + } + + filenamePNGtest = (char*) malloc(memsizetestfilename); + strcpy(filenamePNGtest, inParam.test_filename); + strcat(filenamePNGtest, ".test"); + /*printf("filenamePNGtest = %s [%d / %d octets]\n",filenamePNGtest, strlen(filenamePNGtest),memsizetestfilename );*/ /*----------DIFF IMAGE--------*/ @@ -611,85 +769,66 @@ int main(int argc, char **argv) /* Comparison of header parameters*/ printf("Step 1 -> Header comparison\n"); + /* check dimensions (issue 286)*/ + if(imageBase->numcomps != imageTest->numcomps ) + { + printf("ERROR: dim mismatch (%d><%d)\n", imageBase->numcomps, imageTest->numcomps); + goto cleanup; + } + for (it_comp = 0; it_comp < imageBase->numcomps; it_comp++) { param_image_diff[it_comp].x0 = 0; param_image_diff[it_comp].y0 = 0; param_image_diff[it_comp].dx = 0; param_image_diff[it_comp].dy = 0; + param_image_diff[it_comp].sgnd = 0; + param_image_diff[it_comp].prec = 8; + param_image_diff[it_comp].bpp = 1; + param_image_diff[it_comp].h = imageBase->comps[it_comp].h; + param_image_diff[it_comp].w = imageBase->comps[it_comp].w; if (imageBase->comps[it_comp].sgnd != imageTest->comps[it_comp].sgnd) { printf("ERROR: sign mismatch [comp %d] (%d><%d)\n", it_comp, ((imageBase->comps)[it_comp]).sgnd, ((imageTest->comps)[it_comp]).sgnd); - failed = 1; + goto cleanup; } - else - param_image_diff[it_comp].sgnd = 0 ; if (((imageBase->comps)[it_comp]).prec != ((imageTest->comps)[it_comp]).prec) { printf("ERROR: prec mismatch [comp %d] (%d><%d)\n", it_comp, ((imageBase->comps)[it_comp]).prec, ((imageTest->comps)[it_comp]).prec); - failed = 1; + goto cleanup; } - else - param_image_diff[it_comp].prec = 8 ; if (((imageBase->comps)[it_comp]).bpp != ((imageTest->comps)[it_comp]).bpp) { printf("ERROR: byte per pixel mismatch [comp %d] (%d><%d)\n", it_comp, ((imageBase->comps)[it_comp]).bpp, ((imageTest->comps)[it_comp]).bpp); - failed = 1; + goto cleanup; } - else - param_image_diff[it_comp].bpp = 1 ; if (((imageBase->comps)[it_comp]).h != ((imageTest->comps)[it_comp]).h) { printf("ERROR: height mismatch [comp %d] (%d><%d)\n", it_comp, ((imageBase->comps)[it_comp]).h, ((imageTest->comps)[it_comp]).h); - failed = 1; + goto cleanup; } - else - param_image_diff[it_comp].h = imageBase->comps[it_comp].h ; if (((imageBase->comps)[it_comp]).w != ((imageTest->comps)[it_comp]).w) { printf("ERROR: width mismatch [comp %d] (%d><%d)\n", it_comp, ((imageBase->comps)[it_comp]).w, ((imageTest->comps)[it_comp]).w); - failed = 1; + goto cleanup; } - else - param_image_diff[it_comp].w = imageBase->comps[it_comp].w ; } - /* If only one parameter is different, we stop the test*/ - if (failed) - { - free(inParam.tabMSEvalues); - free(inParam.tabPEAKvalues); - free(inParam.base_filename); - free(inParam.test_filename); - - free(filenamePNGbase); - free(filenamePNGtest); - - opj_image_destroy(imageBase); - opj_image_destroy(imageTest); - - free(param_image_diff); - - return EXIT_FAILURE; - } - imageDiff = opj_image_create(imageBase->numcomps, param_image_diff, CLRSPC_UNSPECIFIED); /* Free memory*/ - free(param_image_diff); + free(param_image_diff); param_image_diff = NULL; /* Measurement computation*/ printf("Step 2 -> measurement comparison\n"); memsizedifffilename = strlen(inParam.test_filename) + 1 + 5 + 2 + 4; filenamePNGdiff = (char*) malloc(memsizedifffilename); - filenamePNGdiff[0] = '\0'; - strncpy(filenamePNGdiff, inParam.test_filename, strlen(inParam.test_filename)); - filenamePNGdiff[strlen(inParam.test_filename)] = '\0'; + strcpy(filenamePNGdiff, inParam.test_filename); strcat(filenamePNGdiff, ".diff"); /*printf("filenamePNGdiff = %s [%d / %d octets]\n",filenamePNGdiff, strlen(filenamePNGdiff),memsizedifffilename );*/ @@ -698,33 +837,16 @@ int main(int argc, char **argv) { double SE=0,PEAK=0; double MSE=0; - char *filenamePNGbase_it_comp, *filenamePNGtest_it_comp, *filenamePNGdiff_it_comp; - - filenamePNGbase_it_comp = (char*) malloc(memsizebasefilename); - filenamePNGbase_it_comp[0] = '\0'; - strncpy(filenamePNGbase_it_comp,filenamePNGbase,strlen(filenamePNGbase)); - filenamePNGbase_it_comp[strlen(filenamePNGbase)] = '\0'; - - filenamePNGtest_it_comp = (char*) malloc(memsizetestfilename); - filenamePNGtest_it_comp[0] = '\0'; - strncpy(filenamePNGtest_it_comp,filenamePNGtest,strlen(filenamePNGtest)); - filenamePNGtest_it_comp[strlen(filenamePNGtest)] = '\0'; - - filenamePNGdiff_it_comp = (char*) malloc(memsizedifffilename); - filenamePNGdiff_it_comp[0] = '\0'; - strncpy(filenamePNGdiff_it_comp,filenamePNGdiff,strlen(filenamePNGdiff)); - filenamePNGdiff_it_comp[strlen(filenamePNGdiff)] = '\0'; - for (itpxl = 0; itpxl < ((imageDiff->comps)[it_comp]).w * ((imageDiff->comps)[it_comp]).h; itpxl++) { if (abs( ((imageBase->comps)[it_comp]).data[itpxl] - ((imageTest->comps)[it_comp]).data[itpxl] ) > 0) { valueDiff = ((imageBase->comps)[it_comp]).data[itpxl] - ((imageTest->comps)[it_comp]).data[itpxl]; ((imageDiff->comps)[it_comp]).data[itpxl] = abs(valueDiff); - sumDiff += (double)valueDiff; + sumDiff += valueDiff; nbPixelDiff++; - SE += (double)(valueDiff * valueDiff); + SE += (double)valueDiff * valueDiff; PEAK = (PEAK > abs(valueDiff)) ? PEAK : abs(valueDiff); } else @@ -741,9 +863,9 @@ int main(int argc, char **argv) if ( (MSE > inParam.tabMSEvalues[it_comp]) || (PEAK > inParam.tabPEAKvalues[it_comp]) ) { printf("ERROR: MSE (%f) or PEAK (%f) values produced by the decoded file are greater " - "than the allowable error (respectively %f and %f) \n", - MSE, PEAK, inParam.tabMSEvalues[it_comp], inParam.tabPEAKvalues[it_comp]); - failed = 1; + "than the allowable error (respectively %f and %f) \n", + MSE, PEAK, inParam.tabMSEvalues[it_comp], inParam.tabPEAKvalues[it_comp]); + goto cleanup; } } else /* Non regression-test */ @@ -751,45 +873,65 @@ int main(int argc, char **argv) if ( nbPixelDiff > 0) { char it_compc[255]; - it_compc[0] = '\0'; + it_compc[0] = 0; printf(" %d \n", it_comp, nbPixelDiff); printf(" %f \n", it_comp, sumDiff); #ifdef HAVE_LIBPNG - sprintf(it_compc, "_%i", it_comp); - strcat(it_compc,".png"); - strcat(filenamePNGbase_it_comp, it_compc); - /*printf("filenamePNGbase_it = %s [%d / %d octets]\n",filenamePNGbase_it_comp, strlen(filenamePNGbase_it_comp),memsizebasefilename );*/ - strcat(filenamePNGtest_it_comp, it_compc); - /*printf("filenamePNGtest_it = %s [%d / %d octets]\n",filenamePNGtest_it_comp, strlen(filenamePNGtest_it_comp),memsizetestfilename );*/ - strcat(filenamePNGdiff_it_comp, it_compc); - /*printf("filenamePNGdiff_it = %s [%d / %d octets]\n",filenamePNGdiff_it_comp, strlen(filenamePNGdiff_it_comp),memsizedifffilename );*/ + { + char *filenamePNGbase_it_comp, *filenamePNGtest_it_comp, *filenamePNGdiff_it_comp; - if ( imageToPNG(imageBase, filenamePNGbase_it_comp, it_comp) == EXIT_SUCCESS ) + filenamePNGbase_it_comp = (char*) malloc(memsizebasefilename); + strcpy(filenamePNGbase_it_comp,filenamePNGbase); + + filenamePNGtest_it_comp = (char*) malloc(memsizetestfilename); + strcpy(filenamePNGtest_it_comp,filenamePNGtest); + + filenamePNGdiff_it_comp = (char*) malloc(memsizedifffilename); + strcpy(filenamePNGdiff_it_comp,filenamePNGdiff); + + sprintf(it_compc, "_%i", it_comp); + strcat(it_compc,".png"); + strcat(filenamePNGbase_it_comp, it_compc); + /*printf("filenamePNGbase_it = %s [%d / %d octets]\n",filenamePNGbase_it_comp, strlen(filenamePNGbase_it_comp),memsizebasefilename );*/ + strcat(filenamePNGtest_it_comp, it_compc); + /*printf("filenamePNGtest_it = %s [%d / %d octets]\n",filenamePNGtest_it_comp, strlen(filenamePNGtest_it_comp),memsizetestfilename );*/ + strcat(filenamePNGdiff_it_comp, it_compc); + /*printf("filenamePNGdiff_it = %s [%d / %d octets]\n",filenamePNGdiff_it_comp, strlen(filenamePNGdiff_it_comp),memsizedifffilename );*/ + + /* + if ( imageToPNG(imageBase, filenamePNGbase_it_comp, it_comp) == EXIT_SUCCESS ) { printf(" %s \n", it_comp, filenamePNGbase_it_comp); } - if ( imageToPNG(imageTest, filenamePNGtest_it_comp, it_comp) == EXIT_SUCCESS ) + if ( imageToPNG(imageTest, filenamePNGtest_it_comp, it_comp) == EXIT_SUCCESS ) { printf(" %s \n", it_comp, filenamePNGtest_it_comp); } - if ( imageToPNG(imageDiff, filenamePNGdiff_it_comp, it_comp) == EXIT_SUCCESS ) + if ( imageToPNG(imageDiff, filenamePNGdiff_it_comp, it_comp) == EXIT_SUCCESS ) { printf(" %s \n", it_comp, filenamePNGdiff_it_comp); } + */ + + free(filenamePNGbase_it_comp); + free(filenamePNGtest_it_comp); + free(filenamePNGdiff_it_comp); + } #endif - failed = 1; + goto cleanup; } } - free(filenamePNGbase_it_comp); - free(filenamePNGtest_it_comp); - free(filenamePNGdiff_it_comp); } /* it_comp loop */ + printf("---- TEST SUCCEED ----\n"); + failed = 0; +cleanup: /*-----------------------------*/ + free(param_image_diff); /* Free memory */ opj_image_destroy(imageBase); opj_image_destroy(imageTest); @@ -804,11 +946,5 @@ int main(int argc, char **argv) free(inParam.base_filename); free(inParam.test_filename); - if (failed) - return EXIT_FAILURE; - else - { - printf("---- TEST SUCCEED ----\n"); - return EXIT_SUCCESS; - } + return failed ? EXIT_FAILURE : EXIT_SUCCESS; } diff --git a/tests/compare_raw_files.c b/tests/compare_raw_files.c new file mode 100644 index 00000000..01b2122d --- /dev/null +++ b/tests/compare_raw_files.c @@ -0,0 +1,193 @@ +/* + * Copyright (c) 2011-2012, Centre National d'Etudes Spatiales (CNES), France + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * compare_raw_files.c + * + * Created on: 31 August 2011 + * Author: mickael + * + * This is equivalent to the UNIX `cmp` command + */ + +#include +#include +#include +#include + +#include "opj_getopt.h" + +typedef struct test_cmp_parameters +{ + /** */ + char* base_filename; + /** */ + char* test_filename; +} test_cmp_parameters; + +/******************************************************************************* + * Command line help function + *******************************************************************************/ +static void compare_raw_files_help_display(void) { + fprintf(stdout,"\nList of parameters for the compare_raw_files function \n"); + fprintf(stdout,"\n"); + fprintf(stdout," -b \t REQUIRED \t filename to the reference/baseline RAW image \n"); + fprintf(stdout," -t \t REQUIRED \t filename to the test RAW image\n"); + fprintf(stdout,"\n"); +} + +/******************************************************************************* + * Parse command line + *******************************************************************************/ +static int parse_cmdline_cmp(int argc, char **argv, test_cmp_parameters* param) +{ + size_t sizemembasefile, sizememtestfile; + int index; + const char optlist[] = "b:t:"; + int c; + + /* Init parameters*/ + param->base_filename = NULL; + param->test_filename = NULL; + + opj_opterr = 0; + while ((c = opj_getopt(argc, argv, optlist)) != -1) + switch (c) + { + case 'b': + sizemembasefile = strlen(opj_optarg)+1; + free(param->base_filename); /* handle dup option */ + param->base_filename = (char*) malloc(sizemembasefile); + strcpy(param->base_filename, opj_optarg); + /*printf("param->base_filename = %s [%d / %d]\n", param->base_filename, strlen(param->base_filename), sizemembasefile );*/ + break; + case 't': + sizememtestfile = strlen(opj_optarg) + 1; + free(param->test_filename); /* handle dup option */ + param->test_filename = (char*) malloc(sizememtestfile); + strcpy(param->test_filename, opj_optarg); + /*printf("param->test_filename = %s [%d / %d]\n", param->test_filename, strlen(param->test_filename), sizememtestfile);*/ + break; + case '?': + if ((opj_optopt == 'b') || (opj_optopt == 't')) + fprintf(stderr, "Option -%c requires an argument.\n", opj_optopt); + else + if (isprint(opj_optopt)) fprintf(stderr, "Unknown option `-%c'.\n", opj_optopt); + else fprintf(stderr, "Unknown option character `\\x%x'.\n", opj_optopt); + return 1; + default: + fprintf(stderr, "WARNING -> this option is not valid \"-%c %s\"\n", c, opj_optarg); + break; + } + + if (opj_optind != argc) { + for (index = opj_optind; index < argc; index++) + fprintf(stderr,"Non-option argument %s\n", argv[index]); + return 1; + } + + return 0; +} + +/******************************************************************************* + * MAIN + *******************************************************************************/ +int main(int argc, char **argv) +{ + int pos = 0; + test_cmp_parameters inParam; + FILE *file_test=NULL, *file_base=NULL; + unsigned char equal = 0U; /* returns error by default */ + + /* Get parameters from command line*/ + if (parse_cmdline_cmp(argc, argv, &inParam)) + { + compare_raw_files_help_display(); + goto cleanup; + } + + file_test = fopen(inParam.test_filename, "rb"); + if (!file_test) { + fprintf(stderr, "Failed to open %s for reading !!\n", inParam.test_filename); + goto cleanup; + } + + file_base = fopen(inParam.base_filename, "rb"); + if (!file_base) { + fprintf(stderr, "Failed to open %s for reading !!\n", inParam.base_filename); + goto cleanup; + } + + /* Read simultaneously the two files*/ + equal = 1U; + while (equal) + { + unsigned char value_test = 0; + unsigned char eof_test = 0; + unsigned char value_base = 0; + unsigned char eof_base = 0; + + /* Read one byte*/ + if (!fread(&value_test, 1, 1, file_test)) { + eof_test = 1; + } + + /* Read one byte*/ + if (!fread(&value_base, 1, 1, file_base)) { + eof_base = 1; + } + + /* End of file reached by the two files?*/ + if (eof_test && eof_base) + break; + + /* End of file reached only by one file?*/ + if (eof_test || eof_base) + { + fprintf(stdout,"Files have different sizes.\n"); + equal = 0; + } + + /* Binary values are equal?*/ + if (value_test != value_base) + { + fprintf(stdout,"Binary values read in the file are different %x vs %x at position %d.\n", value_test, value_base, pos); + equal = 0; + } + pos++; + } + + if(equal) fprintf(stdout,"---- TEST SUCCEED: Files are equal ----\n"); +cleanup: + if(file_test) fclose(file_test); + if(file_base) fclose(file_base); + + /* Free Memory */ + free(inParam.base_filename); + free(inParam.test_filename); + + return equal ? EXIT_SUCCESS : EXIT_FAILURE; +} diff --git a/tests/conformance/CMakeLists.txt b/tests/conformance/CMakeLists.txt index 5fd84fba..9554e5de 100644 --- a/tests/conformance/CMakeLists.txt +++ b/tests/conformance/CMakeLists.txt @@ -1,315 +1,303 @@ # CONFORMANCE TESTS AND NON-REGRESSION ON THIS DATASET -FILE(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/Temporary) +file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/Temporary) -SET(TEMP ${CMAKE_CURRENT_BINARY_DIR}/Temporary) -SET(BASELINE_CONF ${OPJ_DATA_ROOT}/baseline/conformance) -SET(BASELINE_NR ${OPJ_DATA_ROOT}/baseline/nonregression) -SET(INPUT_CONF ${OPJ_DATA_ROOT}/input/conformance) +set(TEMP ${CMAKE_CURRENT_BINARY_DIR}/Temporary) +set(BASELINE_CONF ${OPJ_DATA_ROOT}/baseline/conformance) +set(BASELINE_NR ${OPJ_DATA_ROOT}/baseline/nonregression) +set(INPUT_CONF ${OPJ_DATA_ROOT}/input/conformance) -# List of components by file (normaly p0_13.j2k have 257 components but for this +# List of components by file (normaly p0_13.j2k have 257 components but for this #set of test we consider only 4) -SET( CP0_nbC_list "not_used;1;1;1;3;4;4;3;3;1;3;1;1;4;3;1;1") -SET( CP0_ignore_list "not_used;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0") -SET( CP1_nbC_list "not_used;1;3;4;1;3;3;2") -SET( CP1_ignore_list "not_used;0;0;0;0;0;0;0") +set( CP0_nbC_list "not_used;1;1;1;3;4;4;3;3;1;3;1;1;4;3;1;1") +set( CP1_nbC_list "not_used;1;3;4;1;3;3;2") -SET(COMMENTCODEVAR FALSE) +set(COMMENTCODEVAR FALSE) -#-------------------------------------------------------------------------- -# Tests about class 0 profile 0 -# try to decode -# compare to ref file provided by the Executable Test Suite -# non regression comparison +##-------------------------------------------------------------------------- +## Tests about class 0 profile 0 +## try to decode +## compare to ref file provided by the Executable Test Suite +## non regression comparison -# Parameters and tolerances given by Table C.1 -SET( C0P0_ResFactor_list "not_used;0;0;0;3;3;3;0;5;2;0;0;0;0;2;0;0") -SET( C0P0_PEAK_list "not_used;0;0;0;33;54;109;10;7;4;10;0;0;0;0;0;0") -SET( C0P0_MSE_list "not_used;0;0;0;55.8;68;743;0.34;6.72;1.47;2.84;0;0;0;0;0;0") +## Parameters and tolerances given by Table C.1 +#set( C0P0_ResFactor_list "not_used;0;0;0;3;3;3;0;5;2;0;0;0;0;2;0;0") +#set( C0P0_PEAK_list "not_used;0;0;0;33;54;109;10;7;4;10;0;0;0;0;0;0") +#set( C0P0_MSE_list "not_used;0;0;0;55.8;68;743;0.34;6.72;1.47;2.84;0;0;0;0;0;0") -FOREACH(numFileC0P0 RANGE 1 16) +#foreach(numFileC0P0 RANGE 1 16) -list(GET CP0_ignore_list ${numFileC0P0} ignore_test_value) -IF(ignore_test_value EQUAL 0) +# # Build filenames +# if(${numFileC0P0} LESS 10) +# set( filenameInput p0_0${numFileC0P0}.j2k ) +# set( filenameRef c0p0_0${numFileC0P0}.pgx ) +# else() +# set( filenameInput p0_${numFileC0P0}.j2k ) +# set( filenameRef c0p0_${numFileC0P0}.pgx ) +# endif() - # Build filenames - IF(${numFileC0P0} LESS 10) - SET( filenameInput p0_0${numFileC0P0}.j2k ) - SET( filenameRef c0p0_0${numFileC0P0}.pgx ) - ELSE(${numFileC0P0} LESS 10) - SET( filenameInput p0_${numFileC0P0}.j2k ) - SET( filenameRef c0p0_${numFileC0P0}.pgx ) - ENDIF(${numFileC0P0} LESS 10) - - # Get corresponding tests parameters - list(GET C0P0_ResFactor_list ${numFileC0P0} ResFactor) - #For Class-0 testing, we always focus on the first component only - #list(GET CP0_nbC_list ${numFileC0P0} nbComponents) - set( nbComponents "1") - list(GET C0P0_PEAK_list ${numFileC0P0} PEAK_limit) - list(GET C0P0_MSE_list ${numFileC0P0} MSE_limit) - - # Manage cases which need to try different resolution reduction - IF (numFileC0P0 EQUAL 3 OR numFileC0P0 EQUAL 15) - get_filename_component(filenameRefSub ${filenameRef} NAME_WE) - #r = 0 - - ADD_TEST(NAME ETS-C0P0-${filenameInput}-r0-decode - COMMAND j2k_to_image - -i ${INPUT_CONF}/${filenameInput} - -o ${TEMP}/c0${filenameInput}-r0.pgx - -r 0 - ) - - ADD_TEST(NAME ETS-C0P0-${filenameInput}-r0-compare2ref - COMMAND comparePGXimages - -b ${BASELINE_CONF}/${filenameRefSub}r0.pgx - -t ${TEMP}/c0${filenameInput}-r0.pgx - -n ${nbComponents} - -p ${PEAK_limit} - -m ${MSE_limit} - -s t_ - ) - - SET_TESTS_PROPERTIES(ETS-C0P0-${filenameInput}-r0-compare2ref - PROPERTIES DEPENDS - ETS-C0P0-${filenameInput}-r0-decode) - - ADD_TEST(NAME NR-C0P0-${filenameInput}-r0-compare2base - COMMAND comparePGXimages - -b ${BASELINE_NR}/opj_${filenameRefSub}-r0.pgx - -t ${TEMP}/c0${filenameInput}-r0.pgx - -n ${nbComponents} - -d - -s b_t_ - ) - - SET_TESTS_PROPERTIES(NR-C0P0-${filenameInput}-r0-compare2base - PROPERTIES DEPENDS - ETS-C0P0-${filenameInput}-r0-decode) - - #r = 1 - ADD_TEST(NAME ETS-C0P0-${filenameInput}-r1-decode - COMMAND j2k_to_image - -i ${INPUT_CONF}/${filenameInput} - -o ${TEMP}/c0${filenameInput}-r1.pgx - -r 1 - ) - - ADD_TEST(NAME ETS-C0P0-${filenameInput}-r1-compare2ref - COMMAND comparePGXimages - -b ${BASELINE_CONF}/${filenameRefSub}r1.pgx - -t ${TEMP}/c0${filenameInput}-r1.pgx - -n ${nbComponents} - -p ${PEAK_limit} - -m ${MSE_limit} - -s t_ - ) - - SET_TESTS_PROPERTIES(ETS-C0P0-${filenameInput}-r1-compare2ref - PROPERTIES DEPENDS - ETS-C0P0-${filenameInput}-r1-decode) - - ADD_TEST(NAME NR-C0P0-${filenameInput}-r1-compare2base - COMMAND comparePGXimages - -b ${BASELINE_NR}/opj_${filenameRefSub}-r1.pgx - -t ${TEMP}/c0${filenameInput}-r1.pgx - -n ${nbComponents} - -d - -s b_t_ - ) - - SET_TESTS_PROPERTIES(NR-C0P0-${filenameInput}-r1-compare2base - PROPERTIES DEPENDS - ETS-C0P0-${filenameInput}-r1-decode) +# # Get corresponding tests parameters +# list(GET C0P0_ResFactor_list ${numFileC0P0} ResFactor) +# #For Class-0 testing, we always focus on the first component only +# #list(GET CP0_nbC_list ${numFileC0P0} nbComponents) +# set( nbComponents "1") +# list(GET C0P0_PEAK_list ${numFileC0P0} PEAK_limit) +# list(GET C0P0_MSE_list ${numFileC0P0} MSE_limit) - ELSE(numFileC0P0 EQUAL 3 OR numFileC0P0 EQUAL 15) - - ADD_TEST(NAME ETS-C0P0-${filenameInput}-decode - COMMAND j2k_to_image - -i ${INPUT_CONF}/${filenameInput} - -o ${TEMP}/c0${filenameInput}.pgx - -r ${ResFactor} - ) - - ADD_TEST(NAME ETS-C0P0-${filenameInput}-compare2ref - COMMAND comparePGXimages - -b ${BASELINE_CONF}/${filenameRef} - -t ${TEMP}/c0${filenameInput}.pgx - -n ${nbComponents} - -p ${PEAK_limit} - -m ${MSE_limit} - -s t_ - ) - - SET_TESTS_PROPERTIES(ETS-C0P0-${filenameInput}-compare2ref - PROPERTIES DEPENDS - ETS-C0P0-${filenameInput}-decode) - - ADD_TEST(NAME NR-C0P0-${filenameInput}-compare2base - COMMAND comparePGXimages - -b ${BASELINE_NR}/opj_${filenameRef} - -t ${TEMP}/c0${filenameInput}.pgx - -n ${nbComponents} - -d - -s b_t_ - ) - - SET_TESTS_PROPERTIES(NR-C0P0-${filenameInput}-compare2base - PROPERTIES DEPENDS - ETS-C0P0-${filenameInput}-decode) - - ENDIF(numFileC0P0 EQUAL 3 OR numFileC0P0 EQUAL 15) - - ENDIF(ignore_test_value EQUAL 0) +# # Manage cases which need to try different resolution reduction +# if (numFileC0P0 EQUAL 3 OR numFileC0P0 EQUAL 15) +# get_filename_component(filenameRefSub ${filenameRef} NAME_WE) +# #r = 0 -ENDFOREACH(numFileC0P0) +# add_test(ETS-C0P0-${filenameInput}-r0-decode +# ${EXECUTABLE_OUTPUT_PATH}/j2k_to_image +# -i ${INPUT_CONF}/${filenameInput} +# -o ${TEMP}/c0${filenameInput}-r0.pgx +# -r 0 +# ) -#-------------------------------------------------------------------------- -# Tests about class 0 profile 1 -# try to decode -# compare to ref file -# non regression comparison +# add_test(ETS-C0P0-${filenameInput}-r0-compare2ref +# ${EXECUTABLE_OUTPUT_PATH}/compare_images +# -b ${BASELINE_CONF}/${filenameRefSub}r0.pgx +# -t ${TEMP}/c0${filenameInput}-r0.pgx +# -n ${nbComponents} +# -p ${PEAK_limit} +# -m ${MSE_limit} +# -s t_ +# ) -# Parameters and tolerances given by Table C.4 -SET( C0P1_ResFactor_list "not_used;0;3;3;0;4;1;0") -SET( C0P1_PEAK_list "not_used;0;35;28;2;128;128;0") -SET( C0P1_MSE_list "not_used;0;74;18.8;0.550;16384;16384;0") +# set_tests_properties(ETS-C0P0-${filenameInput}-r0-compare2ref +# PROPERTIES DEPENDS +# ETS-C0P0-${filenameInput}-r0-decode) -FOREACH(numFileC0P1 RANGE 1 7) +# add_test(NR-C0P0-${filenameInput}-r0-compare2base +# ${EXECUTABLE_OUTPUT_PATH}/compare_images +# -b ${BASELINE_NR}/opj_${filenameRefSub}-r0.pgx +# -t ${TEMP}/c0${filenameInput}-r0.pgx +# -n ${nbComponents} +# -d +# -s b_t_ +# ) -list(GET CP1_ignore_list ${numFileC0P1} ignore_test_value2) -IF(ignore_test_value2 EQUAL 0) +# set_tests_properties(NR-C0P0-${filenameInput}-r0-compare2base +# PROPERTIES DEPENDS +# ETS-C0P0-${filenameInput}-r0-decode) - # Build filenames - SET( filenameInput p1_0${numFileC0P1}.j2k ) - SET( filenameRef c0p1_0${numFileC0P1}.pgx ) +# #r = 1 +# add_test(ETS-C0P0-${filenameInput}-r1-decode +# ${EXECUTABLE_OUTPUT_PATH}/j2k_to_image +# -i ${INPUT_CONF}/${filenameInput} +# -o ${TEMP}/c0${filenameInput}-r1.pgx +# -r 1 +# ) - # Get corresponding tests parameters - list(GET C0P1_ResFactor_list ${numFileC0P1} ResFactor) - #For Class-0 testing, we always focus on the first component only - #list(GET CP0_nbC_list ${numFileC0P0} nbComponents) - set( nbComponents "1") - list(GET C0P1_PEAK_list ${numFileC0P1} PEAK_limit) - list(GET C0P1_MSE_list ${numFileC0P1} MSE_limit) +# add_test(ETS-C0P0-${filenameInput}-r1-compare2ref +# ${EXECUTABLE_OUTPUT_PATH}/compare_images +# -b ${BASELINE_CONF}/${filenameRefSub}r1.pgx +# -t ${TEMP}/c0${filenameInput}-r1.pgx +# -n ${nbComponents} +# -p ${PEAK_limit} +# -m ${MSE_limit} +# -s t_ +# ) - # Manage cases which need to try different resolution reduction - IF (numFileC0P1 EQUAL 4 ) - get_filename_component(filenameRefSub ${filenameRef} NAME_WE) - - #r = 0 - ADD_TEST(NAME ETS-C0P1-${filenameInput}-r0-decode - COMMAND j2k_to_image - -i ${INPUT_CONF}/${filenameInput} - -o ${TEMP}/c0${filenameInput}-r0.pgx - -r 0 - ) - - ADD_TEST(NAME ETS-C0P1-${filenameInput}-r0-compare2ref - COMMAND comparePGXimages - -b ${BASELINE_CONF}/${filenameRefSub}r0.pgx - -t ${TEMP}/c0${filenameInput}-r0.pgx - -n ${nbComponents} - -p ${PEAK_limit} - -m ${MSE_limit} - -s t_ - ) - - SET_TESTS_PROPERTIES(ETS-C0P1-${filenameInput}-r0-compare2ref - PROPERTIES DEPENDS - ETS-C0P1-${filenameInput}-r0-decode) - - ADD_TEST(NAME NR-C0P1-${filenameInput}-r0-compare2base - COMMAND comparePGXimages - -b ${BASELINE_NR}/opj_${filenameRefSub}-r0.pgx - -t ${TEMP}/c0${filenameInput}-r0.pgx - -n ${nbComponents} - -d - -s b_t_ - ) - - SET_TESTS_PROPERTIES(NR-C0P1-${filenameInput}-r0-compare2base - PROPERTIES DEPENDS - ETS-C0P1-${filenameInput}-r0-decode) - - #r = 3 - ADD_TEST(NAME ETS-C0P1-${filenameInput}-r3-decode - COMMAND j2k_to_image - -i ${INPUT_CONF}/${filenameInput} - -o ${TEMP}/c0${filenameInput}-r3.pgx - -r 3 - ) - - ADD_TEST(NAME ETS-C0P1-${filenameInput}-r3-compare2ref - COMMAND comparePGXimages - -b ${BASELINE_CONF}/${filenameRefSub}r3.pgx - -t ${TEMP}/c0${filenameInput}-r3.pgx - -n ${nbComponents} - -p ${PEAK_limit} - -m ${MSE_limit} - -s t_ - ) - - SET_TESTS_PROPERTIES(ETS-C0P1-${filenameInput}-r3-compare2ref - PROPERTIES DEPENDS - ETS-C0P1-${filenameInput}-r3-decode) - - ADD_TEST(NAME NR-C0P1-${filenameInput}-r3-compare2base - COMMAND comparePGXimages - -b ${BASELINE_NR}/opj_${filenameRefSub}-r3.pgx - -t ${TEMP}/c0${filenameInput}-r3.pgx - -n ${nbComponents} - -d - -s b_t_ - ) - - SET_TESTS_PROPERTIES(NR-C0P1-${filenameInput}-r3-compare2base - PROPERTIES DEPENDS - ETS-C0P1-${filenameInput}-r3-decode) - - ELSE(numFileC0P1 EQUAL 4) +# set_tests_properties(ETS-C0P0-${filenameInput}-r1-compare2ref +# PROPERTIES DEPENDS +# ETS-C0P0-${filenameInput}-r1-decode) - ADD_TEST(NAME ETS-C0P1-${filenameInput}-decode - COMMAND j2k_to_image - -i ${INPUT_CONF}/${filenameInput} - -o ${TEMP}/c0${filenameInput}.pgx - -r ${ResFactor} - ) - - ADD_TEST(NAME ETS-C0P1-${filenameInput}-compare2ref - COMMAND comparePGXimages - -b ${BASELINE_CONF}/${filenameRef} - -t ${TEMP}/c0${filenameInput}.pgx - -n ${nbComponents} - -p ${PEAK_limit} - -m ${MSE_limit} - -s t_ - ) - - SET_TESTS_PROPERTIES(ETS-C0P1-${filenameInput}-compare2ref - PROPERTIES DEPENDS - ETS-C0P1-${filenameInput}-decode) - - ADD_TEST(NAME NR-C0P1-${filenameInput}-compare2base - COMMAND comparePGXimages - -b ${BASELINE_NR}/opj_${filenameRef} - -t ${TEMP}/c0${filenameInput}.pgx - -n ${nbComponents} - -d - -s b_t_ - ) - - SET_TESTS_PROPERTIES(NR-C0P1-${filenameInput}-compare2base - PROPERTIES DEPENDS - ETS-C0P1-${filenameInput}-decode) - - ENDIF(numFileC0P1 EQUAL 4) - - ENDIF(ignore_test_value2 EQUAL 0) +# add_test(NR-C0P0-${filenameInput}-r1-compare2base +# ${EXECUTABLE_OUTPUT_PATH}/compare_images +# -b ${BASELINE_NR}/opj_${filenameRefSub}-r1.pgx +# -t ${TEMP}/c0${filenameInput}-r1.pgx +# -n ${nbComponents} +# -d +# -s b_t_ +# ) -ENDFOREACH(numFileC0P1) +# set_tests_properties(NR-C0P0-${filenameInput}-r1-compare2base +# PROPERTIES DEPENDS +# ETS-C0P0-${filenameInput}-r1-decode) + +# else() + +# add_test(ETS-C0P0-${filenameInput}-decode +# ${EXECUTABLE_OUTPUT_PATH}/j2k_to_image +# -i ${INPUT_CONF}/${filenameInput} +# -o ${TEMP}/c0${filenameInput}.pgx +# -r ${ResFactor} +# ) + +# add_test(ETS-C0P0-${filenameInput}-compare2ref +# ${EXECUTABLE_OUTPUT_PATH}/compare_images +# -b ${BASELINE_CONF}/${filenameRef} +# -t ${TEMP}/c0${filenameInput}.pgx +# -n ${nbComponents} +# -p ${PEAK_limit} +# -m ${MSE_limit} +# -s t_ +# ) + +# set_tests_properties(ETS-C0P0-${filenameInput}-compare2ref +# PROPERTIES DEPENDS +# ETS-C0P0-${filenameInput}-decode) + +# add_test(NR-C0P0-${filenameInput}-compare2base +# ${EXECUTABLE_OUTPUT_PATH}/compare_images +# -b ${BASELINE_NR}/opj_${filenameRef} +# -t ${TEMP}/c0${filenameInput}.pgx +# -n ${nbComponents} +# -d +# -s b_t_ +# ) + +# set_tests_properties(NR-C0P0-${filenameInput}-compare2base +# PROPERTIES DEPENDS +# ETS-C0P0-${filenameInput}-decode) + +# endif() + +#endforeach() + +##-------------------------------------------------------------------------- +## Tests about class 0 profile 1 +## try to decode +## compare to ref file +## non regression comparison + +## Parameters and tolerances given by Table C.4 +#set( C0P1_ResFactor_list "not_used;0;3;3;0;4;1;0") +#set( C0P1_PEAK_list "not_used;0;35;28;2;128;128;0") +#set( C0P1_MSE_list "not_used;0;74;18.8;0.550;16384;16384;0") + +#foreach(numFileC0P1 RANGE 1 7) + +# # Build filenames +# set( filenameInput p1_0${numFileC0P1}.j2k ) +# set( filenameRef c0p1_0${numFileC0P1}.pgx ) + +# # Get corresponding tests parameters +# list(GET C0P1_ResFactor_list ${numFileC0P1} ResFactor) +# #For Class-0 testing, we always focus on the first component only +# #list(GET CP0_nbC_list ${numFileC0P0} nbComponents) +# set( nbComponents "1") +# list(GET C0P1_PEAK_list ${numFileC0P1} PEAK_limit) +# list(GET C0P1_MSE_list ${numFileC0P1} MSE_limit) + +# # Manage cases which need to try different resolution reduction +# if (numFileC0P1 EQUAL 4 ) +# get_filename_component(filenameRefSub ${filenameRef} NAME_WE) + +# #r = 0 +# add_test(ETS-C0P1-${filenameInput}-r0-decode +# ${EXECUTABLE_OUTPUT_PATH}/j2k_to_image +# -i ${INPUT_CONF}/${filenameInput} +# -o ${TEMP}/c0${filenameInput}-r0.pgx +# -r 0 +# ) + +# add_test(ETS-C0P1-${filenameInput}-r0-compare2ref +# ${EXECUTABLE_OUTPUT_PATH}/compare_images +# -b ${BASELINE_CONF}/${filenameRefSub}r0.pgx +# -t ${TEMP}/c0${filenameInput}-r0.pgx +# -n ${nbComponents} +# -p ${PEAK_limit} +# -m ${MSE_limit} +# -s t_ +# ) + +# set_tests_properties(ETS-C0P1-${filenameInput}-r0-compare2ref +# PROPERTIES DEPENDS +# ETS-C0P1-${filenameInput}-r0-decode) + +# add_test(NR-C0P1-${filenameInput}-r0-compare2base +# ${EXECUTABLE_OUTPUT_PATH}/compare_images +# -b ${BASELINE_NR}/opj_${filenameRefSub}-r0.pgx +# -t ${TEMP}/c0${filenameInput}-r0.pgx +# -n ${nbComponents} +# -d +# -s b_t_ +# ) + +# set_tests_properties(NR-C0P1-${filenameInput}-r0-compare2base +# PROPERTIES DEPENDS +# ETS-C0P1-${filenameInput}-r0-decode) + +# #r = 3 +# add_test(ETS-C0P1-${filenameInput}-r3-decode +# ${EXECUTABLE_OUTPUT_PATH}/j2k_to_image +# -i ${INPUT_CONF}/${filenameInput} +# -o ${TEMP}/c0${filenameInput}-r3.pgx +# -r 3 +# ) + +# add_test(ETS-C0P1-${filenameInput}-r3-compare2ref +# ${EXECUTABLE_OUTPUT_PATH}/compare_images +# -b ${BASELINE_CONF}/${filenameRefSub}r3.pgx +# -t ${TEMP}/c0${filenameInput}-r3.pgx +# -n ${nbComponents} +# -p ${PEAK_limit} +# -m ${MSE_limit} +# -s t_ +# ) + +# set_tests_properties(ETS-C0P1-${filenameInput}-r3-compare2ref +# PROPERTIES DEPENDS +# ETS-C0P1-${filenameInput}-r3-decode) + +# add_test(NR-C0P1-${filenameInput}-r3-compare2base +# ${EXECUTABLE_OUTPUT_PATH}/compare_images +# -b ${BASELINE_NR}/opj_${filenameRefSub}-r3.pgx +# -t ${TEMP}/c0${filenameInput}-r3.pgx +# -n ${nbComponents} +# -d +# -s b_t_ +# ) + +# set_tests_properties(NR-C0P1-${filenameInput}-r3-compare2base +# PROPERTIES DEPENDS +# ETS-C0P1-${filenameInput}-r3-decode) + +# else() + +# add_test(ETS-C0P1-${filenameInput}-decode +# ${EXECUTABLE_OUTPUT_PATH}/j2k_to_image +# -i ${INPUT_CONF}/${filenameInput} +# -o ${TEMP}/c0${filenameInput}.pgx +# -r ${ResFactor} +# ) + +# add_test(ETS-C0P1-${filenameInput}-compare2ref +# ${EXECUTABLE_OUTPUT_PATH}/compare_images +# -b ${BASELINE_CONF}/${filenameRef} +# -t ${TEMP}/c0${filenameInput}.pgx +# -n ${nbComponents} +# -p ${PEAK_limit} +# -m ${MSE_limit} +# -s t_ +# ) + +# set_tests_properties(ETS-C0P1-${filenameInput}-compare2ref +# PROPERTIES DEPENDS +# ETS-C0P1-${filenameInput}-decode) + +# add_test(NR-C0P1-${filenameInput}-compare2base +# ${EXECUTABLE_OUTPUT_PATH}/compare_images +# -b ${BASELINE_NR}/opj_${filenameRef} +# -t ${TEMP}/c0${filenameInput}.pgx +# -n ${nbComponents} +# -d +# -s b_t_ +# ) + +# set_tests_properties(NR-C0P1-${filenameInput}-compare2base +# PROPERTIES DEPENDS +# ETS-C0P1-${filenameInput}-decode) + +# endif() + +#endforeach() #-------------------------------------------------------------------------- # Tests about class 1 profile 0 @@ -318,36 +306,36 @@ ENDFOREACH(numFileC0P1) # non regression comparison # Parameters and tolerances given by Table C.6 -SET( C1P0_ResFactor_list "not_used;0;0;0;0;0;0;0;1;0;0;0;0;0;0;0;0") -SET( C1P0_PEAK_list "not_used;0;0;0;5:4:6;2:2:2:0;635:403:378:0;0:0:0;0:0:0;0;0:0:0;0;0;0:0:0:0;0:0:0;0;0") -SET( C1P0_MSE_list "not_used;0;0;0;0.776:0.626:1.070;0.302:0.307:0.269:0;11287:6124:3968:0;0:0:0;0:0:0;0;0:0:0;0;0;0:0:0:0;0:0:0;0;0") +set( C1P0_ResFactor_list "not_used;0;0;0;0;0;0;0;1;0;0;0;0;0;0;0;0") +set( C1P0_PEAK_list "not_used;0;0;0;5:4:6;2:2:2:0;635:403:378:0;0:0:0;0:0:0;0;0:0:0;0;0;0:0:0:0;0:0:0;0;0") +set( C1P0_MSE_list "not_used;0;0;0;0.776:0.626:1.070;0.302:0.307:0.269:0;11287:6124:3968:0;0:0:0;0:0:0;0;0:0:0;0;0;0:0:0:0;0:0:0;0;0") -FOREACH(numFileC1P0 RANGE 1 16) +foreach(numFileC1P0 RANGE 1 16) # Build filenames - IF(${numFileC1P0} LESS 10) - SET( filenameInput p0_0${numFileC1P0}.j2k ) - SET( filenameRef c1p0_0${numFileC1P0}.pgx ) - ELSE(${numFileC1P0} LESS 10) - SET( filenameInput p0_${numFileC1P0}.j2k ) - SET( filenameRef c1p0_${numFileC1P0}.pgx ) - ENDIF(${numFileC1P0} LESS 10) - - # Get corresponding tests parameters + if(${numFileC1P0} LESS 10) + set( filenameInput p0_0${numFileC1P0}.j2k ) + set( filenameRef c1p0_0${numFileC1P0}.pgx ) + else() + set( filenameInput p0_${numFileC1P0}.j2k ) + set( filenameRef c1p0_${numFileC1P0}.pgx ) + endif() + + # Get corresponding tests parameters list(GET CP0_nbC_list ${numFileC1P0} nbComponents) list(GET C1P0_ResFactor_list ${numFileC1P0} ResFactor) list(GET C1P0_PEAK_list ${numFileC1P0} PEAK_limit) list(GET C1P0_MSE_list ${numFileC1P0} MSE_limit) - - ADD_TEST(NAME ETS-C1P0-${filenameInput}-decode - COMMAND j2k_to_image + + add_test(NAME ETS-C1P0-${filenameInput}-decode + COMMAND j2k_to_image -i ${INPUT_CONF}/${filenameInput} -o ${TEMP}/c1${filenameInput}.pgx -r ${ResFactor} ) - - ADD_TEST(NAME ETS-C1P0-${filenameInput}-compare2ref - COMMAND comparePGXimages + + add_test(NAME ETS-C1P0-${filenameInput}-compare2ref + COMMAND compare_images -b ${BASELINE_CONF}/${filenameRef} -t ${TEMP}/c1${filenameInput}.pgx -n ${nbComponents} @@ -355,27 +343,25 @@ FOREACH(numFileC1P0 RANGE 1 16) -m ${MSE_limit} -s b_t_ ) - - SET_TESTS_PROPERTIES(ETS-C1P0-${filenameInput}-compare2ref - PROPERTIES DEPENDS - ETS-C1P0-${filenameInput}-decode) - - ADD_TEST(NAME NR-C1P0-${filenameInput}-compare2base - COMMAND comparePGXimages + + set_tests_properties(ETS-C1P0-${filenameInput}-compare2ref + PROPERTIES DEPENDS + ETS-C1P0-${filenameInput}-decode) + + add_test(NAME NR-C1P0-${filenameInput}-compare2base + COMMAND compare_images -b ${BASELINE_NR}/opj_${filenameRef} -t ${TEMP}/c1${filenameInput}.pgx -n ${nbComponents} - -d + -d -s b_t_ ) - - SET_TESTS_PROPERTIES(NR-C1P0-${filenameInput}-compare2base - PROPERTIES DEPENDS - ETS-C1P0-${filenameInput}-decode) - - -ENDFOREACH(numFileC1P0) + set_tests_properties(NR-C1P0-${filenameInput}-compare2base + PROPERTIES DEPENDS + ETS-C1P0-${filenameInput}-decode) + +endforeach() #-------------------------------------------------------------------------- # Tests about class 1 profile 1 @@ -384,29 +370,29 @@ ENDFOREACH(numFileC1P0) # non regression comparison # Parameters and tolerances given by Table C.7 -SET( C1P1_PEAK_list "not_used;0;5:4:6;2:2:1:0;624;40:40:40;2:2:2;0:0") -SET( C1P1_MSE_list "not_used;0;0.765:0.616:1.051;0.3:0.210:0.200:0;3080;8.458:9.816:10.154;0.6:0.6:0.6;0:0") +set( C1P1_PEAK_list "not_used;0;5:4:6;2:2:1:0;624;40:40:40;2:2:2;0:0") +set( C1P1_MSE_list "not_used;0;0.765:0.616:1.051;0.3:0.210:0.200:0;3080;8.458:9.816:10.154;0.6:0.6:0.6;0:0") -FOREACH(numFileC1P1 RANGE 1 7) +foreach(numFileC1P1 RANGE 1 7) # Build filenames - SET( filenameInput p1_0${numFileC1P1}.j2k ) - SET( filenameRef c1p1_0${numFileC1P1}.pgx ) - + set( filenameInput p1_0${numFileC1P1}.j2k ) + set( filenameRef c1p1_0${numFileC1P1}.pgx ) + # Get corresponding tests parameters list(GET CP1_nbC_list ${numFileC1P1} nbComponents) list(GET C1P1_PEAK_list ${numFileC1P1} PEAK_limit) list(GET C1P1_MSE_list ${numFileC1P1} MSE_limit) - - ADD_TEST(NAME ETS-C1P1-${filenameInput}-decode - COMMAND j2k_to_image + + add_test(NAME ETS-C1P1-${filenameInput}-decode + COMMAND j2k_to_image -i ${INPUT_CONF}/${filenameInput} -o ${TEMP}/c1${filenameInput}.pgx -r 0 ) - - ADD_TEST(NAME ETS-C1P1-${filenameInput}-compare2ref - COMMAND comparePGXimages + + add_test(NAME ETS-C1P1-${filenameInput}-compare2ref + COMMAND compare_images -b ${BASELINE_CONF}/${filenameRef} -t ${TEMP}/c1${filenameInput}.pgx -n ${nbComponents} @@ -414,25 +400,25 @@ FOREACH(numFileC1P1 RANGE 1 7) -m ${MSE_limit} -s b_t_ ) - - SET_TESTS_PROPERTIES(ETS-C1P1-${filenameInput}-compare2ref - PROPERTIES DEPENDS + + set_tests_properties(ETS-C1P1-${filenameInput}-compare2ref + PROPERTIES DEPENDS ETS-C1P1-${filenameInput}-decode) - - ADD_TEST(NAME NR-C1P1-${filenameInput}-compare2base - COMMAND comparePGXimages + + add_test(NAME NR-C1P1-${filenameInput}-compare2base + COMMAND compare_images -b ${BASELINE_NR}/opj_${filenameRef} -t ${TEMP}/c1${filenameInput}.pgx -n ${nbComponents} - -d + -d -s b_t_ ) - - SET_TESTS_PROPERTIES(NR-C1P1-${filenameInput}-compare2base - PROPERTIES DEPENDS + + set_tests_properties(NR-C1P1-${filenameInput}-compare2base + PROPERTIES DEPENDS ETS-C1P1-${filenameInput}-decode) - -ENDFOREACH(numFileC1P1) + +endforeach() #-------------------------------------------------------------------------- # Tests about JP2 file @@ -440,48 +426,190 @@ ENDFOREACH(numFileC1P1) # compare to ref file # non regression comparison -# Tolerances given by Table G.1 +# Tolerances given by Part 4 - Table G.1 +# Peak is set to 4 only -FOREACH(numFileJP2 RANGE 1 9) +foreach(numFileJP2 RANGE 1 9) # Build filenames - SET( filenameInput "file${numFileJP2}.jp2" ) - SET( filenameRef jp2_${numFileJP2}.tif ) - - # Get corresponding tests parameters - list(GET JP2_PEAK_list ${numFileJP2} PEAK_limit) - - ADD_TEST(NAME ETS-JP2-${filenameInput}-decode - COMMAND j2k_to_image - -i ${INPUT_CONF}/${filenameInput} - -o ${TEMP}/${filenameInput}.tif - ) -# -# FIXME: Need to implement a compare tif images function -# -# ADD_TEST(NAME ETS-JP2-${filenameInput}-compare2ref -# COMMAND compareTIFimages -# -b ${BASELINE_CONF}/${filenameRef_tif} -# -t ${TEMP}/${filenameInput}.pgx -# -p 4 -# ) -# -# SET_TESTS_PROPERTIES(ETS-JP2-${filenameInput}-compare2ref -# PROPERTIES DEPENDS -# ETS-JP2-${filenameInput}-decode) -# -# ADD_TEST(NAME NR-JP2-${filenameInput}-compare2base -# COMMAND compareTIFimages -# -b ${BASELINE_NR}/opj_${filenameRef} -# -t ${TEMP}/${filenameInput}.tif -# -d -# ) -# -# SET_TESTS_PROPERTIES(NR-JP2-${filenameInput}-compare2base -# PROPERTIES DEPENDS -# ETS-JP2-${filenameInput}-decode) - -ENDFOREACH(numFileJP2) + set( filenameInput "file${numFileJP2}.jp2" ) + set( filenameRef jp2_${numFileJP2}.tif ) + + add_test(NAME ETS-JP2-${filenameInput}-decode + COMMAND j2k_to_image + -i ${INPUT_CONF}/${filenameInput} + -o ${TEMP}/${filenameInput}.tif + -p 8S + -force-rgb + ) + + add_test(NAME ETS-JP2-${filenameInput}-compare2ref + COMMAND compare_images + -b ${BASELINE_CONF}/${filenameRef} + -t ${TEMP}/${filenameInput}.tif + -n 3 + -p 4:4:4 + -m 1:1:1 + -s b_t_ + ) + + set_tests_properties(ETS-JP2-${filenameInput}-compare2ref + PROPERTIES DEPENDS + ETS-JP2-${filenameInput}-decode) + + add_test(NAME NR-JP2-${filenameInput}-compare2base + COMMAND compare_images + -b ${BASELINE_NR}/opj_${filenameRef} + -t ${TEMP}/${filenameInput}.tif + -n 3 + -d + -s b_t_ + ) + + set_tests_properties(NR-JP2-${filenameInput}-compare2base + PROPERTIES DEPENDS + ETS-JP2-${filenameInput}-decode) + +endforeach() + +#-------------------------------------------------------------------------- +# Tests about Kakadu/J2K file +# try to decode +# compare to ref file +# non regression comparison + +# Tolerances given by ??? + +set(kdu_j2k_conf_files + a1_mono + a2_colr + a3_mono + a4_colr + a5_mono + a6_mono_colr + b1_mono + b2_mono + b3_mono + c1_mono + c2_mono + d1_colr + d2_colr + e1_colr + e2_colr + f1_mono + f2_mono + g1_colr + g2_colr + g3_colr + g4_colr +) + +foreach(kdu_file ${kdu_j2k_conf_files}) + + # Build filenames + set( filenameInput "${kdu_file}.j2c" ) + set( filenameRef "${kdu_file}.ppm" ) + + if("${kdu_file}" STREQUAL "a6_mono_colr") + set(kdu_test_args -upsample -split-pnm ) + else() + set(kdu_test_args -upsample ) + endif() + + add_test(NAME ETS-KDU-${filenameInput}-decode + COMMAND j2k_to_image + -i ${INPUT_CONF}/${filenameInput} + -o ${TEMP}/${filenameInput}.ppm + ${kdu_test_args} + ) + + if("${kdu_file}" STREQUAL "a6_mono_colr") + set(kdu_test_args -n 4 -s b_t_ ) + set(kdu_test_args_tol -p 4:4:4:4 -m 1:1:1:1) + else() + set(kdu_test_args -n 1 ) + set(kdu_test_args_tol -p 4:4:4 -m 1:1:1) + endif() + + add_test(NAME ETS-KDU-${filenameInput}-compare2ref + COMMAND compare_images + -b ${BASELINE_CONF}/${filenameRef} + -t ${TEMP}/${filenameInput}.ppm + ${kdu_test_args} + ${kdu_test_args_tol} + ) + + set_tests_properties(ETS-KDU-${filenameInput}-compare2ref + PROPERTIES DEPENDS + ETS-KDU-${filenameInput}-decode) + + add_test(NAME NR-KDU-${filenameInput}-compare2base + COMMAND compare_images + -b ${BASELINE_NR}/opj_${filenameRef} + -t ${TEMP}/${filenameInput}.ppm + ${kdu_test_args} + -d + ) + + set_tests_properties(NR-KDU-${filenameInput}-compare2base + PROPERTIES DEPENDS + ETS-KDU-${filenameInput}-decode) +endforeach() + +#-------------------------------------------------------------------------- +# Tests about Richter/J2K file +# try to decode +# compare to ref file +# non regression comparison + +# Tolerances given by ??? + +set(richter_jp2_conf_files + subsampling_1 + subsampling_2 + zoo1 + zoo2 +) + +foreach(r_file ${richter_jp2_conf_files}) + + # Build filenames + set( filenameInput "${r_file}.jp2" ) + set( filenameRef "${r_file}.ppm" ) + + add_test(NAME ETS-RIC-${filenameInput}-decode + COMMAND j2k_to_image + -i ${INPUT_CONF}/${filenameInput} + -o ${TEMP}/${filenameInput}.ppm + ) + + set(ric_test_args -n 1) + + add_test(NAME ETS-RIC-${filenameInput}-compare2ref + COMMAND compare_images + -b ${BASELINE_CONF}/${filenameRef} + -t ${TEMP}/${filenameInput}.ppm + ${ric_test_args} + -p 4:4:4 + -m 2:2:2 + ) + + set_tests_properties(ETS-RIC-${filenameInput}-compare2ref + PROPERTIES DEPENDS + ETS-RIC-${filenameInput}-decode) + + add_test(NAME NR-RIC-${filenameInput}-compare2base + COMMAND compare_images + -b ${BASELINE_NR}/opj_${filenameRef} + -t ${TEMP}/${filenameInput}.ppm + ${ric_test_args} + -d + ) + + set_tests_properties(NR-RIC-${filenameInput}-compare2base + PROPERTIES DEPENDS + ETS-RIC-${filenameInput}-decode) +endforeach() #--------------------------------------------------------------------------# #--------------------------------------------------------------------------# @@ -492,89 +620,89 @@ ENDFOREACH(numFileJP2) # try to dump image and codestream informations into a file # non regression comparison this file to the baseline -FOREACH(numFileP0 RANGE 1 16) +foreach(numFileP0 RANGE 1 16) # Build filenames - IF(${numFileP0} LESS 10) - SET( filenameInput p0_0${numFileP0}.j2k ) - ELSE(${numFileP0} LESS 10) - SET( filenameInput p0_${numFileP0}.j2k ) - ENDIF(${numFileP0} LESS 10) + if(${numFileP0} LESS 10) + set( filenameInput p0_0${numFileP0}.j2k ) + else() + set( filenameInput p0_${numFileP0}.j2k ) + endif() get_filename_component(filenameRefSub ${filenameInput} NAME_WE) - ADD_TEST(NAME NR-${filenameInput}-dump + add_test(NAME NR-${filenameInput}-dump COMMAND j2k_dump -i ${INPUT_CONF}/${filenameInput} -o ${TEMP}/${filenameInput}.txt ) - - ADD_TEST(NAME NR-${filenameInput}-compare_dump2base + + add_test(NAME NR-${filenameInput}-compare_dump2base COMMAND compare_dump_files -b ${BASELINE_NR}/opj_${filenameRefSub}.txt -t ${TEMP}/${filenameInput}.txt ) - - SET_TESTS_PROPERTIES(NR-${filenameInput}-compare_dump2base - PROPERTIES DEPENDS + + set_tests_properties(NR-${filenameInput}-compare_dump2base + PROPERTIES DEPENDS NR-${filenameInput}-dump) - -ENDFOREACH(numFileP0) + +endforeach() #-------------------------------------------------------------------------- # Tests about dump of profile 1 file # try to dump image and codestream informations into a file # non regression comparison this file to the baseline -FOREACH(numFileP1 RANGE 1 7) +foreach(numFileP1 RANGE 1 7) # Build filenames - SET( filenameInput p1_0${numFileP1}.j2k ) + set( filenameInput p1_0${numFileP1}.j2k ) get_filename_component(filenameInputSub ${filenameInput} NAME_WE) - ADD_TEST(NAME NR-${filenameInput}-dump + add_test(NAME NR-${filenameInput}-dump COMMAND j2k_dump -i ${INPUT_CONF}/${filenameInput} -o ${TEMP}/${filenameInput}.txt ) - - ADD_TEST(NAME NR-${filenameInput}-compare_dump2base + + add_test(NAME NR-${filenameInput}-compare_dump2base COMMAND compare_dump_files -b ${BASELINE_NR}/opj_${filenameInputSub}.txt -t ${TEMP}/${filenameInput}.txt ) - - SET_TESTS_PROPERTIES(NR-${filenameInput}-compare_dump2base - PROPERTIES DEPENDS - NR-${filenameInput}-dump) - -ENDFOREACH(numFileP1) + + set_tests_properties(NR-${filenameInput}-compare_dump2base + PROPERTIES DEPENDS + NR-${filenameInput}-dump) + +endforeach() #-------------------------------------------------------------------------- # Tests about dump of JP2 file # try to dump image and codestream informations into a file # non regression comparison this file to the baseline -FOREACH(numFileJP2 RANGE 1 9) +foreach(numFileJP2 RANGE 1 9) # Build filenames - SET( filenameInput "file${numFileJP2}.jp2" ) + set( filenameInput "file${numFileJP2}.jp2" ) get_filename_component(filenameInputSub ${filenameInput} NAME_WE) - ADD_TEST(NAME NR-${filenameInput}-dump + add_test(NAME NR-${filenameInput}-dump COMMAND j2k_dump -i ${INPUT_CONF}/${filenameInput} -o ${TEMP}/${filenameInput}.txt ) - - ADD_TEST(NAME NR-${filenameInput}-compare_dump2base + + add_test(NAME NR-${filenameInput}-compare_dump2base COMMAND compare_dump_files -b ${BASELINE_NR}/opj_${filenameInputSub}.txt -t ${TEMP}/${filenameInput}.txt ) - - SET_TESTS_PROPERTIES(NR-${filenameInput}-compare_dump2base - PROPERTIES DEPENDS - NR-${filenameInput}-dump) - -ENDFOREACH(numFileJP2) + + set_tests_properties(NR-${filenameInput}-compare_dump2base + PROPERTIES DEPENDS + NR-${filenameInput}-dump) + +endforeach() diff --git a/tests/nonregression/CMakeLists.txt b/tests/nonregression/CMakeLists.txt index 434608a0..03ce1ea5 100644 --- a/tests/nonregression/CMakeLists.txt +++ b/tests/nonregression/CMakeLists.txt @@ -1,5 +1,7 @@ # NON-REGRESSION TESTS ON THIS DATASET LOCATED ${OPJ_DATA_ROOT}/input/nonregression +cmake_minimum_required(VERSION 2.8.7) + FILE(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/Temporary) SET(TEMP ${CMAKE_CURRENT_BINARY_DIR}/Temporary) @@ -8,12 +10,124 @@ SET(INPUT_NR ${OPJ_DATA_ROOT}/input/nonregression) SET(INPUT_NR_PATH ${INPUT_NR}) SET(TEMP_PATH ${TEMP}) +set(INPUT_CONF_PATH ${OPJ_DATA_ROOT}/input/conformance) # need kdu_expand if possible find_package(KAKADU) +# need jpylyzer if possible +find_package(JPYLYZER) ######################################################################### -# GENERATION OF THE TEST SUITE +# GENERATION OF THE TEST SUITE (DUMP) +# Dump all files with the selected extension inside the input directory + +# technically opj_dump should simply parse these one, since syntax is ok. +set(BLACKLIST_JPEG2000_TMP + 2539.pdf.SIGFPE.706.1712.jp2 + 0290cb77c5df21828fa74cf2ab2c84d8.SIGFPE.d25.31.jp2 + 26ccf3651020967f7778238ef5af08af.SIGFPE.d25.527.jp2 + 4035.pdf.SIGSEGV.d8b.3375.jp2 + 3635.pdf.asan.77.2930.jp2 + issue165.jp2 + #edf_c2_1103421.jp2 + edf_c2_1178956.jp2 + edf_c2_1000290.jp2 + #edf_c2_1000691.jp2 # ok + #edf_c2_20.jp2 #looks ok as per kdu_jp2info + edf_c2_1377017.jp2 + edf_c2_1002767.jp2 + #edf_c2_10025.jp2 + edf_c2_1000234.jp2 + edf_c2_225881.jp2 + edf_c2_1000671.jp2 + #edf_c2_1013627.jp2 # weird box, but kdu_jp2info ok + edf_c2_1015644.jp2 + edf_c2_101463.jp2 + edf_c2_1674177.jp2 + edf_c2_1673169.jp2 + issue429.jp2 + issue427-null-image-size.jp2 + issue427-illegal-tile-offset.jp2 + ) + +# Define a list of file which should be gracefully rejected: +set(BLACKLIST_JPEG2000 + ${BLACKLIST_JPEG2000_TMP} + broken1.jp2 + broken2.jp2 + broken3.jp2 + broken4.jp2 + gdal_fuzzer_assert_in_opj_j2k_read_SQcd_SQcc.patch.jp2 + gdal_fuzzer_check_comp_dx_dy.jp2 + gdal_fuzzer_check_number_of_tiles.jp2 + gdal_fuzzer_unchecked_numresolutions.jp2 + mem-b2ace68c-1381.jp2 + 1851.pdf.SIGSEGV.ce9.948.jp2 + 1888.pdf.asan.35.988.jp2 + issue362-2863.jp2 #kdu_jp2info ok + issue362-2866.jp2 + issue362-2894.jp2 + issue400.jp2 #kdu_jp2info ok + issue364-38.jp2 + issue364-903.jp2 #kdu_jp2info ok + issue393.jp2 #kdu_jp2info ok + issue408.jp2 #kdu_jp2info ok + issue420.jp2 #kdu_jp2info ok + 27ac957758a35d00d6765a0c86350d9c.SIGFPE.d25.537.jpc #kdu_jp2info crash + 3672da2f1f67bbecad27d7181b4e9d7c.SIGFPE.d25.805.jpc #kdu_jp2info crash + issue476.jp2 #kdu_jp2info ok + issue475.jp2 #kdu_jp2info ok + issue413.jp2 #kdu_jp2info ok + ) + +file(GLOB_RECURSE OPJ_DATA_NR_LIST + "${INPUT_NR}/*.j2k" + "${INPUT_NR}/*.j2c" + "${INPUT_NR}/*.jp2" + "${INPUT_NR}/*.jpc" + #"${INPUT_NR}/*.jpx" + ) + +foreach(INPUT_FILENAME ${OPJ_DATA_NR_LIST}) + get_filename_component(INPUT_FILENAME_NAME ${INPUT_FILENAME} NAME) + #get_filename_component(INPUT_FILENAME_NAME_WE ${INPUT_FILENAME_NAME} NAME_WE) + # cannot use longest extension function, since some name contains multiples + # dots. Instead write out own shortest extension function: + string(FIND ${INPUT_FILENAME_NAME} "." SHORTEST_EXT_POS REVERSE) + string(SUBSTRING ${INPUT_FILENAME_NAME} 0 ${SHORTEST_EXT_POS} INPUT_FILENAME_NAME_WE) + string(REGEX MATCH ${INPUT_FILENAME_NAME} bad_jpeg2000 ${BLACKLIST_JPEG2000}) + + # Dump the input image + add_test(NAME NR-${INPUT_FILENAME_NAME}-dump + COMMAND opj_dump + -i ${INPUT_FILENAME} + -o ${TEMP}/${INPUT_FILENAME_NAME}.txt + -v + ) + + if(bad_jpeg2000) + set_tests_properties(NR-${INPUT_FILENAME_NAME}-dump + PROPERTIES WILL_FAIL TRUE) + + else() + + # Compare the dump output with the baseline + add_test(NAME NR-${INPUT_FILENAME_NAME}-compare_dump2base + COMMAND compare_dump_files + -b ${BASELINE_NR}/opj_v2_${INPUT_FILENAME_NAME_WE}.txt + -t ${TEMP}/${INPUT_FILENAME_NAME}.txt + ) + + set_tests_properties(NR-${INPUT_FILENAME_NAME}-compare_dump2base + PROPERTIES DEPENDS + NR-${INPUT_FILENAME_NAME}-dump) + endif() + +endforeach() + + +######################################################################### +# GENERATION OF THE TEST SUITE (DECODE AND ENCODE) # Read one and more input file(s) (located in ${OPJ_DATA_ROOT}/input/nonregression) # to know which files processed and with which options. @@ -32,7 +146,8 @@ IF (TEST_SUITE_FILES) # Avoid to process the official test suite SET(FILE_ALREADY_READ 0) - STRING(REGEX MATCH "test_suite.ctest.in$" FILE_ALREADY_READ ${TEST_SUITE_FILE}) + get_filename_component(TEST_SUITE_FILENAME ${TEST_SUITE_FILE} NAME) + string(REGEX MATCH "^test_suite.ctest.in$" FILE_ALREADY_READ ${TEST_SUITE_FILENAME}) IF(NOT FILE_ALREADY_READ) # Configure the additional test suite file: @@ -56,6 +171,7 @@ ELSE(TEST_SUITE_FILES) ENDIF(TEST_SUITE_FILES) +set(nonregression_filenames_used) # Parse the command line found in the file(s) SET(IT_TEST_ENC 0) SET(IT_TEST_DEC 0) @@ -68,9 +184,12 @@ FOREACH(OPJ_TEST_CMD_LINE ${OPJ_TEST_CMD_LINE_LIST}) # Check if the first argument begin by the comment sign LIST(GET CMD_ARG_LIST 0 EXE_NAME) + + if(EXE_NAME) STRING(REGEX MATCH "^#" IGNORE_LINE_FOUND ${EXE_NAME}) + endif() - IF(IGNORE_LINE_FOUND) + if(IGNORE_LINE_FOUND OR NOT EXE_NAME) #MESSAGE( STATUS "Current line is ignored: ${OPJ_TEST_CMD_LINE}") @@ -81,7 +200,7 @@ FOREACH(OPJ_TEST_CMD_LINE ${OPJ_TEST_CMD_LINE_LIST}) STRING(REGEX MATCH "^!" FAILED_TEST_FOUND ${EXE_NAME}) IF (FAILED_TEST_FOUND) - # Manage the different cases with the failed sign to remove the first argument which must be image_to_j2k + # Manage the different cases with the failed sign to remove the first argument which must be opj_compress SET(FAILED_TEST_FOUND_1 0) STRING(REGEX MATCH "^!image_to_j2k$|^!j2k_to_image$" FAILED_TEST_FOUND_1 ${EXE_NAME}) @@ -210,7 +329,7 @@ FOREACH(OPJ_TEST_CMD_LINE ${OPJ_TEST_CMD_LINE_LIST}) # Compare the decoding file with baseline generated from the kdu_expand and baseline.j2k ADD_TEST(NAME NR-ENC-${INPUT_FILENAME_NAME}-${IT_TEST_ENC}-compare_dec-ref-out2base - COMMAND compareRAWimages + COMMAND compare_raw_files -b ${BASELINE_NR}/opj_${OUTPUT_FILENAME_NAME_WE}-ENC-${IT_TEST_ENC}.raw -t ${OUTPUT_FILENAME}.raw ) @@ -222,8 +341,47 @@ FOREACH(OPJ_TEST_CMD_LINE ${OPJ_TEST_CMD_LINE_LIST}) ENDIF() ENDIF(FAILED_TEST_FOUND) + # Test the encoded file is a valid JP2 file + if (JPYLYZER_EXECUTABLE) + if (${OUTPUT_FILENAME} MATCHES "\\.jp2$") + add_test(NAME NR-ENC-${INPUT_FILENAME_NAME}-${IT_TEST_ENC}-jpylyser + COMMAND ${JPYLYZER_EXECUTABLE} + ${OUTPUT_FILENAME} + ) + set_tests_properties(NR-ENC-${INPUT_FILENAME_NAME}-${IT_TEST_ENC}-jpylyser PROPERTIES + DEPENDS NR-ENC-${INPUT_FILENAME_NAME}-${IT_TEST_ENC}-encode + PASS_REGULAR_EXPRESSION "True" + ) + endif() + endif(JPYLYZER_EXECUTABLE) + + # If lossless compression (simple test is 4 arguments), decompress & compare + list(LENGTH CMD_ARG_LIST_2 ARG_COUNT) + if (ARG_COUNT EQUAL 4) + # can we compare with the input image ? + if (${INPUT_FILENAME_NAME} MATCHES "\\.tif$") + add_test(NAME NR-ENC-${INPUT_FILENAME_NAME}-${IT_TEST_ENC}-lossless-decode + COMMAND opj_decompress -i ${OUTPUT_FILENAME} -o ${OUTPUT_FILENAME}.lossless.tif + ) + set_tests_properties(NR-ENC-${INPUT_FILENAME_NAME}-${IT_TEST_ENC}-lossless-decode PROPERTIES + DEPENDS NR-ENC-${INPUT_FILENAME_NAME}-${IT_TEST_ENC}-encode + ) + add_test(NAME NR-ENC-${INPUT_FILENAME_NAME}-${IT_TEST_ENC}-lossless-compare + COMMAND compare_images -b ${INPUT_FILENAME} -t ${OUTPUT_FILENAME}.lossless.tif -n 1 -d + ) + set_tests_properties(NR-ENC-${INPUT_FILENAME_NAME}-${IT_TEST_ENC}-lossless-compare PROPERTIES + DEPENDS NR-ENC-${INPUT_FILENAME_NAME}-${IT_TEST_ENC}-lossless-decode + ) + endif() + endif() + endif() + # DECODER TEST SUITE - ELSE(ENC_TEST_FOUND) + else() + string(FIND ${INPUT_FILENAME} "nonregression" nr_pos) + if(${nr_pos} GREATER 0) + list(APPEND nonregression_filenames_used ${INPUT_FILENAME_NAME}) + endif() math(EXPR IT_TEST_DEC "${IT_TEST_DEC}+1" ) # Decode the input image @@ -240,13 +398,17 @@ FOREACH(OPJ_TEST_CMD_LINE ${OPJ_TEST_CMD_LINE_LIST}) # if not failed, check against registered md5: add_test(NAME NR-DEC-${INPUT_FILENAME_NAME}-${IT_TEST_DEC}-decode-md5 COMMAND ${CMAKE_COMMAND} -DREFFILE:STRING=${CMAKE_CURRENT_SOURCE_DIR}/md5refs.txt - -DFILENAME:STRING=${INPUT_FILENAME_NAME} + -DOUTFILENAME:STRING=${OUTPUT_FILENAME} -P ${CMAKE_CURRENT_SOURCE_DIR}/checkmd5refs.cmake) + set_tests_properties(NR-DEC-${INPUT_FILENAME_NAME}-${IT_TEST_DEC}-decode-md5 + PROPERTIES DEPENDS NR-DEC-${INPUT_FILENAME_NAME}-${IT_TEST_DEC}-decode + ) + # FIXME: add a compare2base function base on raw which # can output png diff files if necesary -# ADD_TEST(NAME NR-${filename}-compare2base -# COMMAND comparePGXimages +# add_test(NR-${filename}-compare2base +# ${EXECUTABLE_OUTPUT_PATH}/compare_images # -b ${BASELINE_NR}/opj_${filenameRef} # -t ${TEMP}/${filename}.pgx # -n ${nbComponents} @@ -258,30 +420,27 @@ FOREACH(OPJ_TEST_CMD_LINE ${OPJ_TEST_CMD_LINE_LIST}) # PROPERTIES DEPENDS # NR-${filename}-decode) - # Dump the input image - ADD_TEST(NAME NR-DEC-${INPUT_FILENAME_NAME}-${IT_TEST_DEC}-dump - COMMAND j2k_dump - -i ${INPUT_FILENAME} - -o ${TEMP}/${INPUT_FILENAME_NAME}.txt - ) + endif() - # Compare the dump output with the baseline - ADD_TEST(NAME NR-DEC-${INPUT_FILENAME_NAME}-${IT_TEST_DEC}-compare_dump2base - COMMAND compare_dump_files - -b ${BASELINE_NR}/opj_${INPUT_FILENAME_NAME_WE}.txt - -t ${TEMP}/${INPUT_FILENAME_NAME}.txt - ) + endif() - SET_TESTS_PROPERTIES(NR-DEC-${INPUT_FILENAME_NAME}-${IT_TEST_DEC}-compare_dump2base - PROPERTIES DEPENDS - NR-DEC-${INPUT_FILENAME_NAME}-${IT_TEST_DEC}-dump) + endif() +endforeach() - ENDIF(FAILED_TEST_FOUND) +set(existing_filenames) +foreach(f ${OPJ_DATA_NR_LIST}) + get_filename_component(ff ${f} NAME) + list(APPEND existing_filenames ${ff}) +endforeach() +if(existing_filenames) +list(REMOVE_ITEM existing_filenames ${nonregression_filenames_used}) +endif() - ENDIF(ENC_TEST_FOUND) - - ENDIF(IGNORE_LINE_FOUND) - -ENDFOREACH(OPJ_TEST_CMD_LINE) - +# keep track of new addition: +# if we reach here, then a J2K files was added but no test is present in +# test_suite.ctest.in: +foreach(found_but_no_test ${existing_filenames}) + add_test(NAME Found-But-No-Test-${found_but_no_test} COMMAND ${CMAKE_COMMAND} -E echo "${found_but_no_test}") + set_tests_properties(Found-But-No-Test-${found_but_no_test} PROPERTIES WILL_FAIL TRUE) +endforeach() diff --git a/tests/pdf2jp2.c b/tests/pdf2jp2.c new file mode 100644 index 00000000..38aa739f --- /dev/null +++ b/tests/pdf2jp2.c @@ -0,0 +1,142 @@ +/* + * Copyright (c) 2014, Mathieu Malaterre + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * Extract all JP2 files contained within a PDF file. + * + * Technically you could simply use mutool, eg: + * + * $ mutool show -be -o obj58.jp2 Bug691816.pdf 58 + * + * to extract a given JP2 file from within a PDF + * However it happens sometimes that the PDF is itself corrupted, this tools is + * a lame PDF parser which only extract stream contained in JPXDecode box + * only work on linux since I need memmem function + */ + +/* + * Add support for other signatures: + * + * obj<>stream + */ +#define _GNU_SOURCE +#include +#include +#include +#include + +int main(int argc, char *argv[]) +{ +#define NUMJP2 32 + int i, c = 0; + long offets[NUMJP2]; + char buffer[512]; +#define BUFLEN 4096 + int cont = 1; + FILE *f; + size_t nread; + char haystack[BUFLEN]; + const char needle[] = "JPXDecode"; + + const size_t nlen = strlen( needle ); + const size_t flen = BUFLEN - nlen; + char *fpos = haystack + nlen; + const char *filename; + if( argc < 2 ) return 1; + + filename = argv[1]; + + memset( haystack, 0, nlen ); + + f = fopen( filename, "rb" ); + while( cont ) + { + const char *ret; + size_t hlen; + nread = fread(fpos, 1, flen, f); + hlen = nlen + nread; + ret = memmem( haystack, hlen, needle, nlen); + if( ret ) + { + const long cpos = ftell(f); + const ptrdiff_t diff = ret - haystack; + assert( diff >= 0 ); + /*fprintf( stdout, "Found it: %lx\n", (ptrdiff_t)cpos - (ptrdiff_t)hlen + diff);*/ + offets[c++] = (ptrdiff_t)cpos - (ptrdiff_t)hlen + diff; + } + cont = (nread == flen); + memcpy( haystack, haystack + nread, nlen ); + } + + assert( feof( f ) ); + + for( i = 0; i < c; ++i ) + { + int s, len = 0; + char *r; + const int ret = fseek(f, offets[i], SEEK_SET); + assert( ret == 0 ); + r = fgets(buffer, sizeof(buffer), f); + assert( r ); + /*fprintf( stderr, "DEBUG: %s", r );*/ + s = sscanf(r, "JPXDecode]/Length %d/Width %*d/BitsPerComponent %*d/Height %*d", &len); + if( s == 0 ) + { // try again harder + const int ret = fseek(f, offets[i] - 40, SEEK_SET); // 40 is magic number + assert( ret == 0 ); + r = fgets(buffer, sizeof(buffer), f); + assert( r ); + const char needle2[] = "/Length"; + char * s2 = strstr(buffer, needle2); + s = sscanf(s2, "/Length %d/", &len); + } + if( s == 1 ) + { + FILE *jp2; + int j; + char jp2fn[512]; + sprintf( jp2fn, "%s.%d.jp2", filename, i ); + jp2 = fopen( jp2fn, "wb" ); + for( j = 0; j < len; ++j ) + { + int v = fgetc(f); + int ret2 = fputc(v, jp2); + assert( ret2 != EOF ); + } + fclose( jp2 ); +#if 0 + /* TODO need to check we reached endstream */ + r = fgets(buffer, sizeof(buffer), f); + fprintf( stderr, "DEBUG: [%s]", r ); + r = fgets(buffer, sizeof(buffer), f); + fprintf( stderr, "DEBUG: [%s]", r ); +#endif + } + } + fclose(f); + + return 0; +} diff --git a/tests/ppm2rgb3.c b/tests/ppm2rgb3.c new file mode 100644 index 00000000..58e7102c --- /dev/null +++ b/tests/ppm2rgb3.c @@ -0,0 +1,139 @@ +/* + * Copyright (c) 2014, Mathieu Malaterre + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * Technically on UNIX, one can simply call `ppmtorgb3`, but on my system it + * did not work. So I had to write my own. + */ + +#include /* fprintf */ +#include /* strcmp */ +#include /* malloc */ + +static const char magic[] = "P6"; + +static int readheader( FILE *ppm, int *X, int *Y, int *bpp ) +{ + char buffer[256]; + char strbuffer[256]; + char *line; + int n; + + *X = *Y = *bpp = 0; + + line = fgets(buffer, sizeof(buffer), ppm); + if( !line ) return 0; + n = sscanf(buffer, "%255[^\r\n]", strbuffer); + if( n != 1 ) return 0; + if( strcmp(strbuffer, magic ) != 0 ) return 0; + + /* skip comments */ + while( fgets(buffer, sizeof(buffer), ppm) && *buffer == '#' ) + { + } + n = sscanf(buffer, "%d %d", X,Y); + if( n != 2 ) return 0; + line = fgets(buffer, sizeof(buffer), ppm); + if( !line ) return 0; + n = sscanf(buffer, "%d", bpp); + if( n != 1 ) return 0; + if( *bpp != 255 ) return 0; + + return 1; +} + +static int writeoutput( const char *fn, FILE *ppm, int X, int Y, int bpp ) +{ + FILE *outf[] = {NULL, NULL, NULL}; + int i, x, y = 0; + char outfn[256]; + static const char *exts[3] = { + "red", + "grn", + "blu" + }; + char *image_line = NULL; + int ok = 0; + + /* write single comp as PGM: P5 */ + for( i = 0; i < 3; ++i ) + { +#ifdef _MSC_VER +#define snprintf _snprintf /* Visual Studio */ +#endif + snprintf( outfn, sizeof(outfn), "%s.%s.pgm", fn, exts[i] ); + outf[i] = fopen( outfn, "wb" ); + if( !outf[i] ) goto cleanup; + /* write header */ + fprintf( outf[i], "P5\n" ); + fprintf( outf[i], "%d %d\n", X, Y ); + fprintf( outf[i], "%d\n", bpp ); + } + + /* write pixel data */ + image_line = (char*)malloc( (size_t)X * 3 * sizeof(char) ); + if( !image_line ) goto cleanup; + while( fread(image_line, sizeof(char), (size_t)X * 3, ppm) == (size_t)X * 3 ) + { + for( x = 0; x < X; ++x ) + for( i = 0; i < 3; ++i ) + if( fputc( image_line[3*x+i], outf[i] ) == EOF ) goto cleanup; + ++y; + } + if( y == Y ) + ok = 1; +cleanup: + free(image_line); + for( i = 0; i < 3; ++i ) + if( outf[i] ) fclose( outf[i] ); + + return ok; +} + +int main(int argc, char *argv[]) +{ + const char *fn; + FILE *ppm = NULL; + int X, Y, bpp; + int ok = 0; + + if( argc < 2 ) + { + fprintf( stderr, "%s input.ppm\n", argv[0] ); + goto cleanup; + } + fn = argv[1]; + ppm = fopen( fn, "rb" ); + + if( !readheader( ppm, &X, &Y, &bpp ) ) goto cleanup; + + if( !writeoutput(fn, ppm, X, Y, bpp ) ) goto cleanup; + + ok = 1; +cleanup: + if(ppm) fclose(ppm); + return ok ? EXIT_SUCCESS : EXIT_FAILURE; +} diff --git a/tests/unit/testempty0.c b/tests/unit/testempty0.c new file mode 100644 index 00000000..09850604 --- /dev/null +++ b/tests/unit/testempty0.c @@ -0,0 +1,7 @@ +#include "openjpeg.h" + +int main(int argc, char **argv) { + (void)argc; + (void)argv; + return 0; +}