diff --git a/REAPER/CMakeLists.txt b/REAPER/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..58d95b6e17b5f45223f8c2654913c4f05b4e004d --- /dev/null +++ b/REAPER/CMakeLists.txt @@ -0,0 +1,39 @@ +cmake_minimum_required(VERSION 2.8) +project(Reaper) + +# Use C11 for unique_ptr +include(CheckCXXCompilerFlag) +CHECK_CXX_COMPILER_FLAG("-std=c++11" COMPILER_SUPPORTS_CXX11) +CHECK_CXX_COMPILER_FLAG("-std=c++0x" COMPILER_SUPPORTS_CXX0X) +if(COMPILER_SUPPORTS_CXX11) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11") +elseif(COMPILER_SUPPORTS_CXX0X) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x") +else() + message(STATUS "The compiler ${CMAKE_CXX_COMPILER} has no C++11 support. Please use a different C++ compiler.") +endif() + +include_directories(".") + +# Core functionality. +add_library(core STATIC core/file_resource.h + core/file_resource.cc core/float_matrix.h + core/float_matrix-inl.h core/float_matrix.cc core/track.h + core/track.cc) + +# Wave functionality. +add_library(wave STATIC wave/codec_riff.h wave/codec_riff.cc + wave/codec_api.h wave/codec_api-inl.h wave/wave.h wave/wave.cc + wave/wave_io.h wave/wave_io-inl.h wave/wave_io.cc) + +# Epoch tracker. +add_library(epoch_tracker STATIC epoch_tracker/fft.h epoch_tracker/fft.cc + epoch_tracker/fd_filter.h epoch_tracker/fd_filter.cc + epoch_tracker/lpc_analyzer.cc epoch_tracker/lpc_analyzer.h + epoch_tracker/epoch_tracker.cc epoch_tracker/epoch_tracker.h) + +# Binary to extract F0. +add_executable(reaper epoch_tracker_main.cc) +target_link_libraries(wave core) +target_link_libraries(epoch_tracker wave) +target_link_libraries(reaper epoch_tracker) diff --git a/REAPER/CONTRIBUTING.md b/REAPER/CONTRIBUTING.md new file mode 100644 index 0000000000000000000000000000000000000000..d6508261ad2c3fde4ddcf166eeb88af62a31abc5 --- /dev/null +++ b/REAPER/CONTRIBUTING.md @@ -0,0 +1,13 @@ +Anyone contributing code must sign a Contributor License Agreement. + +Individual contributors can complete the Individual Contributor +License Agreement online: + +https://developers.google.com/open-source/cla/individual + +If you are contributing on behalf of a corporation, fill out the +Corporate Contributor License Agreement and send it in as described on +this page: + +https://developers.google.com/open-source/cla/corporate + diff --git a/REAPER/LICENSE b/REAPER/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..d645695673349e3947e8e5ae42332d0ac3164cd7 --- /dev/null +++ b/REAPER/LICENSE @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/REAPER/README.md b/REAPER/README.md new file mode 100644 index 0000000000000000000000000000000000000000..fa3b441cc5f806260a9c582bf11cdfae171c6214 --- /dev/null +++ b/REAPER/README.md @@ -0,0 +1,159 @@ +# REAPER: Robust Epoch And Pitch EstimatoR + +This is a speech processing system. The _reaper_ program uses the +EpochTracker class to simultaneously estimate the location of +voiced-speech "epochs" or glottal closure instants (GCI), voicing +state (voiced or unvoiced) and fundamental frequency (F0 or "pitch"). +We define the local (instantaneous) F0 as the inverse of the time +between successive GCI. + +This code was developed by David Talkin at Google. This is not an +official Google product (experimental or otherwise), it is just +code that happens to be owned by Google. + +## Downloading and Building _reaper_ +``` +cd convenient_place_for_repository +git clone https://github.com/google/REAPER.git +cd REAPER +mkdir build # In the REAPER top-level directory +cd build +cmake .. +make +``` + +_reaper_ will now be in `convenient_place_for_repository/REAPER/build/reaper` + +You may want to add that path to your PATH environment variable or +move _reaper_ to your favorite bin repository. + +Example: + +To compute F0 (pitch) and pitchmark (GCI) tracks and write them out as ASCII files: + +`reaper -i /tmp/bla.wav -f /tmp/bla.f0 -p /tmp/bla.pm -a` + + +## Input Signals: + +As written, the input stage expects 16-bit, signed integer samples. +Any reasonable sample rate may be used, but rates below 16 kHz will +introduce increasingly coarse quantization of the results, and higher +rates will incur quadratic increase in computational requirements +without gaining much in output accuracy. + +While REAPER is fairly robust to recording quality, it is designed for +use with studio-quality speech signals, such as those recorded for +concatenation text-to-speech systems. Phase distortion, such as that +introduced by some close-talking microphones or by well-intended +recording-studio filtering, including rumble removal, should be +avoided, for best results. A rumble filter is provided within REAPER +as the recommended (default) high-pass pre-filtering option, and is +implemented as a symmetric FIR filter that introduces no phase +distortion. + +The help text _(-h)_ provided by the _reaper_ program describes +various output options, including debug output of some of the feature +signals. Of special interest is the residual waveform which may be +used to check for the expected waveshape. (The residual has a +_.resid_ filename extension.) During non-nasalized, open vocal tract +vocalizations (such as /a/), each period should show a somewhat noisy +version of the derivative of the idealized glottal flow. If the computed +residual deviates radically from this ideal, the Hilbert transform +option _(-t)_ might improve matters. + +## The REAPER Algorithm: + +The process can be broken down into the following phases: +* Signal Conditioning +* Feature Extraction +* Lattice Generation +* Dynamic Programming +* Backtrace and Output Generation + + +## Signal Conditioning + +DC bias and low-frequency noise are removed by high-pass filtering, +and the signal is converted to floating point. If the input is known +to have phase distortion that is impacting tracker performance, a +Hilbert transform, optionally done at this point, may improve +performance. + + +## Feature Extraction + +The following feature signals are derived from the conditioned input: +* Linear Prediction residual: + This is computed using the autocorrelation method and continuous + interpolation of the filter coefficients. It is checked for the + expected polarity (negative impulses), and inverted, if necessary. +* Amplitude-normalized prediction residual: + The normalization factor is based on the running, local RMS. +* Pseudo-probability of voicing: + This is based on a local measure of low-frequency energy normalized + by the peak energy in the utterance. +* Pseudo-probability of voicing onset: + Based on a forward delta of lowpassed energy. +* Pseudo-probability of voicing offset: + Based on a backward delta of lowpassed energy. +* Graded GCI candidates: + Each negative peak in the normalized residual is compared with the + local RMS. Peaks exceeding a threshold are selected as GCI candidates, + and then graded by a weighted combination of peak amplitude, skewness, + and sharpness. Each of the resulting candidates is associated with the + other feature values that occur closest in time to the candidate. +* Normalized cross-correlation functions (NCCF) for each GCI candidate: + The correlations are computed on a weighted combination of the speech + signal and its LP residual. The correlation reference window for + each GCI candidate impulse is centered on the inpulse, and + correlations are computed for all lags in the expected pitch period range. + + +## Lattice Generation + +Each GCI candidate (pulse) is set into a lattice structure that links +preceding and following pulses that occur within minimum and maximum +pitch period limits that are being considered for the utterance. +These links establish all of the period hypotheses that will be +considered for the pulse. Each hypothesis is scored on "local" +evidence derived from the NCCF and peak quality measures. Each pulse +is also assigned an unvoiced hypothesis, which is also given a score +based on the available local evidence. The lattice is checked, and +modified, if necessary to ensure that each pulse has at least one +voiced and one unvoiced hypothesis preceding and following it, to +maintain continuity for the dynamic programming to follow. +(Note that the "scores" are used as costs during dynamic programming, +so that low scores encourage selection of hypotheses.) + + +## Dynamic Programming + +``` +For each pulse in the utterance: + For each period hypotheses following the pulse: + For each period hypothesis preceding the pulse: + Score the transition cost of connecting the periods. Choose the + minimum overall cost (cumulative+local+transition) preceding + period hypothesis, and save its cost and a backpointer to it. + The costs of making a voicing state change are modulated by the + probability of voicing onset and offset. The cost of + voiced-to-voiced transition is based on the delta F0 that + occurs, and the cost of staying in the unvoiced state is a + constant system parameter. +``` + +## Backtrace and Output Generation + +Starting at the last peak in the utterance, the lowest cost period +candidate ending on that peak is found. This is the starting point +for backtracking. The backpointers to the best preceding period +candidates are then followed backwards through the utterance. As each +"best candidate" is found, the time location of the terminal peak is +recorded, along with the F0 corresponding to the period, or 0.0 if the +candidate is unvoiced. Instead of simply taking the inverse of the +period between GCI estimates as F0, the system refers back to the NCCF +for that GCI, and takes the location of the NCCF maximum closest to +the GCI-based period as the actual period. The output array of F0 and +estimated GCI location is then time-reversed for final output. + diff --git a/REAPER/build/CMakeCache.txt b/REAPER/build/CMakeCache.txt new file mode 100644 index 0000000000000000000000000000000000000000..3cab4225a4431b4d3399532afe6286ac8f7d0356 --- /dev/null +++ b/REAPER/build/CMakeCache.txt @@ -0,0 +1,389 @@ +# This is the CMakeCache file. +# For build in directory: /content/NeuCoSVC-2/REAPER/build +# It was generated by CMake: /usr/local/lib/python3.10/dist-packages/cmake/data/bin/cmake +# You can edit this file to change values found and used by cmake. +# If you do not want to change any of the values, simply exit the editor. +# If you do want to change a value, simply edit, save, and exit the editor. +# The syntax for the file is as follows: +# KEY:TYPE=VALUE +# KEY is the name of a variable in the cache. +# TYPE is a hint to GUIs for the type of VALUE, DO NOT EDIT TYPE!. +# VALUE is the current value for the KEY. + +######################## +# EXTERNAL cache entries +######################## + +//Path to a program. +CMAKE_ADDR2LINE:FILEPATH=/usr/bin/addr2line + +//Path to a program. +CMAKE_AR:FILEPATH=/usr/bin/ar + +//Choose the type of build, options are: None Debug Release RelWithDebInfo +// MinSizeRel ... +CMAKE_BUILD_TYPE:STRING= + +//Enable/Disable color output during build. +CMAKE_COLOR_MAKEFILE:BOOL=ON + +//CXX compiler +CMAKE_CXX_COMPILER:FILEPATH=/usr/bin/c++ + +//A wrapper around 'ar' adding the appropriate '--plugin' option +// for the GCC compiler +CMAKE_CXX_COMPILER_AR:FILEPATH=/usr/bin/gcc-ar-11 + +//A wrapper around 'ranlib' adding the appropriate '--plugin' option +// for the GCC compiler +CMAKE_CXX_COMPILER_RANLIB:FILEPATH=/usr/bin/gcc-ranlib-11 + +//Flags used by the CXX compiler during all build types. +CMAKE_CXX_FLAGS:STRING= + +//Flags used by the CXX compiler during DEBUG builds. +CMAKE_CXX_FLAGS_DEBUG:STRING=-g + +//Flags used by the CXX compiler during MINSIZEREL builds. +CMAKE_CXX_FLAGS_MINSIZEREL:STRING=-Os -DNDEBUG + +//Flags used by the CXX compiler during RELEASE builds. +CMAKE_CXX_FLAGS_RELEASE:STRING=-O3 -DNDEBUG + +//Flags used by the CXX compiler during RELWITHDEBINFO builds. +CMAKE_CXX_FLAGS_RELWITHDEBINFO:STRING=-O2 -g -DNDEBUG + +//C compiler +CMAKE_C_COMPILER:FILEPATH=/usr/bin/cc + +//A wrapper around 'ar' adding the appropriate '--plugin' option +// for the GCC compiler +CMAKE_C_COMPILER_AR:FILEPATH=/usr/bin/gcc-ar-11 + +//A wrapper around 'ranlib' adding the appropriate '--plugin' option +// for the GCC compiler +CMAKE_C_COMPILER_RANLIB:FILEPATH=/usr/bin/gcc-ranlib-11 + +//Flags used by the C compiler during all build types. +CMAKE_C_FLAGS:STRING= + +//Flags used by the C compiler during DEBUG builds. +CMAKE_C_FLAGS_DEBUG:STRING=-g + +//Flags used by the C compiler during MINSIZEREL builds. +CMAKE_C_FLAGS_MINSIZEREL:STRING=-Os -DNDEBUG + +//Flags used by the C compiler during RELEASE builds. +CMAKE_C_FLAGS_RELEASE:STRING=-O3 -DNDEBUG + +//Flags used by the C compiler during RELWITHDEBINFO builds. +CMAKE_C_FLAGS_RELWITHDEBINFO:STRING=-O2 -g -DNDEBUG + +//Path to a program. +CMAKE_DLLTOOL:FILEPATH=CMAKE_DLLTOOL-NOTFOUND + +//Flags used by the linker during all build types. +CMAKE_EXE_LINKER_FLAGS:STRING= + +//Flags used by the linker during DEBUG builds. +CMAKE_EXE_LINKER_FLAGS_DEBUG:STRING= + +//Flags used by the linker during MINSIZEREL builds. +CMAKE_EXE_LINKER_FLAGS_MINSIZEREL:STRING= + +//Flags used by the linker during RELEASE builds. +CMAKE_EXE_LINKER_FLAGS_RELEASE:STRING= + +//Flags used by the linker during RELWITHDEBINFO builds. +CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO:STRING= + +//Enable/Disable output of compile commands during generation. +CMAKE_EXPORT_COMPILE_COMMANDS:BOOL= + +//Value Computed by CMake. +CMAKE_FIND_PACKAGE_REDIRECTS_DIR:STATIC=/content/NeuCoSVC-2/REAPER/build/CMakeFiles/pkgRedirects + +//Install path prefix, prepended onto install directories. +CMAKE_INSTALL_PREFIX:PATH=/usr/local + +//Path to a program. +CMAKE_LINKER:FILEPATH=/usr/bin/ld + +//Path to a program. +CMAKE_MAKE_PROGRAM:FILEPATH=/usr/bin/gmake + +//Flags used by the linker during the creation of modules during +// all build types. +CMAKE_MODULE_LINKER_FLAGS:STRING= + +//Flags used by the linker during the creation of modules during +// DEBUG builds. +CMAKE_MODULE_LINKER_FLAGS_DEBUG:STRING= + +//Flags used by the linker during the creation of modules during +// MINSIZEREL builds. +CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL:STRING= + +//Flags used by the linker during the creation of modules during +// RELEASE builds. +CMAKE_MODULE_LINKER_FLAGS_RELEASE:STRING= + +//Flags used by the linker during the creation of modules during +// RELWITHDEBINFO builds. +CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO:STRING= + +//Path to a program. +CMAKE_NM:FILEPATH=/usr/bin/nm + +//Path to a program. +CMAKE_OBJCOPY:FILEPATH=/usr/bin/objcopy + +//Path to a program. +CMAKE_OBJDUMP:FILEPATH=/usr/bin/objdump + +//Value Computed by CMake +CMAKE_PROJECT_DESCRIPTION:STATIC= + +//Value Computed by CMake +CMAKE_PROJECT_HOMEPAGE_URL:STATIC= + +//Value Computed by CMake +CMAKE_PROJECT_NAME:STATIC=Reaper + +//Path to a program. +CMAKE_RANLIB:FILEPATH=/usr/bin/ranlib + +//Path to a program. +CMAKE_READELF:FILEPATH=/usr/bin/readelf + +//Flags used by the linker during the creation of shared libraries +// during all build types. +CMAKE_SHARED_LINKER_FLAGS:STRING= + +//Flags used by the linker during the creation of shared libraries +// during DEBUG builds. +CMAKE_SHARED_LINKER_FLAGS_DEBUG:STRING= + +//Flags used by the linker during the creation of shared libraries +// during MINSIZEREL builds. +CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL:STRING= + +//Flags used by the linker during the creation of shared libraries +// during RELEASE builds. +CMAKE_SHARED_LINKER_FLAGS_RELEASE:STRING= + +//Flags used by the linker during the creation of shared libraries +// during RELWITHDEBINFO builds. +CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO:STRING= + +//If set, runtime paths are not added when installing shared libraries, +// but are added when building. +CMAKE_SKIP_INSTALL_RPATH:BOOL=NO + +//If set, runtime paths are not added when using shared libraries. +CMAKE_SKIP_RPATH:BOOL=NO + +//Flags used by the linker during the creation of static libraries +// during all build types. +CMAKE_STATIC_LINKER_FLAGS:STRING= + +//Flags used by the linker during the creation of static libraries +// during DEBUG builds. +CMAKE_STATIC_LINKER_FLAGS_DEBUG:STRING= + +//Flags used by the linker during the creation of static libraries +// during MINSIZEREL builds. +CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL:STRING= + +//Flags used by the linker during the creation of static libraries +// during RELEASE builds. +CMAKE_STATIC_LINKER_FLAGS_RELEASE:STRING= + +//Flags used by the linker during the creation of static libraries +// during RELWITHDEBINFO builds. +CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO:STRING= + +//Path to a program. +CMAKE_STRIP:FILEPATH=/usr/bin/strip + +//Path to a program. +CMAKE_TAPI:FILEPATH=CMAKE_TAPI-NOTFOUND + +//If this value is on, makefiles will be generated without the +// .SILENT directive, and all commands will be echoed to the console +// during the make. This is useful for debugging only. With Visual +// Studio IDE projects all commands are done without /nologo. +CMAKE_VERBOSE_MAKEFILE:BOOL=FALSE + +//Value Computed by CMake +Reaper_BINARY_DIR:STATIC=/content/NeuCoSVC-2/REAPER/build + +//Value Computed by CMake +Reaper_IS_TOP_LEVEL:STATIC=ON + +//Value Computed by CMake +Reaper_SOURCE_DIR:STATIC=/content/NeuCoSVC-2/REAPER + +//Dependencies for the target +epoch_tracker_LIB_DEPENDS:STATIC=general;wave; + +//Dependencies for the target +wave_LIB_DEPENDS:STATIC=general;core; + + +######################## +# INTERNAL cache entries +######################## + +//ADVANCED property for variable: CMAKE_ADDR2LINE +CMAKE_ADDR2LINE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_AR +CMAKE_AR-ADVANCED:INTERNAL=1 +//This is the directory where this CMakeCache.txt was created +CMAKE_CACHEFILE_DIR:INTERNAL=/content/NeuCoSVC-2/REAPER/build +//Major version of cmake used to create the current loaded cache +CMAKE_CACHE_MAJOR_VERSION:INTERNAL=3 +//Minor version of cmake used to create the current loaded cache +CMAKE_CACHE_MINOR_VERSION:INTERNAL=27 +//Patch version of cmake used to create the current loaded cache +CMAKE_CACHE_PATCH_VERSION:INTERNAL=9 +//ADVANCED property for variable: CMAKE_COLOR_MAKEFILE +CMAKE_COLOR_MAKEFILE-ADVANCED:INTERNAL=1 +//Path to CMake executable. +CMAKE_COMMAND:INTERNAL=/usr/local/lib/python3.10/dist-packages/cmake/data/bin/cmake +//Path to cpack program executable. +CMAKE_CPACK_COMMAND:INTERNAL=/usr/local/lib/python3.10/dist-packages/cmake/data/bin/cpack +//Path to ctest program executable. +CMAKE_CTEST_COMMAND:INTERNAL=/usr/local/lib/python3.10/dist-packages/cmake/data/bin/ctest +//ADVANCED property for variable: CMAKE_CXX_COMPILER +CMAKE_CXX_COMPILER-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_COMPILER_AR +CMAKE_CXX_COMPILER_AR-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_COMPILER_RANLIB +CMAKE_CXX_COMPILER_RANLIB-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_FLAGS +CMAKE_CXX_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_FLAGS_DEBUG +CMAKE_CXX_FLAGS_DEBUG-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_FLAGS_MINSIZEREL +CMAKE_CXX_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_FLAGS_RELEASE +CMAKE_CXX_FLAGS_RELEASE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_FLAGS_RELWITHDEBINFO +CMAKE_CXX_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_C_COMPILER +CMAKE_C_COMPILER-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_C_COMPILER_AR +CMAKE_C_COMPILER_AR-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_C_COMPILER_RANLIB +CMAKE_C_COMPILER_RANLIB-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_C_FLAGS +CMAKE_C_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_C_FLAGS_DEBUG +CMAKE_C_FLAGS_DEBUG-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_C_FLAGS_MINSIZEREL +CMAKE_C_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_C_FLAGS_RELEASE +CMAKE_C_FLAGS_RELEASE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_C_FLAGS_RELWITHDEBINFO +CMAKE_C_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_DLLTOOL +CMAKE_DLLTOOL-ADVANCED:INTERNAL=1 +//Executable file format +CMAKE_EXECUTABLE_FORMAT:INTERNAL=ELF +//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS +CMAKE_EXE_LINKER_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_DEBUG +CMAKE_EXE_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_MINSIZEREL +CMAKE_EXE_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_RELEASE +CMAKE_EXE_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO +CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_EXPORT_COMPILE_COMMANDS +CMAKE_EXPORT_COMPILE_COMMANDS-ADVANCED:INTERNAL=1 +//Name of external makefile project generator. +CMAKE_EXTRA_GENERATOR:INTERNAL= +//Name of generator. +CMAKE_GENERATOR:INTERNAL=Unix Makefiles +//Generator instance identifier. +CMAKE_GENERATOR_INSTANCE:INTERNAL= +//Name of generator platform. +CMAKE_GENERATOR_PLATFORM:INTERNAL= +//Name of generator toolset. +CMAKE_GENERATOR_TOOLSET:INTERNAL= +//Source directory with the top level CMakeLists.txt file for this +// project +CMAKE_HOME_DIRECTORY:INTERNAL=/content/NeuCoSVC-2/REAPER +//Install .so files without execute permission. +CMAKE_INSTALL_SO_NO_EXE:INTERNAL=1 +//ADVANCED property for variable: CMAKE_LINKER +CMAKE_LINKER-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MAKE_PROGRAM +CMAKE_MAKE_PROGRAM-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS +CMAKE_MODULE_LINKER_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_DEBUG +CMAKE_MODULE_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL +CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_RELEASE +CMAKE_MODULE_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO +CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_NM +CMAKE_NM-ADVANCED:INTERNAL=1 +//number of local generators +CMAKE_NUMBER_OF_MAKEFILES:INTERNAL=1 +//ADVANCED property for variable: CMAKE_OBJCOPY +CMAKE_OBJCOPY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_OBJDUMP +CMAKE_OBJDUMP-ADVANCED:INTERNAL=1 +//Platform information initialized +CMAKE_PLATFORM_INFO_INITIALIZED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_RANLIB +CMAKE_RANLIB-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_READELF +CMAKE_READELF-ADVANCED:INTERNAL=1 +//Path to CMake installation. +CMAKE_ROOT:INTERNAL=/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27 +//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS +CMAKE_SHARED_LINKER_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_DEBUG +CMAKE_SHARED_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL +CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_RELEASE +CMAKE_SHARED_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO +CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_SKIP_INSTALL_RPATH +CMAKE_SKIP_INSTALL_RPATH-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_SKIP_RPATH +CMAKE_SKIP_RPATH-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS +CMAKE_STATIC_LINKER_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_DEBUG +CMAKE_STATIC_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL +CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_RELEASE +CMAKE_STATIC_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO +CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_STRIP +CMAKE_STRIP-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_TAPI +CMAKE_TAPI-ADVANCED:INTERNAL=1 +//uname command +CMAKE_UNAME:INTERNAL=/usr/bin/uname +//ADVANCED property for variable: CMAKE_VERBOSE_MAKEFILE +CMAKE_VERBOSE_MAKEFILE-ADVANCED:INTERNAL=1 +//Test COMPILER_SUPPORTS_CXX0X +COMPILER_SUPPORTS_CXX0X:INTERNAL=1 +//Test COMPILER_SUPPORTS_CXX11 +COMPILER_SUPPORTS_CXX11:INTERNAL=1 +//linker supports push/pop state +_CMAKE_LINKER_PUSHPOP_STATE_SUPPORTED:INTERNAL=TRUE + diff --git a/REAPER/build/CMakeFiles/3.27.9/CMakeCCompiler.cmake b/REAPER/build/CMakeFiles/3.27.9/CMakeCCompiler.cmake new file mode 100644 index 0000000000000000000000000000000000000000..8eea66c6ed5231dd3319c5b6dde0a787ac428c82 --- /dev/null +++ b/REAPER/build/CMakeFiles/3.27.9/CMakeCCompiler.cmake @@ -0,0 +1,74 @@ +set(CMAKE_C_COMPILER "/usr/bin/cc") +set(CMAKE_C_COMPILER_ARG1 "") +set(CMAKE_C_COMPILER_ID "GNU") +set(CMAKE_C_COMPILER_VERSION "11.4.0") +set(CMAKE_C_COMPILER_VERSION_INTERNAL "") +set(CMAKE_C_COMPILER_WRAPPER "") +set(CMAKE_C_STANDARD_COMPUTED_DEFAULT "17") +set(CMAKE_C_EXTENSIONS_COMPUTED_DEFAULT "ON") +set(CMAKE_C_COMPILE_FEATURES "c_std_90;c_function_prototypes;c_std_99;c_restrict;c_variadic_macros;c_std_11;c_static_assert;c_std_17;c_std_23") +set(CMAKE_C90_COMPILE_FEATURES "c_std_90;c_function_prototypes") +set(CMAKE_C99_COMPILE_FEATURES "c_std_99;c_restrict;c_variadic_macros") +set(CMAKE_C11_COMPILE_FEATURES "c_std_11;c_static_assert") +set(CMAKE_C17_COMPILE_FEATURES "c_std_17") +set(CMAKE_C23_COMPILE_FEATURES "c_std_23") + +set(CMAKE_C_PLATFORM_ID "Linux") +set(CMAKE_C_SIMULATE_ID "") +set(CMAKE_C_COMPILER_FRONTEND_VARIANT "GNU") +set(CMAKE_C_SIMULATE_VERSION "") + + + + +set(CMAKE_AR "/usr/bin/ar") +set(CMAKE_C_COMPILER_AR "/usr/bin/gcc-ar-11") +set(CMAKE_RANLIB "/usr/bin/ranlib") +set(CMAKE_C_COMPILER_RANLIB "/usr/bin/gcc-ranlib-11") +set(CMAKE_LINKER "/usr/bin/ld") +set(CMAKE_MT "") +set(CMAKE_TAPI "CMAKE_TAPI-NOTFOUND") +set(CMAKE_COMPILER_IS_GNUCC 1) +set(CMAKE_C_COMPILER_LOADED 1) +set(CMAKE_C_COMPILER_WORKS TRUE) +set(CMAKE_C_ABI_COMPILED TRUE) + +set(CMAKE_C_COMPILER_ENV_VAR "CC") + +set(CMAKE_C_COMPILER_ID_RUN 1) +set(CMAKE_C_SOURCE_FILE_EXTENSIONS c;m) +set(CMAKE_C_IGNORE_EXTENSIONS h;H;o;O;obj;OBJ;def;DEF;rc;RC) +set(CMAKE_C_LINKER_PREFERENCE 10) +set(CMAKE_C_LINKER_DEPFILE_SUPPORTED TRUE) + +# Save compiler ABI information. +set(CMAKE_C_SIZEOF_DATA_PTR "8") +set(CMAKE_C_COMPILER_ABI "ELF") +set(CMAKE_C_BYTE_ORDER "LITTLE_ENDIAN") +set(CMAKE_C_LIBRARY_ARCHITECTURE "x86_64-linux-gnu") + +if(CMAKE_C_SIZEOF_DATA_PTR) + set(CMAKE_SIZEOF_VOID_P "${CMAKE_C_SIZEOF_DATA_PTR}") +endif() + +if(CMAKE_C_COMPILER_ABI) + set(CMAKE_INTERNAL_PLATFORM_ABI "${CMAKE_C_COMPILER_ABI}") +endif() + +if(CMAKE_C_LIBRARY_ARCHITECTURE) + set(CMAKE_LIBRARY_ARCHITECTURE "x86_64-linux-gnu") +endif() + +set(CMAKE_C_CL_SHOWINCLUDES_PREFIX "") +if(CMAKE_C_CL_SHOWINCLUDES_PREFIX) + set(CMAKE_CL_SHOWINCLUDES_PREFIX "${CMAKE_C_CL_SHOWINCLUDES_PREFIX}") +endif() + + + + + +set(CMAKE_C_IMPLICIT_INCLUDE_DIRECTORIES "/usr/lib/gcc/x86_64-linux-gnu/11/include;/usr/local/include;/usr/include/x86_64-linux-gnu;/usr/include") +set(CMAKE_C_IMPLICIT_LINK_LIBRARIES "gcc;gcc_s;c;gcc;gcc_s") +set(CMAKE_C_IMPLICIT_LINK_DIRECTORIES "/usr/lib/gcc/x86_64-linux-gnu/11;/usr/lib/x86_64-linux-gnu;/usr/lib;/lib/x86_64-linux-gnu;/lib;/usr/local/cuda/lib64/stubs") +set(CMAKE_C_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES "") diff --git a/REAPER/build/CMakeFiles/3.27.9/CMakeCXXCompiler.cmake b/REAPER/build/CMakeFiles/3.27.9/CMakeCXXCompiler.cmake new file mode 100644 index 0000000000000000000000000000000000000000..c018f1d639a06ccb4263cdfc9edd87258403ba71 --- /dev/null +++ b/REAPER/build/CMakeFiles/3.27.9/CMakeCXXCompiler.cmake @@ -0,0 +1,85 @@ +set(CMAKE_CXX_COMPILER "/usr/bin/c++") +set(CMAKE_CXX_COMPILER_ARG1 "") +set(CMAKE_CXX_COMPILER_ID "GNU") +set(CMAKE_CXX_COMPILER_VERSION "11.4.0") +set(CMAKE_CXX_COMPILER_VERSION_INTERNAL "") +set(CMAKE_CXX_COMPILER_WRAPPER "") +set(CMAKE_CXX_STANDARD_COMPUTED_DEFAULT "17") +set(CMAKE_CXX_EXTENSIONS_COMPUTED_DEFAULT "ON") +set(CMAKE_CXX_COMPILE_FEATURES "cxx_std_98;cxx_template_template_parameters;cxx_std_11;cxx_alias_templates;cxx_alignas;cxx_alignof;cxx_attributes;cxx_auto_type;cxx_constexpr;cxx_decltype;cxx_decltype_incomplete_return_types;cxx_default_function_template_args;cxx_defaulted_functions;cxx_defaulted_move_initializers;cxx_delegating_constructors;cxx_deleted_functions;cxx_enum_forward_declarations;cxx_explicit_conversions;cxx_extended_friend_declarations;cxx_extern_templates;cxx_final;cxx_func_identifier;cxx_generalized_initializers;cxx_inheriting_constructors;cxx_inline_namespaces;cxx_lambdas;cxx_local_type_template_args;cxx_long_long_type;cxx_noexcept;cxx_nonstatic_member_init;cxx_nullptr;cxx_override;cxx_range_for;cxx_raw_string_literals;cxx_reference_qualified_functions;cxx_right_angle_brackets;cxx_rvalue_references;cxx_sizeof_member;cxx_static_assert;cxx_strong_enums;cxx_thread_local;cxx_trailing_return_types;cxx_unicode_literals;cxx_uniform_initialization;cxx_unrestricted_unions;cxx_user_literals;cxx_variadic_macros;cxx_variadic_templates;cxx_std_14;cxx_aggregate_default_initializers;cxx_attribute_deprecated;cxx_binary_literals;cxx_contextual_conversions;cxx_decltype_auto;cxx_digit_separators;cxx_generic_lambdas;cxx_lambda_init_captures;cxx_relaxed_constexpr;cxx_return_type_deduction;cxx_variable_templates;cxx_std_17;cxx_std_20;cxx_std_23") +set(CMAKE_CXX98_COMPILE_FEATURES "cxx_std_98;cxx_template_template_parameters") +set(CMAKE_CXX11_COMPILE_FEATURES "cxx_std_11;cxx_alias_templates;cxx_alignas;cxx_alignof;cxx_attributes;cxx_auto_type;cxx_constexpr;cxx_decltype;cxx_decltype_incomplete_return_types;cxx_default_function_template_args;cxx_defaulted_functions;cxx_defaulted_move_initializers;cxx_delegating_constructors;cxx_deleted_functions;cxx_enum_forward_declarations;cxx_explicit_conversions;cxx_extended_friend_declarations;cxx_extern_templates;cxx_final;cxx_func_identifier;cxx_generalized_initializers;cxx_inheriting_constructors;cxx_inline_namespaces;cxx_lambdas;cxx_local_type_template_args;cxx_long_long_type;cxx_noexcept;cxx_nonstatic_member_init;cxx_nullptr;cxx_override;cxx_range_for;cxx_raw_string_literals;cxx_reference_qualified_functions;cxx_right_angle_brackets;cxx_rvalue_references;cxx_sizeof_member;cxx_static_assert;cxx_strong_enums;cxx_thread_local;cxx_trailing_return_types;cxx_unicode_literals;cxx_uniform_initialization;cxx_unrestricted_unions;cxx_user_literals;cxx_variadic_macros;cxx_variadic_templates") +set(CMAKE_CXX14_COMPILE_FEATURES "cxx_std_14;cxx_aggregate_default_initializers;cxx_attribute_deprecated;cxx_binary_literals;cxx_contextual_conversions;cxx_decltype_auto;cxx_digit_separators;cxx_generic_lambdas;cxx_lambda_init_captures;cxx_relaxed_constexpr;cxx_return_type_deduction;cxx_variable_templates") +set(CMAKE_CXX17_COMPILE_FEATURES "cxx_std_17") +set(CMAKE_CXX20_COMPILE_FEATURES "cxx_std_20") +set(CMAKE_CXX23_COMPILE_FEATURES "cxx_std_23") + +set(CMAKE_CXX_PLATFORM_ID "Linux") +set(CMAKE_CXX_SIMULATE_ID "") +set(CMAKE_CXX_COMPILER_FRONTEND_VARIANT "GNU") +set(CMAKE_CXX_SIMULATE_VERSION "") + + + + +set(CMAKE_AR "/usr/bin/ar") +set(CMAKE_CXX_COMPILER_AR "/usr/bin/gcc-ar-11") +set(CMAKE_RANLIB "/usr/bin/ranlib") +set(CMAKE_CXX_COMPILER_RANLIB "/usr/bin/gcc-ranlib-11") +set(CMAKE_LINKER "/usr/bin/ld") +set(CMAKE_MT "") +set(CMAKE_TAPI "CMAKE_TAPI-NOTFOUND") +set(CMAKE_COMPILER_IS_GNUCXX 1) +set(CMAKE_CXX_COMPILER_LOADED 1) +set(CMAKE_CXX_COMPILER_WORKS TRUE) +set(CMAKE_CXX_ABI_COMPILED TRUE) + +set(CMAKE_CXX_COMPILER_ENV_VAR "CXX") + +set(CMAKE_CXX_COMPILER_ID_RUN 1) +set(CMAKE_CXX_SOURCE_FILE_EXTENSIONS C;M;c++;cc;cpp;cxx;m;mm;mpp;CPP;ixx;cppm;ccm;cxxm;c++m) +set(CMAKE_CXX_IGNORE_EXTENSIONS inl;h;hpp;HPP;H;o;O;obj;OBJ;def;DEF;rc;RC) + +foreach (lang C OBJC OBJCXX) + if (CMAKE_${lang}_COMPILER_ID_RUN) + foreach(extension IN LISTS CMAKE_${lang}_SOURCE_FILE_EXTENSIONS) + list(REMOVE_ITEM CMAKE_CXX_SOURCE_FILE_EXTENSIONS ${extension}) + endforeach() + endif() +endforeach() + +set(CMAKE_CXX_LINKER_PREFERENCE 30) +set(CMAKE_CXX_LINKER_PREFERENCE_PROPAGATES 1) +set(CMAKE_CXX_LINKER_DEPFILE_SUPPORTED TRUE) + +# Save compiler ABI information. +set(CMAKE_CXX_SIZEOF_DATA_PTR "8") +set(CMAKE_CXX_COMPILER_ABI "ELF") +set(CMAKE_CXX_BYTE_ORDER "LITTLE_ENDIAN") +set(CMAKE_CXX_LIBRARY_ARCHITECTURE "x86_64-linux-gnu") + +if(CMAKE_CXX_SIZEOF_DATA_PTR) + set(CMAKE_SIZEOF_VOID_P "${CMAKE_CXX_SIZEOF_DATA_PTR}") +endif() + +if(CMAKE_CXX_COMPILER_ABI) + set(CMAKE_INTERNAL_PLATFORM_ABI "${CMAKE_CXX_COMPILER_ABI}") +endif() + +if(CMAKE_CXX_LIBRARY_ARCHITECTURE) + set(CMAKE_LIBRARY_ARCHITECTURE "x86_64-linux-gnu") +endif() + +set(CMAKE_CXX_CL_SHOWINCLUDES_PREFIX "") +if(CMAKE_CXX_CL_SHOWINCLUDES_PREFIX) + set(CMAKE_CL_SHOWINCLUDES_PREFIX "${CMAKE_CXX_CL_SHOWINCLUDES_PREFIX}") +endif() + + + + + +set(CMAKE_CXX_IMPLICIT_INCLUDE_DIRECTORIES "/usr/include/c++/11;/usr/include/x86_64-linux-gnu/c++/11;/usr/include/c++/11/backward;/usr/lib/gcc/x86_64-linux-gnu/11/include;/usr/local/include;/usr/include/x86_64-linux-gnu;/usr/include") +set(CMAKE_CXX_IMPLICIT_LINK_LIBRARIES "stdc++;m;gcc_s;gcc;c;gcc_s;gcc") +set(CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES "/usr/lib/gcc/x86_64-linux-gnu/11;/usr/lib/x86_64-linux-gnu;/usr/lib;/lib/x86_64-linux-gnu;/lib;/usr/local/cuda/lib64/stubs") +set(CMAKE_CXX_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES "") diff --git a/REAPER/build/CMakeFiles/3.27.9/CMakeDetermineCompilerABI_C.bin b/REAPER/build/CMakeFiles/3.27.9/CMakeDetermineCompilerABI_C.bin new file mode 100644 index 0000000000000000000000000000000000000000..380b97b8b2a0be0d0e936e8a6dfcc95d7b8b6c2d --- /dev/null +++ b/REAPER/build/CMakeFiles/3.27.9/CMakeDetermineCompilerABI_C.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ef64be9d81b97e019f77c3d838930e9679d8d8f33d6d1f4b5840714e45987128 +size 15968 diff --git a/REAPER/build/CMakeFiles/3.27.9/CMakeDetermineCompilerABI_CXX.bin b/REAPER/build/CMakeFiles/3.27.9/CMakeDetermineCompilerABI_CXX.bin new file mode 100644 index 0000000000000000000000000000000000000000..5cfe9138dbdec656bc024dd8bfc6871ca4c1df09 --- /dev/null +++ b/REAPER/build/CMakeFiles/3.27.9/CMakeDetermineCompilerABI_CXX.bin @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3f642dd64274b2cd71b9149b574006831c3103420c752b32d177540a7296d5c3 +size 15992 diff --git a/REAPER/build/CMakeFiles/3.27.9/CMakeSystem.cmake b/REAPER/build/CMakeFiles/3.27.9/CMakeSystem.cmake new file mode 100644 index 0000000000000000000000000000000000000000..abcaa1abfeea65b7caf5c52eec7a7fae88469118 --- /dev/null +++ b/REAPER/build/CMakeFiles/3.27.9/CMakeSystem.cmake @@ -0,0 +1,15 @@ +set(CMAKE_HOST_SYSTEM "Linux-6.1.58+") +set(CMAKE_HOST_SYSTEM_NAME "Linux") +set(CMAKE_HOST_SYSTEM_VERSION "6.1.58+") +set(CMAKE_HOST_SYSTEM_PROCESSOR "x86_64") + + + +set(CMAKE_SYSTEM "Linux-6.1.58+") +set(CMAKE_SYSTEM_NAME "Linux") +set(CMAKE_SYSTEM_VERSION "6.1.58+") +set(CMAKE_SYSTEM_PROCESSOR "x86_64") + +set(CMAKE_CROSSCOMPILING "FALSE") + +set(CMAKE_SYSTEM_LOADED 1) diff --git a/REAPER/build/CMakeFiles/3.27.9/CompilerIdC/CMakeCCompilerId.c b/REAPER/build/CMakeFiles/3.27.9/CompilerIdC/CMakeCCompilerId.c new file mode 100644 index 0000000000000000000000000000000000000000..66be36543f12db963877ff89a29faf7f27ac290a --- /dev/null +++ b/REAPER/build/CMakeFiles/3.27.9/CompilerIdC/CMakeCCompilerId.c @@ -0,0 +1,866 @@ +#ifdef __cplusplus +# error "A C++ compiler has been selected for C." +#endif + +#if defined(__18CXX) +# define ID_VOID_MAIN +#endif +#if defined(__CLASSIC_C__) +/* cv-qualifiers did not exist in K&R C */ +# define const +# define volatile +#endif + +#if !defined(__has_include) +/* If the compiler does not have __has_include, pretend the answer is + always no. */ +# define __has_include(x) 0 +#endif + + +/* Version number components: V=Version, R=Revision, P=Patch + Version date components: YYYY=Year, MM=Month, DD=Day */ + +#if defined(__INTEL_COMPILER) || defined(__ICC) +# define COMPILER_ID "Intel" +# if defined(_MSC_VER) +# define SIMULATE_ID "MSVC" +# endif +# if defined(__GNUC__) +# define SIMULATE_ID "GNU" +# endif + /* __INTEL_COMPILER = VRP prior to 2021, and then VVVV for 2021 and later, + except that a few beta releases use the old format with V=2021. */ +# if __INTEL_COMPILER < 2021 || __INTEL_COMPILER == 202110 || __INTEL_COMPILER == 202111 +# define COMPILER_VERSION_MAJOR DEC(__INTEL_COMPILER/100) +# define COMPILER_VERSION_MINOR DEC(__INTEL_COMPILER/10 % 10) +# if defined(__INTEL_COMPILER_UPDATE) +# define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER_UPDATE) +# else +# define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER % 10) +# endif +# else +# define COMPILER_VERSION_MAJOR DEC(__INTEL_COMPILER) +# define COMPILER_VERSION_MINOR DEC(__INTEL_COMPILER_UPDATE) + /* The third version component from --version is an update index, + but no macro is provided for it. */ +# define COMPILER_VERSION_PATCH DEC(0) +# endif +# if defined(__INTEL_COMPILER_BUILD_DATE) + /* __INTEL_COMPILER_BUILD_DATE = YYYYMMDD */ +# define COMPILER_VERSION_TWEAK DEC(__INTEL_COMPILER_BUILD_DATE) +# endif +# if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +# endif +# if defined(__GNUC__) +# define SIMULATE_VERSION_MAJOR DEC(__GNUC__) +# elif defined(__GNUG__) +# define SIMULATE_VERSION_MAJOR DEC(__GNUG__) +# endif +# if defined(__GNUC_MINOR__) +# define SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__) +# endif +# if defined(__GNUC_PATCHLEVEL__) +# define SIMULATE_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__) +# endif + +#elif (defined(__clang__) && defined(__INTEL_CLANG_COMPILER)) || defined(__INTEL_LLVM_COMPILER) +# define COMPILER_ID "IntelLLVM" +#if defined(_MSC_VER) +# define SIMULATE_ID "MSVC" +#endif +#if defined(__GNUC__) +# define SIMULATE_ID "GNU" +#endif +/* __INTEL_LLVM_COMPILER = VVVVRP prior to 2021.2.0, VVVVRRPP for 2021.2.0 and + * later. Look for 6 digit vs. 8 digit version number to decide encoding. + * VVVV is no smaller than the current year when a version is released. + */ +#if __INTEL_LLVM_COMPILER < 1000000L +# define COMPILER_VERSION_MAJOR DEC(__INTEL_LLVM_COMPILER/100) +# define COMPILER_VERSION_MINOR DEC(__INTEL_LLVM_COMPILER/10 % 10) +# define COMPILER_VERSION_PATCH DEC(__INTEL_LLVM_COMPILER % 10) +#else +# define COMPILER_VERSION_MAJOR DEC(__INTEL_LLVM_COMPILER/10000) +# define COMPILER_VERSION_MINOR DEC(__INTEL_LLVM_COMPILER/100 % 100) +# define COMPILER_VERSION_PATCH DEC(__INTEL_LLVM_COMPILER % 100) +#endif +#if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +#endif +#if defined(__GNUC__) +# define SIMULATE_VERSION_MAJOR DEC(__GNUC__) +#elif defined(__GNUG__) +# define SIMULATE_VERSION_MAJOR DEC(__GNUG__) +#endif +#if defined(__GNUC_MINOR__) +# define SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__) +#endif +#if defined(__GNUC_PATCHLEVEL__) +# define SIMULATE_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__) +#endif + +#elif defined(__PATHCC__) +# define COMPILER_ID "PathScale" +# define COMPILER_VERSION_MAJOR DEC(__PATHCC__) +# define COMPILER_VERSION_MINOR DEC(__PATHCC_MINOR__) +# if defined(__PATHCC_PATCHLEVEL__) +# define COMPILER_VERSION_PATCH DEC(__PATHCC_PATCHLEVEL__) +# endif + +#elif defined(__BORLANDC__) && defined(__CODEGEARC_VERSION__) +# define COMPILER_ID "Embarcadero" +# define COMPILER_VERSION_MAJOR HEX(__CODEGEARC_VERSION__>>24 & 0x00FF) +# define COMPILER_VERSION_MINOR HEX(__CODEGEARC_VERSION__>>16 & 0x00FF) +# define COMPILER_VERSION_PATCH DEC(__CODEGEARC_VERSION__ & 0xFFFF) + +#elif defined(__BORLANDC__) +# define COMPILER_ID "Borland" + /* __BORLANDC__ = 0xVRR */ +# define COMPILER_VERSION_MAJOR HEX(__BORLANDC__>>8) +# define COMPILER_VERSION_MINOR HEX(__BORLANDC__ & 0xFF) + +#elif defined(__WATCOMC__) && __WATCOMC__ < 1200 +# define COMPILER_ID "Watcom" + /* __WATCOMC__ = VVRR */ +# define COMPILER_VERSION_MAJOR DEC(__WATCOMC__ / 100) +# define COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10) +# if (__WATCOMC__ % 10) > 0 +# define COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10) +# endif + +#elif defined(__WATCOMC__) +# define COMPILER_ID "OpenWatcom" + /* __WATCOMC__ = VVRP + 1100 */ +# define COMPILER_VERSION_MAJOR DEC((__WATCOMC__ - 1100) / 100) +# define COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10) +# if (__WATCOMC__ % 10) > 0 +# define COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10) +# endif + +#elif defined(__SUNPRO_C) +# define COMPILER_ID "SunPro" +# if __SUNPRO_C >= 0x5100 + /* __SUNPRO_C = 0xVRRP */ +# define COMPILER_VERSION_MAJOR HEX(__SUNPRO_C>>12) +# define COMPILER_VERSION_MINOR HEX(__SUNPRO_C>>4 & 0xFF) +# define COMPILER_VERSION_PATCH HEX(__SUNPRO_C & 0xF) +# else + /* __SUNPRO_CC = 0xVRP */ +# define COMPILER_VERSION_MAJOR HEX(__SUNPRO_C>>8) +# define COMPILER_VERSION_MINOR HEX(__SUNPRO_C>>4 & 0xF) +# define COMPILER_VERSION_PATCH HEX(__SUNPRO_C & 0xF) +# endif + +#elif defined(__HP_cc) +# define COMPILER_ID "HP" + /* __HP_cc = VVRRPP */ +# define COMPILER_VERSION_MAJOR DEC(__HP_cc/10000) +# define COMPILER_VERSION_MINOR DEC(__HP_cc/100 % 100) +# define COMPILER_VERSION_PATCH DEC(__HP_cc % 100) + +#elif defined(__DECC) +# define COMPILER_ID "Compaq" + /* __DECC_VER = VVRRTPPPP */ +# define COMPILER_VERSION_MAJOR DEC(__DECC_VER/10000000) +# define COMPILER_VERSION_MINOR DEC(__DECC_VER/100000 % 100) +# define COMPILER_VERSION_PATCH DEC(__DECC_VER % 10000) + +#elif defined(__IBMC__) && defined(__COMPILER_VER__) +# define COMPILER_ID "zOS" + /* __IBMC__ = VRP */ +# define COMPILER_VERSION_MAJOR DEC(__IBMC__/100) +# define COMPILER_VERSION_MINOR DEC(__IBMC__/10 % 10) +# define COMPILER_VERSION_PATCH DEC(__IBMC__ % 10) + +#elif defined(__open_xl__) && defined(__clang__) +# define COMPILER_ID "IBMClang" +# define COMPILER_VERSION_MAJOR DEC(__open_xl_version__) +# define COMPILER_VERSION_MINOR DEC(__open_xl_release__) +# define COMPILER_VERSION_PATCH DEC(__open_xl_modification__) +# define COMPILER_VERSION_TWEAK DEC(__open_xl_ptf_fix_level__) + + +#elif defined(__ibmxl__) && defined(__clang__) +# define COMPILER_ID "XLClang" +# define COMPILER_VERSION_MAJOR DEC(__ibmxl_version__) +# define COMPILER_VERSION_MINOR DEC(__ibmxl_release__) +# define COMPILER_VERSION_PATCH DEC(__ibmxl_modification__) +# define COMPILER_VERSION_TWEAK DEC(__ibmxl_ptf_fix_level__) + + +#elif defined(__IBMC__) && !defined(__COMPILER_VER__) && __IBMC__ >= 800 +# define COMPILER_ID "XL" + /* __IBMC__ = VRP */ +# define COMPILER_VERSION_MAJOR DEC(__IBMC__/100) +# define COMPILER_VERSION_MINOR DEC(__IBMC__/10 % 10) +# define COMPILER_VERSION_PATCH DEC(__IBMC__ % 10) + +#elif defined(__IBMC__) && !defined(__COMPILER_VER__) && __IBMC__ < 800 +# define COMPILER_ID "VisualAge" + /* __IBMC__ = VRP */ +# define COMPILER_VERSION_MAJOR DEC(__IBMC__/100) +# define COMPILER_VERSION_MINOR DEC(__IBMC__/10 % 10) +# define COMPILER_VERSION_PATCH DEC(__IBMC__ % 10) + +#elif defined(__NVCOMPILER) +# define COMPILER_ID "NVHPC" +# define COMPILER_VERSION_MAJOR DEC(__NVCOMPILER_MAJOR__) +# define COMPILER_VERSION_MINOR DEC(__NVCOMPILER_MINOR__) +# if defined(__NVCOMPILER_PATCHLEVEL__) +# define COMPILER_VERSION_PATCH DEC(__NVCOMPILER_PATCHLEVEL__) +# endif + +#elif defined(__PGI) +# define COMPILER_ID "PGI" +# define COMPILER_VERSION_MAJOR DEC(__PGIC__) +# define COMPILER_VERSION_MINOR DEC(__PGIC_MINOR__) +# if defined(__PGIC_PATCHLEVEL__) +# define COMPILER_VERSION_PATCH DEC(__PGIC_PATCHLEVEL__) +# endif + +#elif defined(_CRAYC) +# define COMPILER_ID "Cray" +# define COMPILER_VERSION_MAJOR DEC(_RELEASE_MAJOR) +# define COMPILER_VERSION_MINOR DEC(_RELEASE_MINOR) + +#elif defined(__TI_COMPILER_VERSION__) +# define COMPILER_ID "TI" + /* __TI_COMPILER_VERSION__ = VVVRRRPPP */ +# define COMPILER_VERSION_MAJOR DEC(__TI_COMPILER_VERSION__/1000000) +# define COMPILER_VERSION_MINOR DEC(__TI_COMPILER_VERSION__/1000 % 1000) +# define COMPILER_VERSION_PATCH DEC(__TI_COMPILER_VERSION__ % 1000) + +#elif defined(__CLANG_FUJITSU) +# define COMPILER_ID "FujitsuClang" +# define COMPILER_VERSION_MAJOR DEC(__FCC_major__) +# define COMPILER_VERSION_MINOR DEC(__FCC_minor__) +# define COMPILER_VERSION_PATCH DEC(__FCC_patchlevel__) +# define COMPILER_VERSION_INTERNAL_STR __clang_version__ + + +#elif defined(__FUJITSU) +# define COMPILER_ID "Fujitsu" +# if defined(__FCC_version__) +# define COMPILER_VERSION __FCC_version__ +# elif defined(__FCC_major__) +# define COMPILER_VERSION_MAJOR DEC(__FCC_major__) +# define COMPILER_VERSION_MINOR DEC(__FCC_minor__) +# define COMPILER_VERSION_PATCH DEC(__FCC_patchlevel__) +# endif +# if defined(__fcc_version) +# define COMPILER_VERSION_INTERNAL DEC(__fcc_version) +# elif defined(__FCC_VERSION) +# define COMPILER_VERSION_INTERNAL DEC(__FCC_VERSION) +# endif + + +#elif defined(__ghs__) +# define COMPILER_ID "GHS" +/* __GHS_VERSION_NUMBER = VVVVRP */ +# ifdef __GHS_VERSION_NUMBER +# define COMPILER_VERSION_MAJOR DEC(__GHS_VERSION_NUMBER / 100) +# define COMPILER_VERSION_MINOR DEC(__GHS_VERSION_NUMBER / 10 % 10) +# define COMPILER_VERSION_PATCH DEC(__GHS_VERSION_NUMBER % 10) +# endif + +#elif defined(__TASKING__) +# define COMPILER_ID "Tasking" + # define COMPILER_VERSION_MAJOR DEC(__VERSION__/1000) + # define COMPILER_VERSION_MINOR DEC(__VERSION__ % 100) +# define COMPILER_VERSION_INTERNAL DEC(__VERSION__) + +#elif defined(__TINYC__) +# define COMPILER_ID "TinyCC" + +#elif defined(__BCC__) +# define COMPILER_ID "Bruce" + +#elif defined(__SCO_VERSION__) +# define COMPILER_ID "SCO" + +#elif defined(__ARMCC_VERSION) && !defined(__clang__) +# define COMPILER_ID "ARMCC" +#if __ARMCC_VERSION >= 1000000 + /* __ARMCC_VERSION = VRRPPPP */ + # define COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/1000000) + # define COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 100) + # define COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION % 10000) +#else + /* __ARMCC_VERSION = VRPPPP */ + # define COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/100000) + # define COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 10) + # define COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION % 10000) +#endif + + +#elif defined(__clang__) && defined(__apple_build_version__) +# define COMPILER_ID "AppleClang" +# if defined(_MSC_VER) +# define SIMULATE_ID "MSVC" +# endif +# define COMPILER_VERSION_MAJOR DEC(__clang_major__) +# define COMPILER_VERSION_MINOR DEC(__clang_minor__) +# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__) +# if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +# endif +# define COMPILER_VERSION_TWEAK DEC(__apple_build_version__) + +#elif defined(__clang__) && defined(__ARMCOMPILER_VERSION) +# define COMPILER_ID "ARMClang" + # define COMPILER_VERSION_MAJOR DEC(__ARMCOMPILER_VERSION/1000000) + # define COMPILER_VERSION_MINOR DEC(__ARMCOMPILER_VERSION/10000 % 100) + # define COMPILER_VERSION_PATCH DEC(__ARMCOMPILER_VERSION/100 % 100) +# define COMPILER_VERSION_INTERNAL DEC(__ARMCOMPILER_VERSION) + +#elif defined(__clang__) +# define COMPILER_ID "Clang" +# if defined(_MSC_VER) +# define SIMULATE_ID "MSVC" +# endif +# define COMPILER_VERSION_MAJOR DEC(__clang_major__) +# define COMPILER_VERSION_MINOR DEC(__clang_minor__) +# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__) +# if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +# endif + +#elif defined(__LCC__) && (defined(__GNUC__) || defined(__GNUG__) || defined(__MCST__)) +# define COMPILER_ID "LCC" +# define COMPILER_VERSION_MAJOR DEC(__LCC__ / 100) +# define COMPILER_VERSION_MINOR DEC(__LCC__ % 100) +# if defined(__LCC_MINOR__) +# define COMPILER_VERSION_PATCH DEC(__LCC_MINOR__) +# endif +# if defined(__GNUC__) && defined(__GNUC_MINOR__) +# define SIMULATE_ID "GNU" +# define SIMULATE_VERSION_MAJOR DEC(__GNUC__) +# define SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__) +# if defined(__GNUC_PATCHLEVEL__) +# define SIMULATE_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__) +# endif +# endif + +#elif defined(__GNUC__) +# define COMPILER_ID "GNU" +# define COMPILER_VERSION_MAJOR DEC(__GNUC__) +# if defined(__GNUC_MINOR__) +# define COMPILER_VERSION_MINOR DEC(__GNUC_MINOR__) +# endif +# if defined(__GNUC_PATCHLEVEL__) +# define COMPILER_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__) +# endif + +#elif defined(_MSC_VER) +# define COMPILER_ID "MSVC" + /* _MSC_VER = VVRR */ +# define COMPILER_VERSION_MAJOR DEC(_MSC_VER / 100) +# define COMPILER_VERSION_MINOR DEC(_MSC_VER % 100) +# if defined(_MSC_FULL_VER) +# if _MSC_VER >= 1400 + /* _MSC_FULL_VER = VVRRPPPPP */ +# define COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 100000) +# else + /* _MSC_FULL_VER = VVRRPPPP */ +# define COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 10000) +# endif +# endif +# if defined(_MSC_BUILD) +# define COMPILER_VERSION_TWEAK DEC(_MSC_BUILD) +# endif + +#elif defined(_ADI_COMPILER) +# define COMPILER_ID "ADSP" +#if defined(__VERSIONNUM__) + /* __VERSIONNUM__ = 0xVVRRPPTT */ +# define COMPILER_VERSION_MAJOR DEC(__VERSIONNUM__ >> 24 & 0xFF) +# define COMPILER_VERSION_MINOR DEC(__VERSIONNUM__ >> 16 & 0xFF) +# define COMPILER_VERSION_PATCH DEC(__VERSIONNUM__ >> 8 & 0xFF) +# define COMPILER_VERSION_TWEAK DEC(__VERSIONNUM__ & 0xFF) +#endif + +#elif defined(__IAR_SYSTEMS_ICC__) || defined(__IAR_SYSTEMS_ICC) +# define COMPILER_ID "IAR" +# if defined(__VER__) && defined(__ICCARM__) +# define COMPILER_VERSION_MAJOR DEC((__VER__) / 1000000) +# define COMPILER_VERSION_MINOR DEC(((__VER__) / 1000) % 1000) +# define COMPILER_VERSION_PATCH DEC((__VER__) % 1000) +# define COMPILER_VERSION_INTERNAL DEC(__IAR_SYSTEMS_ICC__) +# elif defined(__VER__) && (defined(__ICCAVR__) || defined(__ICCRX__) || defined(__ICCRH850__) || defined(__ICCRL78__) || defined(__ICC430__) || defined(__ICCRISCV__) || defined(__ICCV850__) || defined(__ICC8051__) || defined(__ICCSTM8__)) +# define COMPILER_VERSION_MAJOR DEC((__VER__) / 100) +# define COMPILER_VERSION_MINOR DEC((__VER__) - (((__VER__) / 100)*100)) +# define COMPILER_VERSION_PATCH DEC(__SUBVERSION__) +# define COMPILER_VERSION_INTERNAL DEC(__IAR_SYSTEMS_ICC__) +# endif + +#elif defined(__SDCC_VERSION_MAJOR) || defined(SDCC) +# define COMPILER_ID "SDCC" +# if defined(__SDCC_VERSION_MAJOR) +# define COMPILER_VERSION_MAJOR DEC(__SDCC_VERSION_MAJOR) +# define COMPILER_VERSION_MINOR DEC(__SDCC_VERSION_MINOR) +# define COMPILER_VERSION_PATCH DEC(__SDCC_VERSION_PATCH) +# else + /* SDCC = VRP */ +# define COMPILER_VERSION_MAJOR DEC(SDCC/100) +# define COMPILER_VERSION_MINOR DEC(SDCC/10 % 10) +# define COMPILER_VERSION_PATCH DEC(SDCC % 10) +# endif + + +/* These compilers are either not known or too old to define an + identification macro. Try to identify the platform and guess that + it is the native compiler. */ +#elif defined(__hpux) || defined(__hpua) +# define COMPILER_ID "HP" + +#else /* unknown compiler */ +# define COMPILER_ID "" +#endif + +/* Construct the string literal in pieces to prevent the source from + getting matched. Store it in a pointer rather than an array + because some compilers will just produce instructions to fill the + array rather than assigning a pointer to a static array. */ +char const* info_compiler = "INFO" ":" "compiler[" COMPILER_ID "]"; +#ifdef SIMULATE_ID +char const* info_simulate = "INFO" ":" "simulate[" SIMULATE_ID "]"; +#endif + +#ifdef __QNXNTO__ +char const* qnxnto = "INFO" ":" "qnxnto[]"; +#endif + +#if defined(__CRAYXT_COMPUTE_LINUX_TARGET) +char const *info_cray = "INFO" ":" "compiler_wrapper[CrayPrgEnv]"; +#endif + +#define STRINGIFY_HELPER(X) #X +#define STRINGIFY(X) STRINGIFY_HELPER(X) + +/* Identify known platforms by name. */ +#if defined(__linux) || defined(__linux__) || defined(linux) +# define PLATFORM_ID "Linux" + +#elif defined(__MSYS__) +# define PLATFORM_ID "MSYS" + +#elif defined(__CYGWIN__) +# define PLATFORM_ID "Cygwin" + +#elif defined(__MINGW32__) +# define PLATFORM_ID "MinGW" + +#elif defined(__APPLE__) +# define PLATFORM_ID "Darwin" + +#elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32) +# define PLATFORM_ID "Windows" + +#elif defined(__FreeBSD__) || defined(__FreeBSD) +# define PLATFORM_ID "FreeBSD" + +#elif defined(__NetBSD__) || defined(__NetBSD) +# define PLATFORM_ID "NetBSD" + +#elif defined(__OpenBSD__) || defined(__OPENBSD) +# define PLATFORM_ID "OpenBSD" + +#elif defined(__sun) || defined(sun) +# define PLATFORM_ID "SunOS" + +#elif defined(_AIX) || defined(__AIX) || defined(__AIX__) || defined(__aix) || defined(__aix__) +# define PLATFORM_ID "AIX" + +#elif defined(__hpux) || defined(__hpux__) +# define PLATFORM_ID "HP-UX" + +#elif defined(__HAIKU__) +# define PLATFORM_ID "Haiku" + +#elif defined(__BeOS) || defined(__BEOS__) || defined(_BEOS) +# define PLATFORM_ID "BeOS" + +#elif defined(__QNX__) || defined(__QNXNTO__) +# define PLATFORM_ID "QNX" + +#elif defined(__tru64) || defined(_tru64) || defined(__TRU64__) +# define PLATFORM_ID "Tru64" + +#elif defined(__riscos) || defined(__riscos__) +# define PLATFORM_ID "RISCos" + +#elif defined(__sinix) || defined(__sinix__) || defined(__SINIX__) +# define PLATFORM_ID "SINIX" + +#elif defined(__UNIX_SV__) +# define PLATFORM_ID "UNIX_SV" + +#elif defined(__bsdos__) +# define PLATFORM_ID "BSDOS" + +#elif defined(_MPRAS) || defined(MPRAS) +# define PLATFORM_ID "MP-RAS" + +#elif defined(__osf) || defined(__osf__) +# define PLATFORM_ID "OSF1" + +#elif defined(_SCO_SV) || defined(SCO_SV) || defined(sco_sv) +# define PLATFORM_ID "SCO_SV" + +#elif defined(__ultrix) || defined(__ultrix__) || defined(_ULTRIX) +# define PLATFORM_ID "ULTRIX" + +#elif defined(__XENIX__) || defined(_XENIX) || defined(XENIX) +# define PLATFORM_ID "Xenix" + +#elif defined(__WATCOMC__) +# if defined(__LINUX__) +# define PLATFORM_ID "Linux" + +# elif defined(__DOS__) +# define PLATFORM_ID "DOS" + +# elif defined(__OS2__) +# define PLATFORM_ID "OS2" + +# elif defined(__WINDOWS__) +# define PLATFORM_ID "Windows3x" + +# elif defined(__VXWORKS__) +# define PLATFORM_ID "VxWorks" + +# else /* unknown platform */ +# define PLATFORM_ID +# endif + +#elif defined(__INTEGRITY) +# if defined(INT_178B) +# define PLATFORM_ID "Integrity178" + +# else /* regular Integrity */ +# define PLATFORM_ID "Integrity" +# endif + +# elif defined(_ADI_COMPILER) +# define PLATFORM_ID "ADSP" + +#else /* unknown platform */ +# define PLATFORM_ID + +#endif + +/* For windows compilers MSVC and Intel we can determine + the architecture of the compiler being used. This is because + the compilers do not have flags that can change the architecture, + but rather depend on which compiler is being used +*/ +#if defined(_WIN32) && defined(_MSC_VER) +# if defined(_M_IA64) +# define ARCHITECTURE_ID "IA64" + +# elif defined(_M_ARM64EC) +# define ARCHITECTURE_ID "ARM64EC" + +# elif defined(_M_X64) || defined(_M_AMD64) +# define ARCHITECTURE_ID "x64" + +# elif defined(_M_IX86) +# define ARCHITECTURE_ID "X86" + +# elif defined(_M_ARM64) +# define ARCHITECTURE_ID "ARM64" + +# elif defined(_M_ARM) +# if _M_ARM == 4 +# define ARCHITECTURE_ID "ARMV4I" +# elif _M_ARM == 5 +# define ARCHITECTURE_ID "ARMV5I" +# else +# define ARCHITECTURE_ID "ARMV" STRINGIFY(_M_ARM) +# endif + +# elif defined(_M_MIPS) +# define ARCHITECTURE_ID "MIPS" + +# elif defined(_M_SH) +# define ARCHITECTURE_ID "SHx" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__WATCOMC__) +# if defined(_M_I86) +# define ARCHITECTURE_ID "I86" + +# elif defined(_M_IX86) +# define ARCHITECTURE_ID "X86" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__IAR_SYSTEMS_ICC__) || defined(__IAR_SYSTEMS_ICC) +# if defined(__ICCARM__) +# define ARCHITECTURE_ID "ARM" + +# elif defined(__ICCRX__) +# define ARCHITECTURE_ID "RX" + +# elif defined(__ICCRH850__) +# define ARCHITECTURE_ID "RH850" + +# elif defined(__ICCRL78__) +# define ARCHITECTURE_ID "RL78" + +# elif defined(__ICCRISCV__) +# define ARCHITECTURE_ID "RISCV" + +# elif defined(__ICCAVR__) +# define ARCHITECTURE_ID "AVR" + +# elif defined(__ICC430__) +# define ARCHITECTURE_ID "MSP430" + +# elif defined(__ICCV850__) +# define ARCHITECTURE_ID "V850" + +# elif defined(__ICC8051__) +# define ARCHITECTURE_ID "8051" + +# elif defined(__ICCSTM8__) +# define ARCHITECTURE_ID "STM8" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__ghs__) +# if defined(__PPC64__) +# define ARCHITECTURE_ID "PPC64" + +# elif defined(__ppc__) +# define ARCHITECTURE_ID "PPC" + +# elif defined(__ARM__) +# define ARCHITECTURE_ID "ARM" + +# elif defined(__x86_64__) +# define ARCHITECTURE_ID "x64" + +# elif defined(__i386__) +# define ARCHITECTURE_ID "X86" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__TI_COMPILER_VERSION__) +# if defined(__TI_ARM__) +# define ARCHITECTURE_ID "ARM" + +# elif defined(__MSP430__) +# define ARCHITECTURE_ID "MSP430" + +# elif defined(__TMS320C28XX__) +# define ARCHITECTURE_ID "TMS320C28x" + +# elif defined(__TMS320C6X__) || defined(_TMS320C6X) +# define ARCHITECTURE_ID "TMS320C6x" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +# elif defined(__ADSPSHARC__) +# define ARCHITECTURE_ID "SHARC" + +# elif defined(__ADSPBLACKFIN__) +# define ARCHITECTURE_ID "Blackfin" + +#elif defined(__TASKING__) + +# if defined(__CTC__) || defined(__CPTC__) +# define ARCHITECTURE_ID "TriCore" + +# elif defined(__CMCS__) +# define ARCHITECTURE_ID "MCS" + +# elif defined(__CARM__) +# define ARCHITECTURE_ID "ARM" + +# elif defined(__CARC__) +# define ARCHITECTURE_ID "ARC" + +# elif defined(__C51__) +# define ARCHITECTURE_ID "8051" + +# elif defined(__CPCP__) +# define ARCHITECTURE_ID "PCP" + +# else +# define ARCHITECTURE_ID "" +# endif + +#else +# define ARCHITECTURE_ID +#endif + +/* Convert integer to decimal digit literals. */ +#define DEC(n) \ + ('0' + (((n) / 10000000)%10)), \ + ('0' + (((n) / 1000000)%10)), \ + ('0' + (((n) / 100000)%10)), \ + ('0' + (((n) / 10000)%10)), \ + ('0' + (((n) / 1000)%10)), \ + ('0' + (((n) / 100)%10)), \ + ('0' + (((n) / 10)%10)), \ + ('0' + ((n) % 10)) + +/* Convert integer to hex digit literals. */ +#define HEX(n) \ + ('0' + ((n)>>28 & 0xF)), \ + ('0' + ((n)>>24 & 0xF)), \ + ('0' + ((n)>>20 & 0xF)), \ + ('0' + ((n)>>16 & 0xF)), \ + ('0' + ((n)>>12 & 0xF)), \ + ('0' + ((n)>>8 & 0xF)), \ + ('0' + ((n)>>4 & 0xF)), \ + ('0' + ((n) & 0xF)) + +/* Construct a string literal encoding the version number. */ +#ifdef COMPILER_VERSION +char const* info_version = "INFO" ":" "compiler_version[" COMPILER_VERSION "]"; + +/* Construct a string literal encoding the version number components. */ +#elif defined(COMPILER_VERSION_MAJOR) +char const info_version[] = { + 'I', 'N', 'F', 'O', ':', + 'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','[', + COMPILER_VERSION_MAJOR, +# ifdef COMPILER_VERSION_MINOR + '.', COMPILER_VERSION_MINOR, +# ifdef COMPILER_VERSION_PATCH + '.', COMPILER_VERSION_PATCH, +# ifdef COMPILER_VERSION_TWEAK + '.', COMPILER_VERSION_TWEAK, +# endif +# endif +# endif + ']','\0'}; +#endif + +/* Construct a string literal encoding the internal version number. */ +#ifdef COMPILER_VERSION_INTERNAL +char const info_version_internal[] = { + 'I', 'N', 'F', 'O', ':', + 'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','_', + 'i','n','t','e','r','n','a','l','[', + COMPILER_VERSION_INTERNAL,']','\0'}; +#elif defined(COMPILER_VERSION_INTERNAL_STR) +char const* info_version_internal = "INFO" ":" "compiler_version_internal[" COMPILER_VERSION_INTERNAL_STR "]"; +#endif + +/* Construct a string literal encoding the version number components. */ +#ifdef SIMULATE_VERSION_MAJOR +char const info_simulate_version[] = { + 'I', 'N', 'F', 'O', ':', + 's','i','m','u','l','a','t','e','_','v','e','r','s','i','o','n','[', + SIMULATE_VERSION_MAJOR, +# ifdef SIMULATE_VERSION_MINOR + '.', SIMULATE_VERSION_MINOR, +# ifdef SIMULATE_VERSION_PATCH + '.', SIMULATE_VERSION_PATCH, +# ifdef SIMULATE_VERSION_TWEAK + '.', SIMULATE_VERSION_TWEAK, +# endif +# endif +# endif + ']','\0'}; +#endif + +/* Construct the string literal in pieces to prevent the source from + getting matched. Store it in a pointer rather than an array + because some compilers will just produce instructions to fill the + array rather than assigning a pointer to a static array. */ +char const* info_platform = "INFO" ":" "platform[" PLATFORM_ID "]"; +char const* info_arch = "INFO" ":" "arch[" ARCHITECTURE_ID "]"; + + + +#if !defined(__STDC__) && !defined(__clang__) +# if defined(_MSC_VER) || defined(__ibmxl__) || defined(__IBMC__) +# define C_VERSION "90" +# else +# define C_VERSION +# endif +#elif __STDC_VERSION__ > 201710L +# define C_VERSION "23" +#elif __STDC_VERSION__ >= 201710L +# define C_VERSION "17" +#elif __STDC_VERSION__ >= 201000L +# define C_VERSION "11" +#elif __STDC_VERSION__ >= 199901L +# define C_VERSION "99" +#else +# define C_VERSION "90" +#endif +const char* info_language_standard_default = + "INFO" ":" "standard_default[" C_VERSION "]"; + +const char* info_language_extensions_default = "INFO" ":" "extensions_default[" +#if (defined(__clang__) || defined(__GNUC__) || defined(__xlC__) || \ + defined(__TI_COMPILER_VERSION__)) && \ + !defined(__STRICT_ANSI__) + "ON" +#else + "OFF" +#endif +"]"; + +/*--------------------------------------------------------------------------*/ + +#ifdef ID_VOID_MAIN +void main() {} +#else +# if defined(__CLASSIC_C__) +int main(argc, argv) int argc; char *argv[]; +# else +int main(int argc, char* argv[]) +# endif +{ + int require = 0; + require += info_compiler[argc]; + require += info_platform[argc]; + require += info_arch[argc]; +#ifdef COMPILER_VERSION_MAJOR + require += info_version[argc]; +#endif +#ifdef COMPILER_VERSION_INTERNAL + require += info_version_internal[argc]; +#endif +#ifdef SIMULATE_ID + require += info_simulate[argc]; +#endif +#ifdef SIMULATE_VERSION_MAJOR + require += info_simulate_version[argc]; +#endif +#if defined(__CRAYXT_COMPUTE_LINUX_TARGET) + require += info_cray[argc]; +#endif + require += info_language_standard_default[argc]; + require += info_language_extensions_default[argc]; + (void)argv; + return require; +} +#endif diff --git a/REAPER/build/CMakeFiles/3.27.9/CompilerIdC/a.out b/REAPER/build/CMakeFiles/3.27.9/CompilerIdC/a.out new file mode 100644 index 0000000000000000000000000000000000000000..c786756abbd10a6ac500dd20933efa409d328d0c Binary files /dev/null and b/REAPER/build/CMakeFiles/3.27.9/CompilerIdC/a.out differ diff --git a/REAPER/build/CMakeFiles/3.27.9/CompilerIdCXX/CMakeCXXCompilerId.cpp b/REAPER/build/CMakeFiles/3.27.9/CompilerIdCXX/CMakeCXXCompilerId.cpp new file mode 100644 index 0000000000000000000000000000000000000000..52d56e25da451334157395d4b74a490f45ffb67b --- /dev/null +++ b/REAPER/build/CMakeFiles/3.27.9/CompilerIdCXX/CMakeCXXCompilerId.cpp @@ -0,0 +1,855 @@ +/* This source file must have a .cpp extension so that all C++ compilers + recognize the extension without flags. Borland does not know .cxx for + example. */ +#ifndef __cplusplus +# error "A C compiler has been selected for C++." +#endif + +#if !defined(__has_include) +/* If the compiler does not have __has_include, pretend the answer is + always no. */ +# define __has_include(x) 0 +#endif + + +/* Version number components: V=Version, R=Revision, P=Patch + Version date components: YYYY=Year, MM=Month, DD=Day */ + +#if defined(__COMO__) +# define COMPILER_ID "Comeau" + /* __COMO_VERSION__ = VRR */ +# define COMPILER_VERSION_MAJOR DEC(__COMO_VERSION__ / 100) +# define COMPILER_VERSION_MINOR DEC(__COMO_VERSION__ % 100) + +#elif defined(__INTEL_COMPILER) || defined(__ICC) +# define COMPILER_ID "Intel" +# if defined(_MSC_VER) +# define SIMULATE_ID "MSVC" +# endif +# if defined(__GNUC__) +# define SIMULATE_ID "GNU" +# endif + /* __INTEL_COMPILER = VRP prior to 2021, and then VVVV for 2021 and later, + except that a few beta releases use the old format with V=2021. */ +# if __INTEL_COMPILER < 2021 || __INTEL_COMPILER == 202110 || __INTEL_COMPILER == 202111 +# define COMPILER_VERSION_MAJOR DEC(__INTEL_COMPILER/100) +# define COMPILER_VERSION_MINOR DEC(__INTEL_COMPILER/10 % 10) +# if defined(__INTEL_COMPILER_UPDATE) +# define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER_UPDATE) +# else +# define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER % 10) +# endif +# else +# define COMPILER_VERSION_MAJOR DEC(__INTEL_COMPILER) +# define COMPILER_VERSION_MINOR DEC(__INTEL_COMPILER_UPDATE) + /* The third version component from --version is an update index, + but no macro is provided for it. */ +# define COMPILER_VERSION_PATCH DEC(0) +# endif +# if defined(__INTEL_COMPILER_BUILD_DATE) + /* __INTEL_COMPILER_BUILD_DATE = YYYYMMDD */ +# define COMPILER_VERSION_TWEAK DEC(__INTEL_COMPILER_BUILD_DATE) +# endif +# if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +# endif +# if defined(__GNUC__) +# define SIMULATE_VERSION_MAJOR DEC(__GNUC__) +# elif defined(__GNUG__) +# define SIMULATE_VERSION_MAJOR DEC(__GNUG__) +# endif +# if defined(__GNUC_MINOR__) +# define SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__) +# endif +# if defined(__GNUC_PATCHLEVEL__) +# define SIMULATE_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__) +# endif + +#elif (defined(__clang__) && defined(__INTEL_CLANG_COMPILER)) || defined(__INTEL_LLVM_COMPILER) +# define COMPILER_ID "IntelLLVM" +#if defined(_MSC_VER) +# define SIMULATE_ID "MSVC" +#endif +#if defined(__GNUC__) +# define SIMULATE_ID "GNU" +#endif +/* __INTEL_LLVM_COMPILER = VVVVRP prior to 2021.2.0, VVVVRRPP for 2021.2.0 and + * later. Look for 6 digit vs. 8 digit version number to decide encoding. + * VVVV is no smaller than the current year when a version is released. + */ +#if __INTEL_LLVM_COMPILER < 1000000L +# define COMPILER_VERSION_MAJOR DEC(__INTEL_LLVM_COMPILER/100) +# define COMPILER_VERSION_MINOR DEC(__INTEL_LLVM_COMPILER/10 % 10) +# define COMPILER_VERSION_PATCH DEC(__INTEL_LLVM_COMPILER % 10) +#else +# define COMPILER_VERSION_MAJOR DEC(__INTEL_LLVM_COMPILER/10000) +# define COMPILER_VERSION_MINOR DEC(__INTEL_LLVM_COMPILER/100 % 100) +# define COMPILER_VERSION_PATCH DEC(__INTEL_LLVM_COMPILER % 100) +#endif +#if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +#endif +#if defined(__GNUC__) +# define SIMULATE_VERSION_MAJOR DEC(__GNUC__) +#elif defined(__GNUG__) +# define SIMULATE_VERSION_MAJOR DEC(__GNUG__) +#endif +#if defined(__GNUC_MINOR__) +# define SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__) +#endif +#if defined(__GNUC_PATCHLEVEL__) +# define SIMULATE_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__) +#endif + +#elif defined(__PATHCC__) +# define COMPILER_ID "PathScale" +# define COMPILER_VERSION_MAJOR DEC(__PATHCC__) +# define COMPILER_VERSION_MINOR DEC(__PATHCC_MINOR__) +# if defined(__PATHCC_PATCHLEVEL__) +# define COMPILER_VERSION_PATCH DEC(__PATHCC_PATCHLEVEL__) +# endif + +#elif defined(__BORLANDC__) && defined(__CODEGEARC_VERSION__) +# define COMPILER_ID "Embarcadero" +# define COMPILER_VERSION_MAJOR HEX(__CODEGEARC_VERSION__>>24 & 0x00FF) +# define COMPILER_VERSION_MINOR HEX(__CODEGEARC_VERSION__>>16 & 0x00FF) +# define COMPILER_VERSION_PATCH DEC(__CODEGEARC_VERSION__ & 0xFFFF) + +#elif defined(__BORLANDC__) +# define COMPILER_ID "Borland" + /* __BORLANDC__ = 0xVRR */ +# define COMPILER_VERSION_MAJOR HEX(__BORLANDC__>>8) +# define COMPILER_VERSION_MINOR HEX(__BORLANDC__ & 0xFF) + +#elif defined(__WATCOMC__) && __WATCOMC__ < 1200 +# define COMPILER_ID "Watcom" + /* __WATCOMC__ = VVRR */ +# define COMPILER_VERSION_MAJOR DEC(__WATCOMC__ / 100) +# define COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10) +# if (__WATCOMC__ % 10) > 0 +# define COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10) +# endif + +#elif defined(__WATCOMC__) +# define COMPILER_ID "OpenWatcom" + /* __WATCOMC__ = VVRP + 1100 */ +# define COMPILER_VERSION_MAJOR DEC((__WATCOMC__ - 1100) / 100) +# define COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10) +# if (__WATCOMC__ % 10) > 0 +# define COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10) +# endif + +#elif defined(__SUNPRO_CC) +# define COMPILER_ID "SunPro" +# if __SUNPRO_CC >= 0x5100 + /* __SUNPRO_CC = 0xVRRP */ +# define COMPILER_VERSION_MAJOR HEX(__SUNPRO_CC>>12) +# define COMPILER_VERSION_MINOR HEX(__SUNPRO_CC>>4 & 0xFF) +# define COMPILER_VERSION_PATCH HEX(__SUNPRO_CC & 0xF) +# else + /* __SUNPRO_CC = 0xVRP */ +# define COMPILER_VERSION_MAJOR HEX(__SUNPRO_CC>>8) +# define COMPILER_VERSION_MINOR HEX(__SUNPRO_CC>>4 & 0xF) +# define COMPILER_VERSION_PATCH HEX(__SUNPRO_CC & 0xF) +# endif + +#elif defined(__HP_aCC) +# define COMPILER_ID "HP" + /* __HP_aCC = VVRRPP */ +# define COMPILER_VERSION_MAJOR DEC(__HP_aCC/10000) +# define COMPILER_VERSION_MINOR DEC(__HP_aCC/100 % 100) +# define COMPILER_VERSION_PATCH DEC(__HP_aCC % 100) + +#elif defined(__DECCXX) +# define COMPILER_ID "Compaq" + /* __DECCXX_VER = VVRRTPPPP */ +# define COMPILER_VERSION_MAJOR DEC(__DECCXX_VER/10000000) +# define COMPILER_VERSION_MINOR DEC(__DECCXX_VER/100000 % 100) +# define COMPILER_VERSION_PATCH DEC(__DECCXX_VER % 10000) + +#elif defined(__IBMCPP__) && defined(__COMPILER_VER__) +# define COMPILER_ID "zOS" + /* __IBMCPP__ = VRP */ +# define COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100) +# define COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10) +# define COMPILER_VERSION_PATCH DEC(__IBMCPP__ % 10) + +#elif defined(__open_xl__) && defined(__clang__) +# define COMPILER_ID "IBMClang" +# define COMPILER_VERSION_MAJOR DEC(__open_xl_version__) +# define COMPILER_VERSION_MINOR DEC(__open_xl_release__) +# define COMPILER_VERSION_PATCH DEC(__open_xl_modification__) +# define COMPILER_VERSION_TWEAK DEC(__open_xl_ptf_fix_level__) + + +#elif defined(__ibmxl__) && defined(__clang__) +# define COMPILER_ID "XLClang" +# define COMPILER_VERSION_MAJOR DEC(__ibmxl_version__) +# define COMPILER_VERSION_MINOR DEC(__ibmxl_release__) +# define COMPILER_VERSION_PATCH DEC(__ibmxl_modification__) +# define COMPILER_VERSION_TWEAK DEC(__ibmxl_ptf_fix_level__) + + +#elif defined(__IBMCPP__) && !defined(__COMPILER_VER__) && __IBMCPP__ >= 800 +# define COMPILER_ID "XL" + /* __IBMCPP__ = VRP */ +# define COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100) +# define COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10) +# define COMPILER_VERSION_PATCH DEC(__IBMCPP__ % 10) + +#elif defined(__IBMCPP__) && !defined(__COMPILER_VER__) && __IBMCPP__ < 800 +# define COMPILER_ID "VisualAge" + /* __IBMCPP__ = VRP */ +# define COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100) +# define COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10) +# define COMPILER_VERSION_PATCH DEC(__IBMCPP__ % 10) + +#elif defined(__NVCOMPILER) +# define COMPILER_ID "NVHPC" +# define COMPILER_VERSION_MAJOR DEC(__NVCOMPILER_MAJOR__) +# define COMPILER_VERSION_MINOR DEC(__NVCOMPILER_MINOR__) +# if defined(__NVCOMPILER_PATCHLEVEL__) +# define COMPILER_VERSION_PATCH DEC(__NVCOMPILER_PATCHLEVEL__) +# endif + +#elif defined(__PGI) +# define COMPILER_ID "PGI" +# define COMPILER_VERSION_MAJOR DEC(__PGIC__) +# define COMPILER_VERSION_MINOR DEC(__PGIC_MINOR__) +# if defined(__PGIC_PATCHLEVEL__) +# define COMPILER_VERSION_PATCH DEC(__PGIC_PATCHLEVEL__) +# endif + +#elif defined(_CRAYC) +# define COMPILER_ID "Cray" +# define COMPILER_VERSION_MAJOR DEC(_RELEASE_MAJOR) +# define COMPILER_VERSION_MINOR DEC(_RELEASE_MINOR) + +#elif defined(__TI_COMPILER_VERSION__) +# define COMPILER_ID "TI" + /* __TI_COMPILER_VERSION__ = VVVRRRPPP */ +# define COMPILER_VERSION_MAJOR DEC(__TI_COMPILER_VERSION__/1000000) +# define COMPILER_VERSION_MINOR DEC(__TI_COMPILER_VERSION__/1000 % 1000) +# define COMPILER_VERSION_PATCH DEC(__TI_COMPILER_VERSION__ % 1000) + +#elif defined(__CLANG_FUJITSU) +# define COMPILER_ID "FujitsuClang" +# define COMPILER_VERSION_MAJOR DEC(__FCC_major__) +# define COMPILER_VERSION_MINOR DEC(__FCC_minor__) +# define COMPILER_VERSION_PATCH DEC(__FCC_patchlevel__) +# define COMPILER_VERSION_INTERNAL_STR __clang_version__ + + +#elif defined(__FUJITSU) +# define COMPILER_ID "Fujitsu" +# if defined(__FCC_version__) +# define COMPILER_VERSION __FCC_version__ +# elif defined(__FCC_major__) +# define COMPILER_VERSION_MAJOR DEC(__FCC_major__) +# define COMPILER_VERSION_MINOR DEC(__FCC_minor__) +# define COMPILER_VERSION_PATCH DEC(__FCC_patchlevel__) +# endif +# if defined(__fcc_version) +# define COMPILER_VERSION_INTERNAL DEC(__fcc_version) +# elif defined(__FCC_VERSION) +# define COMPILER_VERSION_INTERNAL DEC(__FCC_VERSION) +# endif + + +#elif defined(__ghs__) +# define COMPILER_ID "GHS" +/* __GHS_VERSION_NUMBER = VVVVRP */ +# ifdef __GHS_VERSION_NUMBER +# define COMPILER_VERSION_MAJOR DEC(__GHS_VERSION_NUMBER / 100) +# define COMPILER_VERSION_MINOR DEC(__GHS_VERSION_NUMBER / 10 % 10) +# define COMPILER_VERSION_PATCH DEC(__GHS_VERSION_NUMBER % 10) +# endif + +#elif defined(__TASKING__) +# define COMPILER_ID "Tasking" + # define COMPILER_VERSION_MAJOR DEC(__VERSION__/1000) + # define COMPILER_VERSION_MINOR DEC(__VERSION__ % 100) +# define COMPILER_VERSION_INTERNAL DEC(__VERSION__) + +#elif defined(__SCO_VERSION__) +# define COMPILER_ID "SCO" + +#elif defined(__ARMCC_VERSION) && !defined(__clang__) +# define COMPILER_ID "ARMCC" +#if __ARMCC_VERSION >= 1000000 + /* __ARMCC_VERSION = VRRPPPP */ + # define COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/1000000) + # define COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 100) + # define COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION % 10000) +#else + /* __ARMCC_VERSION = VRPPPP */ + # define COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/100000) + # define COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 10) + # define COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION % 10000) +#endif + + +#elif defined(__clang__) && defined(__apple_build_version__) +# define COMPILER_ID "AppleClang" +# if defined(_MSC_VER) +# define SIMULATE_ID "MSVC" +# endif +# define COMPILER_VERSION_MAJOR DEC(__clang_major__) +# define COMPILER_VERSION_MINOR DEC(__clang_minor__) +# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__) +# if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +# endif +# define COMPILER_VERSION_TWEAK DEC(__apple_build_version__) + +#elif defined(__clang__) && defined(__ARMCOMPILER_VERSION) +# define COMPILER_ID "ARMClang" + # define COMPILER_VERSION_MAJOR DEC(__ARMCOMPILER_VERSION/1000000) + # define COMPILER_VERSION_MINOR DEC(__ARMCOMPILER_VERSION/10000 % 100) + # define COMPILER_VERSION_PATCH DEC(__ARMCOMPILER_VERSION/100 % 100) +# define COMPILER_VERSION_INTERNAL DEC(__ARMCOMPILER_VERSION) + +#elif defined(__clang__) +# define COMPILER_ID "Clang" +# if defined(_MSC_VER) +# define SIMULATE_ID "MSVC" +# endif +# define COMPILER_VERSION_MAJOR DEC(__clang_major__) +# define COMPILER_VERSION_MINOR DEC(__clang_minor__) +# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__) +# if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +# endif + +#elif defined(__LCC__) && (defined(__GNUC__) || defined(__GNUG__) || defined(__MCST__)) +# define COMPILER_ID "LCC" +# define COMPILER_VERSION_MAJOR DEC(__LCC__ / 100) +# define COMPILER_VERSION_MINOR DEC(__LCC__ % 100) +# if defined(__LCC_MINOR__) +# define COMPILER_VERSION_PATCH DEC(__LCC_MINOR__) +# endif +# if defined(__GNUC__) && defined(__GNUC_MINOR__) +# define SIMULATE_ID "GNU" +# define SIMULATE_VERSION_MAJOR DEC(__GNUC__) +# define SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__) +# if defined(__GNUC_PATCHLEVEL__) +# define SIMULATE_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__) +# endif +# endif + +#elif defined(__GNUC__) || defined(__GNUG__) +# define COMPILER_ID "GNU" +# if defined(__GNUC__) +# define COMPILER_VERSION_MAJOR DEC(__GNUC__) +# else +# define COMPILER_VERSION_MAJOR DEC(__GNUG__) +# endif +# if defined(__GNUC_MINOR__) +# define COMPILER_VERSION_MINOR DEC(__GNUC_MINOR__) +# endif +# if defined(__GNUC_PATCHLEVEL__) +# define COMPILER_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__) +# endif + +#elif defined(_MSC_VER) +# define COMPILER_ID "MSVC" + /* _MSC_VER = VVRR */ +# define COMPILER_VERSION_MAJOR DEC(_MSC_VER / 100) +# define COMPILER_VERSION_MINOR DEC(_MSC_VER % 100) +# if defined(_MSC_FULL_VER) +# if _MSC_VER >= 1400 + /* _MSC_FULL_VER = VVRRPPPPP */ +# define COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 100000) +# else + /* _MSC_FULL_VER = VVRRPPPP */ +# define COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 10000) +# endif +# endif +# if defined(_MSC_BUILD) +# define COMPILER_VERSION_TWEAK DEC(_MSC_BUILD) +# endif + +#elif defined(_ADI_COMPILER) +# define COMPILER_ID "ADSP" +#if defined(__VERSIONNUM__) + /* __VERSIONNUM__ = 0xVVRRPPTT */ +# define COMPILER_VERSION_MAJOR DEC(__VERSIONNUM__ >> 24 & 0xFF) +# define COMPILER_VERSION_MINOR DEC(__VERSIONNUM__ >> 16 & 0xFF) +# define COMPILER_VERSION_PATCH DEC(__VERSIONNUM__ >> 8 & 0xFF) +# define COMPILER_VERSION_TWEAK DEC(__VERSIONNUM__ & 0xFF) +#endif + +#elif defined(__IAR_SYSTEMS_ICC__) || defined(__IAR_SYSTEMS_ICC) +# define COMPILER_ID "IAR" +# if defined(__VER__) && defined(__ICCARM__) +# define COMPILER_VERSION_MAJOR DEC((__VER__) / 1000000) +# define COMPILER_VERSION_MINOR DEC(((__VER__) / 1000) % 1000) +# define COMPILER_VERSION_PATCH DEC((__VER__) % 1000) +# define COMPILER_VERSION_INTERNAL DEC(__IAR_SYSTEMS_ICC__) +# elif defined(__VER__) && (defined(__ICCAVR__) || defined(__ICCRX__) || defined(__ICCRH850__) || defined(__ICCRL78__) || defined(__ICC430__) || defined(__ICCRISCV__) || defined(__ICCV850__) || defined(__ICC8051__) || defined(__ICCSTM8__)) +# define COMPILER_VERSION_MAJOR DEC((__VER__) / 100) +# define COMPILER_VERSION_MINOR DEC((__VER__) - (((__VER__) / 100)*100)) +# define COMPILER_VERSION_PATCH DEC(__SUBVERSION__) +# define COMPILER_VERSION_INTERNAL DEC(__IAR_SYSTEMS_ICC__) +# endif + + +/* These compilers are either not known or too old to define an + identification macro. Try to identify the platform and guess that + it is the native compiler. */ +#elif defined(__hpux) || defined(__hpua) +# define COMPILER_ID "HP" + +#else /* unknown compiler */ +# define COMPILER_ID "" +#endif + +/* Construct the string literal in pieces to prevent the source from + getting matched. Store it in a pointer rather than an array + because some compilers will just produce instructions to fill the + array rather than assigning a pointer to a static array. */ +char const* info_compiler = "INFO" ":" "compiler[" COMPILER_ID "]"; +#ifdef SIMULATE_ID +char const* info_simulate = "INFO" ":" "simulate[" SIMULATE_ID "]"; +#endif + +#ifdef __QNXNTO__ +char const* qnxnto = "INFO" ":" "qnxnto[]"; +#endif + +#if defined(__CRAYXT_COMPUTE_LINUX_TARGET) +char const *info_cray = "INFO" ":" "compiler_wrapper[CrayPrgEnv]"; +#endif + +#define STRINGIFY_HELPER(X) #X +#define STRINGIFY(X) STRINGIFY_HELPER(X) + +/* Identify known platforms by name. */ +#if defined(__linux) || defined(__linux__) || defined(linux) +# define PLATFORM_ID "Linux" + +#elif defined(__MSYS__) +# define PLATFORM_ID "MSYS" + +#elif defined(__CYGWIN__) +# define PLATFORM_ID "Cygwin" + +#elif defined(__MINGW32__) +# define PLATFORM_ID "MinGW" + +#elif defined(__APPLE__) +# define PLATFORM_ID "Darwin" + +#elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32) +# define PLATFORM_ID "Windows" + +#elif defined(__FreeBSD__) || defined(__FreeBSD) +# define PLATFORM_ID "FreeBSD" + +#elif defined(__NetBSD__) || defined(__NetBSD) +# define PLATFORM_ID "NetBSD" + +#elif defined(__OpenBSD__) || defined(__OPENBSD) +# define PLATFORM_ID "OpenBSD" + +#elif defined(__sun) || defined(sun) +# define PLATFORM_ID "SunOS" + +#elif defined(_AIX) || defined(__AIX) || defined(__AIX__) || defined(__aix) || defined(__aix__) +# define PLATFORM_ID "AIX" + +#elif defined(__hpux) || defined(__hpux__) +# define PLATFORM_ID "HP-UX" + +#elif defined(__HAIKU__) +# define PLATFORM_ID "Haiku" + +#elif defined(__BeOS) || defined(__BEOS__) || defined(_BEOS) +# define PLATFORM_ID "BeOS" + +#elif defined(__QNX__) || defined(__QNXNTO__) +# define PLATFORM_ID "QNX" + +#elif defined(__tru64) || defined(_tru64) || defined(__TRU64__) +# define PLATFORM_ID "Tru64" + +#elif defined(__riscos) || defined(__riscos__) +# define PLATFORM_ID "RISCos" + +#elif defined(__sinix) || defined(__sinix__) || defined(__SINIX__) +# define PLATFORM_ID "SINIX" + +#elif defined(__UNIX_SV__) +# define PLATFORM_ID "UNIX_SV" + +#elif defined(__bsdos__) +# define PLATFORM_ID "BSDOS" + +#elif defined(_MPRAS) || defined(MPRAS) +# define PLATFORM_ID "MP-RAS" + +#elif defined(__osf) || defined(__osf__) +# define PLATFORM_ID "OSF1" + +#elif defined(_SCO_SV) || defined(SCO_SV) || defined(sco_sv) +# define PLATFORM_ID "SCO_SV" + +#elif defined(__ultrix) || defined(__ultrix__) || defined(_ULTRIX) +# define PLATFORM_ID "ULTRIX" + +#elif defined(__XENIX__) || defined(_XENIX) || defined(XENIX) +# define PLATFORM_ID "Xenix" + +#elif defined(__WATCOMC__) +# if defined(__LINUX__) +# define PLATFORM_ID "Linux" + +# elif defined(__DOS__) +# define PLATFORM_ID "DOS" + +# elif defined(__OS2__) +# define PLATFORM_ID "OS2" + +# elif defined(__WINDOWS__) +# define PLATFORM_ID "Windows3x" + +# elif defined(__VXWORKS__) +# define PLATFORM_ID "VxWorks" + +# else /* unknown platform */ +# define PLATFORM_ID +# endif + +#elif defined(__INTEGRITY) +# if defined(INT_178B) +# define PLATFORM_ID "Integrity178" + +# else /* regular Integrity */ +# define PLATFORM_ID "Integrity" +# endif + +# elif defined(_ADI_COMPILER) +# define PLATFORM_ID "ADSP" + +#else /* unknown platform */ +# define PLATFORM_ID + +#endif + +/* For windows compilers MSVC and Intel we can determine + the architecture of the compiler being used. This is because + the compilers do not have flags that can change the architecture, + but rather depend on which compiler is being used +*/ +#if defined(_WIN32) && defined(_MSC_VER) +# if defined(_M_IA64) +# define ARCHITECTURE_ID "IA64" + +# elif defined(_M_ARM64EC) +# define ARCHITECTURE_ID "ARM64EC" + +# elif defined(_M_X64) || defined(_M_AMD64) +# define ARCHITECTURE_ID "x64" + +# elif defined(_M_IX86) +# define ARCHITECTURE_ID "X86" + +# elif defined(_M_ARM64) +# define ARCHITECTURE_ID "ARM64" + +# elif defined(_M_ARM) +# if _M_ARM == 4 +# define ARCHITECTURE_ID "ARMV4I" +# elif _M_ARM == 5 +# define ARCHITECTURE_ID "ARMV5I" +# else +# define ARCHITECTURE_ID "ARMV" STRINGIFY(_M_ARM) +# endif + +# elif defined(_M_MIPS) +# define ARCHITECTURE_ID "MIPS" + +# elif defined(_M_SH) +# define ARCHITECTURE_ID "SHx" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__WATCOMC__) +# if defined(_M_I86) +# define ARCHITECTURE_ID "I86" + +# elif defined(_M_IX86) +# define ARCHITECTURE_ID "X86" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__IAR_SYSTEMS_ICC__) || defined(__IAR_SYSTEMS_ICC) +# if defined(__ICCARM__) +# define ARCHITECTURE_ID "ARM" + +# elif defined(__ICCRX__) +# define ARCHITECTURE_ID "RX" + +# elif defined(__ICCRH850__) +# define ARCHITECTURE_ID "RH850" + +# elif defined(__ICCRL78__) +# define ARCHITECTURE_ID "RL78" + +# elif defined(__ICCRISCV__) +# define ARCHITECTURE_ID "RISCV" + +# elif defined(__ICCAVR__) +# define ARCHITECTURE_ID "AVR" + +# elif defined(__ICC430__) +# define ARCHITECTURE_ID "MSP430" + +# elif defined(__ICCV850__) +# define ARCHITECTURE_ID "V850" + +# elif defined(__ICC8051__) +# define ARCHITECTURE_ID "8051" + +# elif defined(__ICCSTM8__) +# define ARCHITECTURE_ID "STM8" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__ghs__) +# if defined(__PPC64__) +# define ARCHITECTURE_ID "PPC64" + +# elif defined(__ppc__) +# define ARCHITECTURE_ID "PPC" + +# elif defined(__ARM__) +# define ARCHITECTURE_ID "ARM" + +# elif defined(__x86_64__) +# define ARCHITECTURE_ID "x64" + +# elif defined(__i386__) +# define ARCHITECTURE_ID "X86" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__TI_COMPILER_VERSION__) +# if defined(__TI_ARM__) +# define ARCHITECTURE_ID "ARM" + +# elif defined(__MSP430__) +# define ARCHITECTURE_ID "MSP430" + +# elif defined(__TMS320C28XX__) +# define ARCHITECTURE_ID "TMS320C28x" + +# elif defined(__TMS320C6X__) || defined(_TMS320C6X) +# define ARCHITECTURE_ID "TMS320C6x" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +# elif defined(__ADSPSHARC__) +# define ARCHITECTURE_ID "SHARC" + +# elif defined(__ADSPBLACKFIN__) +# define ARCHITECTURE_ID "Blackfin" + +#elif defined(__TASKING__) + +# if defined(__CTC__) || defined(__CPTC__) +# define ARCHITECTURE_ID "TriCore" + +# elif defined(__CMCS__) +# define ARCHITECTURE_ID "MCS" + +# elif defined(__CARM__) +# define ARCHITECTURE_ID "ARM" + +# elif defined(__CARC__) +# define ARCHITECTURE_ID "ARC" + +# elif defined(__C51__) +# define ARCHITECTURE_ID "8051" + +# elif defined(__CPCP__) +# define ARCHITECTURE_ID "PCP" + +# else +# define ARCHITECTURE_ID "" +# endif + +#else +# define ARCHITECTURE_ID +#endif + +/* Convert integer to decimal digit literals. */ +#define DEC(n) \ + ('0' + (((n) / 10000000)%10)), \ + ('0' + (((n) / 1000000)%10)), \ + ('0' + (((n) / 100000)%10)), \ + ('0' + (((n) / 10000)%10)), \ + ('0' + (((n) / 1000)%10)), \ + ('0' + (((n) / 100)%10)), \ + ('0' + (((n) / 10)%10)), \ + ('0' + ((n) % 10)) + +/* Convert integer to hex digit literals. */ +#define HEX(n) \ + ('0' + ((n)>>28 & 0xF)), \ + ('0' + ((n)>>24 & 0xF)), \ + ('0' + ((n)>>20 & 0xF)), \ + ('0' + ((n)>>16 & 0xF)), \ + ('0' + ((n)>>12 & 0xF)), \ + ('0' + ((n)>>8 & 0xF)), \ + ('0' + ((n)>>4 & 0xF)), \ + ('0' + ((n) & 0xF)) + +/* Construct a string literal encoding the version number. */ +#ifdef COMPILER_VERSION +char const* info_version = "INFO" ":" "compiler_version[" COMPILER_VERSION "]"; + +/* Construct a string literal encoding the version number components. */ +#elif defined(COMPILER_VERSION_MAJOR) +char const info_version[] = { + 'I', 'N', 'F', 'O', ':', + 'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','[', + COMPILER_VERSION_MAJOR, +# ifdef COMPILER_VERSION_MINOR + '.', COMPILER_VERSION_MINOR, +# ifdef COMPILER_VERSION_PATCH + '.', COMPILER_VERSION_PATCH, +# ifdef COMPILER_VERSION_TWEAK + '.', COMPILER_VERSION_TWEAK, +# endif +# endif +# endif + ']','\0'}; +#endif + +/* Construct a string literal encoding the internal version number. */ +#ifdef COMPILER_VERSION_INTERNAL +char const info_version_internal[] = { + 'I', 'N', 'F', 'O', ':', + 'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','_', + 'i','n','t','e','r','n','a','l','[', + COMPILER_VERSION_INTERNAL,']','\0'}; +#elif defined(COMPILER_VERSION_INTERNAL_STR) +char const* info_version_internal = "INFO" ":" "compiler_version_internal[" COMPILER_VERSION_INTERNAL_STR "]"; +#endif + +/* Construct a string literal encoding the version number components. */ +#ifdef SIMULATE_VERSION_MAJOR +char const info_simulate_version[] = { + 'I', 'N', 'F', 'O', ':', + 's','i','m','u','l','a','t','e','_','v','e','r','s','i','o','n','[', + SIMULATE_VERSION_MAJOR, +# ifdef SIMULATE_VERSION_MINOR + '.', SIMULATE_VERSION_MINOR, +# ifdef SIMULATE_VERSION_PATCH + '.', SIMULATE_VERSION_PATCH, +# ifdef SIMULATE_VERSION_TWEAK + '.', SIMULATE_VERSION_TWEAK, +# endif +# endif +# endif + ']','\0'}; +#endif + +/* Construct the string literal in pieces to prevent the source from + getting matched. Store it in a pointer rather than an array + because some compilers will just produce instructions to fill the + array rather than assigning a pointer to a static array. */ +char const* info_platform = "INFO" ":" "platform[" PLATFORM_ID "]"; +char const* info_arch = "INFO" ":" "arch[" ARCHITECTURE_ID "]"; + + + +#if defined(__INTEL_COMPILER) && defined(_MSVC_LANG) && _MSVC_LANG < 201403L +# if defined(__INTEL_CXX11_MODE__) +# if defined(__cpp_aggregate_nsdmi) +# define CXX_STD 201402L +# else +# define CXX_STD 201103L +# endif +# else +# define CXX_STD 199711L +# endif +#elif defined(_MSC_VER) && defined(_MSVC_LANG) +# define CXX_STD _MSVC_LANG +#else +# define CXX_STD __cplusplus +#endif + +const char* info_language_standard_default = "INFO" ":" "standard_default[" +#if CXX_STD > 202002L + "23" +#elif CXX_STD > 201703L + "20" +#elif CXX_STD >= 201703L + "17" +#elif CXX_STD >= 201402L + "14" +#elif CXX_STD >= 201103L + "11" +#else + "98" +#endif +"]"; + +const char* info_language_extensions_default = "INFO" ":" "extensions_default[" +#if (defined(__clang__) || defined(__GNUC__) || defined(__xlC__) || \ + defined(__TI_COMPILER_VERSION__)) && \ + !defined(__STRICT_ANSI__) + "ON" +#else + "OFF" +#endif +"]"; + +/*--------------------------------------------------------------------------*/ + +int main(int argc, char* argv[]) +{ + int require = 0; + require += info_compiler[argc]; + require += info_platform[argc]; + require += info_arch[argc]; +#ifdef COMPILER_VERSION_MAJOR + require += info_version[argc]; +#endif +#ifdef COMPILER_VERSION_INTERNAL + require += info_version_internal[argc]; +#endif +#ifdef SIMULATE_ID + require += info_simulate[argc]; +#endif +#ifdef SIMULATE_VERSION_MAJOR + require += info_simulate_version[argc]; +#endif +#if defined(__CRAYXT_COMPUTE_LINUX_TARGET) + require += info_cray[argc]; +#endif + require += info_language_standard_default[argc]; + require += info_language_extensions_default[argc]; + (void)argv; + return require; +} diff --git a/REAPER/build/CMakeFiles/3.27.9/CompilerIdCXX/a.out b/REAPER/build/CMakeFiles/3.27.9/CompilerIdCXX/a.out new file mode 100644 index 0000000000000000000000000000000000000000..6f7591430982e78f058bf3d0fb3528e454cf27eb Binary files /dev/null and b/REAPER/build/CMakeFiles/3.27.9/CompilerIdCXX/a.out differ diff --git a/REAPER/build/CMakeFiles/CMakeConfigureLog.yaml b/REAPER/build/CMakeFiles/CMakeConfigureLog.yaml new file mode 100644 index 0000000000000000000000000000000000000000..d0abef5f3d2449a0983b5e7d331eda74b3e17d84 --- /dev/null +++ b/REAPER/build/CMakeFiles/CMakeConfigureLog.yaml @@ -0,0 +1,607 @@ + +--- +events: + - + kind: "message-v1" + backtrace: + - "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CMakeDetermineSystem.cmake:211 (message)" + - "CMakeLists.txt:2 (project)" + message: | + The system is: Linux - 6.1.58+ - x86_64 + - + kind: "message-v1" + backtrace: + - "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CMakeDetermineCompilerId.cmake:17 (message)" + - "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CMakeDetermineCompilerId.cmake:64 (__determine_compiler_id_test)" + - "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CMakeDetermineCCompiler.cmake:123 (CMAKE_DETERMINE_COMPILER_ID)" + - "CMakeLists.txt:2 (project)" + message: | + Compiling the C compiler identification source file "CMakeCCompilerId.c" succeeded. + Compiler: /usr/bin/cc + Build flags: + Id flags: + + The output was: + 0 + + + Compilation of the C compiler identification source "CMakeCCompilerId.c" produced "a.out" + + The C compiler identification is GNU, found in: + /content/NeuCoSVC-2/REAPER/build/CMakeFiles/3.27.9/CompilerIdC/a.out + + - + kind: "message-v1" + backtrace: + - "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CMakeDetermineCompilerId.cmake:17 (message)" + - "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CMakeDetermineCompilerId.cmake:64 (__determine_compiler_id_test)" + - "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CMakeDetermineCXXCompiler.cmake:126 (CMAKE_DETERMINE_COMPILER_ID)" + - "CMakeLists.txt:2 (project)" + message: | + Compiling the CXX compiler identification source file "CMakeCXXCompilerId.cpp" succeeded. + Compiler: /usr/bin/c++ + Build flags: + Id flags: + + The output was: + 0 + + + Compilation of the CXX compiler identification source "CMakeCXXCompilerId.cpp" produced "a.out" + + The CXX compiler identification is GNU, found in: + /content/NeuCoSVC-2/REAPER/build/CMakeFiles/3.27.9/CompilerIdCXX/a.out + + - + kind: "try_compile-v1" + backtrace: + - "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CMakeDetermineCompilerABI.cmake:57 (try_compile)" + - "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CMakeTestCCompiler.cmake:26 (CMAKE_DETERMINE_COMPILER_ABI)" + - "CMakeLists.txt:2 (project)" + checks: + - "Detecting C compiler ABI info" + directories: + source: "/content/NeuCoSVC-2/REAPER/build/CMakeFiles/CMakeScratch/TryCompile-SVHLW0" + binary: "/content/NeuCoSVC-2/REAPER/build/CMakeFiles/CMakeScratch/TryCompile-SVHLW0" + cmakeVariables: + CMAKE_C_FLAGS: "" + buildResult: + variable: "CMAKE_C_ABI_COMPILED" + cached: true + stdout: | + Change Dir: '/content/NeuCoSVC-2/REAPER/build/CMakeFiles/CMakeScratch/TryCompile-SVHLW0' + + Run Build Command(s): /usr/local/lib/python3.10/dist-packages/cmake/data/bin/cmake -E env VERBOSE=1 /usr/bin/gmake -f Makefile cmTC_9a52d/fast + /usr/bin/gmake -f CMakeFiles/cmTC_9a52d.dir/build.make CMakeFiles/cmTC_9a52d.dir/build + gmake[1]: Entering directory '/content/NeuCoSVC-2/REAPER/build/CMakeFiles/CMakeScratch/TryCompile-SVHLW0' + Building C object CMakeFiles/cmTC_9a52d.dir/CMakeCCompilerABI.c.o + /usr/bin/cc -v -o CMakeFiles/cmTC_9a52d.dir/CMakeCCompilerABI.c.o -c /usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CMakeCCompilerABI.c + Using built-in specs. + COLLECT_GCC=/usr/bin/cc + OFFLOAD_TARGET_NAMES=nvptx-none:amdgcn-amdhsa + OFFLOAD_TARGET_DEFAULT=1 + Target: x86_64-linux-gnu + Configured with: ../src/configure -v --with-pkgversion='Ubuntu 11.4.0-1ubuntu1~22.04' --with-bugurl=file:///usr/share/doc/gcc-11/README.Bugs --enable-languages=c,ada,c++,go,brig,d,fortran,objc,obj-c++,m2 --prefix=/usr --with-gcc-major-version-only --program-suffix=-11 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --enable-bootstrap --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-gnu-unique-object --disable-vtable-verify --enable-plugin --enable-default-pie --with-system-zlib --enable-libphobos-checking=release --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --enable-cet --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32,m64,mx32 --enable-multilib --with-tune=generic --enable-offload-targets=nvptx-none=/build/gcc-11-XeT9lY/gcc-11-11.4.0/debian/tmp-nvptx/usr,amdgcn-amdhsa=/build/gcc-11-XeT9lY/gcc-11-11.4.0/debian/tmp-gcn/usr --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu --with-build-config=bootstrap-lto-lean --enable-link-serialization=2 + Thread model: posix + Supported LTO compression algorithms: zlib zstd + gcc version 11.4.0 (Ubuntu 11.4.0-1ubuntu1~22.04) + COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_9a52d.dir/CMakeCCompilerABI.c.o' '-c' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_9a52d.dir/' + /usr/lib/gcc/x86_64-linux-gnu/11/cc1 -quiet -v -imultiarch x86_64-linux-gnu /usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CMakeCCompilerABI.c -quiet -dumpdir CMakeFiles/cmTC_9a52d.dir/ -dumpbase CMakeCCompilerABI.c.c -dumpbase-ext .c -mtune=generic -march=x86-64 -version -fasynchronous-unwind-tables -fstack-protector-strong -Wformat -Wformat-security -fstack-clash-protection -fcf-protection -o /tmp/cctlvjNe.s + GNU C17 (Ubuntu 11.4.0-1ubuntu1~22.04) version 11.4.0 (x86_64-linux-gnu) + compiled by GNU C version 11.4.0, GMP version 6.2.1, MPFR version 4.1.0, MPC version 1.2.1, isl version isl-0.24-GMP + + GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072 + ignoring nonexistent directory "/usr/local/include/x86_64-linux-gnu" + ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/11/include-fixed" + ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/11/../../../../x86_64-linux-gnu/include" + #include "..." search starts here: + #include <...> search starts here: + /usr/lib/gcc/x86_64-linux-gnu/11/include + /usr/local/include + /usr/include/x86_64-linux-gnu + /usr/include + End of search list. + GNU C17 (Ubuntu 11.4.0-1ubuntu1~22.04) version 11.4.0 (x86_64-linux-gnu) + compiled by GNU C version 11.4.0, GMP version 6.2.1, MPFR version 4.1.0, MPC version 1.2.1, isl version isl-0.24-GMP + + GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072 + Compiler executable checksum: 50eaa2331df977b8016186198deb2d18 + COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_9a52d.dir/CMakeCCompilerABI.c.o' '-c' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_9a52d.dir/' + as -v --64 -o CMakeFiles/cmTC_9a52d.dir/CMakeCCompilerABI.c.o /tmp/cctlvjNe.s + GNU assembler version 2.38 (x86_64-linux-gnu) using BFD version (GNU Binutils for Ubuntu) 2.38 + COMPILER_PATH=/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/ + LIBRARY_PATH=/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/usr/local/cuda/lib64/stubs/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../:/lib/:/usr/lib/ + COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_9a52d.dir/CMakeCCompilerABI.c.o' '-c' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_9a52d.dir/CMakeCCompilerABI.c.' + Linking C executable cmTC_9a52d + /usr/local/lib/python3.10/dist-packages/cmake/data/bin/cmake -E cmake_link_script CMakeFiles/cmTC_9a52d.dir/link.txt --verbose=1 + /usr/bin/cc -v -rdynamic CMakeFiles/cmTC_9a52d.dir/CMakeCCompilerABI.c.o -o cmTC_9a52d + Using built-in specs. + COLLECT_GCC=/usr/bin/cc + COLLECT_LTO_WRAPPER=/usr/lib/gcc/x86_64-linux-gnu/11/lto-wrapper + OFFLOAD_TARGET_NAMES=nvptx-none:amdgcn-amdhsa + OFFLOAD_TARGET_DEFAULT=1 + Target: x86_64-linux-gnu + Configured with: ../src/configure -v --with-pkgversion='Ubuntu 11.4.0-1ubuntu1~22.04' --with-bugurl=file:///usr/share/doc/gcc-11/README.Bugs --enable-languages=c,ada,c++,go,brig,d,fortran,objc,obj-c++,m2 --prefix=/usr --with-gcc-major-version-only --program-suffix=-11 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --enable-bootstrap --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-gnu-unique-object --disable-vtable-verify --enable-plugin --enable-default-pie --with-system-zlib --enable-libphobos-checking=release --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --enable-cet --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32,m64,mx32 --enable-multilib --with-tune=generic --enable-offload-targets=nvptx-none=/build/gcc-11-XeT9lY/gcc-11-11.4.0/debian/tmp-nvptx/usr,amdgcn-amdhsa=/build/gcc-11-XeT9lY/gcc-11-11.4.0/debian/tmp-gcn/usr --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu --with-build-config=bootstrap-lto-lean --enable-link-serialization=2 + Thread model: posix + Supported LTO compression algorithms: zlib zstd + gcc version 11.4.0 (Ubuntu 11.4.0-1ubuntu1~22.04) + COMPILER_PATH=/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/ + LIBRARY_PATH=/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/usr/local/cuda/lib64/stubs/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../:/lib/:/usr/lib/ + COLLECT_GCC_OPTIONS='-v' '-rdynamic' '-o' 'cmTC_9a52d' '-mtune=generic' '-march=x86-64' '-dumpdir' 'cmTC_9a52d.' + /usr/lib/gcc/x86_64-linux-gnu/11/collect2 -plugin /usr/lib/gcc/x86_64-linux-gnu/11/liblto_plugin.so -plugin-opt=/usr/lib/gcc/x86_64-linux-gnu/11/lto-wrapper -plugin-opt=-fresolution=/tmp/ccQkw7jQ.res -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lc -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lgcc_s --build-id --eh-frame-hdr -m elf_x86_64 --hash-style=gnu --as-needed -export-dynamic -dynamic-linker /lib64/ld-linux-x86-64.so.2 -pie -z now -z relro -o cmTC_9a52d /usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/Scrt1.o /usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/crti.o /usr/lib/gcc/x86_64-linux-gnu/11/crtbeginS.o -L/usr/lib/gcc/x86_64-linux-gnu/11 -L/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu -L/usr/lib/gcc/x86_64-linux-gnu/11/../../../../lib -L/lib/x86_64-linux-gnu -L/lib/../lib -L/usr/lib/x86_64-linux-gnu -L/usr/lib/../lib -L/usr/local/cuda/lib64/stubs -L/usr/lib/gcc/x86_64-linux-gnu/11/../../.. CMakeFiles/cmTC_9a52d.dir/CMakeCCompilerABI.c.o -lgcc --push-state --as-needed -lgcc_s --pop-state -lc -lgcc --push-state --as-needed -lgcc_s --pop-state /usr/lib/gcc/x86_64-linux-gnu/11/crtendS.o /usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/crtn.o + COLLECT_GCC_OPTIONS='-v' '-rdynamic' '-o' 'cmTC_9a52d' '-mtune=generic' '-march=x86-64' '-dumpdir' 'cmTC_9a52d.' + gmake[1]: Leaving directory '/content/NeuCoSVC-2/REAPER/build/CMakeFiles/CMakeScratch/TryCompile-SVHLW0' + + exitCode: 0 + - + kind: "message-v1" + backtrace: + - "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CMakeDetermineCompilerABI.cmake:127 (message)" + - "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CMakeTestCCompiler.cmake:26 (CMAKE_DETERMINE_COMPILER_ABI)" + - "CMakeLists.txt:2 (project)" + message: | + Parsed C implicit include dir info: rv=done + found start of include info + found start of implicit include info + add: [/usr/lib/gcc/x86_64-linux-gnu/11/include] + add: [/usr/local/include] + add: [/usr/include/x86_64-linux-gnu] + add: [/usr/include] + end of search list found + collapse include dir [/usr/lib/gcc/x86_64-linux-gnu/11/include] ==> [/usr/lib/gcc/x86_64-linux-gnu/11/include] + collapse include dir [/usr/local/include] ==> [/usr/local/include] + collapse include dir [/usr/include/x86_64-linux-gnu] ==> [/usr/include/x86_64-linux-gnu] + collapse include dir [/usr/include] ==> [/usr/include] + implicit include dirs: [/usr/lib/gcc/x86_64-linux-gnu/11/include;/usr/local/include;/usr/include/x86_64-linux-gnu;/usr/include] + + + - + kind: "message-v1" + backtrace: + - "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CMakeDetermineCompilerABI.cmake:152 (message)" + - "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CMakeTestCCompiler.cmake:26 (CMAKE_DETERMINE_COMPILER_ABI)" + - "CMakeLists.txt:2 (project)" + message: | + Parsed C implicit link information: + link line regex: [^( *|.*[/\\])(ld|CMAKE_LINK_STARTFILE-NOTFOUND|([^/\\]+-)?ld|collect2)[^/\\]*( |$)] + ignore line: [Change Dir: '/content/NeuCoSVC-2/REAPER/build/CMakeFiles/CMakeScratch/TryCompile-SVHLW0'] + ignore line: [] + ignore line: [Run Build Command(s): /usr/local/lib/python3.10/dist-packages/cmake/data/bin/cmake -E env VERBOSE=1 /usr/bin/gmake -f Makefile cmTC_9a52d/fast] + ignore line: [/usr/bin/gmake -f CMakeFiles/cmTC_9a52d.dir/build.make CMakeFiles/cmTC_9a52d.dir/build] + ignore line: [gmake[1]: Entering directory '/content/NeuCoSVC-2/REAPER/build/CMakeFiles/CMakeScratch/TryCompile-SVHLW0'] + ignore line: [Building C object CMakeFiles/cmTC_9a52d.dir/CMakeCCompilerABI.c.o] + ignore line: [/usr/bin/cc -v -o CMakeFiles/cmTC_9a52d.dir/CMakeCCompilerABI.c.o -c /usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CMakeCCompilerABI.c] + ignore line: [Using built-in specs.] + ignore line: [COLLECT_GCC=/usr/bin/cc] + ignore line: [OFFLOAD_TARGET_NAMES=nvptx-none:amdgcn-amdhsa] + ignore line: [OFFLOAD_TARGET_DEFAULT=1] + ignore line: [Target: x86_64-linux-gnu] + ignore line: [Configured with: ../src/configure -v --with-pkgversion='Ubuntu 11.4.0-1ubuntu1~22.04' --with-bugurl=file:///usr/share/doc/gcc-11/README.Bugs --enable-languages=c ada c++ go brig d fortran objc obj-c++ m2 --prefix=/usr --with-gcc-major-version-only --program-suffix=-11 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --enable-bootstrap --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-gnu-unique-object --disable-vtable-verify --enable-plugin --enable-default-pie --with-system-zlib --enable-libphobos-checking=release --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --enable-cet --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32 m64 mx32 --enable-multilib --with-tune=generic --enable-offload-targets=nvptx-none=/build/gcc-11-XeT9lY/gcc-11-11.4.0/debian/tmp-nvptx/usr amdgcn-amdhsa=/build/gcc-11-XeT9lY/gcc-11-11.4.0/debian/tmp-gcn/usr --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu --with-build-config=bootstrap-lto-lean --enable-link-serialization=2] + ignore line: [Thread model: posix] + ignore line: [Supported LTO compression algorithms: zlib zstd] + ignore line: [gcc version 11.4.0 (Ubuntu 11.4.0-1ubuntu1~22.04) ] + ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_9a52d.dir/CMakeCCompilerABI.c.o' '-c' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_9a52d.dir/'] + ignore line: [ /usr/lib/gcc/x86_64-linux-gnu/11/cc1 -quiet -v -imultiarch x86_64-linux-gnu /usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CMakeCCompilerABI.c -quiet -dumpdir CMakeFiles/cmTC_9a52d.dir/ -dumpbase CMakeCCompilerABI.c.c -dumpbase-ext .c -mtune=generic -march=x86-64 -version -fasynchronous-unwind-tables -fstack-protector-strong -Wformat -Wformat-security -fstack-clash-protection -fcf-protection -o /tmp/cctlvjNe.s] + ignore line: [GNU C17 (Ubuntu 11.4.0-1ubuntu1~22.04) version 11.4.0 (x86_64-linux-gnu)] + ignore line: [ compiled by GNU C version 11.4.0 GMP version 6.2.1 MPFR version 4.1.0 MPC version 1.2.1 isl version isl-0.24-GMP] + ignore line: [] + ignore line: [GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072] + ignore line: [ignoring nonexistent directory "/usr/local/include/x86_64-linux-gnu"] + ignore line: [ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/11/include-fixed"] + ignore line: [ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/11/../../../../x86_64-linux-gnu/include"] + ignore line: [#include "..." search starts here:] + ignore line: [#include <...> search starts here:] + ignore line: [ /usr/lib/gcc/x86_64-linux-gnu/11/include] + ignore line: [ /usr/local/include] + ignore line: [ /usr/include/x86_64-linux-gnu] + ignore line: [ /usr/include] + ignore line: [End of search list.] + ignore line: [GNU C17 (Ubuntu 11.4.0-1ubuntu1~22.04) version 11.4.0 (x86_64-linux-gnu)] + ignore line: [ compiled by GNU C version 11.4.0 GMP version 6.2.1 MPFR version 4.1.0 MPC version 1.2.1 isl version isl-0.24-GMP] + ignore line: [] + ignore line: [GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072] + ignore line: [Compiler executable checksum: 50eaa2331df977b8016186198deb2d18] + ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_9a52d.dir/CMakeCCompilerABI.c.o' '-c' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_9a52d.dir/'] + ignore line: [ as -v --64 -o CMakeFiles/cmTC_9a52d.dir/CMakeCCompilerABI.c.o /tmp/cctlvjNe.s] + ignore line: [GNU assembler version 2.38 (x86_64-linux-gnu) using BFD version (GNU Binutils for Ubuntu) 2.38] + ignore line: [COMPILER_PATH=/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/] + ignore line: [LIBRARY_PATH=/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/usr/local/cuda/lib64/stubs/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../:/lib/:/usr/lib/] + ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_9a52d.dir/CMakeCCompilerABI.c.o' '-c' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_9a52d.dir/CMakeCCompilerABI.c.'] + ignore line: [Linking C executable cmTC_9a52d] + ignore line: [/usr/local/lib/python3.10/dist-packages/cmake/data/bin/cmake -E cmake_link_script CMakeFiles/cmTC_9a52d.dir/link.txt --verbose=1] + ignore line: [/usr/bin/cc -v -rdynamic CMakeFiles/cmTC_9a52d.dir/CMakeCCompilerABI.c.o -o cmTC_9a52d ] + ignore line: [Using built-in specs.] + ignore line: [COLLECT_GCC=/usr/bin/cc] + ignore line: [COLLECT_LTO_WRAPPER=/usr/lib/gcc/x86_64-linux-gnu/11/lto-wrapper] + ignore line: [OFFLOAD_TARGET_NAMES=nvptx-none:amdgcn-amdhsa] + ignore line: [OFFLOAD_TARGET_DEFAULT=1] + ignore line: [Target: x86_64-linux-gnu] + ignore line: [Configured with: ../src/configure -v --with-pkgversion='Ubuntu 11.4.0-1ubuntu1~22.04' --with-bugurl=file:///usr/share/doc/gcc-11/README.Bugs --enable-languages=c ada c++ go brig d fortran objc obj-c++ m2 --prefix=/usr --with-gcc-major-version-only --program-suffix=-11 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --enable-bootstrap --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-gnu-unique-object --disable-vtable-verify --enable-plugin --enable-default-pie --with-system-zlib --enable-libphobos-checking=release --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --enable-cet --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32 m64 mx32 --enable-multilib --with-tune=generic --enable-offload-targets=nvptx-none=/build/gcc-11-XeT9lY/gcc-11-11.4.0/debian/tmp-nvptx/usr amdgcn-amdhsa=/build/gcc-11-XeT9lY/gcc-11-11.4.0/debian/tmp-gcn/usr --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu --with-build-config=bootstrap-lto-lean --enable-link-serialization=2] + ignore line: [Thread model: posix] + ignore line: [Supported LTO compression algorithms: zlib zstd] + ignore line: [gcc version 11.4.0 (Ubuntu 11.4.0-1ubuntu1~22.04) ] + ignore line: [COMPILER_PATH=/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/] + ignore line: [LIBRARY_PATH=/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/usr/local/cuda/lib64/stubs/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../:/lib/:/usr/lib/] + ignore line: [COLLECT_GCC_OPTIONS='-v' '-rdynamic' '-o' 'cmTC_9a52d' '-mtune=generic' '-march=x86-64' '-dumpdir' 'cmTC_9a52d.'] + link line: [ /usr/lib/gcc/x86_64-linux-gnu/11/collect2 -plugin /usr/lib/gcc/x86_64-linux-gnu/11/liblto_plugin.so -plugin-opt=/usr/lib/gcc/x86_64-linux-gnu/11/lto-wrapper -plugin-opt=-fresolution=/tmp/ccQkw7jQ.res -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lc -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lgcc_s --build-id --eh-frame-hdr -m elf_x86_64 --hash-style=gnu --as-needed -export-dynamic -dynamic-linker /lib64/ld-linux-x86-64.so.2 -pie -z now -z relro -o cmTC_9a52d /usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/Scrt1.o /usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/crti.o /usr/lib/gcc/x86_64-linux-gnu/11/crtbeginS.o -L/usr/lib/gcc/x86_64-linux-gnu/11 -L/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu -L/usr/lib/gcc/x86_64-linux-gnu/11/../../../../lib -L/lib/x86_64-linux-gnu -L/lib/../lib -L/usr/lib/x86_64-linux-gnu -L/usr/lib/../lib -L/usr/local/cuda/lib64/stubs -L/usr/lib/gcc/x86_64-linux-gnu/11/../../.. CMakeFiles/cmTC_9a52d.dir/CMakeCCompilerABI.c.o -lgcc --push-state --as-needed -lgcc_s --pop-state -lc -lgcc --push-state --as-needed -lgcc_s --pop-state /usr/lib/gcc/x86_64-linux-gnu/11/crtendS.o /usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/crtn.o] + arg [/usr/lib/gcc/x86_64-linux-gnu/11/collect2] ==> ignore + arg [-plugin] ==> ignore + arg [/usr/lib/gcc/x86_64-linux-gnu/11/liblto_plugin.so] ==> ignore + arg [-plugin-opt=/usr/lib/gcc/x86_64-linux-gnu/11/lto-wrapper] ==> ignore + arg [-plugin-opt=-fresolution=/tmp/ccQkw7jQ.res] ==> ignore + arg [-plugin-opt=-pass-through=-lgcc] ==> ignore + arg [-plugin-opt=-pass-through=-lgcc_s] ==> ignore + arg [-plugin-opt=-pass-through=-lc] ==> ignore + arg [-plugin-opt=-pass-through=-lgcc] ==> ignore + arg [-plugin-opt=-pass-through=-lgcc_s] ==> ignore + arg [--build-id] ==> ignore + arg [--eh-frame-hdr] ==> ignore + arg [-m] ==> ignore + arg [elf_x86_64] ==> ignore + arg [--hash-style=gnu] ==> ignore + arg [--as-needed] ==> ignore + arg [-export-dynamic] ==> ignore + arg [-dynamic-linker] ==> ignore + arg [/lib64/ld-linux-x86-64.so.2] ==> ignore + arg [-pie] ==> ignore + arg [-znow] ==> ignore + arg [-zrelro] ==> ignore + arg [-o] ==> ignore + arg [cmTC_9a52d] ==> ignore + arg [/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/Scrt1.o] ==> obj [/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/Scrt1.o] + arg [/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/crti.o] ==> obj [/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/crti.o] + arg [/usr/lib/gcc/x86_64-linux-gnu/11/crtbeginS.o] ==> obj [/usr/lib/gcc/x86_64-linux-gnu/11/crtbeginS.o] + arg [-L/usr/lib/gcc/x86_64-linux-gnu/11] ==> dir [/usr/lib/gcc/x86_64-linux-gnu/11] + arg [-L/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu] ==> dir [/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu] + arg [-L/usr/lib/gcc/x86_64-linux-gnu/11/../../../../lib] ==> dir [/usr/lib/gcc/x86_64-linux-gnu/11/../../../../lib] + arg [-L/lib/x86_64-linux-gnu] ==> dir [/lib/x86_64-linux-gnu] + arg [-L/lib/../lib] ==> dir [/lib/../lib] + arg [-L/usr/lib/x86_64-linux-gnu] ==> dir [/usr/lib/x86_64-linux-gnu] + arg [-L/usr/lib/../lib] ==> dir [/usr/lib/../lib] + arg [-L/usr/local/cuda/lib64/stubs] ==> dir [/usr/local/cuda/lib64/stubs] + arg [-L/usr/lib/gcc/x86_64-linux-gnu/11/../../..] ==> dir [/usr/lib/gcc/x86_64-linux-gnu/11/../../..] + arg [CMakeFiles/cmTC_9a52d.dir/CMakeCCompilerABI.c.o] ==> ignore + arg [-lgcc] ==> lib [gcc] + arg [--push-state] ==> ignore + arg [--as-needed] ==> ignore + arg [-lgcc_s] ==> lib [gcc_s] + arg [--pop-state] ==> ignore + arg [-lc] ==> lib [c] + arg [-lgcc] ==> lib [gcc] + arg [--push-state] ==> ignore + arg [--as-needed] ==> ignore + arg [-lgcc_s] ==> lib [gcc_s] + arg [--pop-state] ==> ignore + arg [/usr/lib/gcc/x86_64-linux-gnu/11/crtendS.o] ==> obj [/usr/lib/gcc/x86_64-linux-gnu/11/crtendS.o] + arg [/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/crtn.o] ==> obj [/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/crtn.o] + collapse obj [/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/Scrt1.o] ==> [/usr/lib/x86_64-linux-gnu/Scrt1.o] + collapse obj [/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/crti.o] ==> [/usr/lib/x86_64-linux-gnu/crti.o] + collapse obj [/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/crtn.o] ==> [/usr/lib/x86_64-linux-gnu/crtn.o] + collapse library dir [/usr/lib/gcc/x86_64-linux-gnu/11] ==> [/usr/lib/gcc/x86_64-linux-gnu/11] + collapse library dir [/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu] ==> [/usr/lib/x86_64-linux-gnu] + collapse library dir [/usr/lib/gcc/x86_64-linux-gnu/11/../../../../lib] ==> [/usr/lib] + collapse library dir [/lib/x86_64-linux-gnu] ==> [/lib/x86_64-linux-gnu] + collapse library dir [/lib/../lib] ==> [/lib] + collapse library dir [/usr/lib/x86_64-linux-gnu] ==> [/usr/lib/x86_64-linux-gnu] + collapse library dir [/usr/lib/../lib] ==> [/usr/lib] + collapse library dir [/usr/local/cuda/lib64/stubs] ==> [/usr/local/cuda/lib64/stubs] + collapse library dir [/usr/lib/gcc/x86_64-linux-gnu/11/../../..] ==> [/usr/lib] + implicit libs: [gcc;gcc_s;c;gcc;gcc_s] + implicit objs: [/usr/lib/x86_64-linux-gnu/Scrt1.o;/usr/lib/x86_64-linux-gnu/crti.o;/usr/lib/gcc/x86_64-linux-gnu/11/crtbeginS.o;/usr/lib/gcc/x86_64-linux-gnu/11/crtendS.o;/usr/lib/x86_64-linux-gnu/crtn.o] + implicit dirs: [/usr/lib/gcc/x86_64-linux-gnu/11;/usr/lib/x86_64-linux-gnu;/usr/lib;/lib/x86_64-linux-gnu;/lib;/usr/local/cuda/lib64/stubs] + implicit fwks: [] + + + - + kind: "try_compile-v1" + backtrace: + - "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CMakeDetermineCompilerABI.cmake:57 (try_compile)" + - "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CMakeTestCXXCompiler.cmake:26 (CMAKE_DETERMINE_COMPILER_ABI)" + - "CMakeLists.txt:2 (project)" + checks: + - "Detecting CXX compiler ABI info" + directories: + source: "/content/NeuCoSVC-2/REAPER/build/CMakeFiles/CMakeScratch/TryCompile-uiTn6b" + binary: "/content/NeuCoSVC-2/REAPER/build/CMakeFiles/CMakeScratch/TryCompile-uiTn6b" + cmakeVariables: + CMAKE_CXX_FLAGS: "" + buildResult: + variable: "CMAKE_CXX_ABI_COMPILED" + cached: true + stdout: | + Change Dir: '/content/NeuCoSVC-2/REAPER/build/CMakeFiles/CMakeScratch/TryCompile-uiTn6b' + + Run Build Command(s): /usr/local/lib/python3.10/dist-packages/cmake/data/bin/cmake -E env VERBOSE=1 /usr/bin/gmake -f Makefile cmTC_d7c28/fast + /usr/bin/gmake -f CMakeFiles/cmTC_d7c28.dir/build.make CMakeFiles/cmTC_d7c28.dir/build + gmake[1]: Entering directory '/content/NeuCoSVC-2/REAPER/build/CMakeFiles/CMakeScratch/TryCompile-uiTn6b' + Building CXX object CMakeFiles/cmTC_d7c28.dir/CMakeCXXCompilerABI.cpp.o + /usr/bin/c++ -v -o CMakeFiles/cmTC_d7c28.dir/CMakeCXXCompilerABI.cpp.o -c /usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CMakeCXXCompilerABI.cpp + Using built-in specs. + COLLECT_GCC=/usr/bin/c++ + OFFLOAD_TARGET_NAMES=nvptx-none:amdgcn-amdhsa + OFFLOAD_TARGET_DEFAULT=1 + Target: x86_64-linux-gnu + Configured with: ../src/configure -v --with-pkgversion='Ubuntu 11.4.0-1ubuntu1~22.04' --with-bugurl=file:///usr/share/doc/gcc-11/README.Bugs --enable-languages=c,ada,c++,go,brig,d,fortran,objc,obj-c++,m2 --prefix=/usr --with-gcc-major-version-only --program-suffix=-11 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --enable-bootstrap --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-gnu-unique-object --disable-vtable-verify --enable-plugin --enable-default-pie --with-system-zlib --enable-libphobos-checking=release --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --enable-cet --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32,m64,mx32 --enable-multilib --with-tune=generic --enable-offload-targets=nvptx-none=/build/gcc-11-XeT9lY/gcc-11-11.4.0/debian/tmp-nvptx/usr,amdgcn-amdhsa=/build/gcc-11-XeT9lY/gcc-11-11.4.0/debian/tmp-gcn/usr --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu --with-build-config=bootstrap-lto-lean --enable-link-serialization=2 + Thread model: posix + Supported LTO compression algorithms: zlib zstd + gcc version 11.4.0 (Ubuntu 11.4.0-1ubuntu1~22.04) + COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_d7c28.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_d7c28.dir/' + /usr/lib/gcc/x86_64-linux-gnu/11/cc1plus -quiet -v -imultiarch x86_64-linux-gnu -D_GNU_SOURCE /usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CMakeCXXCompilerABI.cpp -quiet -dumpdir CMakeFiles/cmTC_d7c28.dir/ -dumpbase CMakeCXXCompilerABI.cpp.cpp -dumpbase-ext .cpp -mtune=generic -march=x86-64 -version -fasynchronous-unwind-tables -fstack-protector-strong -Wformat -Wformat-security -fstack-clash-protection -fcf-protection -o /tmp/ccZ5TFqj.s + GNU C++17 (Ubuntu 11.4.0-1ubuntu1~22.04) version 11.4.0 (x86_64-linux-gnu) + compiled by GNU C version 11.4.0, GMP version 6.2.1, MPFR version 4.1.0, MPC version 1.2.1, isl version isl-0.24-GMP + + GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072 + ignoring duplicate directory "/usr/include/x86_64-linux-gnu/c++/11" + ignoring nonexistent directory "/usr/local/include/x86_64-linux-gnu" + ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/11/include-fixed" + ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/11/../../../../x86_64-linux-gnu/include" + #include "..." search starts here: + #include <...> search starts here: + /usr/include/c++/11 + /usr/include/x86_64-linux-gnu/c++/11 + /usr/include/c++/11/backward + /usr/lib/gcc/x86_64-linux-gnu/11/include + /usr/local/include + /usr/include/x86_64-linux-gnu + /usr/include + End of search list. + GNU C++17 (Ubuntu 11.4.0-1ubuntu1~22.04) version 11.4.0 (x86_64-linux-gnu) + compiled by GNU C version 11.4.0, GMP version 6.2.1, MPFR version 4.1.0, MPC version 1.2.1, isl version isl-0.24-GMP + + GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072 + Compiler executable checksum: d591828bb4d392ae8b7b160e5bb0b95f + COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_d7c28.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_d7c28.dir/' + as -v --64 -o CMakeFiles/cmTC_d7c28.dir/CMakeCXXCompilerABI.cpp.o /tmp/ccZ5TFqj.s + GNU assembler version 2.38 (x86_64-linux-gnu) using BFD version (GNU Binutils for Ubuntu) 2.38 + COMPILER_PATH=/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/ + LIBRARY_PATH=/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/usr/local/cuda/lib64/stubs/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../:/lib/:/usr/lib/ + COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_d7c28.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_d7c28.dir/CMakeCXXCompilerABI.cpp.' + Linking CXX executable cmTC_d7c28 + /usr/local/lib/python3.10/dist-packages/cmake/data/bin/cmake -E cmake_link_script CMakeFiles/cmTC_d7c28.dir/link.txt --verbose=1 + /usr/bin/c++ -v -rdynamic CMakeFiles/cmTC_d7c28.dir/CMakeCXXCompilerABI.cpp.o -o cmTC_d7c28 + Using built-in specs. + COLLECT_GCC=/usr/bin/c++ + COLLECT_LTO_WRAPPER=/usr/lib/gcc/x86_64-linux-gnu/11/lto-wrapper + OFFLOAD_TARGET_NAMES=nvptx-none:amdgcn-amdhsa + OFFLOAD_TARGET_DEFAULT=1 + Target: x86_64-linux-gnu + Configured with: ../src/configure -v --with-pkgversion='Ubuntu 11.4.0-1ubuntu1~22.04' --with-bugurl=file:///usr/share/doc/gcc-11/README.Bugs --enable-languages=c,ada,c++,go,brig,d,fortran,objc,obj-c++,m2 --prefix=/usr --with-gcc-major-version-only --program-suffix=-11 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --enable-bootstrap --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-gnu-unique-object --disable-vtable-verify --enable-plugin --enable-default-pie --with-system-zlib --enable-libphobos-checking=release --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --enable-cet --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32,m64,mx32 --enable-multilib --with-tune=generic --enable-offload-targets=nvptx-none=/build/gcc-11-XeT9lY/gcc-11-11.4.0/debian/tmp-nvptx/usr,amdgcn-amdhsa=/build/gcc-11-XeT9lY/gcc-11-11.4.0/debian/tmp-gcn/usr --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu --with-build-config=bootstrap-lto-lean --enable-link-serialization=2 + Thread model: posix + Supported LTO compression algorithms: zlib zstd + gcc version 11.4.0 (Ubuntu 11.4.0-1ubuntu1~22.04) + COMPILER_PATH=/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/ + LIBRARY_PATH=/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/usr/local/cuda/lib64/stubs/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../:/lib/:/usr/lib/ + COLLECT_GCC_OPTIONS='-v' '-rdynamic' '-o' 'cmTC_d7c28' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'cmTC_d7c28.' + /usr/lib/gcc/x86_64-linux-gnu/11/collect2 -plugin /usr/lib/gcc/x86_64-linux-gnu/11/liblto_plugin.so -plugin-opt=/usr/lib/gcc/x86_64-linux-gnu/11/lto-wrapper -plugin-opt=-fresolution=/tmp/ccCQndMb.res -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lc -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc --build-id --eh-frame-hdr -m elf_x86_64 --hash-style=gnu --as-needed -export-dynamic -dynamic-linker /lib64/ld-linux-x86-64.so.2 -pie -z now -z relro -o cmTC_d7c28 /usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/Scrt1.o /usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/crti.o /usr/lib/gcc/x86_64-linux-gnu/11/crtbeginS.o -L/usr/lib/gcc/x86_64-linux-gnu/11 -L/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu -L/usr/lib/gcc/x86_64-linux-gnu/11/../../../../lib -L/lib/x86_64-linux-gnu -L/lib/../lib -L/usr/lib/x86_64-linux-gnu -L/usr/lib/../lib -L/usr/local/cuda/lib64/stubs -L/usr/lib/gcc/x86_64-linux-gnu/11/../../.. CMakeFiles/cmTC_d7c28.dir/CMakeCXXCompilerABI.cpp.o -lstdc++ -lm -lgcc_s -lgcc -lc -lgcc_s -lgcc /usr/lib/gcc/x86_64-linux-gnu/11/crtendS.o /usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/crtn.o + COLLECT_GCC_OPTIONS='-v' '-rdynamic' '-o' 'cmTC_d7c28' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'cmTC_d7c28.' + gmake[1]: Leaving directory '/content/NeuCoSVC-2/REAPER/build/CMakeFiles/CMakeScratch/TryCompile-uiTn6b' + + exitCode: 0 + - + kind: "message-v1" + backtrace: + - "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CMakeDetermineCompilerABI.cmake:127 (message)" + - "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CMakeTestCXXCompiler.cmake:26 (CMAKE_DETERMINE_COMPILER_ABI)" + - "CMakeLists.txt:2 (project)" + message: | + Parsed CXX implicit include dir info: rv=done + found start of include info + found start of implicit include info + add: [/usr/include/c++/11] + add: [/usr/include/x86_64-linux-gnu/c++/11] + add: [/usr/include/c++/11/backward] + add: [/usr/lib/gcc/x86_64-linux-gnu/11/include] + add: [/usr/local/include] + add: [/usr/include/x86_64-linux-gnu] + add: [/usr/include] + end of search list found + collapse include dir [/usr/include/c++/11] ==> [/usr/include/c++/11] + collapse include dir [/usr/include/x86_64-linux-gnu/c++/11] ==> [/usr/include/x86_64-linux-gnu/c++/11] + collapse include dir [/usr/include/c++/11/backward] ==> [/usr/include/c++/11/backward] + collapse include dir [/usr/lib/gcc/x86_64-linux-gnu/11/include] ==> [/usr/lib/gcc/x86_64-linux-gnu/11/include] + collapse include dir [/usr/local/include] ==> [/usr/local/include] + collapse include dir [/usr/include/x86_64-linux-gnu] ==> [/usr/include/x86_64-linux-gnu] + collapse include dir [/usr/include] ==> [/usr/include] + implicit include dirs: [/usr/include/c++/11;/usr/include/x86_64-linux-gnu/c++/11;/usr/include/c++/11/backward;/usr/lib/gcc/x86_64-linux-gnu/11/include;/usr/local/include;/usr/include/x86_64-linux-gnu;/usr/include] + + + - + kind: "message-v1" + backtrace: + - "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CMakeDetermineCompilerABI.cmake:152 (message)" + - "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CMakeTestCXXCompiler.cmake:26 (CMAKE_DETERMINE_COMPILER_ABI)" + - "CMakeLists.txt:2 (project)" + message: | + Parsed CXX implicit link information: + link line regex: [^( *|.*[/\\])(ld|CMAKE_LINK_STARTFILE-NOTFOUND|([^/\\]+-)?ld|collect2)[^/\\]*( |$)] + ignore line: [Change Dir: '/content/NeuCoSVC-2/REAPER/build/CMakeFiles/CMakeScratch/TryCompile-uiTn6b'] + ignore line: [] + ignore line: [Run Build Command(s): /usr/local/lib/python3.10/dist-packages/cmake/data/bin/cmake -E env VERBOSE=1 /usr/bin/gmake -f Makefile cmTC_d7c28/fast] + ignore line: [/usr/bin/gmake -f CMakeFiles/cmTC_d7c28.dir/build.make CMakeFiles/cmTC_d7c28.dir/build] + ignore line: [gmake[1]: Entering directory '/content/NeuCoSVC-2/REAPER/build/CMakeFiles/CMakeScratch/TryCompile-uiTn6b'] + ignore line: [Building CXX object CMakeFiles/cmTC_d7c28.dir/CMakeCXXCompilerABI.cpp.o] + ignore line: [/usr/bin/c++ -v -o CMakeFiles/cmTC_d7c28.dir/CMakeCXXCompilerABI.cpp.o -c /usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CMakeCXXCompilerABI.cpp] + ignore line: [Using built-in specs.] + ignore line: [COLLECT_GCC=/usr/bin/c++] + ignore line: [OFFLOAD_TARGET_NAMES=nvptx-none:amdgcn-amdhsa] + ignore line: [OFFLOAD_TARGET_DEFAULT=1] + ignore line: [Target: x86_64-linux-gnu] + ignore line: [Configured with: ../src/configure -v --with-pkgversion='Ubuntu 11.4.0-1ubuntu1~22.04' --with-bugurl=file:///usr/share/doc/gcc-11/README.Bugs --enable-languages=c ada c++ go brig d fortran objc obj-c++ m2 --prefix=/usr --with-gcc-major-version-only --program-suffix=-11 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --enable-bootstrap --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-gnu-unique-object --disable-vtable-verify --enable-plugin --enable-default-pie --with-system-zlib --enable-libphobos-checking=release --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --enable-cet --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32 m64 mx32 --enable-multilib --with-tune=generic --enable-offload-targets=nvptx-none=/build/gcc-11-XeT9lY/gcc-11-11.4.0/debian/tmp-nvptx/usr amdgcn-amdhsa=/build/gcc-11-XeT9lY/gcc-11-11.4.0/debian/tmp-gcn/usr --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu --with-build-config=bootstrap-lto-lean --enable-link-serialization=2] + ignore line: [Thread model: posix] + ignore line: [Supported LTO compression algorithms: zlib zstd] + ignore line: [gcc version 11.4.0 (Ubuntu 11.4.0-1ubuntu1~22.04) ] + ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_d7c28.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_d7c28.dir/'] + ignore line: [ /usr/lib/gcc/x86_64-linux-gnu/11/cc1plus -quiet -v -imultiarch x86_64-linux-gnu -D_GNU_SOURCE /usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CMakeCXXCompilerABI.cpp -quiet -dumpdir CMakeFiles/cmTC_d7c28.dir/ -dumpbase CMakeCXXCompilerABI.cpp.cpp -dumpbase-ext .cpp -mtune=generic -march=x86-64 -version -fasynchronous-unwind-tables -fstack-protector-strong -Wformat -Wformat-security -fstack-clash-protection -fcf-protection -o /tmp/ccZ5TFqj.s] + ignore line: [GNU C++17 (Ubuntu 11.4.0-1ubuntu1~22.04) version 11.4.0 (x86_64-linux-gnu)] + ignore line: [ compiled by GNU C version 11.4.0 GMP version 6.2.1 MPFR version 4.1.0 MPC version 1.2.1 isl version isl-0.24-GMP] + ignore line: [] + ignore line: [GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072] + ignore line: [ignoring duplicate directory "/usr/include/x86_64-linux-gnu/c++/11"] + ignore line: [ignoring nonexistent directory "/usr/local/include/x86_64-linux-gnu"] + ignore line: [ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/11/include-fixed"] + ignore line: [ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/11/../../../../x86_64-linux-gnu/include"] + ignore line: [#include "..." search starts here:] + ignore line: [#include <...> search starts here:] + ignore line: [ /usr/include/c++/11] + ignore line: [ /usr/include/x86_64-linux-gnu/c++/11] + ignore line: [ /usr/include/c++/11/backward] + ignore line: [ /usr/lib/gcc/x86_64-linux-gnu/11/include] + ignore line: [ /usr/local/include] + ignore line: [ /usr/include/x86_64-linux-gnu] + ignore line: [ /usr/include] + ignore line: [End of search list.] + ignore line: [GNU C++17 (Ubuntu 11.4.0-1ubuntu1~22.04) version 11.4.0 (x86_64-linux-gnu)] + ignore line: [ compiled by GNU C version 11.4.0 GMP version 6.2.1 MPFR version 4.1.0 MPC version 1.2.1 isl version isl-0.24-GMP] + ignore line: [] + ignore line: [GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072] + ignore line: [Compiler executable checksum: d591828bb4d392ae8b7b160e5bb0b95f] + ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_d7c28.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_d7c28.dir/'] + ignore line: [ as -v --64 -o CMakeFiles/cmTC_d7c28.dir/CMakeCXXCompilerABI.cpp.o /tmp/ccZ5TFqj.s] + ignore line: [GNU assembler version 2.38 (x86_64-linux-gnu) using BFD version (GNU Binutils for Ubuntu) 2.38] + ignore line: [COMPILER_PATH=/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/] + ignore line: [LIBRARY_PATH=/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/usr/local/cuda/lib64/stubs/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../:/lib/:/usr/lib/] + ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_d7c28.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_d7c28.dir/CMakeCXXCompilerABI.cpp.'] + ignore line: [Linking CXX executable cmTC_d7c28] + ignore line: [/usr/local/lib/python3.10/dist-packages/cmake/data/bin/cmake -E cmake_link_script CMakeFiles/cmTC_d7c28.dir/link.txt --verbose=1] + ignore line: [/usr/bin/c++ -v -rdynamic CMakeFiles/cmTC_d7c28.dir/CMakeCXXCompilerABI.cpp.o -o cmTC_d7c28 ] + ignore line: [Using built-in specs.] + ignore line: [COLLECT_GCC=/usr/bin/c++] + ignore line: [COLLECT_LTO_WRAPPER=/usr/lib/gcc/x86_64-linux-gnu/11/lto-wrapper] + ignore line: [OFFLOAD_TARGET_NAMES=nvptx-none:amdgcn-amdhsa] + ignore line: [OFFLOAD_TARGET_DEFAULT=1] + ignore line: [Target: x86_64-linux-gnu] + ignore line: [Configured with: ../src/configure -v --with-pkgversion='Ubuntu 11.4.0-1ubuntu1~22.04' --with-bugurl=file:///usr/share/doc/gcc-11/README.Bugs --enable-languages=c ada c++ go brig d fortran objc obj-c++ m2 --prefix=/usr --with-gcc-major-version-only --program-suffix=-11 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --enable-bootstrap --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-gnu-unique-object --disable-vtable-verify --enable-plugin --enable-default-pie --with-system-zlib --enable-libphobos-checking=release --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --enable-cet --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32 m64 mx32 --enable-multilib --with-tune=generic --enable-offload-targets=nvptx-none=/build/gcc-11-XeT9lY/gcc-11-11.4.0/debian/tmp-nvptx/usr amdgcn-amdhsa=/build/gcc-11-XeT9lY/gcc-11-11.4.0/debian/tmp-gcn/usr --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu --with-build-config=bootstrap-lto-lean --enable-link-serialization=2] + ignore line: [Thread model: posix] + ignore line: [Supported LTO compression algorithms: zlib zstd] + ignore line: [gcc version 11.4.0 (Ubuntu 11.4.0-1ubuntu1~22.04) ] + ignore line: [COMPILER_PATH=/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/] + ignore line: [LIBRARY_PATH=/usr/lib/gcc/x86_64-linux-gnu/11/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/usr/local/cuda/lib64/stubs/:/usr/lib/gcc/x86_64-linux-gnu/11/../../../:/lib/:/usr/lib/] + ignore line: [COLLECT_GCC_OPTIONS='-v' '-rdynamic' '-o' 'cmTC_d7c28' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'cmTC_d7c28.'] + link line: [ /usr/lib/gcc/x86_64-linux-gnu/11/collect2 -plugin /usr/lib/gcc/x86_64-linux-gnu/11/liblto_plugin.so -plugin-opt=/usr/lib/gcc/x86_64-linux-gnu/11/lto-wrapper -plugin-opt=-fresolution=/tmp/ccCQndMb.res -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lc -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc --build-id --eh-frame-hdr -m elf_x86_64 --hash-style=gnu --as-needed -export-dynamic -dynamic-linker /lib64/ld-linux-x86-64.so.2 -pie -z now -z relro -o cmTC_d7c28 /usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/Scrt1.o /usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/crti.o /usr/lib/gcc/x86_64-linux-gnu/11/crtbeginS.o -L/usr/lib/gcc/x86_64-linux-gnu/11 -L/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu -L/usr/lib/gcc/x86_64-linux-gnu/11/../../../../lib -L/lib/x86_64-linux-gnu -L/lib/../lib -L/usr/lib/x86_64-linux-gnu -L/usr/lib/../lib -L/usr/local/cuda/lib64/stubs -L/usr/lib/gcc/x86_64-linux-gnu/11/../../.. CMakeFiles/cmTC_d7c28.dir/CMakeCXXCompilerABI.cpp.o -lstdc++ -lm -lgcc_s -lgcc -lc -lgcc_s -lgcc /usr/lib/gcc/x86_64-linux-gnu/11/crtendS.o /usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/crtn.o] + arg [/usr/lib/gcc/x86_64-linux-gnu/11/collect2] ==> ignore + arg [-plugin] ==> ignore + arg [/usr/lib/gcc/x86_64-linux-gnu/11/liblto_plugin.so] ==> ignore + arg [-plugin-opt=/usr/lib/gcc/x86_64-linux-gnu/11/lto-wrapper] ==> ignore + arg [-plugin-opt=-fresolution=/tmp/ccCQndMb.res] ==> ignore + arg [-plugin-opt=-pass-through=-lgcc_s] ==> ignore + arg [-plugin-opt=-pass-through=-lgcc] ==> ignore + arg [-plugin-opt=-pass-through=-lc] ==> ignore + arg [-plugin-opt=-pass-through=-lgcc_s] ==> ignore + arg [-plugin-opt=-pass-through=-lgcc] ==> ignore + arg [--build-id] ==> ignore + arg [--eh-frame-hdr] ==> ignore + arg [-m] ==> ignore + arg [elf_x86_64] ==> ignore + arg [--hash-style=gnu] ==> ignore + arg [--as-needed] ==> ignore + arg [-export-dynamic] ==> ignore + arg [-dynamic-linker] ==> ignore + arg [/lib64/ld-linux-x86-64.so.2] ==> ignore + arg [-pie] ==> ignore + arg [-znow] ==> ignore + arg [-zrelro] ==> ignore + arg [-o] ==> ignore + arg [cmTC_d7c28] ==> ignore + arg [/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/Scrt1.o] ==> obj [/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/Scrt1.o] + arg [/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/crti.o] ==> obj [/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/crti.o] + arg [/usr/lib/gcc/x86_64-linux-gnu/11/crtbeginS.o] ==> obj [/usr/lib/gcc/x86_64-linux-gnu/11/crtbeginS.o] + arg [-L/usr/lib/gcc/x86_64-linux-gnu/11] ==> dir [/usr/lib/gcc/x86_64-linux-gnu/11] + arg [-L/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu] ==> dir [/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu] + arg [-L/usr/lib/gcc/x86_64-linux-gnu/11/../../../../lib] ==> dir [/usr/lib/gcc/x86_64-linux-gnu/11/../../../../lib] + arg [-L/lib/x86_64-linux-gnu] ==> dir [/lib/x86_64-linux-gnu] + arg [-L/lib/../lib] ==> dir [/lib/../lib] + arg [-L/usr/lib/x86_64-linux-gnu] ==> dir [/usr/lib/x86_64-linux-gnu] + arg [-L/usr/lib/../lib] ==> dir [/usr/lib/../lib] + arg [-L/usr/local/cuda/lib64/stubs] ==> dir [/usr/local/cuda/lib64/stubs] + arg [-L/usr/lib/gcc/x86_64-linux-gnu/11/../../..] ==> dir [/usr/lib/gcc/x86_64-linux-gnu/11/../../..] + arg [CMakeFiles/cmTC_d7c28.dir/CMakeCXXCompilerABI.cpp.o] ==> ignore + arg [-lstdc++] ==> lib [stdc++] + arg [-lm] ==> lib [m] + arg [-lgcc_s] ==> lib [gcc_s] + arg [-lgcc] ==> lib [gcc] + arg [-lc] ==> lib [c] + arg [-lgcc_s] ==> lib [gcc_s] + arg [-lgcc] ==> lib [gcc] + arg [/usr/lib/gcc/x86_64-linux-gnu/11/crtendS.o] ==> obj [/usr/lib/gcc/x86_64-linux-gnu/11/crtendS.o] + arg [/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/crtn.o] ==> obj [/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/crtn.o] + collapse obj [/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/Scrt1.o] ==> [/usr/lib/x86_64-linux-gnu/Scrt1.o] + collapse obj [/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/crti.o] ==> [/usr/lib/x86_64-linux-gnu/crti.o] + collapse obj [/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/crtn.o] ==> [/usr/lib/x86_64-linux-gnu/crtn.o] + collapse library dir [/usr/lib/gcc/x86_64-linux-gnu/11] ==> [/usr/lib/gcc/x86_64-linux-gnu/11] + collapse library dir [/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu] ==> [/usr/lib/x86_64-linux-gnu] + collapse library dir [/usr/lib/gcc/x86_64-linux-gnu/11/../../../../lib] ==> [/usr/lib] + collapse library dir [/lib/x86_64-linux-gnu] ==> [/lib/x86_64-linux-gnu] + collapse library dir [/lib/../lib] ==> [/lib] + collapse library dir [/usr/lib/x86_64-linux-gnu] ==> [/usr/lib/x86_64-linux-gnu] + collapse library dir [/usr/lib/../lib] ==> [/usr/lib] + collapse library dir [/usr/local/cuda/lib64/stubs] ==> [/usr/local/cuda/lib64/stubs] + collapse library dir [/usr/lib/gcc/x86_64-linux-gnu/11/../../..] ==> [/usr/lib] + implicit libs: [stdc++;m;gcc_s;gcc;c;gcc_s;gcc] + implicit objs: [/usr/lib/x86_64-linux-gnu/Scrt1.o;/usr/lib/x86_64-linux-gnu/crti.o;/usr/lib/gcc/x86_64-linux-gnu/11/crtbeginS.o;/usr/lib/gcc/x86_64-linux-gnu/11/crtendS.o;/usr/lib/x86_64-linux-gnu/crtn.o] + implicit dirs: [/usr/lib/gcc/x86_64-linux-gnu/11;/usr/lib/x86_64-linux-gnu;/usr/lib;/lib/x86_64-linux-gnu;/lib;/usr/local/cuda/lib64/stubs] + implicit fwks: [] + + + - + kind: "try_compile-v1" + backtrace: + - "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Internal/CheckSourceCompiles.cmake:101 (try_compile)" + - "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Internal/CheckCompilerFlag.cmake:18 (cmake_check_source_compiles)" + - "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CheckCXXCompilerFlag.cmake:34 (cmake_check_compiler_flag)" + - "CMakeLists.txt:6 (CHECK_CXX_COMPILER_FLAG)" + checks: + - "Performing Test COMPILER_SUPPORTS_CXX11" + directories: + source: "/content/NeuCoSVC-2/REAPER/build/CMakeFiles/CMakeScratch/TryCompile-Vyrsx6" + binary: "/content/NeuCoSVC-2/REAPER/build/CMakeFiles/CMakeScratch/TryCompile-Vyrsx6" + cmakeVariables: + CMAKE_CXX_FLAGS: "" + buildResult: + variable: "COMPILER_SUPPORTS_CXX11" + cached: true + stdout: | + Change Dir: '/content/NeuCoSVC-2/REAPER/build/CMakeFiles/CMakeScratch/TryCompile-Vyrsx6' + + Run Build Command(s): /usr/local/lib/python3.10/dist-packages/cmake/data/bin/cmake -E env VERBOSE=1 /usr/bin/gmake -f Makefile cmTC_82721/fast + /usr/bin/gmake -f CMakeFiles/cmTC_82721.dir/build.make CMakeFiles/cmTC_82721.dir/build + gmake[1]: Entering directory '/content/NeuCoSVC-2/REAPER/build/CMakeFiles/CMakeScratch/TryCompile-Vyrsx6' + Building CXX object CMakeFiles/cmTC_82721.dir/src.cxx.o + /usr/bin/c++ -DCOMPILER_SUPPORTS_CXX11 -std=c++11 -o CMakeFiles/cmTC_82721.dir/src.cxx.o -c /content/NeuCoSVC-2/REAPER/build/CMakeFiles/CMakeScratch/TryCompile-Vyrsx6/src.cxx + Linking CXX executable cmTC_82721 + /usr/local/lib/python3.10/dist-packages/cmake/data/bin/cmake -E cmake_link_script CMakeFiles/cmTC_82721.dir/link.txt --verbose=1 + /usr/bin/c++ -rdynamic CMakeFiles/cmTC_82721.dir/src.cxx.o -o cmTC_82721 + gmake[1]: Leaving directory '/content/NeuCoSVC-2/REAPER/build/CMakeFiles/CMakeScratch/TryCompile-Vyrsx6' + + exitCode: 0 + - + kind: "try_compile-v1" + backtrace: + - "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Internal/CheckSourceCompiles.cmake:101 (try_compile)" + - "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Internal/CheckCompilerFlag.cmake:18 (cmake_check_source_compiles)" + - "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CheckCXXCompilerFlag.cmake:34 (cmake_check_compiler_flag)" + - "CMakeLists.txt:7 (CHECK_CXX_COMPILER_FLAG)" + checks: + - "Performing Test COMPILER_SUPPORTS_CXX0X" + directories: + source: "/content/NeuCoSVC-2/REAPER/build/CMakeFiles/CMakeScratch/TryCompile-pWl1UE" + binary: "/content/NeuCoSVC-2/REAPER/build/CMakeFiles/CMakeScratch/TryCompile-pWl1UE" + cmakeVariables: + CMAKE_CXX_FLAGS: "" + buildResult: + variable: "COMPILER_SUPPORTS_CXX0X" + cached: true + stdout: | + Change Dir: '/content/NeuCoSVC-2/REAPER/build/CMakeFiles/CMakeScratch/TryCompile-pWl1UE' + + Run Build Command(s): /usr/local/lib/python3.10/dist-packages/cmake/data/bin/cmake -E env VERBOSE=1 /usr/bin/gmake -f Makefile cmTC_ded5a/fast + /usr/bin/gmake -f CMakeFiles/cmTC_ded5a.dir/build.make CMakeFiles/cmTC_ded5a.dir/build + gmake[1]: Entering directory '/content/NeuCoSVC-2/REAPER/build/CMakeFiles/CMakeScratch/TryCompile-pWl1UE' + Building CXX object CMakeFiles/cmTC_ded5a.dir/src.cxx.o + /usr/bin/c++ -DCOMPILER_SUPPORTS_CXX0X -std=c++0x -o CMakeFiles/cmTC_ded5a.dir/src.cxx.o -c /content/NeuCoSVC-2/REAPER/build/CMakeFiles/CMakeScratch/TryCompile-pWl1UE/src.cxx + Linking CXX executable cmTC_ded5a + /usr/local/lib/python3.10/dist-packages/cmake/data/bin/cmake -E cmake_link_script CMakeFiles/cmTC_ded5a.dir/link.txt --verbose=1 + /usr/bin/c++ -rdynamic CMakeFiles/cmTC_ded5a.dir/src.cxx.o -o cmTC_ded5a + gmake[1]: Leaving directory '/content/NeuCoSVC-2/REAPER/build/CMakeFiles/CMakeScratch/TryCompile-pWl1UE' + + exitCode: 0 +... diff --git a/REAPER/build/CMakeFiles/CMakeDirectoryInformation.cmake b/REAPER/build/CMakeFiles/CMakeDirectoryInformation.cmake new file mode 100644 index 0000000000000000000000000000000000000000..106135ff42f08e1d1ade93e316d1b06fa887f191 --- /dev/null +++ b/REAPER/build/CMakeFiles/CMakeDirectoryInformation.cmake @@ -0,0 +1,16 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.27 + +# Relative path conversion top directories. +set(CMAKE_RELATIVE_PATH_TOP_SOURCE "/content/NeuCoSVC-2/REAPER") +set(CMAKE_RELATIVE_PATH_TOP_BINARY "/content/NeuCoSVC-2/REAPER/build") + +# Force unix paths in dependencies. +set(CMAKE_FORCE_UNIX_PATHS 1) + + +# The C and CXX include file regular expressions for this directory. +set(CMAKE_C_INCLUDE_REGEX_SCAN "^.*$") +set(CMAKE_C_INCLUDE_REGEX_COMPLAIN "^$") +set(CMAKE_CXX_INCLUDE_REGEX_SCAN ${CMAKE_C_INCLUDE_REGEX_SCAN}) +set(CMAKE_CXX_INCLUDE_REGEX_COMPLAIN ${CMAKE_C_INCLUDE_REGEX_COMPLAIN}) diff --git a/REAPER/build/CMakeFiles/Makefile.cmake b/REAPER/build/CMakeFiles/Makefile.cmake new file mode 100644 index 0000000000000000000000000000000000000000..f4eeff136fd808ff9654b291809e696ded32fb56 --- /dev/null +++ b/REAPER/build/CMakeFiles/Makefile.cmake @@ -0,0 +1,137 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.27 + +# The generator used is: +set(CMAKE_DEPENDS_GENERATOR "Unix Makefiles") + +# The top level Makefile was generated from the following files: +set(CMAKE_MAKEFILE_DEPENDS + "CMakeCache.txt" + "/content/NeuCoSVC-2/REAPER/CMakeLists.txt" + "CMakeFiles/3.27.9/CMakeCCompiler.cmake" + "CMakeFiles/3.27.9/CMakeCXXCompiler.cmake" + "CMakeFiles/3.27.9/CMakeSystem.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CMakeCCompiler.cmake.in" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CMakeCCompilerABI.c" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CMakeCInformation.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CMakeCXXCompiler.cmake.in" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CMakeCXXCompilerABI.cpp" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CMakeCXXInformation.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CMakeCheckCompilerFlagCommonPatterns.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CMakeCommonLanguageInclude.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CMakeCompilerIdDetection.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CMakeDetermineCCompiler.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CMakeDetermineCXXCompiler.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CMakeDetermineCompileFeatures.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CMakeDetermineCompiler.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CMakeDetermineCompilerABI.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CMakeDetermineCompilerId.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CMakeDetermineSystem.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CMakeFindBinUtils.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CMakeGenericSystem.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CMakeInitializeConfigs.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CMakeLanguageInformation.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CMakeParseImplicitIncludeInfo.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CMakeParseImplicitLinkInfo.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CMakeParseLibraryArchitecture.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CMakeSystem.cmake.in" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CMakeSystemSpecificInformation.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CMakeSystemSpecificInitialize.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CMakeTestCCompiler.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CMakeTestCXXCompiler.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CMakeTestCompilerCommon.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CMakeUnixFindMake.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CheckCXXCompilerFlag.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/CheckCXXSourceCompiles.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Compiler/ADSP-DetermineCompiler.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Compiler/ARMCC-DetermineCompiler.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Compiler/ARMClang-DetermineCompiler.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Compiler/AppleClang-DetermineCompiler.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Compiler/Borland-DetermineCompiler.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Compiler/Bruce-C-DetermineCompiler.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Compiler/CMakeCommonCompilerMacros.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Compiler/Clang-DetermineCompiler.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Compiler/Clang-DetermineCompilerInternal.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Compiler/Comeau-CXX-DetermineCompiler.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Compiler/Compaq-C-DetermineCompiler.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Compiler/Compaq-CXX-DetermineCompiler.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Compiler/Cray-DetermineCompiler.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Compiler/Embarcadero-DetermineCompiler.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Compiler/Fujitsu-DetermineCompiler.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Compiler/FujitsuClang-DetermineCompiler.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Compiler/GHS-DetermineCompiler.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Compiler/GNU-C-DetermineCompiler.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Compiler/GNU-C.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Compiler/GNU-CXX-DetermineCompiler.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Compiler/GNU-CXX.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Compiler/GNU-FindBinUtils.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Compiler/GNU.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Compiler/HP-C-DetermineCompiler.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Compiler/HP-CXX-DetermineCompiler.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Compiler/IAR-DetermineCompiler.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Compiler/IBMCPP-C-DetermineVersionInternal.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Compiler/IBMCPP-CXX-DetermineVersionInternal.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Compiler/IBMClang-C-DetermineCompiler.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Compiler/IBMClang-CXX-DetermineCompiler.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Compiler/Intel-DetermineCompiler.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Compiler/IntelLLVM-DetermineCompiler.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Compiler/LCC-C-DetermineCompiler.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Compiler/LCC-CXX-DetermineCompiler.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Compiler/MSVC-DetermineCompiler.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Compiler/NVHPC-DetermineCompiler.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Compiler/NVIDIA-DetermineCompiler.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Compiler/OpenWatcom-DetermineCompiler.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Compiler/PGI-DetermineCompiler.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Compiler/PathScale-DetermineCompiler.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Compiler/SCO-DetermineCompiler.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Compiler/SDCC-C-DetermineCompiler.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Compiler/SunPro-C-DetermineCompiler.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Compiler/SunPro-CXX-DetermineCompiler.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Compiler/TI-DetermineCompiler.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Compiler/Tasking-DetermineCompiler.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Compiler/TinyCC-C-DetermineCompiler.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Compiler/VisualAge-C-DetermineCompiler.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Compiler/VisualAge-CXX-DetermineCompiler.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Compiler/Watcom-DetermineCompiler.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Compiler/XL-C-DetermineCompiler.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Compiler/XL-CXX-DetermineCompiler.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Compiler/XLClang-C-DetermineCompiler.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Compiler/XLClang-CXX-DetermineCompiler.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Compiler/zOS-C-DetermineCompiler.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Compiler/zOS-CXX-DetermineCompiler.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Internal/CheckCompilerFlag.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Internal/CheckFlagCommonConfig.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Internal/CheckSourceCompiles.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Internal/FeatureTesting.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Platform/Linux-Determine-CXX.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Platform/Linux-GNU-C.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Platform/Linux-GNU-CXX.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Platform/Linux-GNU.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Platform/Linux-Initialize.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Platform/Linux.cmake" + "/usr/local/lib/python3.10/dist-packages/cmake/data/share/cmake-3.27/Modules/Platform/UnixPaths.cmake" + ) + +# The corresponding makefile is: +set(CMAKE_MAKEFILE_OUTPUTS + "Makefile" + "CMakeFiles/cmake.check_cache" + ) + +# Byproducts of CMake generate step: +set(CMAKE_MAKEFILE_PRODUCTS + "CMakeFiles/3.27.9/CMakeSystem.cmake" + "CMakeFiles/3.27.9/CMakeCCompiler.cmake" + "CMakeFiles/3.27.9/CMakeCXXCompiler.cmake" + "CMakeFiles/3.27.9/CMakeCCompiler.cmake" + "CMakeFiles/3.27.9/CMakeCXXCompiler.cmake" + "CMakeFiles/CMakeDirectoryInformation.cmake" + ) + +# Dependency information for all targets: +set(CMAKE_DEPEND_INFO_FILES + "CMakeFiles/core.dir/DependInfo.cmake" + "CMakeFiles/wave.dir/DependInfo.cmake" + "CMakeFiles/epoch_tracker.dir/DependInfo.cmake" + "CMakeFiles/reaper.dir/DependInfo.cmake" + ) diff --git a/REAPER/build/CMakeFiles/Makefile2 b/REAPER/build/CMakeFiles/Makefile2 new file mode 100644 index 0000000000000000000000000000000000000000..daf6e74902a9bc83814f5582a108b3d3ed82d552 --- /dev/null +++ b/REAPER/build/CMakeFiles/Makefile2 @@ -0,0 +1,199 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.27 + +# Default target executed when no arguments are given to make. +default_target: all +.PHONY : default_target + +#============================================================================= +# Special targets provided by cmake. + +# Disable implicit rules so canonical targets will work. +.SUFFIXES: + +# Disable VCS-based implicit rules. +% : %,v + +# Disable VCS-based implicit rules. +% : RCS/% + +# Disable VCS-based implicit rules. +% : RCS/%,v + +# Disable VCS-based implicit rules. +% : SCCS/s.% + +# Disable VCS-based implicit rules. +% : s.% + +.SUFFIXES: .hpux_make_needs_suffix_list + +# Command-line flag to silence nested $(MAKE). +$(VERBOSE)MAKESILENT = -s + +#Suppress display of executed commands. +$(VERBOSE).SILENT: + +# A target that is always out of date. +cmake_force: +.PHONY : cmake_force + +#============================================================================= +# Set environment variables for the build. + +# The shell in which to execute make rules. +SHELL = /bin/sh + +# The CMake executable. +CMAKE_COMMAND = /usr/local/lib/python3.10/dist-packages/cmake/data/bin/cmake + +# The command to remove a file. +RM = /usr/local/lib/python3.10/dist-packages/cmake/data/bin/cmake -E rm -f + +# Escaping for special characters. +EQUALS = = + +# The top-level source directory on which CMake was run. +CMAKE_SOURCE_DIR = /content/NeuCoSVC-2/REAPER + +# The top-level build directory on which CMake was run. +CMAKE_BINARY_DIR = /content/NeuCoSVC-2/REAPER/build + +#============================================================================= +# Directory level rules for the build root directory + +# The main recursive "all" target. +all: CMakeFiles/core.dir/all +all: CMakeFiles/wave.dir/all +all: CMakeFiles/epoch_tracker.dir/all +all: CMakeFiles/reaper.dir/all +.PHONY : all + +# The main recursive "preinstall" target. +preinstall: +.PHONY : preinstall + +# The main recursive "clean" target. +clean: CMakeFiles/core.dir/clean +clean: CMakeFiles/wave.dir/clean +clean: CMakeFiles/epoch_tracker.dir/clean +clean: CMakeFiles/reaper.dir/clean +.PHONY : clean + +#============================================================================= +# Target rules for target CMakeFiles/core.dir + +# All Build rule for target. +CMakeFiles/core.dir/all: + $(MAKE) $(MAKESILENT) -f CMakeFiles/core.dir/build.make CMakeFiles/core.dir/depend + $(MAKE) $(MAKESILENT) -f CMakeFiles/core.dir/build.make CMakeFiles/core.dir/build + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --progress-dir=/content/NeuCoSVC-2/REAPER/build/CMakeFiles --progress-num=1,2,3,4 "Built target core" +.PHONY : CMakeFiles/core.dir/all + +# Build rule for subdir invocation for target. +CMakeFiles/core.dir/rule: cmake_check_build_system + $(CMAKE_COMMAND) -E cmake_progress_start /content/NeuCoSVC-2/REAPER/build/CMakeFiles 4 + $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 CMakeFiles/core.dir/all + $(CMAKE_COMMAND) -E cmake_progress_start /content/NeuCoSVC-2/REAPER/build/CMakeFiles 0 +.PHONY : CMakeFiles/core.dir/rule + +# Convenience name for target. +core: CMakeFiles/core.dir/rule +.PHONY : core + +# clean rule for target. +CMakeFiles/core.dir/clean: + $(MAKE) $(MAKESILENT) -f CMakeFiles/core.dir/build.make CMakeFiles/core.dir/clean +.PHONY : CMakeFiles/core.dir/clean + +#============================================================================= +# Target rules for target CMakeFiles/wave.dir + +# All Build rule for target. +CMakeFiles/wave.dir/all: CMakeFiles/core.dir/all + $(MAKE) $(MAKESILENT) -f CMakeFiles/wave.dir/build.make CMakeFiles/wave.dir/depend + $(MAKE) $(MAKESILENT) -f CMakeFiles/wave.dir/build.make CMakeFiles/wave.dir/build + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --progress-dir=/content/NeuCoSVC-2/REAPER/build/CMakeFiles --progress-num=12,13,14,15 "Built target wave" +.PHONY : CMakeFiles/wave.dir/all + +# Build rule for subdir invocation for target. +CMakeFiles/wave.dir/rule: cmake_check_build_system + $(CMAKE_COMMAND) -E cmake_progress_start /content/NeuCoSVC-2/REAPER/build/CMakeFiles 8 + $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 CMakeFiles/wave.dir/all + $(CMAKE_COMMAND) -E cmake_progress_start /content/NeuCoSVC-2/REAPER/build/CMakeFiles 0 +.PHONY : CMakeFiles/wave.dir/rule + +# Convenience name for target. +wave: CMakeFiles/wave.dir/rule +.PHONY : wave + +# clean rule for target. +CMakeFiles/wave.dir/clean: + $(MAKE) $(MAKESILENT) -f CMakeFiles/wave.dir/build.make CMakeFiles/wave.dir/clean +.PHONY : CMakeFiles/wave.dir/clean + +#============================================================================= +# Target rules for target CMakeFiles/epoch_tracker.dir + +# All Build rule for target. +CMakeFiles/epoch_tracker.dir/all: CMakeFiles/wave.dir/all +CMakeFiles/epoch_tracker.dir/all: CMakeFiles/core.dir/all + $(MAKE) $(MAKESILENT) -f CMakeFiles/epoch_tracker.dir/build.make CMakeFiles/epoch_tracker.dir/depend + $(MAKE) $(MAKESILENT) -f CMakeFiles/epoch_tracker.dir/build.make CMakeFiles/epoch_tracker.dir/build + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --progress-dir=/content/NeuCoSVC-2/REAPER/build/CMakeFiles --progress-num=5,6,7,8,9 "Built target epoch_tracker" +.PHONY : CMakeFiles/epoch_tracker.dir/all + +# Build rule for subdir invocation for target. +CMakeFiles/epoch_tracker.dir/rule: cmake_check_build_system + $(CMAKE_COMMAND) -E cmake_progress_start /content/NeuCoSVC-2/REAPER/build/CMakeFiles 13 + $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 CMakeFiles/epoch_tracker.dir/all + $(CMAKE_COMMAND) -E cmake_progress_start /content/NeuCoSVC-2/REAPER/build/CMakeFiles 0 +.PHONY : CMakeFiles/epoch_tracker.dir/rule + +# Convenience name for target. +epoch_tracker: CMakeFiles/epoch_tracker.dir/rule +.PHONY : epoch_tracker + +# clean rule for target. +CMakeFiles/epoch_tracker.dir/clean: + $(MAKE) $(MAKESILENT) -f CMakeFiles/epoch_tracker.dir/build.make CMakeFiles/epoch_tracker.dir/clean +.PHONY : CMakeFiles/epoch_tracker.dir/clean + +#============================================================================= +# Target rules for target CMakeFiles/reaper.dir + +# All Build rule for target. +CMakeFiles/reaper.dir/all: CMakeFiles/wave.dir/all +CMakeFiles/reaper.dir/all: CMakeFiles/epoch_tracker.dir/all +CMakeFiles/reaper.dir/all: CMakeFiles/core.dir/all + $(MAKE) $(MAKESILENT) -f CMakeFiles/reaper.dir/build.make CMakeFiles/reaper.dir/depend + $(MAKE) $(MAKESILENT) -f CMakeFiles/reaper.dir/build.make CMakeFiles/reaper.dir/build + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --progress-dir=/content/NeuCoSVC-2/REAPER/build/CMakeFiles --progress-num=10,11 "Built target reaper" +.PHONY : CMakeFiles/reaper.dir/all + +# Build rule for subdir invocation for target. +CMakeFiles/reaper.dir/rule: cmake_check_build_system + $(CMAKE_COMMAND) -E cmake_progress_start /content/NeuCoSVC-2/REAPER/build/CMakeFiles 15 + $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 CMakeFiles/reaper.dir/all + $(CMAKE_COMMAND) -E cmake_progress_start /content/NeuCoSVC-2/REAPER/build/CMakeFiles 0 +.PHONY : CMakeFiles/reaper.dir/rule + +# Convenience name for target. +reaper: CMakeFiles/reaper.dir/rule +.PHONY : reaper + +# clean rule for target. +CMakeFiles/reaper.dir/clean: + $(MAKE) $(MAKESILENT) -f CMakeFiles/reaper.dir/build.make CMakeFiles/reaper.dir/clean +.PHONY : CMakeFiles/reaper.dir/clean + +#============================================================================= +# Special targets to cleanup operation of make. + +# Special rule to run CMake to check the build system integrity. +# No rule that depends on this can have commands that come from listfiles +# because they might be regenerated. +cmake_check_build_system: + $(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 0 +.PHONY : cmake_check_build_system + diff --git a/REAPER/build/CMakeFiles/TargetDirectories.txt b/REAPER/build/CMakeFiles/TargetDirectories.txt new file mode 100644 index 0000000000000000000000000000000000000000..92f212ef2a20c35143a28f15ee27161cecc0836c --- /dev/null +++ b/REAPER/build/CMakeFiles/TargetDirectories.txt @@ -0,0 +1,6 @@ +/content/NeuCoSVC-2/REAPER/build/CMakeFiles/core.dir +/content/NeuCoSVC-2/REAPER/build/CMakeFiles/wave.dir +/content/NeuCoSVC-2/REAPER/build/CMakeFiles/epoch_tracker.dir +/content/NeuCoSVC-2/REAPER/build/CMakeFiles/reaper.dir +/content/NeuCoSVC-2/REAPER/build/CMakeFiles/edit_cache.dir +/content/NeuCoSVC-2/REAPER/build/CMakeFiles/rebuild_cache.dir diff --git a/REAPER/build/CMakeFiles/cmake.check_cache b/REAPER/build/CMakeFiles/cmake.check_cache new file mode 100644 index 0000000000000000000000000000000000000000..3dccd731726d7faa8b29d8d7dba3b981a53ca497 --- /dev/null +++ b/REAPER/build/CMakeFiles/cmake.check_cache @@ -0,0 +1 @@ +# This file is generated by cmake for dependency checking of the CMakeCache.txt file diff --git a/REAPER/build/CMakeFiles/core.dir/DependInfo.cmake b/REAPER/build/CMakeFiles/core.dir/DependInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..f4bbb7b27fe1f544ddb600447ffa46bad56c6691 --- /dev/null +++ b/REAPER/build/CMakeFiles/core.dir/DependInfo.cmake @@ -0,0 +1,21 @@ + +# Consider dependencies only in project. +set(CMAKE_DEPENDS_IN_PROJECT_ONLY OFF) + +# The set of languages for which implicit dependencies are needed: +set(CMAKE_DEPENDS_LANGUAGES + ) + +# The set of dependency files which are needed: +set(CMAKE_DEPENDS_DEPENDENCY_FILES + "/content/NeuCoSVC-2/REAPER/core/file_resource.cc" "CMakeFiles/core.dir/core/file_resource.cc.o" "gcc" "CMakeFiles/core.dir/core/file_resource.cc.o.d" + "/content/NeuCoSVC-2/REAPER/core/float_matrix.cc" "CMakeFiles/core.dir/core/float_matrix.cc.o" "gcc" "CMakeFiles/core.dir/core/float_matrix.cc.o.d" + "/content/NeuCoSVC-2/REAPER/core/track.cc" "CMakeFiles/core.dir/core/track.cc.o" "gcc" "CMakeFiles/core.dir/core/track.cc.o.d" + ) + +# Targets to which this target links which contain Fortran sources. +set(CMAKE_Fortran_TARGET_LINKED_INFO_FILES + ) + +# Fortran module output directory. +set(CMAKE_Fortran_TARGET_MODULE_DIR "") diff --git a/REAPER/build/CMakeFiles/core.dir/build.make b/REAPER/build/CMakeFiles/core.dir/build.make new file mode 100644 index 0000000000000000000000000000000000000000..dbe0149a86f6975fc56df53afb6540de4c62c8b0 --- /dev/null +++ b/REAPER/build/CMakeFiles/core.dir/build.make @@ -0,0 +1,143 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.27 + +# Delete rule output on recipe failure. +.DELETE_ON_ERROR: + +#============================================================================= +# Special targets provided by cmake. + +# Disable implicit rules so canonical targets will work. +.SUFFIXES: + +# Disable VCS-based implicit rules. +% : %,v + +# Disable VCS-based implicit rules. +% : RCS/% + +# Disable VCS-based implicit rules. +% : RCS/%,v + +# Disable VCS-based implicit rules. +% : SCCS/s.% + +# Disable VCS-based implicit rules. +% : s.% + +.SUFFIXES: .hpux_make_needs_suffix_list + +# Command-line flag to silence nested $(MAKE). +$(VERBOSE)MAKESILENT = -s + +#Suppress display of executed commands. +$(VERBOSE).SILENT: + +# A target that is always out of date. +cmake_force: +.PHONY : cmake_force + +#============================================================================= +# Set environment variables for the build. + +# The shell in which to execute make rules. +SHELL = /bin/sh + +# The CMake executable. +CMAKE_COMMAND = /usr/local/lib/python3.10/dist-packages/cmake/data/bin/cmake + +# The command to remove a file. +RM = /usr/local/lib/python3.10/dist-packages/cmake/data/bin/cmake -E rm -f + +# Escaping for special characters. +EQUALS = = + +# The top-level source directory on which CMake was run. +CMAKE_SOURCE_DIR = /content/NeuCoSVC-2/REAPER + +# The top-level build directory on which CMake was run. +CMAKE_BINARY_DIR = /content/NeuCoSVC-2/REAPER/build + +# Include any dependencies generated for this target. +include CMakeFiles/core.dir/depend.make +# Include any dependencies generated by the compiler for this target. +include CMakeFiles/core.dir/compiler_depend.make + +# Include the progress variables for this target. +include CMakeFiles/core.dir/progress.make + +# Include the compile flags for this target's objects. +include CMakeFiles/core.dir/flags.make + +CMakeFiles/core.dir/core/file_resource.cc.o: CMakeFiles/core.dir/flags.make +CMakeFiles/core.dir/core/file_resource.cc.o: /content/NeuCoSVC-2/REAPER/core/file_resource.cc +CMakeFiles/core.dir/core/file_resource.cc.o: CMakeFiles/core.dir/compiler_depend.ts + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/content/NeuCoSVC-2/REAPER/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_1) "Building CXX object CMakeFiles/core.dir/core/file_resource.cc.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/core.dir/core/file_resource.cc.o -MF CMakeFiles/core.dir/core/file_resource.cc.o.d -o CMakeFiles/core.dir/core/file_resource.cc.o -c /content/NeuCoSVC-2/REAPER/core/file_resource.cc + +CMakeFiles/core.dir/core/file_resource.cc.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/core.dir/core/file_resource.cc.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /content/NeuCoSVC-2/REAPER/core/file_resource.cc > CMakeFiles/core.dir/core/file_resource.cc.i + +CMakeFiles/core.dir/core/file_resource.cc.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/core.dir/core/file_resource.cc.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /content/NeuCoSVC-2/REAPER/core/file_resource.cc -o CMakeFiles/core.dir/core/file_resource.cc.s + +CMakeFiles/core.dir/core/float_matrix.cc.o: CMakeFiles/core.dir/flags.make +CMakeFiles/core.dir/core/float_matrix.cc.o: /content/NeuCoSVC-2/REAPER/core/float_matrix.cc +CMakeFiles/core.dir/core/float_matrix.cc.o: CMakeFiles/core.dir/compiler_depend.ts + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/content/NeuCoSVC-2/REAPER/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_2) "Building CXX object CMakeFiles/core.dir/core/float_matrix.cc.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/core.dir/core/float_matrix.cc.o -MF CMakeFiles/core.dir/core/float_matrix.cc.o.d -o CMakeFiles/core.dir/core/float_matrix.cc.o -c /content/NeuCoSVC-2/REAPER/core/float_matrix.cc + +CMakeFiles/core.dir/core/float_matrix.cc.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/core.dir/core/float_matrix.cc.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /content/NeuCoSVC-2/REAPER/core/float_matrix.cc > CMakeFiles/core.dir/core/float_matrix.cc.i + +CMakeFiles/core.dir/core/float_matrix.cc.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/core.dir/core/float_matrix.cc.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /content/NeuCoSVC-2/REAPER/core/float_matrix.cc -o CMakeFiles/core.dir/core/float_matrix.cc.s + +CMakeFiles/core.dir/core/track.cc.o: CMakeFiles/core.dir/flags.make +CMakeFiles/core.dir/core/track.cc.o: /content/NeuCoSVC-2/REAPER/core/track.cc +CMakeFiles/core.dir/core/track.cc.o: CMakeFiles/core.dir/compiler_depend.ts + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/content/NeuCoSVC-2/REAPER/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_3) "Building CXX object CMakeFiles/core.dir/core/track.cc.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/core.dir/core/track.cc.o -MF CMakeFiles/core.dir/core/track.cc.o.d -o CMakeFiles/core.dir/core/track.cc.o -c /content/NeuCoSVC-2/REAPER/core/track.cc + +CMakeFiles/core.dir/core/track.cc.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/core.dir/core/track.cc.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /content/NeuCoSVC-2/REAPER/core/track.cc > CMakeFiles/core.dir/core/track.cc.i + +CMakeFiles/core.dir/core/track.cc.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/core.dir/core/track.cc.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /content/NeuCoSVC-2/REAPER/core/track.cc -o CMakeFiles/core.dir/core/track.cc.s + +# Object files for target core +core_OBJECTS = \ +"CMakeFiles/core.dir/core/file_resource.cc.o" \ +"CMakeFiles/core.dir/core/float_matrix.cc.o" \ +"CMakeFiles/core.dir/core/track.cc.o" + +# External object files for target core +core_EXTERNAL_OBJECTS = + +libcore.a: CMakeFiles/core.dir/core/file_resource.cc.o +libcore.a: CMakeFiles/core.dir/core/float_matrix.cc.o +libcore.a: CMakeFiles/core.dir/core/track.cc.o +libcore.a: CMakeFiles/core.dir/build.make +libcore.a: CMakeFiles/core.dir/link.txt + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --bold --progress-dir=/content/NeuCoSVC-2/REAPER/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_4) "Linking CXX static library libcore.a" + $(CMAKE_COMMAND) -P CMakeFiles/core.dir/cmake_clean_target.cmake + $(CMAKE_COMMAND) -E cmake_link_script CMakeFiles/core.dir/link.txt --verbose=$(VERBOSE) + +# Rule to build all files generated by this target. +CMakeFiles/core.dir/build: libcore.a +.PHONY : CMakeFiles/core.dir/build + +CMakeFiles/core.dir/clean: + $(CMAKE_COMMAND) -P CMakeFiles/core.dir/cmake_clean.cmake +.PHONY : CMakeFiles/core.dir/clean + +CMakeFiles/core.dir/depend: + cd /content/NeuCoSVC-2/REAPER/build && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /content/NeuCoSVC-2/REAPER /content/NeuCoSVC-2/REAPER /content/NeuCoSVC-2/REAPER/build /content/NeuCoSVC-2/REAPER/build /content/NeuCoSVC-2/REAPER/build/CMakeFiles/core.dir/DependInfo.cmake "--color=$(COLOR)" +.PHONY : CMakeFiles/core.dir/depend + diff --git a/REAPER/build/CMakeFiles/core.dir/cmake_clean.cmake b/REAPER/build/CMakeFiles/core.dir/cmake_clean.cmake new file mode 100644 index 0000000000000000000000000000000000000000..8b99cb10e49a2e5dbb10d322390dbad1a75b2b72 --- /dev/null +++ b/REAPER/build/CMakeFiles/core.dir/cmake_clean.cmake @@ -0,0 +1,15 @@ +file(REMOVE_RECURSE + "CMakeFiles/core.dir/core/file_resource.cc.o" + "CMakeFiles/core.dir/core/file_resource.cc.o.d" + "CMakeFiles/core.dir/core/float_matrix.cc.o" + "CMakeFiles/core.dir/core/float_matrix.cc.o.d" + "CMakeFiles/core.dir/core/track.cc.o" + "CMakeFiles/core.dir/core/track.cc.o.d" + "libcore.a" + "libcore.pdb" +) + +# Per-language clean rules from dependency scanning. +foreach(lang CXX) + include(CMakeFiles/core.dir/cmake_clean_${lang}.cmake OPTIONAL) +endforeach() diff --git a/REAPER/build/CMakeFiles/core.dir/cmake_clean_target.cmake b/REAPER/build/CMakeFiles/core.dir/cmake_clean_target.cmake new file mode 100644 index 0000000000000000000000000000000000000000..40fd26100fdb0aabeeed9c99261341f4d1abd806 --- /dev/null +++ b/REAPER/build/CMakeFiles/core.dir/cmake_clean_target.cmake @@ -0,0 +1,3 @@ +file(REMOVE_RECURSE + "libcore.a" +) diff --git a/REAPER/build/CMakeFiles/core.dir/compiler_depend.make b/REAPER/build/CMakeFiles/core.dir/compiler_depend.make new file mode 100644 index 0000000000000000000000000000000000000000..e0483068e84e4f704aa4209024084a240f7bf706 --- /dev/null +++ b/REAPER/build/CMakeFiles/core.dir/compiler_depend.make @@ -0,0 +1,2 @@ +# Empty compiler generated dependencies file for core. +# This may be replaced when dependencies are built. diff --git a/REAPER/build/CMakeFiles/core.dir/compiler_depend.ts b/REAPER/build/CMakeFiles/core.dir/compiler_depend.ts new file mode 100644 index 0000000000000000000000000000000000000000..6d3a0200a5fe76d5f32c64f27458111e4d56eddd --- /dev/null +++ b/REAPER/build/CMakeFiles/core.dir/compiler_depend.ts @@ -0,0 +1,2 @@ +# CMAKE generated file: DO NOT EDIT! +# Timestamp file for compiler generated dependencies management for core. diff --git a/REAPER/build/CMakeFiles/core.dir/core/file_resource.cc.o b/REAPER/build/CMakeFiles/core.dir/core/file_resource.cc.o new file mode 100644 index 0000000000000000000000000000000000000000..4893044ce7e1822ce8ebb5fb00003995a64f6f63 Binary files /dev/null and b/REAPER/build/CMakeFiles/core.dir/core/file_resource.cc.o differ diff --git a/REAPER/build/CMakeFiles/core.dir/core/file_resource.cc.o.d b/REAPER/build/CMakeFiles/core.dir/core/file_resource.cc.o.d new file mode 100644 index 0000000000000000000000000000000000000000..4de4333698f5fd119028ddffec328a0571074d81 --- /dev/null +++ b/REAPER/build/CMakeFiles/core.dir/core/file_resource.cc.o.d @@ -0,0 +1,129 @@ +CMakeFiles/core.dir/core/file_resource.cc.o: \ + /content/NeuCoSVC-2/REAPER/core/file_resource.cc \ + /usr/include/stdc-predef.h \ + /content/NeuCoSVC-2/REAPER/./core/file_resource.h /usr/include/stdio.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/features.h /usr/include/features-time64.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/lib/gcc/x86_64-linux-gnu/11/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/11/include/stdarg.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/c++/11/string \ + /usr/include/x86_64-linux-gnu/c++/11/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/cpu_defines.h \ + /usr/include/c++/11/bits/stringfwd.h \ + /usr/include/c++/11/bits/memoryfwd.h \ + /usr/include/c++/11/bits/char_traits.h \ + /usr/include/c++/11/bits/stl_algobase.h \ + /usr/include/c++/11/bits/functexcept.h \ + /usr/include/c++/11/bits/exception_defines.h \ + /usr/include/c++/11/bits/cpp_type_traits.h \ + /usr/include/c++/11/ext/type_traits.h \ + /usr/include/c++/11/ext/numeric_traits.h \ + /usr/include/c++/11/bits/stl_pair.h /usr/include/c++/11/bits/move.h \ + /usr/include/c++/11/type_traits \ + /usr/include/c++/11/bits/stl_iterator_base_types.h \ + /usr/include/c++/11/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/11/bits/concept_check.h \ + /usr/include/c++/11/debug/assertions.h \ + /usr/include/c++/11/bits/stl_iterator.h \ + /usr/include/c++/11/bits/ptr_traits.h /usr/include/c++/11/debug/debug.h \ + /usr/include/c++/11/bits/predefined_ops.h \ + /usr/include/c++/11/bits/postypes.h /usr/include/c++/11/cwchar \ + /usr/include/wchar.h /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/c++/11/cstdint \ + /usr/lib/gcc/x86_64-linux-gnu/11/include/stdint.h /usr/include/stdint.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/c++/11/bits/allocator.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/c++allocator.h \ + /usr/include/c++/11/ext/new_allocator.h /usr/include/c++/11/new \ + /usr/include/c++/11/bits/exception.h \ + /usr/include/c++/11/bits/localefwd.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/c++locale.h \ + /usr/include/c++/11/clocale /usr/include/locale.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h /usr/include/c++/11/iosfwd \ + /usr/include/c++/11/cctype /usr/include/ctype.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/c++/11/bits/ostream_insert.h \ + /usr/include/c++/11/bits/cxxabi_forced.h \ + /usr/include/c++/11/bits/stl_function.h \ + /usr/include/c++/11/backward/binders.h \ + /usr/include/c++/11/bits/range_access.h \ + /usr/include/c++/11/initializer_list \ + /usr/include/c++/11/bits/basic_string.h \ + /usr/include/c++/11/ext/atomicity.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/gthr-default.h \ + /usr/include/pthread.h /usr/include/sched.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h /usr/include/time.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/sys/single_threaded.h \ + /usr/include/c++/11/ext/alloc_traits.h \ + /usr/include/c++/11/bits/alloc_traits.h \ + /usr/include/c++/11/bits/stl_construct.h \ + /usr/include/c++/11/ext/string_conversions.h /usr/include/c++/11/cstdlib \ + /usr/include/stdlib.h /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/sys/types.h /usr/include/endian.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/alloca.h /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /usr/include/c++/11/bits/std_abs.h /usr/include/c++/11/cstdio \ + /usr/include/c++/11/cerrno /usr/include/errno.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h /usr/include/linux/errno.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/asm-generic/errno.h /usr/include/asm-generic/errno-base.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/c++/11/bits/charconv.h \ + /usr/include/c++/11/bits/functional_hash.h \ + /usr/include/c++/11/bits/hash_bytes.h \ + /usr/include/c++/11/bits/basic_string.tcc diff --git a/REAPER/build/CMakeFiles/core.dir/core/float_matrix.cc.o b/REAPER/build/CMakeFiles/core.dir/core/float_matrix.cc.o new file mode 100644 index 0000000000000000000000000000000000000000..166437c0c9508e4e48fecc73598dd148b472ae5f Binary files /dev/null and b/REAPER/build/CMakeFiles/core.dir/core/float_matrix.cc.o differ diff --git a/REAPER/build/CMakeFiles/core.dir/core/float_matrix.cc.o.d b/REAPER/build/CMakeFiles/core.dir/core/float_matrix.cc.o.d new file mode 100644 index 0000000000000000000000000000000000000000..b2596dbd5de811431cfe6a99a2f16931156364a3 --- /dev/null +++ b/REAPER/build/CMakeFiles/core.dir/core/float_matrix.cc.o.d @@ -0,0 +1,130 @@ +CMakeFiles/core.dir/core/float_matrix.cc.o: \ + /content/NeuCoSVC-2/REAPER/core/float_matrix.cc \ + /usr/include/stdc-predef.h \ + /content/NeuCoSVC-2/REAPER/./core/float_matrix.h \ + /usr/lib/gcc/x86_64-linux-gnu/11/include/stdint.h /usr/include/stdint.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/features.h /usr/include/features-time64.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/c++/11/string \ + /usr/include/x86_64-linux-gnu/c++/11/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/cpu_defines.h \ + /usr/include/c++/11/bits/stringfwd.h \ + /usr/include/c++/11/bits/memoryfwd.h \ + /usr/include/c++/11/bits/char_traits.h \ + /usr/include/c++/11/bits/stl_algobase.h \ + /usr/include/c++/11/bits/functexcept.h \ + /usr/include/c++/11/bits/exception_defines.h \ + /usr/include/c++/11/bits/cpp_type_traits.h \ + /usr/include/c++/11/ext/type_traits.h \ + /usr/include/c++/11/ext/numeric_traits.h \ + /usr/include/c++/11/bits/stl_pair.h /usr/include/c++/11/bits/move.h \ + /usr/include/c++/11/type_traits \ + /usr/include/c++/11/bits/stl_iterator_base_types.h \ + /usr/include/c++/11/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/11/bits/concept_check.h \ + /usr/include/c++/11/debug/assertions.h \ + /usr/include/c++/11/bits/stl_iterator.h \ + /usr/include/c++/11/bits/ptr_traits.h /usr/include/c++/11/debug/debug.h \ + /usr/include/c++/11/bits/predefined_ops.h \ + /usr/include/c++/11/bits/postypes.h /usr/include/c++/11/cwchar \ + /usr/include/wchar.h /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/lib/gcc/x86_64-linux-gnu/11/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/11/include/stdarg.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/c++/11/cstdint /usr/include/c++/11/bits/allocator.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/c++allocator.h \ + /usr/include/c++/11/ext/new_allocator.h /usr/include/c++/11/new \ + /usr/include/c++/11/bits/exception.h \ + /usr/include/c++/11/bits/localefwd.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/c++locale.h \ + /usr/include/c++/11/clocale /usr/include/locale.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h /usr/include/c++/11/iosfwd \ + /usr/include/c++/11/cctype /usr/include/ctype.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/c++/11/bits/ostream_insert.h \ + /usr/include/c++/11/bits/cxxabi_forced.h \ + /usr/include/c++/11/bits/stl_function.h \ + /usr/include/c++/11/backward/binders.h \ + /usr/include/c++/11/bits/range_access.h \ + /usr/include/c++/11/initializer_list \ + /usr/include/c++/11/bits/basic_string.h \ + /usr/include/c++/11/ext/atomicity.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/gthr-default.h \ + /usr/include/pthread.h /usr/include/sched.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h /usr/include/time.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/sys/single_threaded.h \ + /usr/include/c++/11/ext/alloc_traits.h \ + /usr/include/c++/11/bits/alloc_traits.h \ + /usr/include/c++/11/bits/stl_construct.h \ + /usr/include/c++/11/ext/string_conversions.h /usr/include/c++/11/cstdlib \ + /usr/include/stdlib.h /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/sys/types.h /usr/include/endian.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/alloca.h /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /usr/include/c++/11/bits/std_abs.h /usr/include/c++/11/cstdio \ + /usr/include/stdio.h /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/c++/11/cerrno /usr/include/errno.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h /usr/include/linux/errno.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/asm-generic/errno.h /usr/include/asm-generic/errno-base.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/c++/11/bits/charconv.h \ + /usr/include/c++/11/bits/functional_hash.h \ + /usr/include/c++/11/bits/hash_bytes.h \ + /usr/include/c++/11/bits/basic_string.tcc \ + /content/NeuCoSVC-2/REAPER/./core/float_matrix-inl.h \ + /usr/include/string.h /usr/include/strings.h diff --git a/REAPER/build/CMakeFiles/core.dir/core/track.cc.o b/REAPER/build/CMakeFiles/core.dir/core/track.cc.o new file mode 100644 index 0000000000000000000000000000000000000000..245d3cd248e87d7a104a9df6e427b705bcdeb90f Binary files /dev/null and b/REAPER/build/CMakeFiles/core.dir/core/track.cc.o differ diff --git a/REAPER/build/CMakeFiles/core.dir/core/track.cc.o.d b/REAPER/build/CMakeFiles/core.dir/core/track.cc.o.d new file mode 100644 index 0000000000000000000000000000000000000000..59489b54ff0c76d5028fc3c0a5e0ea2f891b0b74 --- /dev/null +++ b/REAPER/build/CMakeFiles/core.dir/core/track.cc.o.d @@ -0,0 +1,165 @@ +CMakeFiles/core.dir/core/track.cc.o: \ + /content/NeuCoSVC-2/REAPER/core/track.cc /usr/include/stdc-predef.h \ + /content/NeuCoSVC-2/REAPER/./core/track.h \ + /usr/lib/gcc/x86_64-linux-gnu/11/include/stdint.h /usr/include/stdint.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/features.h /usr/include/features-time64.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/c++/11/string \ + /usr/include/x86_64-linux-gnu/c++/11/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/cpu_defines.h \ + /usr/include/c++/11/bits/stringfwd.h \ + /usr/include/c++/11/bits/memoryfwd.h \ + /usr/include/c++/11/bits/char_traits.h \ + /usr/include/c++/11/bits/stl_algobase.h \ + /usr/include/c++/11/bits/functexcept.h \ + /usr/include/c++/11/bits/exception_defines.h \ + /usr/include/c++/11/bits/cpp_type_traits.h \ + /usr/include/c++/11/ext/type_traits.h \ + /usr/include/c++/11/ext/numeric_traits.h \ + /usr/include/c++/11/bits/stl_pair.h /usr/include/c++/11/bits/move.h \ + /usr/include/c++/11/type_traits \ + /usr/include/c++/11/bits/stl_iterator_base_types.h \ + /usr/include/c++/11/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/11/bits/concept_check.h \ + /usr/include/c++/11/debug/assertions.h \ + /usr/include/c++/11/bits/stl_iterator.h \ + /usr/include/c++/11/bits/ptr_traits.h /usr/include/c++/11/debug/debug.h \ + /usr/include/c++/11/bits/predefined_ops.h \ + /usr/include/c++/11/bits/postypes.h /usr/include/c++/11/cwchar \ + /usr/include/wchar.h /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/lib/gcc/x86_64-linux-gnu/11/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/11/include/stdarg.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/c++/11/cstdint /usr/include/c++/11/bits/allocator.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/c++allocator.h \ + /usr/include/c++/11/ext/new_allocator.h /usr/include/c++/11/new \ + /usr/include/c++/11/bits/exception.h \ + /usr/include/c++/11/bits/localefwd.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/c++locale.h \ + /usr/include/c++/11/clocale /usr/include/locale.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h /usr/include/c++/11/iosfwd \ + /usr/include/c++/11/cctype /usr/include/ctype.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/c++/11/bits/ostream_insert.h \ + /usr/include/c++/11/bits/cxxabi_forced.h \ + /usr/include/c++/11/bits/stl_function.h \ + /usr/include/c++/11/backward/binders.h \ + /usr/include/c++/11/bits/range_access.h \ + /usr/include/c++/11/initializer_list \ + /usr/include/c++/11/bits/basic_string.h \ + /usr/include/c++/11/ext/atomicity.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/gthr-default.h \ + /usr/include/pthread.h /usr/include/sched.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h /usr/include/time.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/sys/single_threaded.h \ + /usr/include/c++/11/ext/alloc_traits.h \ + /usr/include/c++/11/bits/alloc_traits.h \ + /usr/include/c++/11/bits/stl_construct.h \ + /usr/include/c++/11/ext/string_conversions.h /usr/include/c++/11/cstdlib \ + /usr/include/stdlib.h /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/sys/types.h /usr/include/endian.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/alloca.h /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /usr/include/c++/11/bits/std_abs.h /usr/include/c++/11/cstdio \ + /usr/include/stdio.h /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/c++/11/cerrno /usr/include/errno.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h /usr/include/linux/errno.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/asm-generic/errno.h /usr/include/asm-generic/errno-base.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/c++/11/bits/charconv.h \ + /usr/include/c++/11/bits/functional_hash.h \ + /usr/include/c++/11/bits/hash_bytes.h \ + /usr/include/c++/11/bits/basic_string.tcc /usr/include/c++/11/vector \ + /usr/include/c++/11/bits/stl_uninitialized.h \ + /usr/include/c++/11/bits/stl_vector.h \ + /usr/include/c++/11/bits/stl_bvector.h \ + /usr/include/c++/11/bits/vector.tcc \ + /content/NeuCoSVC-2/REAPER/./core/file_resource.h \ + /content/NeuCoSVC-2/REAPER/./core/float_matrix.h \ + /content/NeuCoSVC-2/REAPER/./core/float_matrix-inl.h \ + /usr/include/c++/11/math.h /usr/include/c++/11/cmath /usr/include/math.h \ + /usr/include/x86_64-linux-gnu/bits/math-vector.h \ + /usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h \ + /usr/include/x86_64-linux-gnu/bits/flt-eval-method.h \ + /usr/include/x86_64-linux-gnu/bits/fp-logb.h \ + /usr/include/x86_64-linux-gnu/bits/fp-fast.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h \ + /usr/include/x86_64-linux-gnu/bits/iscanonical.h \ + /usr/include/c++/11/memory /usr/include/c++/11/bits/stl_tempbuf.h \ + /usr/include/c++/11/bits/stl_raw_storage_iter.h \ + /usr/include/c++/11/bits/align.h /usr/include/c++/11/bit \ + /usr/include/c++/11/bits/uses_allocator.h \ + /usr/include/c++/11/bits/unique_ptr.h /usr/include/c++/11/utility \ + /usr/include/c++/11/bits/stl_relops.h /usr/include/c++/11/tuple \ + /usr/include/c++/11/array /usr/include/c++/11/bits/invoke.h \ + /usr/include/c++/11/bits/shared_ptr.h \ + /usr/include/c++/11/bits/shared_ptr_base.h /usr/include/c++/11/typeinfo \ + /usr/include/c++/11/bits/allocated_ptr.h \ + /usr/include/c++/11/bits/refwrap.h \ + /usr/include/c++/11/ext/aligned_buffer.h \ + /usr/include/c++/11/ext/concurrence.h /usr/include/c++/11/exception \ + /usr/include/c++/11/bits/exception_ptr.h \ + /usr/include/c++/11/bits/cxxabi_init_exception.h \ + /usr/include/c++/11/bits/nested_exception.h \ + /usr/include/c++/11/bits/shared_ptr_atomic.h \ + /usr/include/c++/11/bits/atomic_base.h \ + /usr/include/c++/11/bits/atomic_lockfree_defines.h \ + /usr/include/c++/11/backward/auto_ptr.h /usr/include/c++/11/stdlib.h \ + /usr/include/inttypes.h diff --git a/REAPER/build/CMakeFiles/core.dir/depend.make b/REAPER/build/CMakeFiles/core.dir/depend.make new file mode 100644 index 0000000000000000000000000000000000000000..e89a2a3e96284c6c376d1e048309462cca2dd216 --- /dev/null +++ b/REAPER/build/CMakeFiles/core.dir/depend.make @@ -0,0 +1,2 @@ +# Empty dependencies file for core. +# This may be replaced when dependencies are built. diff --git a/REAPER/build/CMakeFiles/core.dir/flags.make b/REAPER/build/CMakeFiles/core.dir/flags.make new file mode 100644 index 0000000000000000000000000000000000000000..de2965e1d495155c0f22b4ba2de6c2ef5b82b629 --- /dev/null +++ b/REAPER/build/CMakeFiles/core.dir/flags.make @@ -0,0 +1,10 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.27 + +# compile CXX with /usr/bin/c++ +CXX_DEFINES = + +CXX_INCLUDES = -I/content/NeuCoSVC-2/REAPER/. + +CXX_FLAGS = -std=c++11 + diff --git a/REAPER/build/CMakeFiles/core.dir/link.txt b/REAPER/build/CMakeFiles/core.dir/link.txt new file mode 100644 index 0000000000000000000000000000000000000000..819ae3cb73a53575bd90410f14c592a48572300d --- /dev/null +++ b/REAPER/build/CMakeFiles/core.dir/link.txt @@ -0,0 +1,2 @@ +/usr/bin/ar qc libcore.a CMakeFiles/core.dir/core/file_resource.cc.o CMakeFiles/core.dir/core/float_matrix.cc.o CMakeFiles/core.dir/core/track.cc.o +/usr/bin/ranlib libcore.a diff --git a/REAPER/build/CMakeFiles/core.dir/progress.make b/REAPER/build/CMakeFiles/core.dir/progress.make new file mode 100644 index 0000000000000000000000000000000000000000..a69a57e8e4ffee737b6054e9068354426a41030f --- /dev/null +++ b/REAPER/build/CMakeFiles/core.dir/progress.make @@ -0,0 +1,5 @@ +CMAKE_PROGRESS_1 = 1 +CMAKE_PROGRESS_2 = 2 +CMAKE_PROGRESS_3 = 3 +CMAKE_PROGRESS_4 = 4 + diff --git a/REAPER/build/CMakeFiles/epoch_tracker.dir/DependInfo.cmake b/REAPER/build/CMakeFiles/epoch_tracker.dir/DependInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..cbd289a81fbfa120512c8cd14602edab001545ae --- /dev/null +++ b/REAPER/build/CMakeFiles/epoch_tracker.dir/DependInfo.cmake @@ -0,0 +1,22 @@ + +# Consider dependencies only in project. +set(CMAKE_DEPENDS_IN_PROJECT_ONLY OFF) + +# The set of languages for which implicit dependencies are needed: +set(CMAKE_DEPENDS_LANGUAGES + ) + +# The set of dependency files which are needed: +set(CMAKE_DEPENDS_DEPENDENCY_FILES + "/content/NeuCoSVC-2/REAPER/epoch_tracker/epoch_tracker.cc" "CMakeFiles/epoch_tracker.dir/epoch_tracker/epoch_tracker.cc.o" "gcc" "CMakeFiles/epoch_tracker.dir/epoch_tracker/epoch_tracker.cc.o.d" + "/content/NeuCoSVC-2/REAPER/epoch_tracker/fd_filter.cc" "CMakeFiles/epoch_tracker.dir/epoch_tracker/fd_filter.cc.o" "gcc" "CMakeFiles/epoch_tracker.dir/epoch_tracker/fd_filter.cc.o.d" + "/content/NeuCoSVC-2/REAPER/epoch_tracker/fft.cc" "CMakeFiles/epoch_tracker.dir/epoch_tracker/fft.cc.o" "gcc" "CMakeFiles/epoch_tracker.dir/epoch_tracker/fft.cc.o.d" + "/content/NeuCoSVC-2/REAPER/epoch_tracker/lpc_analyzer.cc" "CMakeFiles/epoch_tracker.dir/epoch_tracker/lpc_analyzer.cc.o" "gcc" "CMakeFiles/epoch_tracker.dir/epoch_tracker/lpc_analyzer.cc.o.d" + ) + +# Targets to which this target links which contain Fortran sources. +set(CMAKE_Fortran_TARGET_LINKED_INFO_FILES + ) + +# Fortran module output directory. +set(CMAKE_Fortran_TARGET_MODULE_DIR "") diff --git a/REAPER/build/CMakeFiles/epoch_tracker.dir/build.make b/REAPER/build/CMakeFiles/epoch_tracker.dir/build.make new file mode 100644 index 0000000000000000000000000000000000000000..02b3c851c7bb2bfc9963525b8dec528135ecf641 --- /dev/null +++ b/REAPER/build/CMakeFiles/epoch_tracker.dir/build.make @@ -0,0 +1,159 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.27 + +# Delete rule output on recipe failure. +.DELETE_ON_ERROR: + +#============================================================================= +# Special targets provided by cmake. + +# Disable implicit rules so canonical targets will work. +.SUFFIXES: + +# Disable VCS-based implicit rules. +% : %,v + +# Disable VCS-based implicit rules. +% : RCS/% + +# Disable VCS-based implicit rules. +% : RCS/%,v + +# Disable VCS-based implicit rules. +% : SCCS/s.% + +# Disable VCS-based implicit rules. +% : s.% + +.SUFFIXES: .hpux_make_needs_suffix_list + +# Command-line flag to silence nested $(MAKE). +$(VERBOSE)MAKESILENT = -s + +#Suppress display of executed commands. +$(VERBOSE).SILENT: + +# A target that is always out of date. +cmake_force: +.PHONY : cmake_force + +#============================================================================= +# Set environment variables for the build. + +# The shell in which to execute make rules. +SHELL = /bin/sh + +# The CMake executable. +CMAKE_COMMAND = /usr/local/lib/python3.10/dist-packages/cmake/data/bin/cmake + +# The command to remove a file. +RM = /usr/local/lib/python3.10/dist-packages/cmake/data/bin/cmake -E rm -f + +# Escaping for special characters. +EQUALS = = + +# The top-level source directory on which CMake was run. +CMAKE_SOURCE_DIR = /content/NeuCoSVC-2/REAPER + +# The top-level build directory on which CMake was run. +CMAKE_BINARY_DIR = /content/NeuCoSVC-2/REAPER/build + +# Include any dependencies generated for this target. +include CMakeFiles/epoch_tracker.dir/depend.make +# Include any dependencies generated by the compiler for this target. +include CMakeFiles/epoch_tracker.dir/compiler_depend.make + +# Include the progress variables for this target. +include CMakeFiles/epoch_tracker.dir/progress.make + +# Include the compile flags for this target's objects. +include CMakeFiles/epoch_tracker.dir/flags.make + +CMakeFiles/epoch_tracker.dir/epoch_tracker/fft.cc.o: CMakeFiles/epoch_tracker.dir/flags.make +CMakeFiles/epoch_tracker.dir/epoch_tracker/fft.cc.o: /content/NeuCoSVC-2/REAPER/epoch_tracker/fft.cc +CMakeFiles/epoch_tracker.dir/epoch_tracker/fft.cc.o: CMakeFiles/epoch_tracker.dir/compiler_depend.ts + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/content/NeuCoSVC-2/REAPER/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_1) "Building CXX object CMakeFiles/epoch_tracker.dir/epoch_tracker/fft.cc.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/epoch_tracker.dir/epoch_tracker/fft.cc.o -MF CMakeFiles/epoch_tracker.dir/epoch_tracker/fft.cc.o.d -o CMakeFiles/epoch_tracker.dir/epoch_tracker/fft.cc.o -c /content/NeuCoSVC-2/REAPER/epoch_tracker/fft.cc + +CMakeFiles/epoch_tracker.dir/epoch_tracker/fft.cc.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/epoch_tracker.dir/epoch_tracker/fft.cc.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /content/NeuCoSVC-2/REAPER/epoch_tracker/fft.cc > CMakeFiles/epoch_tracker.dir/epoch_tracker/fft.cc.i + +CMakeFiles/epoch_tracker.dir/epoch_tracker/fft.cc.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/epoch_tracker.dir/epoch_tracker/fft.cc.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /content/NeuCoSVC-2/REAPER/epoch_tracker/fft.cc -o CMakeFiles/epoch_tracker.dir/epoch_tracker/fft.cc.s + +CMakeFiles/epoch_tracker.dir/epoch_tracker/fd_filter.cc.o: CMakeFiles/epoch_tracker.dir/flags.make +CMakeFiles/epoch_tracker.dir/epoch_tracker/fd_filter.cc.o: /content/NeuCoSVC-2/REAPER/epoch_tracker/fd_filter.cc +CMakeFiles/epoch_tracker.dir/epoch_tracker/fd_filter.cc.o: CMakeFiles/epoch_tracker.dir/compiler_depend.ts + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/content/NeuCoSVC-2/REAPER/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_2) "Building CXX object CMakeFiles/epoch_tracker.dir/epoch_tracker/fd_filter.cc.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/epoch_tracker.dir/epoch_tracker/fd_filter.cc.o -MF CMakeFiles/epoch_tracker.dir/epoch_tracker/fd_filter.cc.o.d -o CMakeFiles/epoch_tracker.dir/epoch_tracker/fd_filter.cc.o -c /content/NeuCoSVC-2/REAPER/epoch_tracker/fd_filter.cc + +CMakeFiles/epoch_tracker.dir/epoch_tracker/fd_filter.cc.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/epoch_tracker.dir/epoch_tracker/fd_filter.cc.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /content/NeuCoSVC-2/REAPER/epoch_tracker/fd_filter.cc > CMakeFiles/epoch_tracker.dir/epoch_tracker/fd_filter.cc.i + +CMakeFiles/epoch_tracker.dir/epoch_tracker/fd_filter.cc.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/epoch_tracker.dir/epoch_tracker/fd_filter.cc.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /content/NeuCoSVC-2/REAPER/epoch_tracker/fd_filter.cc -o CMakeFiles/epoch_tracker.dir/epoch_tracker/fd_filter.cc.s + +CMakeFiles/epoch_tracker.dir/epoch_tracker/lpc_analyzer.cc.o: CMakeFiles/epoch_tracker.dir/flags.make +CMakeFiles/epoch_tracker.dir/epoch_tracker/lpc_analyzer.cc.o: /content/NeuCoSVC-2/REAPER/epoch_tracker/lpc_analyzer.cc +CMakeFiles/epoch_tracker.dir/epoch_tracker/lpc_analyzer.cc.o: CMakeFiles/epoch_tracker.dir/compiler_depend.ts + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/content/NeuCoSVC-2/REAPER/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_3) "Building CXX object CMakeFiles/epoch_tracker.dir/epoch_tracker/lpc_analyzer.cc.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/epoch_tracker.dir/epoch_tracker/lpc_analyzer.cc.o -MF CMakeFiles/epoch_tracker.dir/epoch_tracker/lpc_analyzer.cc.o.d -o CMakeFiles/epoch_tracker.dir/epoch_tracker/lpc_analyzer.cc.o -c /content/NeuCoSVC-2/REAPER/epoch_tracker/lpc_analyzer.cc + +CMakeFiles/epoch_tracker.dir/epoch_tracker/lpc_analyzer.cc.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/epoch_tracker.dir/epoch_tracker/lpc_analyzer.cc.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /content/NeuCoSVC-2/REAPER/epoch_tracker/lpc_analyzer.cc > CMakeFiles/epoch_tracker.dir/epoch_tracker/lpc_analyzer.cc.i + +CMakeFiles/epoch_tracker.dir/epoch_tracker/lpc_analyzer.cc.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/epoch_tracker.dir/epoch_tracker/lpc_analyzer.cc.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /content/NeuCoSVC-2/REAPER/epoch_tracker/lpc_analyzer.cc -o CMakeFiles/epoch_tracker.dir/epoch_tracker/lpc_analyzer.cc.s + +CMakeFiles/epoch_tracker.dir/epoch_tracker/epoch_tracker.cc.o: CMakeFiles/epoch_tracker.dir/flags.make +CMakeFiles/epoch_tracker.dir/epoch_tracker/epoch_tracker.cc.o: /content/NeuCoSVC-2/REAPER/epoch_tracker/epoch_tracker.cc +CMakeFiles/epoch_tracker.dir/epoch_tracker/epoch_tracker.cc.o: CMakeFiles/epoch_tracker.dir/compiler_depend.ts + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/content/NeuCoSVC-2/REAPER/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_4) "Building CXX object CMakeFiles/epoch_tracker.dir/epoch_tracker/epoch_tracker.cc.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/epoch_tracker.dir/epoch_tracker/epoch_tracker.cc.o -MF CMakeFiles/epoch_tracker.dir/epoch_tracker/epoch_tracker.cc.o.d -o CMakeFiles/epoch_tracker.dir/epoch_tracker/epoch_tracker.cc.o -c /content/NeuCoSVC-2/REAPER/epoch_tracker/epoch_tracker.cc + +CMakeFiles/epoch_tracker.dir/epoch_tracker/epoch_tracker.cc.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/epoch_tracker.dir/epoch_tracker/epoch_tracker.cc.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /content/NeuCoSVC-2/REAPER/epoch_tracker/epoch_tracker.cc > CMakeFiles/epoch_tracker.dir/epoch_tracker/epoch_tracker.cc.i + +CMakeFiles/epoch_tracker.dir/epoch_tracker/epoch_tracker.cc.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/epoch_tracker.dir/epoch_tracker/epoch_tracker.cc.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /content/NeuCoSVC-2/REAPER/epoch_tracker/epoch_tracker.cc -o CMakeFiles/epoch_tracker.dir/epoch_tracker/epoch_tracker.cc.s + +# Object files for target epoch_tracker +epoch_tracker_OBJECTS = \ +"CMakeFiles/epoch_tracker.dir/epoch_tracker/fft.cc.o" \ +"CMakeFiles/epoch_tracker.dir/epoch_tracker/fd_filter.cc.o" \ +"CMakeFiles/epoch_tracker.dir/epoch_tracker/lpc_analyzer.cc.o" \ +"CMakeFiles/epoch_tracker.dir/epoch_tracker/epoch_tracker.cc.o" + +# External object files for target epoch_tracker +epoch_tracker_EXTERNAL_OBJECTS = + +libepoch_tracker.a: CMakeFiles/epoch_tracker.dir/epoch_tracker/fft.cc.o +libepoch_tracker.a: CMakeFiles/epoch_tracker.dir/epoch_tracker/fd_filter.cc.o +libepoch_tracker.a: CMakeFiles/epoch_tracker.dir/epoch_tracker/lpc_analyzer.cc.o +libepoch_tracker.a: CMakeFiles/epoch_tracker.dir/epoch_tracker/epoch_tracker.cc.o +libepoch_tracker.a: CMakeFiles/epoch_tracker.dir/build.make +libepoch_tracker.a: CMakeFiles/epoch_tracker.dir/link.txt + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --bold --progress-dir=/content/NeuCoSVC-2/REAPER/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_5) "Linking CXX static library libepoch_tracker.a" + $(CMAKE_COMMAND) -P CMakeFiles/epoch_tracker.dir/cmake_clean_target.cmake + $(CMAKE_COMMAND) -E cmake_link_script CMakeFiles/epoch_tracker.dir/link.txt --verbose=$(VERBOSE) + +# Rule to build all files generated by this target. +CMakeFiles/epoch_tracker.dir/build: libepoch_tracker.a +.PHONY : CMakeFiles/epoch_tracker.dir/build + +CMakeFiles/epoch_tracker.dir/clean: + $(CMAKE_COMMAND) -P CMakeFiles/epoch_tracker.dir/cmake_clean.cmake +.PHONY : CMakeFiles/epoch_tracker.dir/clean + +CMakeFiles/epoch_tracker.dir/depend: + cd /content/NeuCoSVC-2/REAPER/build && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /content/NeuCoSVC-2/REAPER /content/NeuCoSVC-2/REAPER /content/NeuCoSVC-2/REAPER/build /content/NeuCoSVC-2/REAPER/build /content/NeuCoSVC-2/REAPER/build/CMakeFiles/epoch_tracker.dir/DependInfo.cmake "--color=$(COLOR)" +.PHONY : CMakeFiles/epoch_tracker.dir/depend + diff --git a/REAPER/build/CMakeFiles/epoch_tracker.dir/cmake_clean.cmake b/REAPER/build/CMakeFiles/epoch_tracker.dir/cmake_clean.cmake new file mode 100644 index 0000000000000000000000000000000000000000..80e69f0cc840f57077f4830cf9439475371c3687 --- /dev/null +++ b/REAPER/build/CMakeFiles/epoch_tracker.dir/cmake_clean.cmake @@ -0,0 +1,17 @@ +file(REMOVE_RECURSE + "CMakeFiles/epoch_tracker.dir/epoch_tracker/epoch_tracker.cc.o" + "CMakeFiles/epoch_tracker.dir/epoch_tracker/epoch_tracker.cc.o.d" + "CMakeFiles/epoch_tracker.dir/epoch_tracker/fd_filter.cc.o" + "CMakeFiles/epoch_tracker.dir/epoch_tracker/fd_filter.cc.o.d" + "CMakeFiles/epoch_tracker.dir/epoch_tracker/fft.cc.o" + "CMakeFiles/epoch_tracker.dir/epoch_tracker/fft.cc.o.d" + "CMakeFiles/epoch_tracker.dir/epoch_tracker/lpc_analyzer.cc.o" + "CMakeFiles/epoch_tracker.dir/epoch_tracker/lpc_analyzer.cc.o.d" + "libepoch_tracker.a" + "libepoch_tracker.pdb" +) + +# Per-language clean rules from dependency scanning. +foreach(lang CXX) + include(CMakeFiles/epoch_tracker.dir/cmake_clean_${lang}.cmake OPTIONAL) +endforeach() diff --git a/REAPER/build/CMakeFiles/epoch_tracker.dir/cmake_clean_target.cmake b/REAPER/build/CMakeFiles/epoch_tracker.dir/cmake_clean_target.cmake new file mode 100644 index 0000000000000000000000000000000000000000..b2d3e82c94bf5d353678f2312be1b4dbf43f69b4 --- /dev/null +++ b/REAPER/build/CMakeFiles/epoch_tracker.dir/cmake_clean_target.cmake @@ -0,0 +1,3 @@ +file(REMOVE_RECURSE + "libepoch_tracker.a" +) diff --git a/REAPER/build/CMakeFiles/epoch_tracker.dir/compiler_depend.make b/REAPER/build/CMakeFiles/epoch_tracker.dir/compiler_depend.make new file mode 100644 index 0000000000000000000000000000000000000000..de2619d0b192c0c1b73a6657921323f11de3b35b --- /dev/null +++ b/REAPER/build/CMakeFiles/epoch_tracker.dir/compiler_depend.make @@ -0,0 +1,2 @@ +# Empty compiler generated dependencies file for epoch_tracker. +# This may be replaced when dependencies are built. diff --git a/REAPER/build/CMakeFiles/epoch_tracker.dir/compiler_depend.ts b/REAPER/build/CMakeFiles/epoch_tracker.dir/compiler_depend.ts new file mode 100644 index 0000000000000000000000000000000000000000..68d3f87cc4f605d06e5b8399e1c501614f21df2b --- /dev/null +++ b/REAPER/build/CMakeFiles/epoch_tracker.dir/compiler_depend.ts @@ -0,0 +1,2 @@ +# CMAKE generated file: DO NOT EDIT! +# Timestamp file for compiler generated dependencies management for epoch_tracker. diff --git a/REAPER/build/CMakeFiles/epoch_tracker.dir/depend.make b/REAPER/build/CMakeFiles/epoch_tracker.dir/depend.make new file mode 100644 index 0000000000000000000000000000000000000000..bc3af85bc12bc9bc374db3f1a968265412020843 --- /dev/null +++ b/REAPER/build/CMakeFiles/epoch_tracker.dir/depend.make @@ -0,0 +1,2 @@ +# Empty dependencies file for epoch_tracker. +# This may be replaced when dependencies are built. diff --git a/REAPER/build/CMakeFiles/epoch_tracker.dir/epoch_tracker/epoch_tracker.cc.o b/REAPER/build/CMakeFiles/epoch_tracker.dir/epoch_tracker/epoch_tracker.cc.o new file mode 100644 index 0000000000000000000000000000000000000000..f291d23d1a5ecbfd16aa6863322528bebcd23b4a Binary files /dev/null and b/REAPER/build/CMakeFiles/epoch_tracker.dir/epoch_tracker/epoch_tracker.cc.o differ diff --git a/REAPER/build/CMakeFiles/epoch_tracker.dir/epoch_tracker/epoch_tracker.cc.o.d b/REAPER/build/CMakeFiles/epoch_tracker.dir/epoch_tracker/epoch_tracker.cc.o.d new file mode 100644 index 0000000000000000000000000000000000000000..e9e0f9651caf7fe4d5cb5244c3c0425515d2e905 --- /dev/null +++ b/REAPER/build/CMakeFiles/epoch_tracker.dir/epoch_tracker/epoch_tracker.cc.o.d @@ -0,0 +1,164 @@ +CMakeFiles/epoch_tracker.dir/epoch_tracker/epoch_tracker.cc.o: \ + /content/NeuCoSVC-2/REAPER/epoch_tracker/epoch_tracker.cc \ + /usr/include/stdc-predef.h \ + /content/NeuCoSVC-2/REAPER/./epoch_tracker/epoch_tracker.h \ + /usr/include/c++/11/memory /usr/include/c++/11/bits/stl_algobase.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/os_defines.h \ + /usr/include/features.h /usr/include/features-time64.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/cpu_defines.h \ + /usr/include/c++/11/bits/functexcept.h \ + /usr/include/c++/11/bits/exception_defines.h \ + /usr/include/c++/11/bits/cpp_type_traits.h \ + /usr/include/c++/11/ext/type_traits.h \ + /usr/include/c++/11/ext/numeric_traits.h \ + /usr/include/c++/11/bits/stl_pair.h /usr/include/c++/11/bits/move.h \ + /usr/include/c++/11/type_traits \ + /usr/include/c++/11/bits/stl_iterator_base_types.h \ + /usr/include/c++/11/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/11/bits/concept_check.h \ + /usr/include/c++/11/debug/assertions.h \ + /usr/include/c++/11/bits/stl_iterator.h \ + /usr/include/c++/11/bits/ptr_traits.h /usr/include/c++/11/debug/debug.h \ + /usr/include/c++/11/bits/predefined_ops.h \ + /usr/include/c++/11/bits/allocator.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/c++allocator.h \ + /usr/include/c++/11/ext/new_allocator.h /usr/include/c++/11/new \ + /usr/include/c++/11/bits/exception.h \ + /usr/include/c++/11/bits/memoryfwd.h \ + /usr/include/c++/11/bits/stl_construct.h \ + /usr/include/c++/11/bits/stl_uninitialized.h \ + /usr/include/c++/11/ext/alloc_traits.h \ + /usr/include/c++/11/bits/alloc_traits.h \ + /usr/include/c++/11/bits/stl_tempbuf.h \ + /usr/include/c++/11/bits/stl_raw_storage_iter.h \ + /usr/include/c++/11/bits/align.h /usr/include/c++/11/bit \ + /usr/lib/gcc/x86_64-linux-gnu/11/include/stdint.h /usr/include/stdint.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/c++/11/bits/uses_allocator.h \ + /usr/include/c++/11/bits/unique_ptr.h /usr/include/c++/11/utility \ + /usr/include/c++/11/bits/stl_relops.h \ + /usr/include/c++/11/initializer_list /usr/include/c++/11/tuple \ + /usr/include/c++/11/array /usr/include/c++/11/bits/range_access.h \ + /usr/include/c++/11/bits/invoke.h \ + /usr/include/c++/11/bits/stl_function.h \ + /usr/include/c++/11/backward/binders.h \ + /usr/include/c++/11/bits/functional_hash.h \ + /usr/include/c++/11/bits/hash_bytes.h \ + /usr/include/c++/11/bits/shared_ptr.h /usr/include/c++/11/iosfwd \ + /usr/include/c++/11/bits/stringfwd.h /usr/include/c++/11/bits/postypes.h \ + /usr/include/c++/11/cwchar /usr/include/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/lib/gcc/x86_64-linux-gnu/11/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/11/include/stdarg.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/c++/11/bits/shared_ptr_base.h /usr/include/c++/11/typeinfo \ + /usr/include/c++/11/bits/allocated_ptr.h \ + /usr/include/c++/11/bits/refwrap.h \ + /usr/include/c++/11/ext/aligned_buffer.h \ + /usr/include/c++/11/ext/atomicity.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/gthr-default.h \ + /usr/include/pthread.h /usr/include/sched.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h /usr/include/time.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/sys/single_threaded.h \ + /usr/include/c++/11/ext/concurrence.h /usr/include/c++/11/exception \ + /usr/include/c++/11/bits/exception_ptr.h \ + /usr/include/c++/11/bits/cxxabi_init_exception.h \ + /usr/include/c++/11/bits/nested_exception.h \ + /usr/include/c++/11/bits/shared_ptr_atomic.h \ + /usr/include/c++/11/bits/atomic_base.h \ + /usr/include/c++/11/bits/atomic_lockfree_defines.h \ + /usr/include/c++/11/backward/auto_ptr.h /usr/include/c++/11/vector \ + /usr/include/c++/11/bits/stl_vector.h \ + /usr/include/c++/11/bits/stl_bvector.h \ + /usr/include/c++/11/bits/vector.tcc /usr/include/c++/11/string \ + /usr/include/c++/11/bits/char_traits.h /usr/include/c++/11/cstdint \ + /usr/include/c++/11/bits/localefwd.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/c++locale.h \ + /usr/include/c++/11/clocale /usr/include/locale.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h /usr/include/c++/11/cctype \ + /usr/include/ctype.h /usr/include/c++/11/bits/ostream_insert.h \ + /usr/include/c++/11/bits/cxxabi_forced.h \ + /usr/include/c++/11/bits/basic_string.h \ + /usr/include/c++/11/ext/string_conversions.h /usr/include/c++/11/cstdlib \ + /usr/include/stdlib.h /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/sys/types.h /usr/include/endian.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/alloca.h /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /usr/include/c++/11/bits/std_abs.h /usr/include/c++/11/cstdio \ + /usr/include/stdio.h /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/c++/11/cerrno /usr/include/errno.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h /usr/include/linux/errno.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/asm-generic/errno.h /usr/include/asm-generic/errno-base.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/c++/11/bits/charconv.h \ + /usr/include/c++/11/bits/basic_string.tcc \ + /content/NeuCoSVC-2/REAPER/./epoch_tracker/fd_filter.h \ + /content/NeuCoSVC-2/REAPER/./epoch_tracker/lpc_analyzer.h \ + /content/NeuCoSVC-2/REAPER/./epoch_tracker/fft.h \ + /usr/include/c++/11/math.h /usr/include/c++/11/cmath /usr/include/math.h \ + /usr/include/x86_64-linux-gnu/bits/math-vector.h \ + /usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h \ + /usr/include/x86_64-linux-gnu/bits/flt-eval-method.h \ + /usr/include/x86_64-linux-gnu/bits/fp-logb.h \ + /usr/include/x86_64-linux-gnu/bits/fp-fast.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h \ + /usr/include/x86_64-linux-gnu/bits/iscanonical.h \ + /usr/include/c++/11/stdlib.h diff --git a/REAPER/build/CMakeFiles/epoch_tracker.dir/epoch_tracker/fd_filter.cc.o b/REAPER/build/CMakeFiles/epoch_tracker.dir/epoch_tracker/fd_filter.cc.o new file mode 100644 index 0000000000000000000000000000000000000000..808e7269151cc63bb084e68aed76eaf6e3d4463c Binary files /dev/null and b/REAPER/build/CMakeFiles/epoch_tracker.dir/epoch_tracker/fd_filter.cc.o differ diff --git a/REAPER/build/CMakeFiles/epoch_tracker.dir/epoch_tracker/fd_filter.cc.o.d b/REAPER/build/CMakeFiles/epoch_tracker.dir/epoch_tracker/fd_filter.cc.o.d new file mode 100644 index 0000000000000000000000000000000000000000..5c307128f59f21a244356e1c4432f2f9ffeaae6a --- /dev/null +++ b/REAPER/build/CMakeFiles/epoch_tracker.dir/epoch_tracker/fd_filter.cc.o.d @@ -0,0 +1,76 @@ +CMakeFiles/epoch_tracker.dir/epoch_tracker/fd_filter.cc.o: \ + /content/NeuCoSVC-2/REAPER/epoch_tracker/fd_filter.cc \ + /usr/include/stdc-predef.h \ + /content/NeuCoSVC-2/REAPER/./epoch_tracker/fd_filter.h \ + /usr/include/stdio.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/features.h /usr/include/features-time64.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/lib/gcc/x86_64-linux-gnu/11/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/11/include/stdarg.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/lib/gcc/x86_64-linux-gnu/11/include/stdint.h /usr/include/stdint.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/c++/11/math.h /usr/include/c++/11/cmath \ + /usr/include/x86_64-linux-gnu/c++/11/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/cpu_defines.h \ + /usr/include/c++/11/bits/cpp_type_traits.h \ + /usr/include/c++/11/ext/type_traits.h /usr/include/math.h \ + /usr/include/x86_64-linux-gnu/bits/math-vector.h \ + /usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h \ + /usr/include/x86_64-linux-gnu/bits/flt-eval-method.h \ + /usr/include/x86_64-linux-gnu/bits/fp-logb.h \ + /usr/include/x86_64-linux-gnu/bits/fp-fast.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h \ + /usr/include/x86_64-linux-gnu/bits/iscanonical.h \ + /usr/include/c++/11/bits/std_abs.h /usr/include/stdlib.h \ + /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/sys/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h /usr/include/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h /usr/include/alloca.h \ + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /content/NeuCoSVC-2/REAPER/./epoch_tracker/fft.h \ + /usr/include/c++/11/stdlib.h /usr/include/c++/11/cstdlib diff --git a/REAPER/build/CMakeFiles/epoch_tracker.dir/epoch_tracker/fft.cc.o b/REAPER/build/CMakeFiles/epoch_tracker.dir/epoch_tracker/fft.cc.o new file mode 100644 index 0000000000000000000000000000000000000000..2466034d95ab177e78c156fd11195150d582a525 Binary files /dev/null and b/REAPER/build/CMakeFiles/epoch_tracker.dir/epoch_tracker/fft.cc.o differ diff --git a/REAPER/build/CMakeFiles/epoch_tracker.dir/epoch_tracker/fft.cc.o.d b/REAPER/build/CMakeFiles/epoch_tracker.dir/epoch_tracker/fft.cc.o.d new file mode 100644 index 0000000000000000000000000000000000000000..65e94a46394827b83023094d8f6393f4d80d1e60 --- /dev/null +++ b/REAPER/build/CMakeFiles/epoch_tracker.dir/epoch_tracker/fft.cc.o.d @@ -0,0 +1,71 @@ +CMakeFiles/epoch_tracker.dir/epoch_tracker/fft.cc.o: \ + /content/NeuCoSVC-2/REAPER/epoch_tracker/fft.cc \ + /usr/include/stdc-predef.h \ + /content/NeuCoSVC-2/REAPER/./epoch_tracker/fft.h \ + /usr/include/c++/11/math.h /usr/include/c++/11/cmath \ + /usr/include/x86_64-linux-gnu/c++/11/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/os_defines.h \ + /usr/include/features.h /usr/include/features-time64.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/cpu_defines.h \ + /usr/include/c++/11/bits/cpp_type_traits.h \ + /usr/include/c++/11/ext/type_traits.h /usr/include/math.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/math-vector.h \ + /usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/flt-eval-method.h \ + /usr/include/x86_64-linux-gnu/bits/fp-logb.h \ + /usr/include/x86_64-linux-gnu/bits/fp-fast.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h \ + /usr/include/x86_64-linux-gnu/bits/iscanonical.h \ + /usr/include/c++/11/bits/std_abs.h /usr/include/stdlib.h \ + /usr/lib/gcc/x86_64-linux-gnu/11/include/stddef.h \ + /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/sys/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h /usr/include/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h /usr/include/alloca.h \ + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h /usr/include/stdio.h \ + /usr/lib/gcc/x86_64-linux-gnu/11/include/stdarg.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/c++/11/stdlib.h /usr/include/c++/11/cstdlib diff --git a/REAPER/build/CMakeFiles/epoch_tracker.dir/epoch_tracker/lpc_analyzer.cc.o b/REAPER/build/CMakeFiles/epoch_tracker.dir/epoch_tracker/lpc_analyzer.cc.o new file mode 100644 index 0000000000000000000000000000000000000000..012c2acdb7dea353a6343be8b0a6e8c39e4df645 Binary files /dev/null and b/REAPER/build/CMakeFiles/epoch_tracker.dir/epoch_tracker/lpc_analyzer.cc.o differ diff --git a/REAPER/build/CMakeFiles/epoch_tracker.dir/epoch_tracker/lpc_analyzer.cc.o.d b/REAPER/build/CMakeFiles/epoch_tracker.dir/epoch_tracker/lpc_analyzer.cc.o.d new file mode 100644 index 0000000000000000000000000000000000000000..f6134610d0995553bf4bd3de4017e09779a7c2b9 --- /dev/null +++ b/REAPER/build/CMakeFiles/epoch_tracker.dir/epoch_tracker/lpc_analyzer.cc.o.d @@ -0,0 +1,91 @@ +CMakeFiles/epoch_tracker.dir/epoch_tracker/lpc_analyzer.cc.o: \ + /content/NeuCoSVC-2/REAPER/epoch_tracker/lpc_analyzer.cc \ + /usr/include/stdc-predef.h \ + /content/NeuCoSVC-2/REAPER/./epoch_tracker/lpc_analyzer.h \ + /usr/include/c++/11/vector /usr/include/c++/11/bits/stl_algobase.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/os_defines.h \ + /usr/include/features.h /usr/include/features-time64.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/cpu_defines.h \ + /usr/include/c++/11/bits/functexcept.h \ + /usr/include/c++/11/bits/exception_defines.h \ + /usr/include/c++/11/bits/cpp_type_traits.h \ + /usr/include/c++/11/ext/type_traits.h \ + /usr/include/c++/11/ext/numeric_traits.h \ + /usr/include/c++/11/bits/stl_pair.h /usr/include/c++/11/bits/move.h \ + /usr/include/c++/11/type_traits \ + /usr/include/c++/11/bits/stl_iterator_base_types.h \ + /usr/include/c++/11/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/11/bits/concept_check.h \ + /usr/include/c++/11/debug/assertions.h \ + /usr/include/c++/11/bits/stl_iterator.h \ + /usr/include/c++/11/bits/ptr_traits.h /usr/include/c++/11/debug/debug.h \ + /usr/include/c++/11/bits/predefined_ops.h \ + /usr/include/c++/11/bits/allocator.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/c++allocator.h \ + /usr/include/c++/11/ext/new_allocator.h /usr/include/c++/11/new \ + /usr/include/c++/11/bits/exception.h \ + /usr/include/c++/11/bits/memoryfwd.h \ + /usr/include/c++/11/bits/stl_construct.h \ + /usr/include/c++/11/bits/stl_uninitialized.h \ + /usr/include/c++/11/ext/alloc_traits.h \ + /usr/include/c++/11/bits/alloc_traits.h \ + /usr/include/c++/11/bits/stl_vector.h \ + /usr/include/c++/11/initializer_list \ + /usr/include/c++/11/bits/stl_bvector.h \ + /usr/include/c++/11/bits/functional_hash.h \ + /usr/include/c++/11/bits/hash_bytes.h \ + /usr/include/c++/11/bits/range_access.h \ + /usr/include/c++/11/bits/vector.tcc /usr/include/c++/11/stdlib.h \ + /usr/include/c++/11/cstdlib /usr/include/stdlib.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/lib/gcc/x86_64-linux-gnu/11/include/stddef.h \ + /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/sys/types.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h /usr/include/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h /usr/include/alloca.h \ + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /usr/include/c++/11/bits/std_abs.h /usr/include/c++/11/math.h \ + /usr/include/c++/11/cmath /usr/include/math.h \ + /usr/include/x86_64-linux-gnu/bits/math-vector.h \ + /usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h \ + /usr/include/x86_64-linux-gnu/bits/flt-eval-method.h \ + /usr/include/x86_64-linux-gnu/bits/fp-logb.h \ + /usr/include/x86_64-linux-gnu/bits/fp-fast.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h \ + /usr/include/x86_64-linux-gnu/bits/iscanonical.h diff --git a/REAPER/build/CMakeFiles/epoch_tracker.dir/flags.make b/REAPER/build/CMakeFiles/epoch_tracker.dir/flags.make new file mode 100644 index 0000000000000000000000000000000000000000..de2965e1d495155c0f22b4ba2de6c2ef5b82b629 --- /dev/null +++ b/REAPER/build/CMakeFiles/epoch_tracker.dir/flags.make @@ -0,0 +1,10 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.27 + +# compile CXX with /usr/bin/c++ +CXX_DEFINES = + +CXX_INCLUDES = -I/content/NeuCoSVC-2/REAPER/. + +CXX_FLAGS = -std=c++11 + diff --git a/REAPER/build/CMakeFiles/epoch_tracker.dir/link.txt b/REAPER/build/CMakeFiles/epoch_tracker.dir/link.txt new file mode 100644 index 0000000000000000000000000000000000000000..cbcab38068de8060288c896605f3506aa7419e59 --- /dev/null +++ b/REAPER/build/CMakeFiles/epoch_tracker.dir/link.txt @@ -0,0 +1,2 @@ +/usr/bin/ar qc libepoch_tracker.a CMakeFiles/epoch_tracker.dir/epoch_tracker/fft.cc.o CMakeFiles/epoch_tracker.dir/epoch_tracker/fd_filter.cc.o CMakeFiles/epoch_tracker.dir/epoch_tracker/lpc_analyzer.cc.o CMakeFiles/epoch_tracker.dir/epoch_tracker/epoch_tracker.cc.o +/usr/bin/ranlib libepoch_tracker.a diff --git a/REAPER/build/CMakeFiles/epoch_tracker.dir/progress.make b/REAPER/build/CMakeFiles/epoch_tracker.dir/progress.make new file mode 100644 index 0000000000000000000000000000000000000000..d79b0814ce410e79343cfcb41f806c483d9d7003 --- /dev/null +++ b/REAPER/build/CMakeFiles/epoch_tracker.dir/progress.make @@ -0,0 +1,6 @@ +CMAKE_PROGRESS_1 = 5 +CMAKE_PROGRESS_2 = 6 +CMAKE_PROGRESS_3 = 7 +CMAKE_PROGRESS_4 = 8 +CMAKE_PROGRESS_5 = 9 + diff --git a/REAPER/build/CMakeFiles/progress.marks b/REAPER/build/CMakeFiles/progress.marks new file mode 100644 index 0000000000000000000000000000000000000000..60d3b2f4a4cd5f1637eba020358bfe5ecb5edcf2 --- /dev/null +++ b/REAPER/build/CMakeFiles/progress.marks @@ -0,0 +1 @@ +15 diff --git a/REAPER/build/CMakeFiles/reaper.dir/DependInfo.cmake b/REAPER/build/CMakeFiles/reaper.dir/DependInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..10d00e5ff5fa3f88fe33e2ed0dc487531fde46f0 --- /dev/null +++ b/REAPER/build/CMakeFiles/reaper.dir/DependInfo.cmake @@ -0,0 +1,19 @@ + +# Consider dependencies only in project. +set(CMAKE_DEPENDS_IN_PROJECT_ONLY OFF) + +# The set of languages for which implicit dependencies are needed: +set(CMAKE_DEPENDS_LANGUAGES + ) + +# The set of dependency files which are needed: +set(CMAKE_DEPENDS_DEPENDENCY_FILES + "/content/NeuCoSVC-2/REAPER/epoch_tracker_main.cc" "CMakeFiles/reaper.dir/epoch_tracker_main.cc.o" "gcc" "CMakeFiles/reaper.dir/epoch_tracker_main.cc.o.d" + ) + +# Targets to which this target links which contain Fortran sources. +set(CMAKE_Fortran_TARGET_LINKED_INFO_FILES + ) + +# Fortran module output directory. +set(CMAKE_Fortran_TARGET_MODULE_DIR "") diff --git a/REAPER/build/CMakeFiles/reaper.dir/build.make b/REAPER/build/CMakeFiles/reaper.dir/build.make new file mode 100644 index 0000000000000000000000000000000000000000..02a5dd2a5bd5381da238d9ea62c7f60c8afea16b --- /dev/null +++ b/REAPER/build/CMakeFiles/reaper.dir/build.make @@ -0,0 +1,113 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.27 + +# Delete rule output on recipe failure. +.DELETE_ON_ERROR: + +#============================================================================= +# Special targets provided by cmake. + +# Disable implicit rules so canonical targets will work. +.SUFFIXES: + +# Disable VCS-based implicit rules. +% : %,v + +# Disable VCS-based implicit rules. +% : RCS/% + +# Disable VCS-based implicit rules. +% : RCS/%,v + +# Disable VCS-based implicit rules. +% : SCCS/s.% + +# Disable VCS-based implicit rules. +% : s.% + +.SUFFIXES: .hpux_make_needs_suffix_list + +# Command-line flag to silence nested $(MAKE). +$(VERBOSE)MAKESILENT = -s + +#Suppress display of executed commands. +$(VERBOSE).SILENT: + +# A target that is always out of date. +cmake_force: +.PHONY : cmake_force + +#============================================================================= +# Set environment variables for the build. + +# The shell in which to execute make rules. +SHELL = /bin/sh + +# The CMake executable. +CMAKE_COMMAND = /usr/local/lib/python3.10/dist-packages/cmake/data/bin/cmake + +# The command to remove a file. +RM = /usr/local/lib/python3.10/dist-packages/cmake/data/bin/cmake -E rm -f + +# Escaping for special characters. +EQUALS = = + +# The top-level source directory on which CMake was run. +CMAKE_SOURCE_DIR = /content/NeuCoSVC-2/REAPER + +# The top-level build directory on which CMake was run. +CMAKE_BINARY_DIR = /content/NeuCoSVC-2/REAPER/build + +# Include any dependencies generated for this target. +include CMakeFiles/reaper.dir/depend.make +# Include any dependencies generated by the compiler for this target. +include CMakeFiles/reaper.dir/compiler_depend.make + +# Include the progress variables for this target. +include CMakeFiles/reaper.dir/progress.make + +# Include the compile flags for this target's objects. +include CMakeFiles/reaper.dir/flags.make + +CMakeFiles/reaper.dir/epoch_tracker_main.cc.o: CMakeFiles/reaper.dir/flags.make +CMakeFiles/reaper.dir/epoch_tracker_main.cc.o: /content/NeuCoSVC-2/REAPER/epoch_tracker_main.cc +CMakeFiles/reaper.dir/epoch_tracker_main.cc.o: CMakeFiles/reaper.dir/compiler_depend.ts + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/content/NeuCoSVC-2/REAPER/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_1) "Building CXX object CMakeFiles/reaper.dir/epoch_tracker_main.cc.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/reaper.dir/epoch_tracker_main.cc.o -MF CMakeFiles/reaper.dir/epoch_tracker_main.cc.o.d -o CMakeFiles/reaper.dir/epoch_tracker_main.cc.o -c /content/NeuCoSVC-2/REAPER/epoch_tracker_main.cc + +CMakeFiles/reaper.dir/epoch_tracker_main.cc.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/reaper.dir/epoch_tracker_main.cc.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /content/NeuCoSVC-2/REAPER/epoch_tracker_main.cc > CMakeFiles/reaper.dir/epoch_tracker_main.cc.i + +CMakeFiles/reaper.dir/epoch_tracker_main.cc.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/reaper.dir/epoch_tracker_main.cc.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /content/NeuCoSVC-2/REAPER/epoch_tracker_main.cc -o CMakeFiles/reaper.dir/epoch_tracker_main.cc.s + +# Object files for target reaper +reaper_OBJECTS = \ +"CMakeFiles/reaper.dir/epoch_tracker_main.cc.o" + +# External object files for target reaper +reaper_EXTERNAL_OBJECTS = + +reaper: CMakeFiles/reaper.dir/epoch_tracker_main.cc.o +reaper: CMakeFiles/reaper.dir/build.make +reaper: libepoch_tracker.a +reaper: libwave.a +reaper: libcore.a +reaper: CMakeFiles/reaper.dir/link.txt + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --bold --progress-dir=/content/NeuCoSVC-2/REAPER/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_2) "Linking CXX executable reaper" + $(CMAKE_COMMAND) -E cmake_link_script CMakeFiles/reaper.dir/link.txt --verbose=$(VERBOSE) + +# Rule to build all files generated by this target. +CMakeFiles/reaper.dir/build: reaper +.PHONY : CMakeFiles/reaper.dir/build + +CMakeFiles/reaper.dir/clean: + $(CMAKE_COMMAND) -P CMakeFiles/reaper.dir/cmake_clean.cmake +.PHONY : CMakeFiles/reaper.dir/clean + +CMakeFiles/reaper.dir/depend: + cd /content/NeuCoSVC-2/REAPER/build && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /content/NeuCoSVC-2/REAPER /content/NeuCoSVC-2/REAPER /content/NeuCoSVC-2/REAPER/build /content/NeuCoSVC-2/REAPER/build /content/NeuCoSVC-2/REAPER/build/CMakeFiles/reaper.dir/DependInfo.cmake "--color=$(COLOR)" +.PHONY : CMakeFiles/reaper.dir/depend + diff --git a/REAPER/build/CMakeFiles/reaper.dir/cmake_clean.cmake b/REAPER/build/CMakeFiles/reaper.dir/cmake_clean.cmake new file mode 100644 index 0000000000000000000000000000000000000000..c2e2dbca88bd11782c2af2f12a79d20b47c6610f --- /dev/null +++ b/REAPER/build/CMakeFiles/reaper.dir/cmake_clean.cmake @@ -0,0 +1,11 @@ +file(REMOVE_RECURSE + "CMakeFiles/reaper.dir/epoch_tracker_main.cc.o" + "CMakeFiles/reaper.dir/epoch_tracker_main.cc.o.d" + "reaper" + "reaper.pdb" +) + +# Per-language clean rules from dependency scanning. +foreach(lang CXX) + include(CMakeFiles/reaper.dir/cmake_clean_${lang}.cmake OPTIONAL) +endforeach() diff --git a/REAPER/build/CMakeFiles/reaper.dir/compiler_depend.make b/REAPER/build/CMakeFiles/reaper.dir/compiler_depend.make new file mode 100644 index 0000000000000000000000000000000000000000..a63742159bcbc46eca9d55aa2e4c8d46b2a89eea --- /dev/null +++ b/REAPER/build/CMakeFiles/reaper.dir/compiler_depend.make @@ -0,0 +1,2 @@ +# Empty compiler generated dependencies file for reaper. +# This may be replaced when dependencies are built. diff --git a/REAPER/build/CMakeFiles/reaper.dir/compiler_depend.ts b/REAPER/build/CMakeFiles/reaper.dir/compiler_depend.ts new file mode 100644 index 0000000000000000000000000000000000000000..45643c2a862712af5abdd3b040241fa68f9ff279 --- /dev/null +++ b/REAPER/build/CMakeFiles/reaper.dir/compiler_depend.ts @@ -0,0 +1,2 @@ +# CMAKE generated file: DO NOT EDIT! +# Timestamp file for compiler generated dependencies management for reaper. diff --git a/REAPER/build/CMakeFiles/reaper.dir/depend.make b/REAPER/build/CMakeFiles/reaper.dir/depend.make new file mode 100644 index 0000000000000000000000000000000000000000..3547a7b6ef5d64a161207bb9943d87c7f85bc3d9 --- /dev/null +++ b/REAPER/build/CMakeFiles/reaper.dir/depend.make @@ -0,0 +1,2 @@ +# Empty dependencies file for reaper. +# This may be replaced when dependencies are built. diff --git a/REAPER/build/CMakeFiles/reaper.dir/epoch_tracker_main.cc.o b/REAPER/build/CMakeFiles/reaper.dir/epoch_tracker_main.cc.o new file mode 100644 index 0000000000000000000000000000000000000000..0fc76fada4a79338425a851893bebe0a7bc2f99c Binary files /dev/null and b/REAPER/build/CMakeFiles/reaper.dir/epoch_tracker_main.cc.o differ diff --git a/REAPER/build/CMakeFiles/reaper.dir/epoch_tracker_main.cc.o.d b/REAPER/build/CMakeFiles/reaper.dir/epoch_tracker_main.cc.o.d new file mode 100644 index 0000000000000000000000000000000000000000..dba1daf5e5cd593d9a60fa20fc00123ce3d6c2d4 --- /dev/null +++ b/REAPER/build/CMakeFiles/reaper.dir/epoch_tracker_main.cc.o.d @@ -0,0 +1,164 @@ +CMakeFiles/reaper.dir/epoch_tracker_main.cc.o: \ + /content/NeuCoSVC-2/REAPER/epoch_tracker_main.cc \ + /usr/include/stdc-predef.h /usr/include/c++/11/memory \ + /usr/include/c++/11/bits/stl_algobase.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/os_defines.h \ + /usr/include/features.h /usr/include/features-time64.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/cpu_defines.h \ + /usr/include/c++/11/bits/functexcept.h \ + /usr/include/c++/11/bits/exception_defines.h \ + /usr/include/c++/11/bits/cpp_type_traits.h \ + /usr/include/c++/11/ext/type_traits.h \ + /usr/include/c++/11/ext/numeric_traits.h \ + /usr/include/c++/11/bits/stl_pair.h /usr/include/c++/11/bits/move.h \ + /usr/include/c++/11/type_traits \ + /usr/include/c++/11/bits/stl_iterator_base_types.h \ + /usr/include/c++/11/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/11/bits/concept_check.h \ + /usr/include/c++/11/debug/assertions.h \ + /usr/include/c++/11/bits/stl_iterator.h \ + /usr/include/c++/11/bits/ptr_traits.h /usr/include/c++/11/debug/debug.h \ + /usr/include/c++/11/bits/predefined_ops.h \ + /usr/include/c++/11/bits/allocator.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/c++allocator.h \ + /usr/include/c++/11/ext/new_allocator.h /usr/include/c++/11/new \ + /usr/include/c++/11/bits/exception.h \ + /usr/include/c++/11/bits/memoryfwd.h \ + /usr/include/c++/11/bits/stl_construct.h \ + /usr/include/c++/11/bits/stl_uninitialized.h \ + /usr/include/c++/11/ext/alloc_traits.h \ + /usr/include/c++/11/bits/alloc_traits.h \ + /usr/include/c++/11/bits/stl_tempbuf.h \ + /usr/include/c++/11/bits/stl_raw_storage_iter.h \ + /usr/include/c++/11/bits/align.h /usr/include/c++/11/bit \ + /usr/lib/gcc/x86_64-linux-gnu/11/include/stdint.h /usr/include/stdint.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/c++/11/bits/uses_allocator.h \ + /usr/include/c++/11/bits/unique_ptr.h /usr/include/c++/11/utility \ + /usr/include/c++/11/bits/stl_relops.h \ + /usr/include/c++/11/initializer_list /usr/include/c++/11/tuple \ + /usr/include/c++/11/array /usr/include/c++/11/bits/range_access.h \ + /usr/include/c++/11/bits/invoke.h \ + /usr/include/c++/11/bits/stl_function.h \ + /usr/include/c++/11/backward/binders.h \ + /usr/include/c++/11/bits/functional_hash.h \ + /usr/include/c++/11/bits/hash_bytes.h \ + /usr/include/c++/11/bits/shared_ptr.h /usr/include/c++/11/iosfwd \ + /usr/include/c++/11/bits/stringfwd.h /usr/include/c++/11/bits/postypes.h \ + /usr/include/c++/11/cwchar /usr/include/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/lib/gcc/x86_64-linux-gnu/11/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/11/include/stdarg.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/c++/11/bits/shared_ptr_base.h /usr/include/c++/11/typeinfo \ + /usr/include/c++/11/bits/allocated_ptr.h \ + /usr/include/c++/11/bits/refwrap.h \ + /usr/include/c++/11/ext/aligned_buffer.h \ + /usr/include/c++/11/ext/atomicity.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/gthr-default.h \ + /usr/include/pthread.h /usr/include/sched.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h /usr/include/time.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/sys/single_threaded.h \ + /usr/include/c++/11/ext/concurrence.h /usr/include/c++/11/exception \ + /usr/include/c++/11/bits/exception_ptr.h \ + /usr/include/c++/11/bits/cxxabi_init_exception.h \ + /usr/include/c++/11/bits/nested_exception.h \ + /usr/include/c++/11/bits/shared_ptr_atomic.h \ + /usr/include/c++/11/bits/atomic_base.h \ + /usr/include/c++/11/bits/atomic_lockfree_defines.h \ + /usr/include/c++/11/backward/auto_ptr.h /usr/include/unistd.h \ + /usr/include/x86_64-linux-gnu/bits/posix_opt.h \ + /usr/include/x86_64-linux-gnu/bits/environments.h \ + /usr/include/x86_64-linux-gnu/bits/confname.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_core.h \ + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h \ + /usr/include/linux/close_range.h /usr/include/stdio.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/c++/11/stdlib.h /usr/include/c++/11/cstdlib \ + /usr/include/stdlib.h /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/sys/types.h /usr/include/endian.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/alloca.h /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /usr/include/c++/11/bits/std_abs.h /usr/include/c++/11/string \ + /usr/include/c++/11/bits/char_traits.h /usr/include/c++/11/cstdint \ + /usr/include/c++/11/bits/localefwd.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/c++locale.h \ + /usr/include/c++/11/clocale /usr/include/locale.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h /usr/include/c++/11/cctype \ + /usr/include/ctype.h /usr/include/c++/11/bits/ostream_insert.h \ + /usr/include/c++/11/bits/cxxabi_forced.h \ + /usr/include/c++/11/bits/basic_string.h \ + /usr/include/c++/11/ext/string_conversions.h /usr/include/c++/11/cstdio \ + /usr/include/c++/11/cerrno /usr/include/errno.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h /usr/include/linux/errno.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/asm-generic/errno.h /usr/include/asm-generic/errno-base.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/c++/11/bits/charconv.h \ + /usr/include/c++/11/bits/basic_string.tcc \ + /content/NeuCoSVC-2/REAPER/core/file_resource.h \ + /content/NeuCoSVC-2/REAPER/core/track.h /usr/include/c++/11/vector \ + /usr/include/c++/11/bits/stl_vector.h \ + /usr/include/c++/11/bits/stl_bvector.h \ + /usr/include/c++/11/bits/vector.tcc \ + /content/NeuCoSVC-2/REAPER/./core/file_resource.h \ + /content/NeuCoSVC-2/REAPER/./core/float_matrix.h \ + /content/NeuCoSVC-2/REAPER/./core/float_matrix-inl.h \ + /content/NeuCoSVC-2/REAPER/epoch_tracker/epoch_tracker.h \ + /content/NeuCoSVC-2/REAPER/wave/wave.h diff --git a/REAPER/build/CMakeFiles/reaper.dir/flags.make b/REAPER/build/CMakeFiles/reaper.dir/flags.make new file mode 100644 index 0000000000000000000000000000000000000000..de2965e1d495155c0f22b4ba2de6c2ef5b82b629 --- /dev/null +++ b/REAPER/build/CMakeFiles/reaper.dir/flags.make @@ -0,0 +1,10 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.27 + +# compile CXX with /usr/bin/c++ +CXX_DEFINES = + +CXX_INCLUDES = -I/content/NeuCoSVC-2/REAPER/. + +CXX_FLAGS = -std=c++11 + diff --git a/REAPER/build/CMakeFiles/reaper.dir/link.txt b/REAPER/build/CMakeFiles/reaper.dir/link.txt new file mode 100644 index 0000000000000000000000000000000000000000..eb592595934e33db2577460ef633c13f14c03e90 --- /dev/null +++ b/REAPER/build/CMakeFiles/reaper.dir/link.txt @@ -0,0 +1 @@ +/usr/bin/c++ -std=c++11 -rdynamic CMakeFiles/reaper.dir/epoch_tracker_main.cc.o -o reaper libepoch_tracker.a libwave.a libcore.a diff --git a/REAPER/build/CMakeFiles/reaper.dir/progress.make b/REAPER/build/CMakeFiles/reaper.dir/progress.make new file mode 100644 index 0000000000000000000000000000000000000000..17875e3238da3ecdefe39c6875b6b441dc576689 --- /dev/null +++ b/REAPER/build/CMakeFiles/reaper.dir/progress.make @@ -0,0 +1,3 @@ +CMAKE_PROGRESS_1 = 10 +CMAKE_PROGRESS_2 = 11 + diff --git a/REAPER/build/CMakeFiles/wave.dir/DependInfo.cmake b/REAPER/build/CMakeFiles/wave.dir/DependInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..620d21c0b62dc88d57bb43680c24e2f644b92d7d --- /dev/null +++ b/REAPER/build/CMakeFiles/wave.dir/DependInfo.cmake @@ -0,0 +1,21 @@ + +# Consider dependencies only in project. +set(CMAKE_DEPENDS_IN_PROJECT_ONLY OFF) + +# The set of languages for which implicit dependencies are needed: +set(CMAKE_DEPENDS_LANGUAGES + ) + +# The set of dependency files which are needed: +set(CMAKE_DEPENDS_DEPENDENCY_FILES + "/content/NeuCoSVC-2/REAPER/wave/codec_riff.cc" "CMakeFiles/wave.dir/wave/codec_riff.cc.o" "gcc" "CMakeFiles/wave.dir/wave/codec_riff.cc.o.d" + "/content/NeuCoSVC-2/REAPER/wave/wave.cc" "CMakeFiles/wave.dir/wave/wave.cc.o" "gcc" "CMakeFiles/wave.dir/wave/wave.cc.o.d" + "/content/NeuCoSVC-2/REAPER/wave/wave_io.cc" "CMakeFiles/wave.dir/wave/wave_io.cc.o" "gcc" "CMakeFiles/wave.dir/wave/wave_io.cc.o.d" + ) + +# Targets to which this target links which contain Fortran sources. +set(CMAKE_Fortran_TARGET_LINKED_INFO_FILES + ) + +# Fortran module output directory. +set(CMAKE_Fortran_TARGET_MODULE_DIR "") diff --git a/REAPER/build/CMakeFiles/wave.dir/build.make b/REAPER/build/CMakeFiles/wave.dir/build.make new file mode 100644 index 0000000000000000000000000000000000000000..6673497bdefa09bc1033f0024b48c2719a345955 --- /dev/null +++ b/REAPER/build/CMakeFiles/wave.dir/build.make @@ -0,0 +1,143 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.27 + +# Delete rule output on recipe failure. +.DELETE_ON_ERROR: + +#============================================================================= +# Special targets provided by cmake. + +# Disable implicit rules so canonical targets will work. +.SUFFIXES: + +# Disable VCS-based implicit rules. +% : %,v + +# Disable VCS-based implicit rules. +% : RCS/% + +# Disable VCS-based implicit rules. +% : RCS/%,v + +# Disable VCS-based implicit rules. +% : SCCS/s.% + +# Disable VCS-based implicit rules. +% : s.% + +.SUFFIXES: .hpux_make_needs_suffix_list + +# Command-line flag to silence nested $(MAKE). +$(VERBOSE)MAKESILENT = -s + +#Suppress display of executed commands. +$(VERBOSE).SILENT: + +# A target that is always out of date. +cmake_force: +.PHONY : cmake_force + +#============================================================================= +# Set environment variables for the build. + +# The shell in which to execute make rules. +SHELL = /bin/sh + +# The CMake executable. +CMAKE_COMMAND = /usr/local/lib/python3.10/dist-packages/cmake/data/bin/cmake + +# The command to remove a file. +RM = /usr/local/lib/python3.10/dist-packages/cmake/data/bin/cmake -E rm -f + +# Escaping for special characters. +EQUALS = = + +# The top-level source directory on which CMake was run. +CMAKE_SOURCE_DIR = /content/NeuCoSVC-2/REAPER + +# The top-level build directory on which CMake was run. +CMAKE_BINARY_DIR = /content/NeuCoSVC-2/REAPER/build + +# Include any dependencies generated for this target. +include CMakeFiles/wave.dir/depend.make +# Include any dependencies generated by the compiler for this target. +include CMakeFiles/wave.dir/compiler_depend.make + +# Include the progress variables for this target. +include CMakeFiles/wave.dir/progress.make + +# Include the compile flags for this target's objects. +include CMakeFiles/wave.dir/flags.make + +CMakeFiles/wave.dir/wave/codec_riff.cc.o: CMakeFiles/wave.dir/flags.make +CMakeFiles/wave.dir/wave/codec_riff.cc.o: /content/NeuCoSVC-2/REAPER/wave/codec_riff.cc +CMakeFiles/wave.dir/wave/codec_riff.cc.o: CMakeFiles/wave.dir/compiler_depend.ts + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/content/NeuCoSVC-2/REAPER/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_1) "Building CXX object CMakeFiles/wave.dir/wave/codec_riff.cc.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/wave.dir/wave/codec_riff.cc.o -MF CMakeFiles/wave.dir/wave/codec_riff.cc.o.d -o CMakeFiles/wave.dir/wave/codec_riff.cc.o -c /content/NeuCoSVC-2/REAPER/wave/codec_riff.cc + +CMakeFiles/wave.dir/wave/codec_riff.cc.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/wave.dir/wave/codec_riff.cc.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /content/NeuCoSVC-2/REAPER/wave/codec_riff.cc > CMakeFiles/wave.dir/wave/codec_riff.cc.i + +CMakeFiles/wave.dir/wave/codec_riff.cc.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/wave.dir/wave/codec_riff.cc.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /content/NeuCoSVC-2/REAPER/wave/codec_riff.cc -o CMakeFiles/wave.dir/wave/codec_riff.cc.s + +CMakeFiles/wave.dir/wave/wave.cc.o: CMakeFiles/wave.dir/flags.make +CMakeFiles/wave.dir/wave/wave.cc.o: /content/NeuCoSVC-2/REAPER/wave/wave.cc +CMakeFiles/wave.dir/wave/wave.cc.o: CMakeFiles/wave.dir/compiler_depend.ts + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/content/NeuCoSVC-2/REAPER/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_2) "Building CXX object CMakeFiles/wave.dir/wave/wave.cc.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/wave.dir/wave/wave.cc.o -MF CMakeFiles/wave.dir/wave/wave.cc.o.d -o CMakeFiles/wave.dir/wave/wave.cc.o -c /content/NeuCoSVC-2/REAPER/wave/wave.cc + +CMakeFiles/wave.dir/wave/wave.cc.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/wave.dir/wave/wave.cc.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /content/NeuCoSVC-2/REAPER/wave/wave.cc > CMakeFiles/wave.dir/wave/wave.cc.i + +CMakeFiles/wave.dir/wave/wave.cc.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/wave.dir/wave/wave.cc.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /content/NeuCoSVC-2/REAPER/wave/wave.cc -o CMakeFiles/wave.dir/wave/wave.cc.s + +CMakeFiles/wave.dir/wave/wave_io.cc.o: CMakeFiles/wave.dir/flags.make +CMakeFiles/wave.dir/wave/wave_io.cc.o: /content/NeuCoSVC-2/REAPER/wave/wave_io.cc +CMakeFiles/wave.dir/wave/wave_io.cc.o: CMakeFiles/wave.dir/compiler_depend.ts + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/content/NeuCoSVC-2/REAPER/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_3) "Building CXX object CMakeFiles/wave.dir/wave/wave_io.cc.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/wave.dir/wave/wave_io.cc.o -MF CMakeFiles/wave.dir/wave/wave_io.cc.o.d -o CMakeFiles/wave.dir/wave/wave_io.cc.o -c /content/NeuCoSVC-2/REAPER/wave/wave_io.cc + +CMakeFiles/wave.dir/wave/wave_io.cc.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/wave.dir/wave/wave_io.cc.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /content/NeuCoSVC-2/REAPER/wave/wave_io.cc > CMakeFiles/wave.dir/wave/wave_io.cc.i + +CMakeFiles/wave.dir/wave/wave_io.cc.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/wave.dir/wave/wave_io.cc.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /content/NeuCoSVC-2/REAPER/wave/wave_io.cc -o CMakeFiles/wave.dir/wave/wave_io.cc.s + +# Object files for target wave +wave_OBJECTS = \ +"CMakeFiles/wave.dir/wave/codec_riff.cc.o" \ +"CMakeFiles/wave.dir/wave/wave.cc.o" \ +"CMakeFiles/wave.dir/wave/wave_io.cc.o" + +# External object files for target wave +wave_EXTERNAL_OBJECTS = + +libwave.a: CMakeFiles/wave.dir/wave/codec_riff.cc.o +libwave.a: CMakeFiles/wave.dir/wave/wave.cc.o +libwave.a: CMakeFiles/wave.dir/wave/wave_io.cc.o +libwave.a: CMakeFiles/wave.dir/build.make +libwave.a: CMakeFiles/wave.dir/link.txt + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --bold --progress-dir=/content/NeuCoSVC-2/REAPER/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_4) "Linking CXX static library libwave.a" + $(CMAKE_COMMAND) -P CMakeFiles/wave.dir/cmake_clean_target.cmake + $(CMAKE_COMMAND) -E cmake_link_script CMakeFiles/wave.dir/link.txt --verbose=$(VERBOSE) + +# Rule to build all files generated by this target. +CMakeFiles/wave.dir/build: libwave.a +.PHONY : CMakeFiles/wave.dir/build + +CMakeFiles/wave.dir/clean: + $(CMAKE_COMMAND) -P CMakeFiles/wave.dir/cmake_clean.cmake +.PHONY : CMakeFiles/wave.dir/clean + +CMakeFiles/wave.dir/depend: + cd /content/NeuCoSVC-2/REAPER/build && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /content/NeuCoSVC-2/REAPER /content/NeuCoSVC-2/REAPER /content/NeuCoSVC-2/REAPER/build /content/NeuCoSVC-2/REAPER/build /content/NeuCoSVC-2/REAPER/build/CMakeFiles/wave.dir/DependInfo.cmake "--color=$(COLOR)" +.PHONY : CMakeFiles/wave.dir/depend + diff --git a/REAPER/build/CMakeFiles/wave.dir/cmake_clean.cmake b/REAPER/build/CMakeFiles/wave.dir/cmake_clean.cmake new file mode 100644 index 0000000000000000000000000000000000000000..60e16089d7c52c347fb1c4b0e15584bf171d7bb4 --- /dev/null +++ b/REAPER/build/CMakeFiles/wave.dir/cmake_clean.cmake @@ -0,0 +1,15 @@ +file(REMOVE_RECURSE + "CMakeFiles/wave.dir/wave/codec_riff.cc.o" + "CMakeFiles/wave.dir/wave/codec_riff.cc.o.d" + "CMakeFiles/wave.dir/wave/wave.cc.o" + "CMakeFiles/wave.dir/wave/wave.cc.o.d" + "CMakeFiles/wave.dir/wave/wave_io.cc.o" + "CMakeFiles/wave.dir/wave/wave_io.cc.o.d" + "libwave.a" + "libwave.pdb" +) + +# Per-language clean rules from dependency scanning. +foreach(lang CXX) + include(CMakeFiles/wave.dir/cmake_clean_${lang}.cmake OPTIONAL) +endforeach() diff --git a/REAPER/build/CMakeFiles/wave.dir/cmake_clean_target.cmake b/REAPER/build/CMakeFiles/wave.dir/cmake_clean_target.cmake new file mode 100644 index 0000000000000000000000000000000000000000..04321a91a15e2273b6f7d39be3155e0c412745e5 --- /dev/null +++ b/REAPER/build/CMakeFiles/wave.dir/cmake_clean_target.cmake @@ -0,0 +1,3 @@ +file(REMOVE_RECURSE + "libwave.a" +) diff --git a/REAPER/build/CMakeFiles/wave.dir/compiler_depend.make b/REAPER/build/CMakeFiles/wave.dir/compiler_depend.make new file mode 100644 index 0000000000000000000000000000000000000000..8ea0b5e1428762de877dbdb0e6e94e5005f5d22d --- /dev/null +++ b/REAPER/build/CMakeFiles/wave.dir/compiler_depend.make @@ -0,0 +1,2 @@ +# Empty compiler generated dependencies file for wave. +# This may be replaced when dependencies are built. diff --git a/REAPER/build/CMakeFiles/wave.dir/compiler_depend.ts b/REAPER/build/CMakeFiles/wave.dir/compiler_depend.ts new file mode 100644 index 0000000000000000000000000000000000000000..13fd1d8d3651c8c17ad51a112917ec8d3ec07582 --- /dev/null +++ b/REAPER/build/CMakeFiles/wave.dir/compiler_depend.ts @@ -0,0 +1,2 @@ +# CMAKE generated file: DO NOT EDIT! +# Timestamp file for compiler generated dependencies management for wave. diff --git a/REAPER/build/CMakeFiles/wave.dir/depend.make b/REAPER/build/CMakeFiles/wave.dir/depend.make new file mode 100644 index 0000000000000000000000000000000000000000..aca36073baed5f80498f90a023ceb2ca6d5e2ea7 --- /dev/null +++ b/REAPER/build/CMakeFiles/wave.dir/depend.make @@ -0,0 +1,2 @@ +# Empty dependencies file for wave. +# This may be replaced when dependencies are built. diff --git a/REAPER/build/CMakeFiles/wave.dir/flags.make b/REAPER/build/CMakeFiles/wave.dir/flags.make new file mode 100644 index 0000000000000000000000000000000000000000..de2965e1d495155c0f22b4ba2de6c2ef5b82b629 --- /dev/null +++ b/REAPER/build/CMakeFiles/wave.dir/flags.make @@ -0,0 +1,10 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.27 + +# compile CXX with /usr/bin/c++ +CXX_DEFINES = + +CXX_INCLUDES = -I/content/NeuCoSVC-2/REAPER/. + +CXX_FLAGS = -std=c++11 + diff --git a/REAPER/build/CMakeFiles/wave.dir/link.txt b/REAPER/build/CMakeFiles/wave.dir/link.txt new file mode 100644 index 0000000000000000000000000000000000000000..acdbe2c9717302cfe17b3c88ddf7617a56b2d3f3 --- /dev/null +++ b/REAPER/build/CMakeFiles/wave.dir/link.txt @@ -0,0 +1,2 @@ +/usr/bin/ar qc libwave.a CMakeFiles/wave.dir/wave/codec_riff.cc.o CMakeFiles/wave.dir/wave/wave.cc.o CMakeFiles/wave.dir/wave/wave_io.cc.o +/usr/bin/ranlib libwave.a diff --git a/REAPER/build/CMakeFiles/wave.dir/progress.make b/REAPER/build/CMakeFiles/wave.dir/progress.make new file mode 100644 index 0000000000000000000000000000000000000000..3938ebe59acc5fbdda79ddd3fd2933d0f80bb4b2 --- /dev/null +++ b/REAPER/build/CMakeFiles/wave.dir/progress.make @@ -0,0 +1,5 @@ +CMAKE_PROGRESS_1 = 12 +CMAKE_PROGRESS_2 = 13 +CMAKE_PROGRESS_3 = 14 +CMAKE_PROGRESS_4 = 15 + diff --git a/REAPER/build/CMakeFiles/wave.dir/wave/codec_riff.cc.o b/REAPER/build/CMakeFiles/wave.dir/wave/codec_riff.cc.o new file mode 100644 index 0000000000000000000000000000000000000000..6ed600842252de730d0c428646213d8586a72b74 Binary files /dev/null and b/REAPER/build/CMakeFiles/wave.dir/wave/codec_riff.cc.o differ diff --git a/REAPER/build/CMakeFiles/wave.dir/wave/codec_riff.cc.o.d b/REAPER/build/CMakeFiles/wave.dir/wave/codec_riff.cc.o.d new file mode 100644 index 0000000000000000000000000000000000000000..309b797f3841c08e50a09f9847cbb085d6a98f3e --- /dev/null +++ b/REAPER/build/CMakeFiles/wave.dir/wave/codec_riff.cc.o.d @@ -0,0 +1,132 @@ +CMakeFiles/wave.dir/wave/codec_riff.cc.o: \ + /content/NeuCoSVC-2/REAPER/wave/codec_riff.cc /usr/include/stdc-predef.h \ + /content/NeuCoSVC-2/REAPER/./wave/codec_riff.h \ + /usr/lib/gcc/x86_64-linux-gnu/11/include/stdint.h /usr/include/stdint.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/features.h /usr/include/features-time64.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/c++/11/string \ + /usr/include/x86_64-linux-gnu/c++/11/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/cpu_defines.h \ + /usr/include/c++/11/bits/stringfwd.h \ + /usr/include/c++/11/bits/memoryfwd.h \ + /usr/include/c++/11/bits/char_traits.h \ + /usr/include/c++/11/bits/stl_algobase.h \ + /usr/include/c++/11/bits/functexcept.h \ + /usr/include/c++/11/bits/exception_defines.h \ + /usr/include/c++/11/bits/cpp_type_traits.h \ + /usr/include/c++/11/ext/type_traits.h \ + /usr/include/c++/11/ext/numeric_traits.h \ + /usr/include/c++/11/bits/stl_pair.h /usr/include/c++/11/bits/move.h \ + /usr/include/c++/11/type_traits \ + /usr/include/c++/11/bits/stl_iterator_base_types.h \ + /usr/include/c++/11/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/11/bits/concept_check.h \ + /usr/include/c++/11/debug/assertions.h \ + /usr/include/c++/11/bits/stl_iterator.h \ + /usr/include/c++/11/bits/ptr_traits.h /usr/include/c++/11/debug/debug.h \ + /usr/include/c++/11/bits/predefined_ops.h \ + /usr/include/c++/11/bits/postypes.h /usr/include/c++/11/cwchar \ + /usr/include/wchar.h /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/lib/gcc/x86_64-linux-gnu/11/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/11/include/stdarg.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/c++/11/cstdint /usr/include/c++/11/bits/allocator.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/c++allocator.h \ + /usr/include/c++/11/ext/new_allocator.h /usr/include/c++/11/new \ + /usr/include/c++/11/bits/exception.h \ + /usr/include/c++/11/bits/localefwd.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/c++locale.h \ + /usr/include/c++/11/clocale /usr/include/locale.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h /usr/include/c++/11/iosfwd \ + /usr/include/c++/11/cctype /usr/include/ctype.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/c++/11/bits/ostream_insert.h \ + /usr/include/c++/11/bits/cxxabi_forced.h \ + /usr/include/c++/11/bits/stl_function.h \ + /usr/include/c++/11/backward/binders.h \ + /usr/include/c++/11/bits/range_access.h \ + /usr/include/c++/11/initializer_list \ + /usr/include/c++/11/bits/basic_string.h \ + /usr/include/c++/11/ext/atomicity.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/gthr-default.h \ + /usr/include/pthread.h /usr/include/sched.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h /usr/include/time.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/sys/single_threaded.h \ + /usr/include/c++/11/ext/alloc_traits.h \ + /usr/include/c++/11/bits/alloc_traits.h \ + /usr/include/c++/11/bits/stl_construct.h \ + /usr/include/c++/11/ext/string_conversions.h /usr/include/c++/11/cstdlib \ + /usr/include/stdlib.h /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/sys/types.h /usr/include/endian.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/alloca.h /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /usr/include/c++/11/bits/std_abs.h /usr/include/c++/11/cstdio \ + /usr/include/stdio.h /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/c++/11/cerrno /usr/include/errno.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h /usr/include/linux/errno.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/asm-generic/errno.h /usr/include/asm-generic/errno-base.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/c++/11/bits/charconv.h \ + /usr/include/c++/11/bits/functional_hash.h \ + /usr/include/c++/11/bits/hash_bytes.h \ + /usr/include/c++/11/bits/basic_string.tcc /usr/include/c++/11/vector \ + /usr/include/c++/11/bits/stl_uninitialized.h \ + /usr/include/c++/11/bits/stl_vector.h \ + /usr/include/c++/11/bits/stl_bvector.h \ + /usr/include/c++/11/bits/vector.tcc /usr/include/c++/11/limits \ + /content/NeuCoSVC-2/REAPER/./core/file_resource.h diff --git a/REAPER/build/CMakeFiles/wave.dir/wave/wave.cc.o b/REAPER/build/CMakeFiles/wave.dir/wave/wave.cc.o new file mode 100644 index 0000000000000000000000000000000000000000..faaa04828e26763237a27bb939bb564af4514a44 Binary files /dev/null and b/REAPER/build/CMakeFiles/wave.dir/wave/wave.cc.o differ diff --git a/REAPER/build/CMakeFiles/wave.dir/wave/wave.cc.o.d b/REAPER/build/CMakeFiles/wave.dir/wave/wave.cc.o.d new file mode 100644 index 0000000000000000000000000000000000000000..18ea8eb155b6135f239dc808cf9604e8af6dda1b --- /dev/null +++ b/REAPER/build/CMakeFiles/wave.dir/wave/wave.cc.o.d @@ -0,0 +1,138 @@ +CMakeFiles/wave.dir/wave/wave.cc.o: \ + /content/NeuCoSVC-2/REAPER/wave/wave.cc /usr/include/stdc-predef.h \ + /content/NeuCoSVC-2/REAPER/./wave/wave.h \ + /content/NeuCoSVC-2/REAPER/./core/file_resource.h /usr/include/stdio.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/features.h /usr/include/features-time64.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/lib/gcc/x86_64-linux-gnu/11/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/11/include/stdarg.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/c++/11/string \ + /usr/include/x86_64-linux-gnu/c++/11/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/cpu_defines.h \ + /usr/include/c++/11/bits/stringfwd.h \ + /usr/include/c++/11/bits/memoryfwd.h \ + /usr/include/c++/11/bits/char_traits.h \ + /usr/include/c++/11/bits/stl_algobase.h \ + /usr/include/c++/11/bits/functexcept.h \ + /usr/include/c++/11/bits/exception_defines.h \ + /usr/include/c++/11/bits/cpp_type_traits.h \ + /usr/include/c++/11/ext/type_traits.h \ + /usr/include/c++/11/ext/numeric_traits.h \ + /usr/include/c++/11/bits/stl_pair.h /usr/include/c++/11/bits/move.h \ + /usr/include/c++/11/type_traits \ + /usr/include/c++/11/bits/stl_iterator_base_types.h \ + /usr/include/c++/11/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/11/bits/concept_check.h \ + /usr/include/c++/11/debug/assertions.h \ + /usr/include/c++/11/bits/stl_iterator.h \ + /usr/include/c++/11/bits/ptr_traits.h /usr/include/c++/11/debug/debug.h \ + /usr/include/c++/11/bits/predefined_ops.h \ + /usr/include/c++/11/bits/postypes.h /usr/include/c++/11/cwchar \ + /usr/include/wchar.h /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/c++/11/cstdint \ + /usr/lib/gcc/x86_64-linux-gnu/11/include/stdint.h /usr/include/stdint.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/c++/11/bits/allocator.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/c++allocator.h \ + /usr/include/c++/11/ext/new_allocator.h /usr/include/c++/11/new \ + /usr/include/c++/11/bits/exception.h \ + /usr/include/c++/11/bits/localefwd.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/c++locale.h \ + /usr/include/c++/11/clocale /usr/include/locale.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h /usr/include/c++/11/iosfwd \ + /usr/include/c++/11/cctype /usr/include/ctype.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/c++/11/bits/ostream_insert.h \ + /usr/include/c++/11/bits/cxxabi_forced.h \ + /usr/include/c++/11/bits/stl_function.h \ + /usr/include/c++/11/backward/binders.h \ + /usr/include/c++/11/bits/range_access.h \ + /usr/include/c++/11/initializer_list \ + /usr/include/c++/11/bits/basic_string.h \ + /usr/include/c++/11/ext/atomicity.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/gthr-default.h \ + /usr/include/pthread.h /usr/include/sched.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h /usr/include/time.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/sys/single_threaded.h \ + /usr/include/c++/11/ext/alloc_traits.h \ + /usr/include/c++/11/bits/alloc_traits.h \ + /usr/include/c++/11/bits/stl_construct.h \ + /usr/include/c++/11/ext/string_conversions.h /usr/include/c++/11/cstdlib \ + /usr/include/stdlib.h /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/sys/types.h /usr/include/endian.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/alloca.h /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /usr/include/c++/11/bits/std_abs.h /usr/include/c++/11/cstdio \ + /usr/include/c++/11/cerrno /usr/include/errno.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h /usr/include/linux/errno.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/asm-generic/errno.h /usr/include/asm-generic/errno-base.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/c++/11/bits/charconv.h \ + /usr/include/c++/11/bits/functional_hash.h \ + /usr/include/c++/11/bits/hash_bytes.h \ + /usr/include/c++/11/bits/basic_string.tcc /usr/include/c++/11/vector \ + /usr/include/c++/11/bits/stl_uninitialized.h \ + /usr/include/c++/11/bits/stl_vector.h \ + /usr/include/c++/11/bits/stl_bvector.h \ + /usr/include/c++/11/bits/vector.tcc /usr/include/c++/11/limits \ + /usr/include/c++/11/stdlib.h /content/NeuCoSVC-2/REAPER/./wave/wave_io.h \ + /content/NeuCoSVC-2/REAPER/./wave/codec_api.h \ + /content/NeuCoSVC-2/REAPER/./wave/codec_riff.h \ + /content/NeuCoSVC-2/REAPER/./wave/codec_api-inl.h \ + /content/NeuCoSVC-2/REAPER/./wave/wave_io-inl.h diff --git a/REAPER/build/CMakeFiles/wave.dir/wave/wave_io.cc.o b/REAPER/build/CMakeFiles/wave.dir/wave/wave_io.cc.o new file mode 100644 index 0000000000000000000000000000000000000000..9fbf7f79ad8bd54fede8b7cb24a96a102aa33e5e Binary files /dev/null and b/REAPER/build/CMakeFiles/wave.dir/wave/wave_io.cc.o differ diff --git a/REAPER/build/CMakeFiles/wave.dir/wave/wave_io.cc.o.d b/REAPER/build/CMakeFiles/wave.dir/wave/wave_io.cc.o.d new file mode 100644 index 0000000000000000000000000000000000000000..e3d4a5b26e61551a2b5021904ff34c69113e4bad --- /dev/null +++ b/REAPER/build/CMakeFiles/wave.dir/wave/wave_io.cc.o.d @@ -0,0 +1,137 @@ +CMakeFiles/wave.dir/wave/wave_io.cc.o: \ + /content/NeuCoSVC-2/REAPER/wave/wave_io.cc /usr/include/stdc-predef.h \ + /content/NeuCoSVC-2/REAPER/./wave/wave_io.h \ + /content/NeuCoSVC-2/REAPER/./wave/codec_api.h \ + /usr/lib/gcc/x86_64-linux-gnu/11/include/stdint.h /usr/include/stdint.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/features.h /usr/include/features-time64.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/c++/11/string \ + /usr/include/x86_64-linux-gnu/c++/11/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/cpu_defines.h \ + /usr/include/c++/11/bits/stringfwd.h \ + /usr/include/c++/11/bits/memoryfwd.h \ + /usr/include/c++/11/bits/char_traits.h \ + /usr/include/c++/11/bits/stl_algobase.h \ + /usr/include/c++/11/bits/functexcept.h \ + /usr/include/c++/11/bits/exception_defines.h \ + /usr/include/c++/11/bits/cpp_type_traits.h \ + /usr/include/c++/11/ext/type_traits.h \ + /usr/include/c++/11/ext/numeric_traits.h \ + /usr/include/c++/11/bits/stl_pair.h /usr/include/c++/11/bits/move.h \ + /usr/include/c++/11/type_traits \ + /usr/include/c++/11/bits/stl_iterator_base_types.h \ + /usr/include/c++/11/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/11/bits/concept_check.h \ + /usr/include/c++/11/debug/assertions.h \ + /usr/include/c++/11/bits/stl_iterator.h \ + /usr/include/c++/11/bits/ptr_traits.h /usr/include/c++/11/debug/debug.h \ + /usr/include/c++/11/bits/predefined_ops.h \ + /usr/include/c++/11/bits/postypes.h /usr/include/c++/11/cwchar \ + /usr/include/wchar.h /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/lib/gcc/x86_64-linux-gnu/11/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/11/include/stdarg.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/c++/11/cstdint /usr/include/c++/11/bits/allocator.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/c++allocator.h \ + /usr/include/c++/11/ext/new_allocator.h /usr/include/c++/11/new \ + /usr/include/c++/11/bits/exception.h \ + /usr/include/c++/11/bits/localefwd.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/c++locale.h \ + /usr/include/c++/11/clocale /usr/include/locale.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h /usr/include/c++/11/iosfwd \ + /usr/include/c++/11/cctype /usr/include/ctype.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/c++/11/bits/ostream_insert.h \ + /usr/include/c++/11/bits/cxxabi_forced.h \ + /usr/include/c++/11/bits/stl_function.h \ + /usr/include/c++/11/backward/binders.h \ + /usr/include/c++/11/bits/range_access.h \ + /usr/include/c++/11/initializer_list \ + /usr/include/c++/11/bits/basic_string.h \ + /usr/include/c++/11/ext/atomicity.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/gthr-default.h \ + /usr/include/pthread.h /usr/include/sched.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h /usr/include/time.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/x86_64-linux-gnu/c++/11/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/sys/single_threaded.h \ + /usr/include/c++/11/ext/alloc_traits.h \ + /usr/include/c++/11/bits/alloc_traits.h \ + /usr/include/c++/11/bits/stl_construct.h \ + /usr/include/c++/11/ext/string_conversions.h /usr/include/c++/11/cstdlib \ + /usr/include/stdlib.h /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/sys/types.h /usr/include/endian.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/alloca.h /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /usr/include/c++/11/bits/std_abs.h /usr/include/c++/11/cstdio \ + /usr/include/stdio.h /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/c++/11/cerrno /usr/include/errno.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h /usr/include/linux/errno.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/asm-generic/errno.h /usr/include/asm-generic/errno-base.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/c++/11/bits/charconv.h \ + /usr/include/c++/11/bits/functional_hash.h \ + /usr/include/c++/11/bits/hash_bytes.h \ + /usr/include/c++/11/bits/basic_string.tcc /usr/include/c++/11/vector \ + /usr/include/c++/11/bits/stl_uninitialized.h \ + /usr/include/c++/11/bits/stl_vector.h \ + /usr/include/c++/11/bits/stl_bvector.h \ + /usr/include/c++/11/bits/vector.tcc \ + /content/NeuCoSVC-2/REAPER/./wave/codec_riff.h \ + /content/NeuCoSVC-2/REAPER/./wave/codec_api-inl.h \ + /content/NeuCoSVC-2/REAPER/./core/file_resource.h \ + /content/NeuCoSVC-2/REAPER/./wave/wave_io-inl.h \ + /usr/include/c++/11/limits diff --git a/REAPER/build/Makefile b/REAPER/build/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..c2d1fe0b98832fc93ce0bb6b17122498b23d918b --- /dev/null +++ b/REAPER/build/Makefile @@ -0,0 +1,493 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.27 + +# Default target executed when no arguments are given to make. +default_target: all +.PHONY : default_target + +# Allow only one "make -f Makefile2" at a time, but pass parallelism. +.NOTPARALLEL: + +#============================================================================= +# Special targets provided by cmake. + +# Disable implicit rules so canonical targets will work. +.SUFFIXES: + +# Disable VCS-based implicit rules. +% : %,v + +# Disable VCS-based implicit rules. +% : RCS/% + +# Disable VCS-based implicit rules. +% : RCS/%,v + +# Disable VCS-based implicit rules. +% : SCCS/s.% + +# Disable VCS-based implicit rules. +% : s.% + +.SUFFIXES: .hpux_make_needs_suffix_list + +# Command-line flag to silence nested $(MAKE). +$(VERBOSE)MAKESILENT = -s + +#Suppress display of executed commands. +$(VERBOSE).SILENT: + +# A target that is always out of date. +cmake_force: +.PHONY : cmake_force + +#============================================================================= +# Set environment variables for the build. + +# The shell in which to execute make rules. +SHELL = /bin/sh + +# The CMake executable. +CMAKE_COMMAND = /usr/local/lib/python3.10/dist-packages/cmake/data/bin/cmake + +# The command to remove a file. +RM = /usr/local/lib/python3.10/dist-packages/cmake/data/bin/cmake -E rm -f + +# Escaping for special characters. +EQUALS = = + +# The top-level source directory on which CMake was run. +CMAKE_SOURCE_DIR = /content/NeuCoSVC-2/REAPER + +# The top-level build directory on which CMake was run. +CMAKE_BINARY_DIR = /content/NeuCoSVC-2/REAPER/build + +#============================================================================= +# Targets provided globally by CMake. + +# Special rule for the target edit_cache +edit_cache: + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "No interactive CMake dialog available..." + /usr/local/lib/python3.10/dist-packages/cmake/data/bin/cmake -E echo No\ interactive\ CMake\ dialog\ available. +.PHONY : edit_cache + +# Special rule for the target edit_cache +edit_cache/fast: edit_cache +.PHONY : edit_cache/fast + +# Special rule for the target rebuild_cache +rebuild_cache: + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Running CMake to regenerate build system..." + /usr/local/lib/python3.10/dist-packages/cmake/data/bin/cmake --regenerate-during-build -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) +.PHONY : rebuild_cache + +# Special rule for the target rebuild_cache +rebuild_cache/fast: rebuild_cache +.PHONY : rebuild_cache/fast + +# The main all target +all: cmake_check_build_system + $(CMAKE_COMMAND) -E cmake_progress_start /content/NeuCoSVC-2/REAPER/build/CMakeFiles /content/NeuCoSVC-2/REAPER/build//CMakeFiles/progress.marks + $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 all + $(CMAKE_COMMAND) -E cmake_progress_start /content/NeuCoSVC-2/REAPER/build/CMakeFiles 0 +.PHONY : all + +# The main clean target +clean: + $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 clean +.PHONY : clean + +# The main clean target +clean/fast: clean +.PHONY : clean/fast + +# Prepare targets for installation. +preinstall: all + $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 preinstall +.PHONY : preinstall + +# Prepare targets for installation. +preinstall/fast: + $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 preinstall +.PHONY : preinstall/fast + +# clear depends +depend: + $(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 1 +.PHONY : depend + +#============================================================================= +# Target rules for targets named core + +# Build rule for target. +core: cmake_check_build_system + $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 core +.PHONY : core + +# fast build rule for target. +core/fast: + $(MAKE) $(MAKESILENT) -f CMakeFiles/core.dir/build.make CMakeFiles/core.dir/build +.PHONY : core/fast + +#============================================================================= +# Target rules for targets named wave + +# Build rule for target. +wave: cmake_check_build_system + $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 wave +.PHONY : wave + +# fast build rule for target. +wave/fast: + $(MAKE) $(MAKESILENT) -f CMakeFiles/wave.dir/build.make CMakeFiles/wave.dir/build +.PHONY : wave/fast + +#============================================================================= +# Target rules for targets named epoch_tracker + +# Build rule for target. +epoch_tracker: cmake_check_build_system + $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 epoch_tracker +.PHONY : epoch_tracker + +# fast build rule for target. +epoch_tracker/fast: + $(MAKE) $(MAKESILENT) -f CMakeFiles/epoch_tracker.dir/build.make CMakeFiles/epoch_tracker.dir/build +.PHONY : epoch_tracker/fast + +#============================================================================= +# Target rules for targets named reaper + +# Build rule for target. +reaper: cmake_check_build_system + $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 reaper +.PHONY : reaper + +# fast build rule for target. +reaper/fast: + $(MAKE) $(MAKESILENT) -f CMakeFiles/reaper.dir/build.make CMakeFiles/reaper.dir/build +.PHONY : reaper/fast + +core/file_resource.o: core/file_resource.cc.o +.PHONY : core/file_resource.o + +# target to build an object file +core/file_resource.cc.o: + $(MAKE) $(MAKESILENT) -f CMakeFiles/core.dir/build.make CMakeFiles/core.dir/core/file_resource.cc.o +.PHONY : core/file_resource.cc.o + +core/file_resource.i: core/file_resource.cc.i +.PHONY : core/file_resource.i + +# target to preprocess a source file +core/file_resource.cc.i: + $(MAKE) $(MAKESILENT) -f CMakeFiles/core.dir/build.make CMakeFiles/core.dir/core/file_resource.cc.i +.PHONY : core/file_resource.cc.i + +core/file_resource.s: core/file_resource.cc.s +.PHONY : core/file_resource.s + +# target to generate assembly for a file +core/file_resource.cc.s: + $(MAKE) $(MAKESILENT) -f CMakeFiles/core.dir/build.make CMakeFiles/core.dir/core/file_resource.cc.s +.PHONY : core/file_resource.cc.s + +core/float_matrix.o: core/float_matrix.cc.o +.PHONY : core/float_matrix.o + +# target to build an object file +core/float_matrix.cc.o: + $(MAKE) $(MAKESILENT) -f CMakeFiles/core.dir/build.make CMakeFiles/core.dir/core/float_matrix.cc.o +.PHONY : core/float_matrix.cc.o + +core/float_matrix.i: core/float_matrix.cc.i +.PHONY : core/float_matrix.i + +# target to preprocess a source file +core/float_matrix.cc.i: + $(MAKE) $(MAKESILENT) -f CMakeFiles/core.dir/build.make CMakeFiles/core.dir/core/float_matrix.cc.i +.PHONY : core/float_matrix.cc.i + +core/float_matrix.s: core/float_matrix.cc.s +.PHONY : core/float_matrix.s + +# target to generate assembly for a file +core/float_matrix.cc.s: + $(MAKE) $(MAKESILENT) -f CMakeFiles/core.dir/build.make CMakeFiles/core.dir/core/float_matrix.cc.s +.PHONY : core/float_matrix.cc.s + +core/track.o: core/track.cc.o +.PHONY : core/track.o + +# target to build an object file +core/track.cc.o: + $(MAKE) $(MAKESILENT) -f CMakeFiles/core.dir/build.make CMakeFiles/core.dir/core/track.cc.o +.PHONY : core/track.cc.o + +core/track.i: core/track.cc.i +.PHONY : core/track.i + +# target to preprocess a source file +core/track.cc.i: + $(MAKE) $(MAKESILENT) -f CMakeFiles/core.dir/build.make CMakeFiles/core.dir/core/track.cc.i +.PHONY : core/track.cc.i + +core/track.s: core/track.cc.s +.PHONY : core/track.s + +# target to generate assembly for a file +core/track.cc.s: + $(MAKE) $(MAKESILENT) -f CMakeFiles/core.dir/build.make CMakeFiles/core.dir/core/track.cc.s +.PHONY : core/track.cc.s + +epoch_tracker/epoch_tracker.o: epoch_tracker/epoch_tracker.cc.o +.PHONY : epoch_tracker/epoch_tracker.o + +# target to build an object file +epoch_tracker/epoch_tracker.cc.o: + $(MAKE) $(MAKESILENT) -f CMakeFiles/epoch_tracker.dir/build.make CMakeFiles/epoch_tracker.dir/epoch_tracker/epoch_tracker.cc.o +.PHONY : epoch_tracker/epoch_tracker.cc.o + +epoch_tracker/epoch_tracker.i: epoch_tracker/epoch_tracker.cc.i +.PHONY : epoch_tracker/epoch_tracker.i + +# target to preprocess a source file +epoch_tracker/epoch_tracker.cc.i: + $(MAKE) $(MAKESILENT) -f CMakeFiles/epoch_tracker.dir/build.make CMakeFiles/epoch_tracker.dir/epoch_tracker/epoch_tracker.cc.i +.PHONY : epoch_tracker/epoch_tracker.cc.i + +epoch_tracker/epoch_tracker.s: epoch_tracker/epoch_tracker.cc.s +.PHONY : epoch_tracker/epoch_tracker.s + +# target to generate assembly for a file +epoch_tracker/epoch_tracker.cc.s: + $(MAKE) $(MAKESILENT) -f CMakeFiles/epoch_tracker.dir/build.make CMakeFiles/epoch_tracker.dir/epoch_tracker/epoch_tracker.cc.s +.PHONY : epoch_tracker/epoch_tracker.cc.s + +epoch_tracker/fd_filter.o: epoch_tracker/fd_filter.cc.o +.PHONY : epoch_tracker/fd_filter.o + +# target to build an object file +epoch_tracker/fd_filter.cc.o: + $(MAKE) $(MAKESILENT) -f CMakeFiles/epoch_tracker.dir/build.make CMakeFiles/epoch_tracker.dir/epoch_tracker/fd_filter.cc.o +.PHONY : epoch_tracker/fd_filter.cc.o + +epoch_tracker/fd_filter.i: epoch_tracker/fd_filter.cc.i +.PHONY : epoch_tracker/fd_filter.i + +# target to preprocess a source file +epoch_tracker/fd_filter.cc.i: + $(MAKE) $(MAKESILENT) -f CMakeFiles/epoch_tracker.dir/build.make CMakeFiles/epoch_tracker.dir/epoch_tracker/fd_filter.cc.i +.PHONY : epoch_tracker/fd_filter.cc.i + +epoch_tracker/fd_filter.s: epoch_tracker/fd_filter.cc.s +.PHONY : epoch_tracker/fd_filter.s + +# target to generate assembly for a file +epoch_tracker/fd_filter.cc.s: + $(MAKE) $(MAKESILENT) -f CMakeFiles/epoch_tracker.dir/build.make CMakeFiles/epoch_tracker.dir/epoch_tracker/fd_filter.cc.s +.PHONY : epoch_tracker/fd_filter.cc.s + +epoch_tracker/fft.o: epoch_tracker/fft.cc.o +.PHONY : epoch_tracker/fft.o + +# target to build an object file +epoch_tracker/fft.cc.o: + $(MAKE) $(MAKESILENT) -f CMakeFiles/epoch_tracker.dir/build.make CMakeFiles/epoch_tracker.dir/epoch_tracker/fft.cc.o +.PHONY : epoch_tracker/fft.cc.o + +epoch_tracker/fft.i: epoch_tracker/fft.cc.i +.PHONY : epoch_tracker/fft.i + +# target to preprocess a source file +epoch_tracker/fft.cc.i: + $(MAKE) $(MAKESILENT) -f CMakeFiles/epoch_tracker.dir/build.make CMakeFiles/epoch_tracker.dir/epoch_tracker/fft.cc.i +.PHONY : epoch_tracker/fft.cc.i + +epoch_tracker/fft.s: epoch_tracker/fft.cc.s +.PHONY : epoch_tracker/fft.s + +# target to generate assembly for a file +epoch_tracker/fft.cc.s: + $(MAKE) $(MAKESILENT) -f CMakeFiles/epoch_tracker.dir/build.make CMakeFiles/epoch_tracker.dir/epoch_tracker/fft.cc.s +.PHONY : epoch_tracker/fft.cc.s + +epoch_tracker/lpc_analyzer.o: epoch_tracker/lpc_analyzer.cc.o +.PHONY : epoch_tracker/lpc_analyzer.o + +# target to build an object file +epoch_tracker/lpc_analyzer.cc.o: + $(MAKE) $(MAKESILENT) -f CMakeFiles/epoch_tracker.dir/build.make CMakeFiles/epoch_tracker.dir/epoch_tracker/lpc_analyzer.cc.o +.PHONY : epoch_tracker/lpc_analyzer.cc.o + +epoch_tracker/lpc_analyzer.i: epoch_tracker/lpc_analyzer.cc.i +.PHONY : epoch_tracker/lpc_analyzer.i + +# target to preprocess a source file +epoch_tracker/lpc_analyzer.cc.i: + $(MAKE) $(MAKESILENT) -f CMakeFiles/epoch_tracker.dir/build.make CMakeFiles/epoch_tracker.dir/epoch_tracker/lpc_analyzer.cc.i +.PHONY : epoch_tracker/lpc_analyzer.cc.i + +epoch_tracker/lpc_analyzer.s: epoch_tracker/lpc_analyzer.cc.s +.PHONY : epoch_tracker/lpc_analyzer.s + +# target to generate assembly for a file +epoch_tracker/lpc_analyzer.cc.s: + $(MAKE) $(MAKESILENT) -f CMakeFiles/epoch_tracker.dir/build.make CMakeFiles/epoch_tracker.dir/epoch_tracker/lpc_analyzer.cc.s +.PHONY : epoch_tracker/lpc_analyzer.cc.s + +epoch_tracker_main.o: epoch_tracker_main.cc.o +.PHONY : epoch_tracker_main.o + +# target to build an object file +epoch_tracker_main.cc.o: + $(MAKE) $(MAKESILENT) -f CMakeFiles/reaper.dir/build.make CMakeFiles/reaper.dir/epoch_tracker_main.cc.o +.PHONY : epoch_tracker_main.cc.o + +epoch_tracker_main.i: epoch_tracker_main.cc.i +.PHONY : epoch_tracker_main.i + +# target to preprocess a source file +epoch_tracker_main.cc.i: + $(MAKE) $(MAKESILENT) -f CMakeFiles/reaper.dir/build.make CMakeFiles/reaper.dir/epoch_tracker_main.cc.i +.PHONY : epoch_tracker_main.cc.i + +epoch_tracker_main.s: epoch_tracker_main.cc.s +.PHONY : epoch_tracker_main.s + +# target to generate assembly for a file +epoch_tracker_main.cc.s: + $(MAKE) $(MAKESILENT) -f CMakeFiles/reaper.dir/build.make CMakeFiles/reaper.dir/epoch_tracker_main.cc.s +.PHONY : epoch_tracker_main.cc.s + +wave/codec_riff.o: wave/codec_riff.cc.o +.PHONY : wave/codec_riff.o + +# target to build an object file +wave/codec_riff.cc.o: + $(MAKE) $(MAKESILENT) -f CMakeFiles/wave.dir/build.make CMakeFiles/wave.dir/wave/codec_riff.cc.o +.PHONY : wave/codec_riff.cc.o + +wave/codec_riff.i: wave/codec_riff.cc.i +.PHONY : wave/codec_riff.i + +# target to preprocess a source file +wave/codec_riff.cc.i: + $(MAKE) $(MAKESILENT) -f CMakeFiles/wave.dir/build.make CMakeFiles/wave.dir/wave/codec_riff.cc.i +.PHONY : wave/codec_riff.cc.i + +wave/codec_riff.s: wave/codec_riff.cc.s +.PHONY : wave/codec_riff.s + +# target to generate assembly for a file +wave/codec_riff.cc.s: + $(MAKE) $(MAKESILENT) -f CMakeFiles/wave.dir/build.make CMakeFiles/wave.dir/wave/codec_riff.cc.s +.PHONY : wave/codec_riff.cc.s + +wave/wave.o: wave/wave.cc.o +.PHONY : wave/wave.o + +# target to build an object file +wave/wave.cc.o: + $(MAKE) $(MAKESILENT) -f CMakeFiles/wave.dir/build.make CMakeFiles/wave.dir/wave/wave.cc.o +.PHONY : wave/wave.cc.o + +wave/wave.i: wave/wave.cc.i +.PHONY : wave/wave.i + +# target to preprocess a source file +wave/wave.cc.i: + $(MAKE) $(MAKESILENT) -f CMakeFiles/wave.dir/build.make CMakeFiles/wave.dir/wave/wave.cc.i +.PHONY : wave/wave.cc.i + +wave/wave.s: wave/wave.cc.s +.PHONY : wave/wave.s + +# target to generate assembly for a file +wave/wave.cc.s: + $(MAKE) $(MAKESILENT) -f CMakeFiles/wave.dir/build.make CMakeFiles/wave.dir/wave/wave.cc.s +.PHONY : wave/wave.cc.s + +wave/wave_io.o: wave/wave_io.cc.o +.PHONY : wave/wave_io.o + +# target to build an object file +wave/wave_io.cc.o: + $(MAKE) $(MAKESILENT) -f CMakeFiles/wave.dir/build.make CMakeFiles/wave.dir/wave/wave_io.cc.o +.PHONY : wave/wave_io.cc.o + +wave/wave_io.i: wave/wave_io.cc.i +.PHONY : wave/wave_io.i + +# target to preprocess a source file +wave/wave_io.cc.i: + $(MAKE) $(MAKESILENT) -f CMakeFiles/wave.dir/build.make CMakeFiles/wave.dir/wave/wave_io.cc.i +.PHONY : wave/wave_io.cc.i + +wave/wave_io.s: wave/wave_io.cc.s +.PHONY : wave/wave_io.s + +# target to generate assembly for a file +wave/wave_io.cc.s: + $(MAKE) $(MAKESILENT) -f CMakeFiles/wave.dir/build.make CMakeFiles/wave.dir/wave/wave_io.cc.s +.PHONY : wave/wave_io.cc.s + +# Help Target +help: + @echo "The following are some of the valid targets for this Makefile:" + @echo "... all (the default if no target is provided)" + @echo "... clean" + @echo "... depend" + @echo "... edit_cache" + @echo "... rebuild_cache" + @echo "... core" + @echo "... epoch_tracker" + @echo "... reaper" + @echo "... wave" + @echo "... core/file_resource.o" + @echo "... core/file_resource.i" + @echo "... core/file_resource.s" + @echo "... core/float_matrix.o" + @echo "... core/float_matrix.i" + @echo "... core/float_matrix.s" + @echo "... core/track.o" + @echo "... core/track.i" + @echo "... core/track.s" + @echo "... epoch_tracker/epoch_tracker.o" + @echo "... epoch_tracker/epoch_tracker.i" + @echo "... epoch_tracker/epoch_tracker.s" + @echo "... epoch_tracker/fd_filter.o" + @echo "... epoch_tracker/fd_filter.i" + @echo "... epoch_tracker/fd_filter.s" + @echo "... epoch_tracker/fft.o" + @echo "... epoch_tracker/fft.i" + @echo "... epoch_tracker/fft.s" + @echo "... epoch_tracker/lpc_analyzer.o" + @echo "... epoch_tracker/lpc_analyzer.i" + @echo "... epoch_tracker/lpc_analyzer.s" + @echo "... epoch_tracker_main.o" + @echo "... epoch_tracker_main.i" + @echo "... epoch_tracker_main.s" + @echo "... wave/codec_riff.o" + @echo "... wave/codec_riff.i" + @echo "... wave/codec_riff.s" + @echo "... wave/wave.o" + @echo "... wave/wave.i" + @echo "... wave/wave.s" + @echo "... wave/wave_io.o" + @echo "... wave/wave_io.i" + @echo "... wave/wave_io.s" +.PHONY : help + + + +#============================================================================= +# Special targets to cleanup operation of make. + +# Special rule to run CMake to check the build system integrity. +# No rule that depends on this can have commands that come from listfiles +# because they might be regenerated. +cmake_check_build_system: + $(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 0 +.PHONY : cmake_check_build_system + diff --git a/REAPER/build/cmake_install.cmake b/REAPER/build/cmake_install.cmake new file mode 100644 index 0000000000000000000000000000000000000000..7eff4d2a957b2660ab8cfbccba8731f0e72dab8d --- /dev/null +++ b/REAPER/build/cmake_install.cmake @@ -0,0 +1,54 @@ +# Install script for directory: /content/NeuCoSVC-2/REAPER + +# Set the install prefix +if(NOT DEFINED CMAKE_INSTALL_PREFIX) + set(CMAKE_INSTALL_PREFIX "/usr/local") +endif() +string(REGEX REPLACE "/$" "" CMAKE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}") + +# Set the install configuration name. +if(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME) + if(BUILD_TYPE) + string(REGEX REPLACE "^[^A-Za-z0-9_]+" "" + CMAKE_INSTALL_CONFIG_NAME "${BUILD_TYPE}") + else() + set(CMAKE_INSTALL_CONFIG_NAME "") + endif() + message(STATUS "Install configuration: \"${CMAKE_INSTALL_CONFIG_NAME}\"") +endif() + +# Set the component getting installed. +if(NOT CMAKE_INSTALL_COMPONENT) + if(COMPONENT) + message(STATUS "Install component: \"${COMPONENT}\"") + set(CMAKE_INSTALL_COMPONENT "${COMPONENT}") + else() + set(CMAKE_INSTALL_COMPONENT) + endif() +endif() + +# Install shared libraries without execute permission? +if(NOT DEFINED CMAKE_INSTALL_SO_NO_EXE) + set(CMAKE_INSTALL_SO_NO_EXE "1") +endif() + +# Is this installation the result of a crosscompile? +if(NOT DEFINED CMAKE_CROSSCOMPILING) + set(CMAKE_CROSSCOMPILING "FALSE") +endif() + +# Set default install directory permissions. +if(NOT DEFINED CMAKE_OBJDUMP) + set(CMAKE_OBJDUMP "/usr/bin/objdump") +endif() + +if(CMAKE_INSTALL_COMPONENT) + set(CMAKE_INSTALL_MANIFEST "install_manifest_${CMAKE_INSTALL_COMPONENT}.txt") +else() + set(CMAKE_INSTALL_MANIFEST "install_manifest.txt") +endif() + +string(REPLACE ";" "\n" CMAKE_INSTALL_MANIFEST_CONTENT + "${CMAKE_INSTALL_MANIFEST_FILES}") +file(WRITE "/content/NeuCoSVC-2/REAPER/build/${CMAKE_INSTALL_MANIFEST}" + "${CMAKE_INSTALL_MANIFEST_CONTENT}") diff --git a/REAPER/build/libcore.a b/REAPER/build/libcore.a new file mode 100644 index 0000000000000000000000000000000000000000..fac7f63e661c55e207dff0bd51eebd048a936286 Binary files /dev/null and b/REAPER/build/libcore.a differ diff --git a/REAPER/build/libepoch_tracker.a b/REAPER/build/libepoch_tracker.a new file mode 100644 index 0000000000000000000000000000000000000000..326c7b79c811fb3ae0f1e0b4f1c78932b85db6b6 Binary files /dev/null and b/REAPER/build/libepoch_tracker.a differ diff --git a/REAPER/build/libwave.a b/REAPER/build/libwave.a new file mode 100644 index 0000000000000000000000000000000000000000..c4eae31cc30eb3fee01996c9d9aaf9b392db93f0 Binary files /dev/null and b/REAPER/build/libwave.a differ diff --git a/REAPER/build/reaper b/REAPER/build/reaper new file mode 100644 index 0000000000000000000000000000000000000000..01bc05ccae56ea9b0d4e3c48ed5000bb594631d7 Binary files /dev/null and b/REAPER/build/reaper differ diff --git a/REAPER/core/file_resource.cc b/REAPER/core/file_resource.cc new file mode 100644 index 0000000000000000000000000000000000000000..aea9fa87e8364d53cc17d51b3d33e46ec6d82c58 --- /dev/null +++ b/REAPER/core/file_resource.cc @@ -0,0 +1,30 @@ +/* +Copyright 2015 Google Inc. All rights reserved. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +#include "core/file_resource.h" + +FileResource::FileResource(const std::string &filename, const std::string &mode) + : filename_(filename), mode_(mode) { +} + +FileResource::~FileResource() { + fclose(fp_); +} + +bool FileResource::Get() { + fp_ = fopen(filename_.c_str(), mode_.c_str()); + return fp_ != NULL; +} diff --git a/REAPER/core/file_resource.h b/REAPER/core/file_resource.h new file mode 100644 index 0000000000000000000000000000000000000000..271e9ce660700eb64de8281ccc14d95f16fa5f3c --- /dev/null +++ b/REAPER/core/file_resource.h @@ -0,0 +1,44 @@ +/* +Copyright 2015 Google Inc. All rights reserved. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +#ifndef _FILE_RESOURCE_H_ +#define _FILE_RESOURCE_H_ + +#include +#include + +class FileResource { + public: + // Mode follows the standard (eg. "wb", "r"). + FileResource(const std::string &filename, const std::string &mode); + ~FileResource(); + + // Opens a file with the specified mode. Returns false if it fails. + bool Get(); + + FILE *fp() { return fp_; } + + bool eof() const { + return feof(fp_) != 0; + } + + private: + std::string filename_; + std::string mode_; + FILE *fp_; +}; + +#endif // _FILE_RESOURCE_H_ diff --git a/REAPER/core/float_matrix-inl.h b/REAPER/core/float_matrix-inl.h new file mode 100644 index 0000000000000000000000000000000000000000..86cb13fce94a2fdaf1c556f21f31bac846278dd9 --- /dev/null +++ b/REAPER/core/float_matrix-inl.h @@ -0,0 +1,72 @@ +/* +Copyright 2015 Google Inc. All rights reserved. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +#ifndef _FLOAT_MATRIX_INL_H_ +#define _FLOAT_MATRIX_INL_H_ + +// IWYU pragma: private, include "float_matrix.h" + + + +inline uint32_t FloatMatrix::get_x_size(void) const { + return x_size_; +} + +inline uint32_t FloatMatrix::get_y_size(void) const { + return y_size_; +} + +// y1x1 y1x2 y1x3 y1x4 y2x1 y2x2 y2x3 y2x4 +inline float FloatMatrix::Get(uint32_t x, uint32_t y) const { + return data_[y * x_size_ + x]; +} + +inline float &FloatMatrix::Get(uint32_t x, uint32_t y) { +#ifdef _DEBUG + if (y >= y_size_ || x >= x_size_) { + fprintf(stderr, "Matrix boundary overrun error"); + } +#endif + return data_[y * x_size_ + x]; +} + +inline void FloatMatrix::Set(uint32_t x, uint32_t y, float val) { +#ifdef _DEBUG + if (y >= y_size_ || x >= x_size_) { + fprintf(stderr, "Matrix boundary overrun error"); + } +#endif + data_[y *x_size_ + x] = val; +} + +inline uint32_t FloatMatrix::size() const { + return x_size_ * y_size_; +} + +inline const float *FloatMatrix::data(void) const { + return data_; +} + +inline void FloatMatrix::StringWrite(std::string *out) const { + if (size()) { + char *source = reinterpret_cast(data_); + out->append(source, size() * sizeof(*data_)); + } +} + + + +#endif // SPEECH_PATTS_ENGINE_COMMON_CORE_FLOAT_MATRIX_INL_H_ diff --git a/REAPER/core/float_matrix.cc b/REAPER/core/float_matrix.cc new file mode 100644 index 0000000000000000000000000000000000000000..ab163ee6b43ccaa117d07100fb604797f08825e5 --- /dev/null +++ b/REAPER/core/float_matrix.cc @@ -0,0 +1,78 @@ +/* +Copyright 2015 Google Inc. All rights reserved. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +#include "core/float_matrix.h" + +#include + + + +FloatMatrix::FloatMatrix() { + data_ = NULL; + x_size_ = 0; + y_size_ = 0; +} + +FloatMatrix::FloatMatrix(const FloatMatrix &m) { + clear(); + resize(m.x_size_, m.y_size_); + for (uint32_t i = 0; i < x_size_ * y_size_; i++) { + data_[i] = m.data_[i]; + } +} + +FloatMatrix::~FloatMatrix() { + clear(); +} + +void FloatMatrix::operator=(const FloatMatrix &m) { + clear(); + resize(m.x_size_, m.y_size_); + for (uint32_t i = 0; i < x_size_ * y_size_; i++) { + data_[i] = m.data_[i]; + } +} + +void FloatMatrix::clear() { + if (data_ != NULL) { + delete [] data_; + data_ = NULL; + } + x_size_ = 0; + y_size_ = 0; +} + +void FloatMatrix::resize(uint32_t x_size, uint32_t y_size) { + if (data_ == NULL) { + data_ = new float [x_size * y_size]; + memset(data_, 0, sizeof(float)*x_size * y_size); + } else if (x_size == x_size_ && y_size == y_size_) { + return; + } else { + float *newdata = new float [x_size * y_size]; + memset(newdata, 0, sizeof(float) * x_size * y_size); + int min_x = x_size < x_size_ ? x_size : x_size_; + int min_y = y_size < y_size_ ? y_size : y_size_; + for (int y = 0; y < min_y; y++) { + memcpy(newdata + y * x_size, data_ + y * x_size_, min_x * sizeof(float)); + } + delete [] data_; + data_ = newdata; + } + + x_size_ = x_size; + y_size_ = y_size; +} diff --git a/REAPER/core/float_matrix.h b/REAPER/core/float_matrix.h new file mode 100644 index 0000000000000000000000000000000000000000..8b253757ae2afe057f375e9691d413a00eec89ff --- /dev/null +++ b/REAPER/core/float_matrix.h @@ -0,0 +1,57 @@ +/* +Copyright 2015 Google Inc. All rights reserved. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ +// A memory mappable float matrix with restricted use, composite audio and +// track classes being its current uses. Its further use should be avoided +// as its designed to meet the specific needs of these classes. + +#ifndef _FLOAT_MATRIX_H_ +#define _FLOAT_MATRIX_H_ + +#include +#include + +class FloatMatrix { + public: + FloatMatrix(); + FloatMatrix(const FloatMatrix &); + ~FloatMatrix(); + + void operator = (const FloatMatrix &); + + void resize(uint32_t x_size, uint32_t y_size); + void clear(); + + float Get(uint32_t x, uint32_t y) const; + float &Get(uint32_t x, uint32_t y); + void Set(uint32_t x, uint32_t y, float val); + + uint32_t get_x_size() const; + uint32_t get_y_size() const; + + uint32_t size() const; + const float *data(void) const; + + void StringWrite(std::string *out) const; + + private: + float *data_; + uint32_t x_size_; + uint32_t y_size_; +}; + +#include "float_matrix-inl.h" + +#endif // _FLOAT_MATRIX_H_ diff --git a/REAPER/core/track.cc b/REAPER/core/track.cc new file mode 100644 index 0000000000000000000000000000000000000000..1ab0a995e4e37e042015d597124b1dded4738eb7 --- /dev/null +++ b/REAPER/core/track.cc @@ -0,0 +1,581 @@ +/* +Copyright 2015 Google Inc. All rights reserved. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ +#include "core/track.h" + +#include +#include +#include + +#define __STDC_FORMAT_MACROS +#include + +#if !defined(INVALID_LOG) +#define INVALID_LOG -1.0E+10F +#endif // INVALID_LOG + +namespace { + +int ToInt(const std::string &s) { + char *p = 0; + int32_t r = strtol(s.c_str(), &p, 10); + return static_cast(r); +} + +std::string ToString(float n, int p) { + char buf[1000]; + buf[0] = 0; + snprintf(buf, sizeof(buf), "%.*f", p, n); + return buf; +} + +std::string ToString(uint32_t n) { + char buf[1000]; + buf[0] = 0; + snprintf(buf, sizeof(buf), "%" PRIu32, n); + return buf; +} + +double ToDouble(const std::string &s) { + char *p = 0; + return strtod(s.c_str(), &p); +} + +float ToFloat(const std::string &s) { + return static_cast(ToDouble(s)); +} + +// +// Default size of character I/O buffers: +// +const uint32_t kMaxCharBufSize = 8192; // 8k + +std::string GetToken(FileResource *fr) { + char buff[kMaxCharBufSize]; + uint32_t i = 0; + bool foundData = false; + do { + buff[i] = fgetc(fr->fp()); + if ((iscntrl((unsigned char)buff[i]) || isspace((unsigned char)buff[i])) && + !foundData) { + continue; + } + foundData = true; + if (iscntrl((unsigned char)buff[i]) || isspace((unsigned char)buff[i])) { + break; + } + i++; + } while (i < kMaxCharBufSize && !fr->eof()); + buff[i] = 0; + return std::string(buff); +} + +// Find the first whitespace/newline delimited token in the character +// array c. Return the stripped token in s. return the position of +// the first character following the token in tok_end. If the end of +// c is found during the search, return true, else return false. If no +// token is found, return 0 in tok_end. +bool GetTokenFromChars(const char *c, std::string *s, int32_t *tok_end) { + int32_t i = 0; + s->clear(); + *tok_end = 0; + // skip initial whitespace + while (c[i] && ((c[i] == ' ') || (c[i] == '\t') || (c[i] == '\n'))) { + i++; + } + if (!c[i]) { + return true; + } + int32_t start = i; + while (c[i] && (c[i] != ' ') && (c[i] != '\t') && (c[i] != '\n')) { + i++; + } + *tok_end = i; + + if (c[i-1] == '\r') { + --i; + } + s->assign(c + start, i - start); + return c[i] == 0; +} + +} // namespace + + +Track::Track() { + num_frames_ = 0; + num_channels_ = 0; + shift_ = 0.0F; + voicing_enabled_ = false; +} + +void Track::FillFrom(const Track &t) { + num_frames_ = t.num_frames_; + num_channels_ = t.num_channels_; + shift_ = t.shift_; + data_ = t.data_; + val_ = t.val_; + voicing_enabled_ = t.voicing_enabled_; +} + + +Track::~Track() { + Clear(); +} + +bool Track::Save(FileResource *fr) const { + fprintf(fr->fp(), "EST_File Track\n"); + fprintf(fr->fp(), "DataType binary2\n"); + fprintf(fr->fp(), "NumFrames %d\n", num_frames()); + fprintf(fr->fp(), "NumChannels %d\n", num_channels()); + fprintf(fr->fp(), "FrameShift %f\n", shift()); + if (voicing_enabled_) { + fprintf(fr->fp(), "VoicingEnabled true\n"); + } else { + fprintf(fr->fp(), "VoicingEnabled false\n"); + } + fprintf(fr->fp(), "EST_Header_End\n"); + + // write time information + for (int i = 0; i < num_frames(); ++i) { + float f = t(i); + if (fwrite(&f, sizeof(f), 1, fr->fp()) != 1) { + fprintf(stderr, "Failed to write to track file"); + return false; + } + } + + // write voicing information + if (voicing_enabled_) { + for (int i = 0; i < num_frames(); ++i) { + char vu = v(i) ? 1 : 0; + if (fwrite(&vu, sizeof(vu), 1, fr->fp()) != 1) { + fprintf(stderr, "Failed to write to track file"); + return false; + } + } + } + + // write coefficient information + for (int i = 0; i < num_frames(); ++i) { + for (int j = 0; j < num_channels(); ++j) { + float f = a(i, j); + if (fwrite(&f, sizeof(f), 1, fr->fp()) != 1) { + fprintf(stderr, "Failed to write to track file"); + return false; + } + } + } + return true; +} + +int Track::Index(float x) const { + if (num_frames() > 1) { // if single frame, return that index (0) + int bst, bmid, bend; + bst = 1; + bend = num_frames(); + if (x < t(bst)) { + bmid = bst; + } + if (x >= t(bend - 1)) { + bmid = bend - 1; + } else { + while (1) { + bmid = bst + (bend - bst) / 2; + if (bst == bmid) { + break; + } else if (x < t(bmid)) { + if (x >= t(bmid - 1)) { + break; + } + bend = bmid; + } else { + bst = bmid; + } + } + } + if (fabs(x - t(bmid)) < fabs(x - t(bmid - 1))) { + return bmid; + } else { + return bmid - 1; + } + } + return num_frames() - 1; +} + +int Track::IndexBelow(float x) const { + for (int i = 1; i < num_frames(); ++i) { + if (x <= t(i)) { + return i - 1; + } + } + return num_frames() - 1; +} + +int Track::IndexAbove(float x) const { + for (int i = 0; i < num_frames(); ++i) { + if (x <= t(i)) { + return i; + } + } + return num_frames() - 1; +} + +std::string Track::HeaderToString() const { + std::string ret; + ret = "EST_File Track\n"; + ret += "DataType ascii\n"; + ret += "NumFrames " + ::ToString(num_frames()) + "\n"; + ret += "NumChannels " + ::ToString(num_channels()) + "\n"; + ret += "FrameShift " + ::ToString(shift(), 5) + "\n"; + ret += "VoicingEnabled "; + if (voicing_enabled_) { + ret += "true\n"; + } else { + ret += "false\n"; + } + ret += "EST_Header_End\n"; + return ret; +} + +std::string Track::ToString(uint32_t precision) const { + std::string ret; + ret = HeaderToString(); + char buf[1024]; + for (int i = 0; i < num_frames(); ++i) { + snprintf(buf, 1024, "%f %d", t(i), v(i) ? 1 : 0); + ret += buf; + for (int j = 0; j < num_channels(); ++j) { + ret += " "; + ret += ::ToString(a(i, j), precision); + } + ret += std::string("\n"); + } + return ret; +} + +std::string Track::ToString() const { + const uint32_t kPrintOutPrecision = 6; + return ToString(kPrintOutPrecision); +} + +float Track::shift() const { + return shift_; +} + +void Track::FillTime(float frame_shift, int start) { + shift_ = frame_shift; + for (int i = 0; i < num_frames_; ++i) { + data_.Set(0, i, frame_shift * (i + start)); + } +} + +void Track::FillTime(const Track &t) { + for (int i = 0; i < num_frames_; ++i) { + data_.Set(0, i, t.t(i)); + } +} + +void Track::SetTimes(float *times, int length) { + if (length != num_frames_) { + fprintf(stderr, "Track::SetTimes: input `times` has different number " + "of frames (%d != %d)", length, num_frames_); + } + for (int i = 0; i < num_frames_; ++i) { + data_.Set(0, i, times[i]); + } +} + +bool Track::SetVoicing(const std::vector &vuv) { + if (vuv.size() != num_frames_) { + fprintf(stderr, "Track::SetVoicing: input has different number " + "of frames (%zu != %d)", vuv.size(), num_frames_); + return false; + } + val_ = vuv; + return true; +} + +void Track::FrameOut(std::vector *fv, int n) const { + fv->resize(num_channels_); + for (int i = 0; i < num_channels_; i++) { + (*fv)[i] = a(n, i); + } +} + +void Track::FrameOut(std::vector *fv, int n) const { + fv->resize(num_channels_); + for (int i = 0; i < num_channels_; i++) { + (*fv)[i] = a(n, i); + } +} + +void Track::FrameIn(const float &f, int n) { + a(n) = f; +} + +void Track::FrameIn(const std::vector &fv, int n) { + for (int i = 0; i < num_channels_; i++) { + a(n, i) = fv[i]; + } +} + +void Track::FrameIn(const std::vector &fv, int n) { + for (int i = 0; i < num_channels_; i++) { + a(n, i) = fv[i]; + } +} + +Track *Track::GetSubTrack(float start, + float end, + int ch_offset, + int ch_size) const { + int start_frame = -1; + int end_frame = -1; + int n_sub_frames; + int i, j; + + for (i = 0; i < this->num_frames(); ++i) { + if ((start_frame == -1) && (this->t(i) > start)) { + start_frame = i - 1; + } + if ((end_frame == -1) && (this->t(i) > end)) { + end_frame = i; + } + } + if (start_frame == -1) { + start_frame = this->num_frames() - 1; + } + if (end_frame == -1) { + end_frame = this->num_frames() - 1; + } + n_sub_frames = end_frame - start_frame; + if (n_sub_frames < 1) { + // make sure we have at least one frame + n_sub_frames = 1; + } + if (ch_size == -1 && ch_offset == -1) { + ch_offset = 0; + ch_size = this->num_channels(); + } else { + if (ch_size > this->num_channels()) { + fprintf(stderr, "Incorrect number of channels for sub track"); + return NULL; + } + } + Track *sub_track = new Track; + sub_track->resize(n_sub_frames, ch_size); + for (i = 0; i < n_sub_frames; ++i) { + sub_track->t(i) = this->t(i + start_frame); + for (j = ch_offset; j < ch_size; ++j) { + sub_track->a(i, j) = this->a(i + start_frame, j); + } + } + return sub_track; +} + + +Track *Track::GetSubTrack(int start_frame_index, + int end_frame_index, + int start_channel_index, + int end_channel_index) const { + if (start_frame_index > end_frame_index || + start_frame_index < 0 || start_frame_index >= this->num_frames() || + end_frame_index < 0 || end_frame_index >= this->num_frames()) { + fprintf(stderr, "Incorrect frame indices for sub-track 0<%d<=%d<%d\n", + start_frame_index, + end_frame_index, + this->num_frames()); + return NULL; + } + + if (start_channel_index > end_channel_index || + start_channel_index < 0 || start_channel_index >= this->num_channels() || + end_channel_index < 0 || end_channel_index >= this->num_channels()) { + fprintf(stderr, "Incorrect channel indices for sub-track 0<%d<=%d<%d\n", + start_channel_index, + end_channel_index, + this->num_channels()); + return NULL; + } + + Track *sub_track = new Track; + + int number_frames = end_frame_index - start_frame_index + 1; + int number_channels = end_channel_index - start_channel_index + 1; + sub_track->resize(number_frames, number_channels); + + for (int f = 0; f < number_frames; f++) { + for (int p = 0; p < number_channels; p++) { + sub_track->a(f, p) = this->a(start_frame_index + f, + start_channel_index + p); + } + sub_track->t(f) = this->t(start_frame_index + f); + sub_track->set_v(f, this->v(start_frame_index + f)); + } + + sub_track->set_shift(this->shift()); + return sub_track; +} + +void Track::resize(int n, int c) { + if (n != num_frames_) { + val_.resize(n, 1); + } + + data_.resize(c + 1, n); + num_frames_ = n; + num_channels_ = c; +} + +void Track::Clear() { + num_frames_ = 0; + num_channels_ = 0; + shift_ = 0.0F; + data_.clear(); + val_.clear(); +} + +void Track::CopyFrom(const char *v, int32_t num_frames, int32_t num_channels) { + resize(num_frames, num_channels); + const float* source = reinterpret_cast(v); + for (int32_t i = 0; i < num_frames; ++i) { + for (int32_t j = 0; j < num_channels; ++j) { + a(i, j) = *source++; + } + } +} + +// Sets current track to be combination of two tracks +bool Track::SetCombinedTrack(const Track &track_a, const Track &track_b) { + if (track_a.num_frames() != track_b.num_frames()) { + fprintf(stderr, "Mismatching number of frames: %d vs. %d", + track_a.num_frames(), + track_b.num_frames()); + return false; + } + + const int n_frames = track_a.num_frames(); + const int n_channels_a = track_a.num_channels(); + const int n_channels_b = track_b.num_channels(); + resize(n_frames, n_channels_a + n_channels_b); + for (int i = 0; i < n_frames; i++) { + for (int j = 0; j < n_channels_a; j++) { + a(i, j) = track_a.a(i, j); + } + for (int j = 0; j < n_channels_b; j++) { + a(i, n_channels_a + j) = track_b.a(i, j); + } + set_v(i, track_a.v(i) && track_b.v(i)); + } + return true; +} + +bool Track::SetCombinedTrack(const Track &track_a, + const Track &track_b, + const Track &track_c) { + Track track_ab; + if (!track_ab.SetCombinedTrack(track_a, track_b)) { + return false; + } + return SetCombinedTrack(track_ab, track_c); +} + +// Pads a track with frames: +bool Track::Pad(int num_pads) { + if (num_pads <= 0) { + return false; + } + const int num_original_frames = num_frames(); + const int num_original_channels = num_channels(); + + Track new_track; + new_track.resize(num_original_frames + num_pads, num_original_channels); + for (int i = 0; i < num_original_frames; ++i) { + for (int j = 0; j < num_original_channels; ++j) { + new_track.a(i, j) = a(i, j); + } + new_track.set_v(i, v(i)); + } + for (int i = 0; i < num_pads; ++i) { + for (int j = 0; j < num_original_channels; ++j) { + new_track.a(num_original_frames + i, j) = a(num_original_frames - 1, j); + } + new_track.set_v(i, v(num_original_frames - 1)); + } + + const int num_new_frames = new_track.num_frames(); + Clear(); + resize(num_new_frames, num_original_channels); + for (int i = 0; i < num_new_frames; ++i) { + for (int j = 0; j < num_original_channels; ++j) { + a(i, j) = new_track.a(i, j); + } + set_v(i, new_track.v(i)); + } + return true; +} + +// Forces the two tracks to have the same size, padding if necessary. +void Track::MakeSameSize(Track *track) { + int max_frames = num_frames(); + if (track->num_frames() > max_frames) { + max_frames = track->num_frames(); + } + Pad(max_frames - num_frames()); + track->Pad(max_frames - track->num_frames()); +} + +// Forces the three tracks to have same size, padding if necessary. +void Track::MakeSameSize(Track *track_a, Track *track_b) { + int max_frames = num_frames(); + if (track_a->num_frames() > max_frames) { + max_frames = track_a->num_frames(); + } + if (track_b->num_frames() > max_frames) { + max_frames = track_b->num_frames(); + } + Pad(max_frames - num_frames()); + track_a->Pad(max_frames - track_a->num_frames()); + track_b->Pad(max_frames - track_b->num_frames()); +} + +//------------------------------------------------------------------------------ +// Utils. +//------------------------------------------------------------------------------ + +void ConvertToLogarithmic(Track *t) { + for (int32_t i = 0; i < t->num_frames(); ++i) { + for (int32_t j = 0; j < t->num_channels(); ++j) { + if (t->a(i, j) <= 0.0F) { + t->a(i, j) = INVALID_LOG; + } else { + t->a(i, j) = log(t->a(i, j)); + } + } + } +} + +float *TrackToFloatPointer(const Track &track, int *num_samples) { + *num_samples = track.num_channels() * track.num_frames(); + float *array = new float[*num_samples]; + uint32_t k = 0; + for (int i = 0; i < track.num_frames(); ++i) { + for (int j = 0; j < track.num_channels(); ++j) { + array[k++] = track.a(i, j); + } + } + return array; +} diff --git a/REAPER/core/track.h b/REAPER/core/track.h new file mode 100644 index 0000000000000000000000000000000000000000..c66dfdac257a4ffbd883aa0cc7a8b4764dfcae8c --- /dev/null +++ b/REAPER/core/track.h @@ -0,0 +1,320 @@ +/* +Copyright 2015 Google Inc. All rights reserved. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +#ifndef _TRACK_H_ +#define _TRACK_H_ + +#include +#include +#include + +#include "core/file_resource.h" +#include "core/float_matrix.h" + +class Track { + public: + Track(); + ~Track(); + + void FillFrom(const Track &track); + + // Returns the number of frames contained within this track instance. + int num_frames() const; + + // Returns the number of channels contained within this track instance. + int num_channels() const; + + // Returns whether the voicing is enabled on this track instance. + bool voicing_enabled() const; + + // Sets the voicing enable flag on this track instance. + void set_voicing_enabled(bool b); + + // Gets values for frame "f" and channel "c". + float &a(int f, int c = 0); + + // Gets values for frame "f" and channel "c". + float a(int f, int c = 0) const; + + // Gets voiced flags for frame "f". + void set_v(int f, bool value); + + // Gets voiced flags for frame "f". + bool v(int f) const; + + // Gets time instant for frame "f". + float &t(int f); + + // Gets time instant for frame "f". + float t(int f) const; + + // Sets the interval between frames in seconds. + void set_shift(float shift); + + // Returns the interval between frames in seconds. + float shift() const; + + // Modifies this track instances frame times with that given, from the + // given frame index. + void FillTime(float frame_shift, int start = 1); + + // Modifies this track instances frame times with the value corresponding + // to its frame index. + void FillTime(const Track &t); + + // Modifies the times of this track instance with the given values. + // NOTE: the length must be equal to the number of frames in the track. + void SetTimes(float *times, int length); + + // Modifies the voicing flag of this track instance with the given values. +bool SetVoicing(const std::vector &vuv); + + // Sets the track from the given time and value vectors. + // All frames are set to voiced. + template + void Set(const std::vector ×, const std::vector &values); + + // Sets the track from the given time and value vectors. + // All frames are set to voiced. + template + void Set(float time_shift, const std::vector &values); + + // Populates the given vector with the values for all channels for + // the given frame index. + void FrameOut(std::vector *fv, int n) const; + + // Populates the given vector with the values for all channels for + // the given frame index. + void FrameOut(std::vector *fv, int n) const; + + // Updates the values for all channels for the given frame index with + // the values given. + void FrameIn(const float &f, int n); + + // Updates the values for all channels for the given frame index with + // the values given. + void FrameIn(const std::vector &fv, int n); + + // Updates the values for all channels for the given frame index with + // the values given. + void FrameIn(const std::vector &fv, int n); + + // Returns the index of the frame at the given time index. + int Index(float x) const; + + // Returns the index of the first frame below that at the given time index, x. + int IndexBelow(float x) const; + + // Returns the index of the first frame above that at the given time index, x. + int IndexAbove(float x) const; + + // Resizes the data and voicing flags to the given value, n, and the + // number of channels to that given, c. + void resize(int n, int c = 1); + + // Resets all the data associated with this track instance. + void Clear(); + + // Returns a portion of this track instance as defined by the input + // start and end times along with the channels required. + // Note: Ownership of the returned track is required to prevent + // memory leaks downstream. + Track *GetSubTrack(float start, + float end, + int ch_offset = -1, + int ch_size = -1) const; + + // Returns a portion of this track instance as defined by the input + // start and end frame indices along with the channels required. + // Note: Ownership of the returned track is required to prevent + // memory leaks downstream. + Track *GetSubTrack(int start_frame_index, + int end_frame_index, + int start_channel_index, + int end_channel_index) const; + + // Returns a std::string representation of the header of this track: + // The number of frames in this track + // The number of channels in this track + // The interval between frames + // Whether voicing is enabled or not + std::string HeaderToString() const; + + // Returns a std::string representation of this track instance containing: + // The number of frames in this track + // The number of channels in this track + // The interval between frames + // Whether voicing is enabled or not + // values + // If precision is specified, float numbers are printed out up to + // the specified number of decimal places. + std::string ToString(uint32_t precision) const; + std::string ToString() const; + + // Saves this track instance to the given FileResource. + bool Save(FileResource *fr) const; + + // Saves this track instance to the given FileResource. + bool Save(const std::string &filename, bool ascii) const; + + const FloatMatrix &data() const; + + // Resizes the track to the number of frames and channels given, + // copying the given data into the track. + void CopyFrom(const char *v, int32_t num_frames, int32_t num_channels); + + // Sets this track to be a combination of two input tracks + bool SetCombinedTrack(const Track &track_a, + const Track &track_b); + + // Sets this track to be combination of three input tracks + bool SetCombinedTrack(const Track &track_a, + const Track &track_b, + const Track &track_c); + + // Pads a track by repeating the last frame num_pads times. + bool Pad(int num_pads); + + // Makes the current track and ref track equal lengths, use the longest length + // and zero pad the shorter track if the are different lengths. + void MakeSameSize(Track *track); + + // Makes the current track and ref track equal lengths, use the longest length + // and zero pad the shorter tracks if any are shorter than the longest. + void MakeSameSize(Track *track_a, + Track *track_b); + + private: + // Holds the number of frames of this track instance. + int num_frames_; + + // Holds the number of channels of this track instance. + int num_channels_; + + // Holds the frames values and times of this track instance. + FloatMatrix data_; + + // Holds the voicing flags of this track instance. + std::vector val_; + + // Holds whether this track instance has voicing enabled. + bool voicing_enabled_; + + // The frame interval in seconds. + float shift_; +}; + +// Applies logarithm to all data values. Invalid values are set to INVALID_LOG. +void ConvertToLogarithmic(Track *t); + +// Returns a new vector with the track data as a single sequence of +// values. The caller takes ownership fo the pointer. +float *TrackToFloatPointer(const Track &track, int *num_samples); + +inline int Track::num_frames() const { + return num_frames_; +} + +inline int Track::num_channels() const { + return num_channels_; +} + +inline float &Track::a(int f, int c) { + return data_.Get(c + 1, f); +} + +inline float Track::a(int f, int c) const { + return data_.Get(c + 1, f); +} + +inline void Track::set_v(int f, bool value) { + // If a writable reference is used, force the track into + // voicing enabled mode. + voicing_enabled_ = true; + val_[f] = value; +} + +inline bool Track::v(int f) const { + return val_[f]; +} + +inline float &Track::t(int f) { + return data_.Get(0, f); +} + +inline float Track::t(int f) const { + return data_.Get(0, f); +} + +inline void Track::set_shift(float shift) { + shift_ = shift; +} + +inline const FloatMatrix &Track::data() const { + return data_; +} + +inline bool Track::voicing_enabled() const { + return voicing_enabled_; +} + +inline void Track::set_voicing_enabled(bool b) { + voicing_enabled_ = b; +} + +inline bool Track::Save(const std::string &filename, bool ascii) const { + FileResource fr(filename, "wb"); + if (!fr.Get()) { + fprintf(stderr, "Failed to write '%s'", filename.c_str()); + return false; + } + if (!ascii) { + return Save(&fr); + } + const std::string data = ToString(); + if (fprintf(fr.fp(), "%s", data.c_str()) != data.size()) { + return false; + } + return true; +} + +template +void Track::Set(const std::vector ×, + const std::vector &values) { + if (times.size() != values.size()) { + fprintf(stderr, "Length of time and value vectors should equal (%d != %d)", + times.size(), values.size()); + return; + } + resize(times.size()); + for (int n = 0; n < times.size(); ++n) { + t(n) = times[n]; + a(n) = values[n]; + set_v(n, true); + } +} + +template +void Track::Set(float time_shift, const std::vector &values) { + resize(values.size()); + FillTime(time_shift, 0); + for (int n = 0; n < values.size(); ++n) { + a(n) = values[n]; + set_v(n, true); + } +} + +#endif // _TRACK_H_ diff --git a/REAPER/epoch_tracker/epoch_tracker.cc b/REAPER/epoch_tracker/epoch_tracker.cc new file mode 100644 index 0000000000000000000000000000000000000000..0b640f536adbbe2ab8abce7133632617290e5fc1 --- /dev/null +++ b/REAPER/epoch_tracker/epoch_tracker.cc @@ -0,0 +1,1255 @@ +/* +Copyright 2015 Google Inc. All rights reserved. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ +// Author: dtalkin@google.com (David Talkin) + +// Implementation of the EpochTracker class. This does all of the +// processing necessary to estimate the F0, voicing state and epochs +// (glottal-closure instants) in human speech signals. See +// epoch_tracker.h for details. + +#include "epoch_tracker/epoch_tracker.h" + +#include +#include + +#include "epoch_tracker/fd_filter.h" +#include "epoch_tracker/lpc_analyzer.h" +#include "epoch_tracker/fft.h" + +const int kMinSampleRate = 6000; + +EpochTracker::EpochTracker(void) : sample_rate_(-1.0) { + SetParameters(); +} + +EpochTracker::~EpochTracker(void) { + CleanUp(); +} + +static inline int32_t RoundUp(float val) { + return static_cast(val + 0.5); +} + +void EpochTracker::CleanUp(void) { + for (size_t i = 0; i < resid_peaks_.size(); ++i) { + for (size_t j = 0; j < resid_peaks_[i].future.size(); ++j) { + delete resid_peaks_[i].future[j]; + } + } + resid_peaks_.clear(); + output_.clear(); + best_corr_.clear(); +} + +void EpochTracker::SetParameters(void) { + // Externally-settable control parameters: + // Period for the returned F0 signal. + external_frame_interval_ = kExternalFrameInterval; + do_highpass_ = kDoHighpass; // Enables highpassing of input signal. + // Enables Hilbert transformation of the input data. + do_hilbert_transform_ = kDoHilbertTransform; + max_f0_search_ = kMaxF0Search; // Maximum F0 to search for. + min_f0_search_ = kMinF0Search; // Minimum F0 to search for. + // Pulse spacing to use in unvoiced regions of the returned epoch signal. + unvoiced_pulse_interval_ = kUnvoicedPulseInterval; + debug_name_ = kDebugName; // base path for all debugging signals. + + // Internal feature-computation parameters: + // For internal feature computations + internal_frame_interval_ = kInternalFrameInterval; + // for the high-pass filter + corner_frequency_ = 80.0; + filter_duration_ = 0.05; + // for the LPC inverse filter. + frame_duration_ = 0.02; // window size (sec) + lpc_frame_interval_ = 0.01; // (sec) + preemphasis_ = 0.98; // preemphasis for LPC analysis + noise_floor_ = 70.0; // SNR in dB simulated during LPC analysis. + // for computing LPC residual peak quality. + peak_delay_ = 0.0004; // for measuring prominence + skew_delay_ = 0.00015; // for measuring shape + peak_val_wt_ = 0.1; + peak_prominence_wt_ = 0.3; + peak_skew_wt_ = 0.1; + peak_quality_floor_ = 0.01; + // for computing voice-transition pseudo-probabilities + time_span_ = 0.020; // the interval (sec) centered on the + // measurement point, used to compute parameter + // deltas. + level_change_den_ = 30.0; // max. dB level change expected over + // time_span_ for bandpassed RMS for + // computing pseudo-probability of + // voicing. + min_rms_db_ = 20.0; // level floor in dB + // window size for computing amplitude-normalizing RMS + ref_dur_ = 0.02; + // low and high frequency limits for bandpassed RMS used in voicing indicator + min_freq_for_rms_ = 100.0; + max_freq_for_rms_ = 1000.0; + // duration of integrator for bandpassed RMS + rms_window_dur_ = 0.025; + // window duration, in seconds, for NCCF computations + correlation_dur_ = 0.0075; + // ignore any NCCF peaks less than this + correlation_thresh_ = 0.2; + + // Parametrs used by the dynamic-programming tracker: + // reward for inserting another period + reward_ = -1.5; + // weight given to deviation of inter-pulse interval from the + // closest NCCF peak lag + period_deviation_wt_ = 1.0; + // weight given to the quality of the residual peak + peak_quality_wt_ = 1.3; + // cost of the unvoiced hypothesis + unvoiced_cost_ = kUnvoicedCost; + // cost of high NCCF values in hypothetical unvoiced regions + nccf_uv_peak_wt_ = 0.9; + // weight given to period length + period_wt_ = 0.0002; + // weight given to the pseudo-probability of voicing feature + level_wt_ = 0.8; + // weight given to period-length differences between adjacent periods. + freq_trans_wt_ = 1.8; + // cost of switching between voicing states; modulated by voicing + // onset/offset probs. + voice_transition_factor_ = 1.4; + + // Parameters used to generate final outputs: + // pad time in seconds to add to the last measured period during + // output of periodically-resampled data + endpoint_padding_ = 0.01; +} + +bool EpochTracker::Init(const int16_t* input, int32_t n_input, float sample_rate, + float min_f0_search, float max_f0_search, + bool do_highpass, bool do_hilbert_transform) { + if (input && (sample_rate > 6000.0) && (n_input > (sample_rate * 0.05)) && + (min_f0_search < max_f0_search) && (min_f0_search > 0.0)) { + CleanUp(); + min_f0_search_ = min_f0_search; + max_f0_search_ = max_f0_search; + sample_rate_ = sample_rate; + int16_t* input_p = const_cast(input); + if (do_highpass) { + input_p = HighpassFilter(input_p, n_input, sample_rate, + corner_frequency_, filter_duration_); + } + signal_.resize(n_input); + if (do_hilbert_transform) { + HilbertTransform(input_p, n_input, &(signal_.front())); + } else { + for (int32_t i = 0; i < n_input; ++i) { + signal_[i] = input_p[i]; + } + } + if (input_p != input) { + delete [] input_p; + } + return true; + } + return false; +} + +void EpochTracker::HilbertTransform(int16_t* input, int32_t n_input, + float* output) { + FFT ft = FFT(FFT::fft_pow2_from_window_size(n_input)); + int32_t n_fft = ft.get_fftSize(); + float* re = new float[n_fft]; + float* im = new float[n_fft]; + for (int i = 0; i < n_input; ++i) { + re[i] = input[i]; + im[i] = 0.0; + } + for (int i = n_input; i < n_fft; ++i) { + re[i] = 0.0; + im[i] = 0.0; + } + ft.fft(re, im); + for (int i = 1; i < n_fft/2; ++i) { + float tmp = im[i]; + im[i] = -re[i]; + re[i] = tmp; + } + re[0] = im[0] = 0.0; + for (int i = n_fft/2 + 1; i < n_fft; ++i) { + float tmp = im[i]; + im[i] = re[i]; + re[i] = -tmp; + } + ft.ifft(re, im); + for (int i = 0; i < n_input; ++i) { + output[i] = re[i] / n_fft; + } + delete [] re; + delete [] im; +} + + +int16_t* EpochTracker::HighpassFilter(int16_t* input, int32_t n_input, + float sample_rate, float corner_freq, + float fir_duration) { + FdFilter filter(sample_rate, corner_freq, true, fir_duration, false); + int16_t* filtered_data = new int16_t[n_input]; + int32_t max_buffer_size = filter.GetMaxInputSize(); + int32_t to_process = n_input; + bool start = true; + bool end = false; + int32_t input_index = 0; + int32_t output_index = 0; + while (to_process > 0) { + int32_t to_send = to_process; + if (to_send > max_buffer_size) { + to_send = max_buffer_size; + } else { + end = true; + } + int32_t samples_returned = filter.FilterArray(input + input_index, to_send, + start, end, + filtered_data + output_index, + n_input - output_index); + input_index += to_send; + to_process -= to_send; + output_index += samples_returned; + start = false; + } + return filtered_data; +} + + +static float LpcDcGain(float* lpc, int32_t order) { + float sum = 0.0; + for (int32_t i = 0; i <= order; ++i) { + sum += lpc[i]; + } + if (sum > 0.0) { + return sum; + } else { + return 1.0; + } +} + + +static void MakeDeltas(float* now, float* next, int32_t size, int32_t n_steps, + float* deltas) { + for (int32_t i = 0; i < size; ++i) { + deltas[i] = (next[i] - now[i]) / n_steps; + } +} + + +bool EpochTracker::GetLpcResidual(const std::vector& input, float sample_rate, + std::vector* output) { + int32_t n_input = input.size(); + if (!((n_input > 0) && (sample_rate > 0.0) && output)) { + return false; + } + output->resize(n_input); + int32_t frame_step = RoundUp(sample_rate * lpc_frame_interval_); + int32_t frame_size = RoundUp(sample_rate * frame_duration_); + int32_t n_frames = 1 + ((n_input - frame_size) / frame_step); + int32_t n_analyzed = ((n_frames - 1) * frame_step) + frame_size; + // Must have one more than frame size to do a complete frame. + if (n_analyzed <= n_input) { + n_frames--; + if (n_frames <= 0) { + return false; + } + } + LpcAnalyzer lp; + int32_t order = lp.GetLpcOrder(sample_rate); + float* lpc = new float[order + 1]; + float* old_lpc = new float[order + 1]; + float* delta_lpc = new float[order + 1]; + float norm_error = 0.0; + float preemp_rms = 0.0; + +#define RELEASE_MEMORY() { \ + delete [] lpc; \ + delete [] old_lpc; \ + delete [] delta_lpc; \ + } + + if (!lp.ComputeLpc(order, noise_floor_, frame_size, &(input.front()), + old_lpc, NULL, NULL, &norm_error, &preemp_rms, + preemphasis_)) { + RELEASE_MEMORY(); + return false; + } + for (int32_t i = 0; i <= order; ++i) { + delta_lpc[i] = 0.0; + (*output)[i] = 0.0; + } + float old_gain = LpcDcGain(old_lpc, order); + float new_gain = 1.0; + int32_t n_to_filter = (frame_size / 2) - order; // How many samples + // to process before + // computing the next + // LPC frame. + int32_t input_p = 0; // Where to get the next frame for LPC analysis + int32_t output_p = order; // where to store output samples. + int32_t proc_p = 0; // Where to pick up samples for input to the filter + + // Main processing loop: + // Compute a new frame of LPC + // Compute the DC gain for the new LPC + // Compute delta DC gain. + // Compute the LPC deltas. + // For each point in the frame: + // Use old_lpc to produce an output point. + // Update the old LPCs and the DC gain + // As soon as the center of the current frame is reached, compute + // the LPC for the next frame. + for ( ; n_frames > 0; --n_frames, input_p += frame_step, + n_to_filter = frame_step) { + if (!lp.ComputeLpc(order, noise_floor_, frame_size, + (&(input.front())) + input_p, lpc, NULL, NULL, + &norm_error, &preemp_rms, preemphasis_)) { + RELEASE_MEMORY(); + return false; + } + new_gain = LpcDcGain(lpc, order); + float delta_gain = (new_gain - old_gain) / n_to_filter; + MakeDeltas(old_lpc, lpc, order+1, n_to_filter, delta_lpc); + for (int32_t sample = 0; sample < n_to_filter; ++sample, ++proc_p, + ++output_p) { + float sum = 0.0; + int32_t mem = proc_p; + for (int32_t k = order; k > 0; --k, ++mem) { + sum += (old_lpc[k] * input[mem]); + old_lpc[k] += delta_lpc[k]; + } + sum += input[mem]; // lpc[0] is always 1.0 + (*output)[output_p] = sum / old_gain; + old_gain += delta_gain; + } + } + RELEASE_MEMORY(); + return true; +} + +// Note that GetResidualPulses assumes the LPC residual is in the +// "correct" polarity, with the GCI pulses of interest being negative +// pulses with a gradual fall and an abrupt rise. +void EpochTracker::GetResidualPulses(void) { + int32_t peak_ind = RoundUp(peak_delay_ * sample_rate_); + int32_t skew_ind = RoundUp(skew_delay_ * sample_rate_); + float min_peak = -1.0; // minimum value that will be considered as a peak + int32_t limit = norm_residual_.size() - peak_ind; + resid_peaks_.resize(0); + peaks_debug_.resize(residual_.size()); + for (size_t i = 0; i < peaks_debug_.size(); ++i) { + peaks_debug_[i] = 0.0; + } + for (int32_t i = peak_ind; i < limit; ++i) { + float val = norm_residual_[i]; + if (val > min_peak) { + continue; + } + if ((norm_residual_[i-1] > val) && (val <= norm_residual_[i+1])) { + float vm_peak = norm_residual_[i - peak_ind]; + float vp_peak = norm_residual_[i + peak_ind]; + if ((vm_peak < val) || (vp_peak < val)) { + continue; + } + float vm_skew = norm_residual_[i - skew_ind]; + float vp_skew = norm_residual_[i + skew_ind]; + float sharp = (0.5 * (vp_peak + vm_peak)) - val; + float skew = -(vm_skew - vp_skew); + ResidPeak p; + p.resid_index = i; + float time = static_cast(i) / sample_rate_; + p.frame_index = RoundUp(time / internal_frame_interval_); + if (p.frame_index >= n_feature_frames_) { + p.frame_index = n_feature_frames_ - 1; + } + p.peak_quality = (-val * peak_val_wt_) + (skew * peak_skew_wt_) + + (sharp * peak_prominence_wt_); + if (p.peak_quality < peak_quality_floor_) { + p.peak_quality = peak_quality_floor_; + } + resid_peaks_.push_back(p); + peaks_debug_[i] = p.peak_quality; + } + } +} + + +void EpochTracker::GetVoiceTransitionFeatures(void) { + int32_t frame_offset = RoundUp(0.5 * time_span_ / internal_frame_interval_); + if (frame_offset <= 0) { + frame_offset = 1; + } + voice_onset_prob_.resize(n_feature_frames_); + voice_offset_prob_.resize(n_feature_frames_); + int32_t limit = n_feature_frames_ - frame_offset; + for (int32_t frame = frame_offset; frame < limit; ++frame) { + float delta_rms = (bandpassed_rms_[frame + frame_offset] - + bandpassed_rms_[frame - frame_offset]) / level_change_den_; + if (delta_rms > 1.0) { + delta_rms = 1.0; + } else { + if (delta_rms < -1.0) { + delta_rms = -1.0; + } + } + float prob_onset = delta_rms; + float prob_offset = -prob_onset; + if (prob_onset > 1.0) { + prob_onset = 1.0; + } else { + if (prob_onset < 0.0) { + prob_onset = 0.0; + } + } + if (prob_offset > 1.0) { + prob_offset = 1.0; + } else { + if (prob_offset < 0.0) { + prob_offset = 0.0; + } + } + voice_onset_prob_[frame] = prob_onset; + voice_offset_prob_[frame] = prob_offset; + } + // Just set the onset and offset probs to zero in the end zones. + for (int32_t frame = 0; frame < frame_offset; ++frame) { + int32_t bframe = n_feature_frames_ - 1 - frame; + voice_onset_prob_[frame] = voice_offset_prob_[frame] = 0.0; + voice_onset_prob_[bframe] = voice_offset_prob_[bframe] = 0.0; + } +} + + +void EpochTracker::GetRmsVoicingModulator(void) { + float min_val = bandpassed_rms_[0]; + float max_val = min_val; + + prob_voiced_.resize(bandpassed_rms_.size()); + // Find the max and min over the whole RMS array. Scale and offset + // the RMS values to all fall in th range of 0.0 to 1.0. + for (size_t i = 1; i < bandpassed_rms_.size(); ++i) { + float val = bandpassed_rms_[i]; + if (val < min_val) { + min_val = val; + } else { + if (val > max_val) { + max_val = val; + } + } + } + if (min_val < min_rms_db_) { + min_val = min_rms_db_; + } + float range = max_val - min_val; + if (range < 1.0) { + range = 1.0; + } + for (size_t i = 0; i < bandpassed_rms_.size(); ++i) { + prob_voiced_[i] = (bandpassed_rms_[i] - min_val) / range; + if (prob_voiced_[i] < 0.0) { + prob_voiced_[i] = 0.0; + } + } +} + + +int32_t EpochTracker::FindNccfPeaks(const std::vector& input, float thresh, + std::vector* output) { + int32_t limit = input.size() - 1; + uint32_t n_peaks = 0; + float max_val = 0.0; + int16_t max_index = 1; + int16_t max_out_index = 0; + output->resize(0); + for (int16_t i = 1; i < limit; ++i) { + float val = input[i]; + if ((val > thresh) && (val > input[i-1]) && (val >= input[i+1])) { + if (val > max_val) { + max_val = val; + max_out_index = n_peaks; + max_index = i; + } + n_peaks++; + output->push_back(i); + } + } + // Be sure the highest peak is the first one in the array. + if ((n_peaks > 1) && (max_out_index > 0)) { + int16_t hold = (*output)[0]; + (*output)[0] = (*output)[max_out_index]; + (*output)[max_out_index] = hold; + } else { + if (n_peaks <= 0) { + n_peaks = 1; + output->push_back(max_index); + } + } + return n_peaks; +} + + +void EpochTracker::CrossCorrelation(const std::vector& data, int32_t start, + int32_t first_lag, int32_t n_lags, + int32_t size, std::vector* corr) { + const float* input = (&(data.front())) + start; + corr->resize(n_lags); + float energy = 0.0; // Zero-lag energy part of the normalizer. + for (int32_t i = 0; i < size; ++i) { + energy += input[i] * input[i]; + } + if (energy == 0.0) { // Bail out if no energy is found. + for (int32_t i = 0; i < n_lags; ++i) { + (*corr)[i] = 0.0; + } + return; + } + int32_t limit = first_lag + size; + double lag_energy = 0.0; // Energy at the period hypothesis lag. + for (int32_t i = first_lag; i < limit; ++i) { + lag_energy += input[i] * input[i]; + } + int32_t last_lag = first_lag + n_lags; + int32_t oind = 0; // Index for storing output values. + for (int32_t lag = first_lag; lag < last_lag; ++lag, ++oind) { + float sum = 0.0; + int32_t lag_ind = lag; + for (int32_t i = 0; i < size; ++i, ++lag_ind) { + sum += input[i] * input[lag_ind]; + } + if (lag_energy <= 0.0) + lag_energy = 1.0; + (*corr)[oind] = sum / sqrt(energy * lag_energy); + lag_energy -= input[lag] * input[lag]; // Discard old sample. + lag_energy += input[lag_ind] * input[lag_ind]; // Pick up the new sample. + } + return; +} + + +void EpochTracker::GetPulseCorrelations(float window_dur, float peak_thresh) { + first_nccf_lag_ = RoundUp(sample_rate_ / max_f0_search_); + int32_t max_lag = RoundUp(sample_rate_ / min_f0_search_); + n_nccf_lags_ = max_lag - first_nccf_lag_; + int32_t window_size = RoundUp(window_dur * sample_rate_); + int32_t half_wind = window_size / 2; + int32_t frame_size = window_size + max_lag; + + std::vector mixture; + mixture.resize(residual_.size()); + const float kMinCorrelationStep = 0.001; // Pulse separation + // before computing new + // correlation values. + const float kResidFract = 0.7; // Fraction of the residual to use. + const float kPcmFract = 1.0 - kResidFract; // Fraction of the input to use. + for (size_t i = 0; i < residual_.size(); ++i) { + mixture[i] = (kResidFract * residual_[i]) + (kPcmFract * signal_[i]); + } + + int32_t min_step = RoundUp(sample_rate_ * kMinCorrelationStep); + int32_t old_start = - (2.0 * min_step); + for (size_t peak = 0; peak < resid_peaks_.size(); ++peak) { + int32_t start = resid_peaks_[peak].resid_index - half_wind; + if (start < 0) { + start = 0; + } + size_t end = start + frame_size; + if ((end >= mixture.size()) || ((start - old_start) < min_step)) { + resid_peaks_[peak].nccf = resid_peaks_[peak - 1].nccf; + resid_peaks_[peak].nccf_periods = resid_peaks_[peak - 1].nccf_periods; + } else { + CrossCorrelation(mixture, start, first_nccf_lag_, n_nccf_lags_, + window_size, &(resid_peaks_[peak].nccf)); + FindNccfPeaks(resid_peaks_[peak].nccf, peak_thresh, + &(resid_peaks_[peak].nccf_periods)); + // Turn the peak indices from FindNccfPeaks into NCCF period hyps. + for (size_t i = 0; i < resid_peaks_[peak].nccf_periods.size(); ++i) { + resid_peaks_[peak].nccf_periods[i] += first_nccf_lag_; + } + old_start = start; + } + } +} + + +void EpochTracker::Window(const std::vector& input, int32_t offset, size_t size, + float* output) { + if (size != window_.size()) { + window_.resize(size); + float arg = 2.0 * M_PI / size; + for (size_t i = 0; i < size; ++i) { + window_[i] = 0.5 - (0.5 * cos((i + 0.5) * arg)); + } + } + const float* data = (&(input.front())) + offset; + for (size_t i = 0; i < size; ++i) { + output[i] = data[i] * window_[i]; + } +} + + +bool EpochTracker::GetBandpassedRmsSignal(const std::vector& input, + float sample_rate, + float low_limit, float high_limit, + float frame_interval, + float frame_dur, + std::vector* output_rms) { + size_t frame_step = RoundUp(sample_rate * frame_interval); + size_t frame_size = RoundUp(sample_rate * frame_dur); + size_t n_frames = 1 + ((input.size() - frame_size) / frame_step); + if (n_frames < 2) { + fprintf(stderr, "input too small (%d) in GetBandpassedRmsSignal\n", + static_cast(input.size())); + output_rms->resize(0); + return false; + } + output_rms->resize(n_frames); + FFT ft(FFT::fft_pow2_from_window_size(frame_size)); + int32_t fft_size = ft.get_fftSize(); + int32_t first_bin = RoundUp(fft_size * low_limit / sample_rate); + int32_t last_bin = RoundUp(fft_size * high_limit / sample_rate); + float* re = new float[fft_size]; + float* im = new float[fft_size]; + size_t first_frame = frame_size / (2 * frame_step); + if ((first_frame * 2 * frame_step) < frame_size) { + first_frame++; + } + for (size_t frame = first_frame; frame < n_frames; ++frame) { + Window(input, (frame - first_frame) * frame_step, frame_size, re); + for (size_t i = 0; i < frame_size; ++i) { + im[i] = 0.0; + } + for (int32_t i = frame_size; i < fft_size; ++i) { + re[i] = im[i] = 0.0; + } + ft.fft(re, im); + float rms = 20.0 * + log10(1.0 + ft.get_band_rms(re, im, first_bin, last_bin)); + (*output_rms)[frame] = rms; + if (frame == first_frame) { + for (size_t bframe = 0; bframe < first_frame; ++bframe) { + (*output_rms)[bframe] = rms; + } + } + } + delete [] re; + delete [] im; + return true; +} + + +void EpochTracker::GetSymmetryStats(const std::vector& data, float* pos_rms, + float* neg_rms, float* mean) { + int32_t n_input = data.size(); + double p_sum = 0.0; + double n_sum = 0.0; + double sum = 0.0; + int32_t n_p = 0; + int32_t n_n = 0; + for (int32_t i = 0; i < n_input; ++i) { + sum += data[i]; + } + *mean = sum / n_input; + for (int32_t i = 0; i < n_input; ++i) { + double val = data[i] - *mean; + if (val > 0.0) { + p_sum += (val * val); + n_p++; + } else { + if (val < 0.0) { + n_sum += (val * val); + n_n++; + } + } + } + *pos_rms = sqrt(p_sum / n_p); + *neg_rms = sqrt(n_sum / n_n); +} + + +void EpochTracker::NormalizeAmplitude(const std::vector& input, + float sample_rate, + std::vector* output) { + int32_t n_input = input.size(); + int32_t ref_size = RoundUp(sample_rate * ref_dur_); + std::vector wind; + + output->resize(n_input); + // Just calling Window here to create a Hann window in window_. + Window(input, 0, ref_size, &(output->front())); + int32_t ref_by_2 = ref_size / 2; + int32_t frame_step = RoundUp(sample_rate * internal_frame_interval_); + int32_t limit = n_input - ref_size; + int32_t frame_limit = ref_by_2; + int32_t data_p = 0; + int32_t frame_p = 0; + double old_inv_rms = 0.0; + while (frame_p < limit) { + double ref_energy = 1.0; // to prevent divz + for (int32_t i = 0; i < ref_size; ++i) { + double val = window_[i] * input[i + frame_p]; + ref_energy += (val * val); + } + double inv_rms = sqrt(static_cast(ref_size) / ref_energy); + double delta_inv_rms = 0.0; + if (frame_p > 0) { + delta_inv_rms = (inv_rms - old_inv_rms) / frame_step; + } else { + old_inv_rms = inv_rms; + } + for (int i = 0; i < frame_limit; ++i, ++data_p) { + (*output)[data_p] = input[data_p] * old_inv_rms; + old_inv_rms += delta_inv_rms; + } + frame_limit = frame_step; + frame_p += frame_step; + } + for ( ; data_p < n_input; ++data_p) { + (*output)[data_p] = input[data_p] * old_inv_rms; + } +} + +bool EpochTracker::ComputePolarity(int *polarity) { + if (sample_rate_ <= 0.0) { + fprintf(stderr, "EpochTracker not initialized in ComputeFeatures\n"); + return false; + } + if (!GetBandpassedRmsSignal(signal_, sample_rate_, min_freq_for_rms_, + max_freq_for_rms_, internal_frame_interval_, + rms_window_dur_, &bandpassed_rms_)) { + fprintf(stderr, "Failure in GetBandpassedRmsSignal\n"); + return false; + } + if (!GetLpcResidual(signal_, sample_rate_, &residual_)) { + fprintf(stderr, "Failure in GetLpcResidual\n"); + return false; + } + float mean = 0.0; + GetSymmetryStats(residual_, &positive_rms_, &negative_rms_, &mean); + *polarity = -1; + if (positive_rms_ > negative_rms_) { + *polarity = 1; + } + return true; +} + +bool EpochTracker::ComputeFeatures(void) { + if (sample_rate_ <= 0.0) { + fprintf(stderr, "EpochTracker not initialized in ComputeFeatures\n"); + return false; + } + if (!GetBandpassedRmsSignal(signal_, sample_rate_, min_freq_for_rms_, + max_freq_for_rms_, internal_frame_interval_, + rms_window_dur_, &bandpassed_rms_)) { + fprintf(stderr, "Failure in GetBandpassedRmsSignal\n"); + return false; + } + if (!GetLpcResidual(signal_, sample_rate_, &residual_)) { + fprintf(stderr, "Failure in GetLpcResidual\n"); + return false; + } + n_feature_frames_ = bandpassed_rms_.size(); + float mean = 0.0; + GetSymmetryStats(residual_, &positive_rms_, &negative_rms_, &mean); + fprintf(stdout, "Residual symmetry: P:%f N:%f MEAN:%f\n", + positive_rms_, negative_rms_, mean); + if (positive_rms_ > negative_rms_) { + fprintf(stdout, "Inverting signal\n"); + for (size_t i = 0; i < residual_.size(); ++i) { + residual_[i] = -residual_[i]; + signal_[i] = -signal_[i]; + } + } + NormalizeAmplitude(residual_, sample_rate_, &norm_residual_); + GetResidualPulses(); + GetPulseCorrelations(correlation_dur_, correlation_thresh_); + GetVoiceTransitionFeatures(); + GetRmsVoicingModulator(); + return true; +} + + +bool EpochTracker::TrackEpochs(void) { + CreatePeriodLattice(); + DoDynamicProgramming(); + return BacktrackAndSaveOutput(); +} + + +void EpochTracker::CreatePeriodLattice(void) { + int32_t low_period = RoundUp(sample_rate_ / max_f0_search_); + int32_t high_period = RoundUp(sample_rate_ / min_f0_search_); + int32_t total_cands = 0; + + // For each pulse in the normalized residual... + for (size_t peak = 0; peak < resid_peaks_.size(); ++peak) { + size_t frame_index = resid_peaks_[peak].frame_index; + size_t resid_index = resid_peaks_[peak].resid_index; + int32_t min_period = resid_index + low_period; + int32_t max_period = resid_index + high_period; + float lowest_cost = 1.0e30; + float time = resid_index / sample_rate_; + int32_t best_nccf_period = resid_peaks_[peak].nccf_periods[0]; + float best_cc_val = + resid_peaks_[peak].nccf[best_nccf_period - first_nccf_lag_]; + best_corr_.push_back(time); + best_corr_.push_back(best_cc_val); + EpochCand* uv_cand = new EpochCand; // pre-allocate an unvoiced candidate. + uv_cand->voiced = false; + uv_cand->start_peak = peak; + uv_cand->cost_sum = 0.0; + uv_cand->local_cost = 0.0; + uv_cand->best_prev_cand = -1; + int32_t next_cands_created = 0; + // For each of the next residual pulses in the search range... + for (size_t npeak = peak + 1; npeak < resid_peaks_.size(); ++npeak) { + int32_t iperiod = resid_peaks_[npeak].resid_index - resid_index; + if (resid_peaks_[npeak].resid_index >= min_period) { + float fperiod = iperiod; + // Find the NCCF period that most closely matches. + int32_t cc_peak = 0; + float min_period_diff = fabs(log(fperiod / best_nccf_period)); + for (size_t cc_peak_ind = 1; + cc_peak_ind < resid_peaks_[peak].nccf_periods.size(); + ++cc_peak_ind) { + int32_t nccf_period = resid_peaks_[peak].nccf_periods[cc_peak_ind]; + float test_diff = fabs(log(fperiod / nccf_period)); + if (test_diff < min_period_diff) { + min_period_diff = test_diff; + cc_peak = cc_peak_ind; + } + } + // Generate a forward-period candidate. Grade the candidate + // on closeness to a NCCF period hyp, value of the NCCF, + // values of the candidate endpoint peaks. + EpochCand* v_cand = new EpochCand; + v_cand->voiced = true; + v_cand->period = iperiod; + int32_t cc_index = iperiod - first_nccf_lag_; + float cc_value = 0.0; + // If this period is in the normal search range, retrieve the + // actual NCCF value for that lag. + if ((cc_index >= 0) && (cc_index < n_nccf_lags_)) { + cc_value = resid_peaks_[peak].nccf[cc_index]; + } else { // punt and use the "closest" nccf peak + int32_t peak_cc_index = resid_peaks_[peak].nccf_periods[cc_peak] - + first_nccf_lag_; + cc_value = resid_peaks_[peak].nccf[peak_cc_index]; + } + float per_dev_cost = period_deviation_wt_ * min_period_diff; + float level_cost = level_wt_ * (1.0 - prob_voiced_[frame_index]); + float period_cost = fperiod * period_wt_; + float peak_qual_cost = peak_quality_wt_ / + (resid_peaks_[npeak].peak_quality + resid_peaks_[peak].peak_quality); + float local_cost = (1.0 - cc_value) + per_dev_cost + peak_qual_cost + + level_cost + period_cost + reward_; + v_cand->local_cost = local_cost; + if (local_cost < lowest_cost) { + lowest_cost = local_cost; + // Evaluate this best voiced period as an unvoiced + // hypothesis. (There are always plenty of poor + // voiced candidates!) + uv_cand->period = iperiod; + level_cost = level_wt_ * prob_voiced_[frame_index]; + uv_cand->local_cost = (nccf_uv_peak_wt_ * cc_value) + + level_cost + unvoiced_cost_ + reward_; + uv_cand->end_peak = npeak; + uv_cand->closest_nccf_period = + resid_peaks_[peak].nccf_periods[cc_peak]; + } + v_cand->start_peak = peak; + v_cand->end_peak = npeak; + v_cand->closest_nccf_period = resid_peaks_[peak].nccf_periods[cc_peak]; + v_cand->cost_sum = 0.0; + v_cand->best_prev_cand = -1; + resid_peaks_[peak].future.push_back(v_cand); + resid_peaks_[npeak].past.push_back(v_cand); + total_cands++; + next_cands_created++; + if (resid_peaks_[npeak].resid_index >= max_period) { + break; // Exit the search only after at least one peak has + // been found, even if it is necessary to go beyond + // the nominal maximum period. + } + } // end if this period is >= minimum search period. + } // end for each next pulse in the global period-search range. + // Install the unvoiced candidate for this pulse. + if (next_cands_created) { // Register the unvoiced hyp iff there + // was at least one voiced hyp. + resid_peaks_[peak].future.push_back(uv_cand); + resid_peaks_[uv_cand->end_peak].past.push_back(uv_cand); + total_cands++; + } else { + delete uv_cand; + } + // Now all residual-pulse period hyps that start at the current + // pulse have been generated. + + // If this pulse is one of the first few in the residual that had + // no possible preceeding periods, mark it as an origin. + if (resid_peaks_[peak].past.size() == 0) { // Is this pulse an origin? + for (size_t pp = 0; pp < resid_peaks_[peak].future.size(); ++pp) { + resid_peaks_[peak].future[pp]->cost_sum = + resid_peaks_[peak].future[pp]->local_cost; + resid_peaks_[peak].future[pp]->best_prev_cand = -1; + } + } else { // There are previous period hyps to consider... + // Check if at least one UV hyp is included in the period hyps + // that end on this peak. If there are none, generate one by + // cloning the best voiced hyp in the collection, but score it + // as unvoiced. + int32_t uv_hyps_found = 0; + float lowest_cost = resid_peaks_[peak].past[0]->local_cost; + size_t lowest_index = 0; + for (size_t pcand = 0; pcand < resid_peaks_[peak].past.size(); ++pcand) { + if (!resid_peaks_[peak].past[pcand]->voiced) { + uv_hyps_found++; + } else { + if (resid_peaks_[peak].past[pcand]->local_cost < lowest_cost) { + lowest_index = pcand; + lowest_cost = resid_peaks_[peak].past[pcand]->local_cost; + } + } + } + if (!uv_hyps_found) { // clone an UV hyp from the best V hyp found. + size_t start_peak = resid_peaks_[peak].past[lowest_index]->start_peak; + EpochCand* uv_cand = new EpochCand; + uv_cand->voiced = false; + uv_cand->start_peak = start_peak; + uv_cand->end_peak = peak; + uv_cand->period = resid_peaks_[peak].past[lowest_index]->period; + uv_cand->closest_nccf_period = + resid_peaks_[peak].past[lowest_index]->closest_nccf_period; + uv_cand->cost_sum = 0.0; + uv_cand->local_cost = 0.0; + uv_cand->best_prev_cand = -1; + float llevel_cost = level_wt_ * + prob_voiced_[resid_peaks_[start_peak].frame_index]; + int32_t lcc_index = uv_cand->period - first_nccf_lag_; + float lcc_value = 0.0; + // If this period is in the normal search range, retrieve the + // actual NCCF value for that lag. + if ((lcc_index >= 0) && (lcc_index < n_nccf_lags_)) { + lcc_value = resid_peaks_[start_peak].nccf[lcc_index]; + } else { + int32_t peak_cc_index = uv_cand->closest_nccf_period - first_nccf_lag_; + lcc_value = resid_peaks_[start_peak].nccf[peak_cc_index]; + } + uv_cand->local_cost = (nccf_uv_peak_wt_ * lcc_value) + llevel_cost + + unvoiced_cost_ + reward_; + resid_peaks_[start_peak].future.push_back(uv_cand); + resid_peaks_[peak].past.push_back(uv_cand); + total_cands++; + } + } + } // end of the first pass at all pulses in the residual. + // All forward period hypotheses that start on all residual pulses + // in the signal have now been generated, and both voiced and + // unvoiced continuity throughout the lattice of hyps have been + // assured. +} + + +void EpochTracker::DoDynamicProgramming(void) { + // Perform the dynamic programming iterations over all pulses in + // the residual. + // For each pulse in the residual.... + for (size_t peak = 0; peak < resid_peaks_.size(); ++peak) { + if (resid_peaks_[peak].past.size() == 0) { // Is this peak an origin? + continue; + } + // For each forward period hypothesis starting at this pulse... + for (size_t fhyp = 0; fhyp < resid_peaks_[peak].future.size(); ++fhyp) { + float min_cost = 1.0e30; // huge + size_t min_index = 0; + float forward_period = resid_peaks_[peak].future[fhyp]->period; + // For each of the previous period hyps ending on this pulse... + for (size_t phyp = 0; phyp < resid_peaks_[peak].past.size(); ++phyp) { + float sum_cost = 0.0; + // There are 4 voicing hyps to consider: V->V V->UV UV->V UV->UV + if (resid_peaks_[peak].future[fhyp]->voiced && + resid_peaks_[peak].past[phyp]->voiced) { // v->v + float f_trans_cost = freq_trans_wt_ * + fabs(log(forward_period / resid_peaks_[peak].past[phyp]->period)); + sum_cost = f_trans_cost + resid_peaks_[peak].past[phyp]->cost_sum; + } else { + if (resid_peaks_[peak].future[fhyp]->voiced && + !resid_peaks_[peak].past[phyp]->voiced) { // uv->v + float v_transition_cost = voice_transition_factor_ * + (1.0 - voice_onset_prob_[resid_peaks_[peak].frame_index]); + sum_cost = resid_peaks_[peak].past[phyp]->cost_sum + + v_transition_cost; + } else { + if ((!resid_peaks_[peak].future[fhyp]->voiced) && + resid_peaks_[peak].past[phyp]->voiced) { // v->uv + float v_transition_cost = voice_transition_factor_ * + (1.0 - voice_offset_prob_[resid_peaks_[peak].frame_index]); + sum_cost = resid_peaks_[peak].past[phyp]->cost_sum + + v_transition_cost; + } else { // UV->UV + sum_cost = resid_peaks_[peak].past[phyp]->cost_sum; + } + } + } + if (sum_cost < min_cost) { + min_cost = sum_cost; + min_index = phyp; + } + } // end for each previous period hyp + resid_peaks_[peak].future[fhyp]->cost_sum = + resid_peaks_[peak].future[fhyp]->local_cost + min_cost; + resid_peaks_[peak].future[fhyp]->best_prev_cand = min_index; + } // end for each foreward period hyp + } // end for each pulse in the residual signal. + // Here ends the dynamic programming. +} + + +bool EpochTracker::BacktrackAndSaveOutput(void) { + if (resid_peaks_.size() == 0) { + fprintf(stderr, "Can't backtrack with no residual peaks\n"); + return false; + } + // Now find the best period hypothesis at the end of the signal, + // and backtrack from there. + float min_cost = 1.0e30; + int32_t min_index = 0; + // First, find a terminal peak which is the end of more than one + // period candidate. + size_t end = 0; + for (size_t peak = resid_peaks_.size() - 1; peak > 0; --peak) { + if ((resid_peaks_[peak].past.size() > 1)) { + for (size_t ind = 0; ind < resid_peaks_[peak].past.size(); ++ind) { + if (resid_peaks_[peak].past[ind]->cost_sum < min_cost) { + min_cost = resid_peaks_[peak].past[ind]->cost_sum; + min_index = ind; + } + } + end = peak; + break; + } + } + if (end == 0) { + fprintf(stderr, "No terminal peak found in DynamicProgramming\n"); + return false; + } + output_.clear(); + // Backtrack through the best pointers to retrieve the optimum + // period and voicing candidates. Save the GCI and voicing + // estimates. + while (1) { + int32_t start_peak = resid_peaks_[end].past[min_index]->start_peak; + TrackerResults tr; + tr.resid_index = resid_peaks_[start_peak].resid_index; + if (resid_peaks_[end].past[min_index]->voiced) { + float nccf_period = + resid_peaks_[end].past[min_index]->closest_nccf_period; + // TODO(dtalkin) If the closest NCCF period is more than epsilon + // different from the inter-pulse interval, use the inter-pulse + // interval instead. + tr.f0 = sample_rate_ / nccf_period; + tr.voiced = true; + } else { + tr.f0 = 0.0; + tr.voiced = false; + } + int32_t cc_index = resid_peaks_[end].past[min_index]->period - + first_nccf_lag_; + // If this period is in the normal search range, retrieve the + // actual NCCF value for that lag. + if ((cc_index >= 0) && (cc_index < n_nccf_lags_)) { + tr.nccf_value = resid_peaks_[start_peak].nccf[cc_index]; + } else { + int32_t peak_cc_index = + resid_peaks_[end].past[min_index]->closest_nccf_period - + first_nccf_lag_; + tr.nccf_value = resid_peaks_[start_peak].nccf[peak_cc_index]; + } + output_.push_back(tr); + size_t new_end = resid_peaks_[end].past[min_index]->start_peak; + min_index = resid_peaks_[end].past[min_index]->best_prev_cand; + if (min_index < 0) { // Has an origin pulse been reached? + break; + } + end = new_end; + } + // NOTE: The output_ array is in reverse time order! + return true; +} + + +void EpochTracker::GetFilledEpochs(float unvoiced_pm_interval, + std::vector* times, + std::vector* voicing) { + times->clear(); + voicing->clear(); + float final_time = norm_residual_.size() / sample_rate_; + int32_t limit = output_.size() - 1; + int32_t i = limit; + // Produce the output in normal time order. + while (i >= 0) { + int32_t i_old = i; + float time = output_[i].resid_index / sample_rate_; + // Note that the pulse locations of both the beginning and end + // of any voiced period are of interest. + if (output_[i].voiced || ((i < limit) && (output_[i+1].voiced))) { + times->push_back(time); + voicing->push_back(1); + i--; + } + if (i == limit) { + time = 0.0; + } + if ((i > 0) && (!output_[i].voiced) && (time < final_time)) { + for ( ; i > 0; --i) { + if (output_[i].voiced) { + break; + } + } + float next_time = final_time; + int32_t fill_ind = 1; + if (i > 0) { + next_time = (output_[i].resid_index / sample_rate_) - + (1.0 / max_f0_search_); + } + float now = time + (fill_ind * unvoiced_pm_interval); + while (now < next_time) { + times->push_back(now); + voicing->push_back(0); + fill_ind++; + now = time + (fill_ind * unvoiced_pm_interval); + } + } + if (i == i_old) { + i--; + } + } +} + + +bool EpochTracker::ResampleAndReturnResults(float resample_interval, + std::vector* f0, + std::vector* correlations) { + if ((sample_rate_ <= 0.0) || (output_.size() == 0)) { + fprintf(stderr, + "Un-initialized EpochTracker or no output_ in ResampleAndReturnF0\n"); + return false; + } + if (resample_interval <= 0.0) { + fprintf(stderr, "resample_interval <= 0.0 in ResampleAndReturnF0\n"); + return false; + } + float last_time = (output_[0].resid_index / sample_rate_) + endpoint_padding_; + int32_t n_frames = RoundUp(last_time / resample_interval); + f0->resize(0); + correlations->resize(0); + f0->insert(f0->begin(), n_frames, 0.0); + correlations->insert(correlations->begin(), n_frames, 0.0); + int32_t limit = output_.size() - 1; + int32_t prev_frame = 0; + float prev_f0 = output_[limit].f0; + float prev_corr = output_[limit].nccf_value; + for (int32_t i = limit; i >= 0; --i) { + int32_t frame = RoundUp(output_[i].resid_index / + (sample_rate_ * resample_interval)); + (*f0)[frame] = output_[i].f0; + (*correlations)[frame] = output_[i].nccf_value; + if ((frame - prev_frame) > 1) { + for (int32_t fr = prev_frame + 1; fr < frame; ++fr) { + (*f0)[fr] = prev_f0; + (*correlations)[fr] = prev_corr; + } + } + prev_frame = frame; + prev_corr = output_[i].nccf_value; + prev_f0 = output_[i].f0; + } + for (int32_t frame = prev_frame; frame < n_frames; ++frame) { + (*f0)[frame] = prev_f0; + (*correlations)[frame] = prev_corr; + } + return true; +} + + +bool EpochTracker::WriteDebugData(const std::vector& data, + const std::string& extension) { + if (debug_name_.empty()) { + return true; + } + std::string filename = debug_name_ + "." + extension; + if (data.size() == 0) { + fprintf(stdout, "Data size==0 for %s in WriteDebugData\n", + filename.c_str()); + return false; + } + FILE* out = fopen(filename.c_str(), "w"); + if (!out) { + fprintf(stderr, "Can't open %s for debug output\n", filename.c_str()); + return false; + } + size_t written = fwrite(&(data.front()), sizeof(data.front()), + data.size(), out); + fclose(out); + if (written != data.size()) { + fprintf(stderr, "Problems writing debug data (%d %d)\n", + static_cast(written), static_cast(data.size())); + return false; + } + return true; +} + +bool EpochTracker::WriteDiagnostics(const std::string& file_base) { + if (!file_base.empty()) { + set_debug_name(file_base); + } + WriteDebugData(signal_, "pcm"); + WriteDebugData(residual_, "resid"); + WriteDebugData(norm_residual_, "nresid"); + WriteDebugData(bandpassed_rms_, "bprms"); + WriteDebugData(voice_onset_prob_, "onsetp"); + WriteDebugData(voice_offset_prob_, "offsetp"); + WriteDebugData(peaks_debug_, "pvals"); + WriteDebugData(prob_voiced_, "pvoiced"); + // best_corr_ is only available after CreatePeriodLattice. + WriteDebugData(best_corr_, "bestcorr"); + // NOTE: if WriteDiagnostics is called before the + // DynamicProgramming, there will be nothing in output_. + if ((!debug_name_.empty()) && (output_.size() > 2)) { + std::string pm_name = debug_name_ + ".pmlab"; + FILE* pmfile = fopen(pm_name.c_str(), "w"); + fprintf(pmfile, "#\n"); + std::vector f0; + int32_t limit = output_.size() - 1; + // Produce debug output in normal time order. + for (int32_t i = limit; i >= 0; --i) { + float time = output_[i].resid_index / sample_rate_; + // Note that the pulse locations of both the beginning and end + // of any voiced period are of interest. + if (output_[i].voiced || ((i < limit) && (output_[i+1].voiced))) { + fprintf(pmfile, "%f blue \n", time); + } else { + fprintf(pmfile, "%f red \n", time); + } + f0.push_back(time); + f0.push_back(output_[i].f0); + f0.push_back(output_[i].nccf_value); + } + fclose(pmfile); + WriteDebugData(f0, "f0ap"); + } + return true; +} diff --git a/REAPER/epoch_tracker/epoch_tracker.h b/REAPER/epoch_tracker/epoch_tracker.h new file mode 100644 index 0000000000000000000000000000000000000000..22d7a20111f1339ac94e20402676e2f13e77856c --- /dev/null +++ b/REAPER/epoch_tracker/epoch_tracker.h @@ -0,0 +1,478 @@ +/* +Copyright 2015 Google Inc. All rights reserved. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ +// Author: dtalkin@google.com (David Talkin) + +// EpochTracker estimates the location of glottal closure instants +// (GCI), also known as "epochs" from digitized acoustic speech +// signals. It simultaneously estimates the local fundamental +// frequency (F0) and voicing state of the speech on a per-epoch +// basis. Various output methods are available for retrieving the +// results. +// +// The processing stages are: +// * Optionally highpass the signal at 80 Hz to remove rumble, etc. +// * Compute the LPC residual, obtaining an approximation of the +// differentiated glottal flow. +// * Normalize the amplitude of the residual by a local RMS measure. +// * Pick the prominent peaks in the glottal flow, and grade them by +// peakiness, skew and relative amplitude. +// * Compute correlates of voicing to serve as pseudo-probabilities +// of voicing, voicing onset and voicing offset. +// * For every peak selected from the residual, compute a normalized +// cross-correlation function (NCCF) of the LPC residual with a +// relatively short reference window centered on the peak. +// * For each peak in the residual, hypothesize all following peaks +// within a specified F0 seaqrch range, that might be the end of a +// period starting on that peak. +// * Grade each of these hypothesized periods on local measures of +// "voicedness" using the NCCF and the pseudo-probability of voicing +// feature. +// * Generate an unvoiced hypothesis for each period and grade it +// for "voicelessness". +// * Do a dynamic programming iteration to grade the goodness of +// continuity between all hypotheses that start on a peak and +// those that end on the same peak. For voiced-voiced +// connections add a cost for F0 transitions. For +// unvoiced-voiced and voiced-unvoiced transitions add a cost +// that is modulated by the voicing onset or offset inverse +// pseudo-probability. Unvoiced-unvoiced transitions incur no cost. +// * Backtrack through the lowest-cost path developed during the +// dynamic-programming stage to determine the best peak collection +// in the residual. At each voiced peak, find the peak in the NCCF +// (computed above) that corresponds to the duration closest to the +// inter-peak interval, and use that as the inverse F0 for the +// peak. +// +// A typical calling sequence might look like: +/* ============================================================== + EpochTracker et; + et.Init(); // Prepare the instance for, possibly, multiple calls. + Track* f0; // for returning the F0 track + Track* pm; // for returning the epoch track + if (!et.ComputeEpochs(my_input_waveform, &pm, &f0)) { + exit(-2); // problems in the epoch computations + } + DoSomethingWithTracks(f0, pm); + delete f0; + delete pm; + ============================================================== */ +// +// NOTE: Any client of this code inherits the Google command-line flags +// defined in epoch_tracker.cc. These flags are processed in the Init() +// method, and override both default and params-sourced settings. +// +// As currently written, this is a batch process. Very little has +// been done to conserve either memory or CPU. The aim was simply to +// make the best possible tracker. As will be seen in the +// implementation, there are many parameters that can be adjusted to +// influence the processing. It is very unlikely that the best +// parameter setting is currently expressed in the code! However, the +// performance, as written, appears to be quite good on a variety of voices. + +#ifndef _EPOCH_TRACKER_H_ +#define _EPOCH_TRACKER_H_ + +#include +#include +#include +#include + +static const float kExternalFrameInterval = 0.005; +static const float kInternalFrameInterval = 0.002; +static const float kMinF0Search = 40.0; +static const float kMaxF0Search = 500.0; +static const float kUnvoicedPulseInterval = 0.01; +static const float kUnvoicedCost = 0.9; +static const bool kDoHighpass = true; +static const bool kDoHilbertTransform = false; +static const char kDebugName[] = ""; + + +class EpochTracker { + public: + EpochTracker(void); + + virtual ~EpochTracker(void); + + // Set the default operating parameters of the tracker. + void SetParameters(void); + + // NOTE: The following methods are exposed primarily for algorithm + // development purposes, where EpochTracker is used in a developer's test + // harness. These need not/should not be called directly in normal use. + + // Prepare the instance for use. Some sanity check is made on the + // parameters, and the instance is reset so it can be reused + // multiple times by simply calling Init() for each new input + // signal. frame_interval determines the framing for some of the + // internal feature computations, and for the periodic resampling of + // F0 that will occur during final tracking result output. min_ + // and max_f0_search are the bounding values, in Hz, for the F0 + // search. + // NOTE: This Init method is DEPRECATED, and is only retained to + // support legacy code. IT MAY GO AWAY SOON. This is NOT to be + // used with ComputeEpochs(). + bool Init(const int16_t* input, int32_t n_input, float sample_rate, + float min_f0_search, float max_f0_search, + bool do_highpass, bool do_hilbert_transform); + + // Set the name for various intermediate features and other signals + // that may be written to files used during debug and development of + // the algorithm. If this is set to the empty std::string, no debug + // signals will be output. + void set_debug_name(const std::string& debug_name) { + debug_name_ = debug_name; + } + + std::string debug_name(void) { return debug_name_; } + + // Compute the Hilbert transform of the signal in input, and place + // the floating-point results in output. output must be at least + // n_input samples long. TODO(dtalkin): Make these vector inputs + // and outputs. + void HilbertTransform(int16_t* input, int32_t n_input, float* output); + + // Apply a highpass filter to the signal in input. The filter + // corner frequency is corner_freq, and the duration, in seconds, of + // the Hann-truncated symmetric FIR is in fir_duration. The + // transition bandwidth is the inverse of fir_duration. The return + // value is a pointer to the filtered result, which is the same + // length as the input (n_input). It is up to the caller to free + // this returned memory. TODO(dtalkin): Make this vector I/O and + // supply the output as floats. + int16_t* HighpassFilter(int16_t* input, int32_t n_input, + float sample_rate, float corner_freq, + float fir_duration); + + // Compute the LPC residual of the speech signal in input. + // sample_rate is the rate of both the input and the residual to be + // placed in output. The order of the LPC analysis is automatically + // set to be appropriate for the sample rate, and the output is + // integrated so it approximates the derivative of the glottal flow. + bool GetLpcResidual(const std::vector& input, float sample_rate, + std::vector* output); + + // Compute the normalized cross-correlation function (NCCF) of the + // signal in data, starting at sample start. size is the number of + // samples to include in the inner product. Compute n_lags + // contiguous correlations starting at a delay of first_lag samples. + // Return the resulting n_lags correlation values in corr. Note + // that the NCCF is bounded by +-1.0. + void CrossCorrelation(const std::vector& data, int32_t start, + int32_t first_lag, int32_t n_lags, + int32_t size, std::vector* corr); + + // Compute the band-limited RMS of the signal in input, which is + // sampled at sample_rate. low_limit and high_limit are the + // frequency bounds, in Hz, within which th RMS is measured. + // frame_interval is the period of the RMS signal returned in + // output_rms. frame_dur is the duration, in seconds, of the + // Hanning window used for each measurement. + bool GetBandpassedRmsSignal(const std::vector& input, float sample_rate, + float low_limit, float high_limit, float frame_interval, + float frame_dur, std::vector* output_rms); + + // Compute the RMS of positive and negative signal values separately. + // The signal is made to be zero mean before this computation. Any + // imbalance in these measures is an indication of asymmetrical peak + // distribution, which is charactristic of the LPC residual of voiced speech. + void GetSymmetryStats(const std::vector& data, float* pos_rms, + float* neg_rms, float* mean); + + // Normalize the input signal based on a local measure of its RMS. + void NormalizeAmplitude(const std::vector& input, float sample_rate, + std::vector* output); + + // Apply a Hann weighting to the signal in input starting at + // sample index offset. The window will contain size samples, and + // the windowed signal is placed in output. + void Window(const std::vector& input, int32_t offset, size_t size, + float* output); + + // Computes signal polarity (-1 for negative, +1 for + // positive). Requires data to be initialized via Init(...). Returns + // false if there's an error. + bool ComputePolarity(int *polarity); + + // Compute NCCF, NCCF peak locations and values, bandpass RMS, + // residual, symmetry statistics (and invert residual, if necessary), + // normalized residual, residual peaks and values. Finally, generate + // the pulse working array in preparation for dynamic programming. + bool ComputeFeatures(void); + + // Write all of data to a file, wht name of which is + // debug_name_ _ "." + extension. If debug_name_ is empty, do nothing. + bool WriteDebugData(const std::vector& data, + const std::string& extension); + + // Write a collection of debugging signals to separate files with + // various, internally-defined name extensions. If file_base is not + // empty, use this as the base path for all of the files. If file + // base is empty, use debug_name_ as the base path. If both are + // empty, do nothing. + bool WriteDiagnostics(const std::string& file_base); + + // After Init, ComputeFeatures and CreatePeriodLattice have been + // successfully called, TrackEpochs should be called to do the + // actual tracking of epochs (GCI) and to estimate the corresponding + // F0. This method integrates the information from all of the + // features, including the LPC residual peaks and the NCCF values, + // to find the optimum period assignments and voicing state + // assignments over the entire signal. The results are left in + // internal storage, pending retrieval by other methods. + bool TrackEpochs(void); + + // Create a lattice of glottal period hypotheses in preparation for + // dynamic programming. This fills out most of the data fields in + // resid_peaks_. This must be called after ComputeFeatures. + void CreatePeriodLattice(void); + + // Apply the Viterbi dynamic programming algorithm to find the best + // path through the period hypothesis lattice created by + // CreatePeriodLattice. The backpointers and cumulative scores are + // left in the relevant fields in resid_peaks_. + void DoDynamicProgramming(void); + + // Backtrack through the best pointers in the period hypothesis + // lattice created by CreatePeriodLattice and processed by + // DoDynamicProgramming. The estimated GCI locations + // (epochs) and the corresponding F0 and voicing-states are placed + // in the output_ array pending retrieval using other methods. + bool BacktrackAndSaveOutput(void); + + // Resample the per-period F0 and correlation data that results from + // the tracker to a periodic signal at an interval of + // resample_interval seconds. Samples returned are those nearest in + // time to an epoch. Thus, if the resample_interval is greater than + // the local epoch interval, some epochs, and their period + // information, will be skipped. Conversely, if the + // resample_interval is less than the local epoch interval, + // measurements will be replicated as required. + bool ResampleAndReturnResults(float resample_interval, + std::vector* f0, + std::vector* correlations); + + // Convert the raw backtracking results in output_ into + // normal-time-order epoch markers. In unvoiced regions, fill with + // regularly-spaced pulses separated by unvoiced_pm_interval + // seconds. The epoch/pulse times are returned in times re the + // utterance beginning, and the corresponding voicing states in + // voicing (0=unvoiced; 1=voiced). This can only be called after + // TrackEpochs. + void GetFilledEpochs(float unvoiced_pm_interval, std::vector* times, + std::vector* voicing); + + // Setters. + void set_do_hilbert_transform(bool v) { do_hilbert_transform_ = v; } + void set_do_highpass(bool v) { do_highpass_ = v; } + void set_external_frame_interval(float v) { external_frame_interval_ = v; } + void set_unvoiced_pulse_interval(float v) { unvoiced_pulse_interval_ = v; } + void set_min_f0_search(float v) { min_f0_search_ = v; } + void set_max_f0_search(float v) { max_f0_search_ = v; } + void set_unvoiced_cost(float v) { unvoiced_cost_ = v; } + + private: + // Search the signal in norm_residual_ for prominent negative peaks. + // Grade the peaks on a combination of amplitude, "peakiness" and + // skew. (It is expected that the glottal pulses will + // have a relatively slow fall, and a rapid rise.) Place the + // selected and graded pulses in resid_peaks_. + void GetResidualPulses(void); + + // Create pseudo-probability functions in voice_onset_prob_ and + // voice_offset_prob_ that attempt to indicate the time-varying + // probability that a voice onset or offset is occurring. + // Presently, this is based solely on the derivative of the + // bandpassed RMS signal, bandpassed_rms_. + void GetVoiceTransitionFeatures(void); + + // Generate a pseudo-probability function that attempts to corespond + // to the probability that voicing is occurring. This is presently + // based solely on the bandpassed RMS signal, bandpassed_rms_. + void GetRmsVoicingModulator(void); + + // Free memory, and prepare the instance for a new signal. + void CleanUp(void); + + // Scan the signal in input searching for all local maxima that + // exceed thresh. The indices corresponding to the location of the + // peaks are placed in output. The first entry in output is always + // the location of the largest maximum found. + int32_t FindNccfPeaks(const std::vector& input, float thresh, + std::vector* output); + + // Compute the NCCF with the reference window centered on each of + // the residual pulses identified in GetResidualPulses. window_dur + // is the duration in seconds of the correlation inner product. + // After the NCCF for each residual pulse is computed, it is + // searched for local maxima that exceed peak_thresh. These peak + // locations and the full NCCF are saved in the corresponding + // elements of the resid_peaks_ array of structures. + void GetPulseCorrelations(float window_dur, float peak_thresh); + + + private: + // EpochCand stores all of the period hypotheses that can be + // generated from the peaks found in the LPC residual. It also + // maintains the cumulative path costs and backpointers generated + // during dynamic programming. + struct EpochCand { + int32_t period; // # of samples in this period candidate + float local_cost; // cost of calling this a period (or unvoiced) + float cost_sum; // cumulative cost from DP + int32_t start_peak; // index in resid_peaks_ where this period hyp starts + int32_t end_peak; // where this period ends + int32_t best_prev_cand; // backpointer used after DP + int32_t closest_nccf_period; // per. implied by the closest correlation peak + bool voiced; // hypothesized voicing state for this cand. + }; + + typedef std::vector CandList; + + // The ResidPeak stores data for each residual impulse. The array + // of these in resid_peaks_ serves as input to the dynamic + // programming search for GCI, voicing state and F0. + struct ResidPeak { + int32_t resid_index; // index into the resid_ array of this peak + int32_t frame_index; // index into the feature arrays for this peak + float peak_quality; // "goodness" measure for this peak + std::vector nccf; // the NCCF computed centered on this peak + std::vector nccf_periods; // periods implied by major peaks in nccf + CandList future; // period candidates that start on this peak + CandList past; // period candidates that end on this peak + }; + + struct TrackerResults { + bool voiced; + float f0; + int32_t resid_index; + float nccf_value; + }; + typedef std::vector TrackerOutput; + + protected: + std::vector resid_peaks_; // array of structures used to + // store the peak search lattice + TrackerOutput output_; // Array of time stamped results of the tracker. + // signal_, residual_, norm_residual and peaks_debug_ are all + // sampled at the original signal input sample_rate_. + std::vector signal_; // floating version of input speech signal + std::vector residual_; // LPC residual normalized for constant DC. + std::vector norm_residual_; // LPC residual normalized by its local RMS. + std::vector peaks_debug_; // for debug output of residual peak candidates + // bandpassed_rms_, voice_onset_prob_, voice_offset_prob_ and + // prob_voiced_ are all sampled with a period of internal_frame_interval_. + std::vector bandpassed_rms_; // RMS sampled at internal_frame_interval_ + std::vector voice_onset_prob_; // prob that a voice onset is occurring + std::vector voice_offset_prob_; // prob that a voice offset is occurring + std::vector prob_voiced_; // prob that voicing is occurring + std::vector best_corr_; // An array of best NCCF vals for all resid peaks. + std::vector window_; // Hann weighting array for Window() + float sample_rate_; // original input signal sample rate in Hz + + float positive_rms_; // RMS of all positive, non-zero samples in residual_ + float negative_rms_; // RMS of all negative, non-zero samples in residual_ + int32_t n_feature_frames_; // The number of feature frames available + // for all features computed at + // internal_frame_interval_. + int32_t first_nccf_lag_; // The index of the first correlation of the + // NCCF. This is determined by + // max_f0_search_. + int32_t n_nccf_lags_; // The number of correlations computed at each + // residual peak candidate. This is determined + // by max_f0_search_ and min_f0_search_. + std::string debug_name_; // The base path name for all debug output files. + + // Below are all of the parameters that control the functioning of + // the tracker. These are all set to default known-to-work values in + // SetParameters(). + + // Control parameters available to clients of EpochTracker. + float external_frame_interval_; // Frame interval for final output of F0. + float unvoiced_pulse_interval_; // Pulse interval in unvoiced regions + float min_f0_search_; // minimum F0 to search for (Hz) + float max_f0_search_; // maximum F0 to search for (Hz) + bool do_highpass_; // Highpass input sighal iff true. + bool do_hilbert_transform_; // Hilbert trans. input data iff true. + + // Internal feature-computation Parameters: + float internal_frame_interval_; // interval, in seconds, between frame onsets + // for the high-pass filter + float corner_frequency_; + float filter_duration_; + // for the LPC inverse filter. + float frame_duration_; // window size (sec) + float lpc_frame_interval_; // (sec) + float preemphasis_; // preemphasis for LPC analysis + float noise_floor_; // SNR in dB simulated during LPC analysis. + // for computing LPC residual peak quality. + float peak_delay_; // for measuring prominence + float skew_delay_; // for measuring shape + float peak_val_wt_; + float peak_prominence_wt_; + float peak_skew_wt_; + float peak_quality_floor_; + // for computing voice-transition pseudo-probabilities + float time_span_; // the interval (sec) centered on the + // measurement point, used to + // compute parameter deltas + float level_change_den_; // max. dB level change + // expected over time_span_ for + // bandpassed RMS + // for computing pseudo-probability of voicing + float min_rms_db_; // level floor in dB + // window size for computing amplitude-normalizing RMS + float ref_dur_; + // low and high frequency limits for bandpassed RMS used in voicing indicator + float min_freq_for_rms_; + float max_freq_for_rms_; + // duration of integrator for bandpassed RMS + float rms_window_dur_; + // window duration, in seconds, for NCCF computations + float correlation_dur_; + // ignore any NCCF peaks less than this + float correlation_thresh_; + + // Parametrs used by the dynamic-programming tracker: + // reward for inserting another period + float reward_; + // weight given to deviation of inter-pulse interval from the + // closest NCCF peak lag + float period_deviation_wt_; + // weight given to the quality of the residual peak + float peak_quality_wt_; + // cost of the unvoiced hypothesis + float unvoiced_cost_; + // cost of high NCCF values in hypothetical unvoiced regions + float nccf_uv_peak_wt_; + // weight given to period length + float period_wt_; + // weight given to the pseudo-probability of voicing feature + float level_wt_; + // weight given to period-length differences between adjacent periods. + float freq_trans_wt_; + // cost of switching between voicing states; modulated by voicing + // onset/offset probs. + float voice_transition_factor_; + + // Parameters used to generate final outputs: + // pad time in seconds to add to the last measured period during + // output of periodically-resampled data + float endpoint_padding_; +}; + + +#endif // _EPOCH_TRACKER_H_ diff --git a/REAPER/epoch_tracker/fd_filter.cc b/REAPER/epoch_tracker/fd_filter.cc new file mode 100644 index 0000000000000000000000000000000000000000..f37787aeb7dde82f067d30430fceda8e70305e5e --- /dev/null +++ b/REAPER/epoch_tracker/fd_filter.cc @@ -0,0 +1,767 @@ +/* +Copyright 2015 Google Inc. All rights reserved. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +/* FdFilter: In-Line Filter class */ +/* +Author: David Talkin (dtalkin@google.com) +*/ + +/* +This class implements a general-purpose streaming FIR filter that is +applied in the frequency domain for speed/efficiency. Using +FFT-multiply-IFFT rather than a simple time-domain convolution greatly +speeds up the computations. The longer the impulse response of the +filter, the greater the advantage of this FFT approach over +time-domain convolution. + +This class also supports sample-rate conversion. For simple +input/output rate ratios, it is also quite efficient, but becomes +rather inefficient for ratios with denominator terms greater than 5. +It therefore limits the maximum denominator value to kMaxDecimation, +and thus can only approximate rate conversions that require larger +denominator terms. For large denominator ratios, or extreme +decimation, indexed time-domain implementations can be much faster. + +All filters implemented with FdFilter are symmetric FIR, and thus have +linear phase response. The filter is implemented non-causally, so +that there is no signal delay introduced by filtering or downsampling +operations. + +See the individual methods for details of use. See fd_filter_msin.cc +for a test harness and use examples. +*/ + +#include "epoch_tracker/fd_filter.h" + +#include +#include + +#include "epoch_tracker/fft.h" + +// kIoBufferSize can be any reasonable size. +static const int kIoBufferSize = 10000; + +// kMaxDecimation sets the limit on the maximum value of the denominator in the +// ratio that approximates the sample rate ratios when rate conversion +// is done. FdFilter is really not appropriate if the ratio needs to be +// greater than about 7, because time-domain approaches are then likely to be +// faster. However, perverse or adventuresome souls might want to try +// increasing this if they have extra computer cycles to waste. +static const int kMaxDecimation = 12; + +// Constructor when FdFilter is to be used as a high- or low-pass +// filter or as a sample-rate converter. 'input_freq' is the sample +// rate of the input signal in Hz. If input_freq != corner_freq and +// do_rate_conversion is true, FdFilter is confgured to convert the +// sample rate to corner_freq using a filter of length specified by +// filter_dur. +// +// If do_rate_conversion is false, FdFilter is configured to be a +// high- or low-pass filter. In this case, corner_freq is interpreted +// as the corner frequency of the filter, and must be in the range 0 < +// corner_freq < (input_freq/2). If do_highpass is true, the filter +// will be high-pass, else, low-pass. Again, filter_dur determines +// the filter length. in all cases, the filter length is specified in +// seconds, and determines the transition band width. The band width +// is approximately 1.0/filter_dur Hz wide. +/* ******************************************************************** */ +FdFilter::FdFilter(float input_freq, float corner_freq, bool do_highpass, + float filter_dur, bool do_rate_conversion) { + FdFilterInitialize(input_freq, corner_freq, do_highpass, filter_dur, + do_rate_conversion, NULL, NULL, 0); +} + +// Constructor when FdFilter will be used to implement a filter whose +// spectral magnitude values are listed in the plain text file with +// the name specified by 'spectrum_shape'. input_freq is the sample +// rate in Hz of the input signal. The file must have the following +// format: +// +// Line 1: pow2 nMags +// Lines 2 through (nMags+1): ind val +// +// nMags must equal ((1 << pow2)/2)+1, +// pow2 is typically in the range 3 < pow2 < 15. + +// The lines in the file containing (ind, val) pairs specify the +// magnitude response of the filter uniformly sampling the spectrum +// from 0 Hz to (input_freq/2) Hz. the 'ind' column is just a line index +// to make the file easily human readable, the 'val' column contains +// (positive) magnitude scaling values. Note that values > 1.0 cause +// an increase in output signal amplitude re the input signal at the +// corresponding frequency, and have the potential to cause clipping, +// if the input signal is too energetic at those frequencies. +/* ******************************************************************** */ +FdFilter::FdFilter(float input_freq, char *spectrum_shape) { + FdFilterInitialize(input_freq, input_freq, 0, 0.01, 0, spectrum_shape, + NULL, 0); +} + +// Constructor when FdFilter will be used to implement a filter whose +// 'n_magnitudes' spectral magnitude values are in the array 'spectrum_array'. +// n_magnitudes must equal ((1 << pow2)+1) for some pow2 in the +// range 2 < pow2 < 16. The values in spectrum_array are interpreted as +// above for the 'val' column in the 'spectrum_shape' file. +/* ******************************************************************** */ +FdFilter::FdFilter(float input_freq, float *spectrum_array, int n_magnitudes) { + FdFilterInitialize(input_freq, input_freq, 0, 0.01, 0, NULL, + spectrum_array, n_magnitudes); +} + +// This is the private method that configures FdFilter to satisfy the +// requirements of the constructor. +/* ----------------------------------------------------------------------- */ +void FdFilter::FdFilterInitialize(float input_freq, float corner_freq, + bool do_highpass, float filter_dur, + bool do_rate_conversion, + char *spectrum_shape, float *spectrum_array, + int n_magnitudes) { + float beta = 0.0, *b = NULL; + float ratio_t, ratio, freq1 = input_freq; + int pow2, i; + bool do_eq_filtering = false; + bool b_allocated = true; + + insert_ = 1; + decimate_ = 1; + filter_state_ = 1; + array_leftover_ = 0; + array_index_ = 0; + array_samples_used_ = 0; + true_output_rate_ = input_freq; + + output_buffer_ = new int16_t[kIoBufferSize * 2]; + input_buffer_ = new int16_t[kIoBufferSize]; + + if (spectrum_shape || (spectrum_array && (n_magnitudes > 1))) { + do_eq_filtering = true; + } else { + if (do_rate_conversion) { + freq1 = input_freq; + } else { /* it is just a symmetric FIR */ + if (corner_freq >= (freq1 = input_freq) / 2.0) { + fprintf(stderr, + "Unreasonable corner frequency specified to filter() (%f)\n", + corner_freq); + } + } + } + + if (spectrum_shape) { + FILE *spec_stream = fopen(spectrum_shape, "r"); + if (spec_stream) { + int n_spect, ind; + char line[500]; + float fs; + if (fgets(line, 500, spec_stream)) { + int nItems = sscanf(line, "%d %d %f", &pow2, &n_spect, &fs); + if ((nItems == 3) && (fs != input_freq)) { // This should be a + // fatal error! + fprintf(stderr, + "Filter spec (%f) does not match input frequency (%f)\n", + fs, input_freq); + fprintf(stderr, + "The filtering results will probably not be what you want!\n"); + } + b = new float[n_spect]; + n_filter_coeffs_ = n_spect - 1; // n_filter_coeffs_ represents actual + // filter-kernel length, + // instead of half filter + // length when using external + // filter. + for (i = 0; i < n_spect; i++) { + if ((!fgets(line, 500, spec_stream)) || + (sscanf(line, "%d %f", &ind, &(b[i])) != 2)) { + fprintf(stderr, "Parsing error in spect ratio file %s\n", + spectrum_shape); + } + } + } else { + fprintf(stderr, "Bad format in spectrum file %s\n", + spectrum_shape); + } + fclose(spec_stream); + } else { + fprintf(stderr, "Can't open %s as a spectrum file\n", + spectrum_shape); + } + } else { + // Note: n_magnitudes MUST be ((2^k)+1) for k > 1. + if (spectrum_array && (n_magnitudes > 1)) { + n_filter_coeffs_ = n_magnitudes - 1; + int nft = n_filter_coeffs_ * 2; + pow2 = 1; + while ((1 << pow2) < nft) { + pow2++; + } + b = spectrum_array; // Note: b must not be deleted in this case! + b_allocated = false; + } else { /* it is not an eq filter */ + if (do_rate_conversion) { + /* get a ratio of integers close to desired freq. ratio. */ + ratio = corner_freq/freq1; + RationalApproximation(ratio, &insert_, &decimate_, kMaxDecimation); + ratio_t = static_cast(insert_) / decimate_; + + if (fabs(1.0 - ratio_t) < .01) { + fprintf(stderr, + "Input and output frequencies are essentially equal!\n"); + } + true_output_rate_ = ratio_t * freq1; + // if (corner_freq != true_output_rate_) { + // fprintf(stderr, + // "Warning: Output frequency obtained(%f) is not as requested(%f)\n", + // true_output_rate_, corner_freq); + // } + corner_freq = true_output_rate_; + n_filter_coeffs_ = static_cast(freq1 * insert_ * filter_dur) | 1; + if (corner_freq < freq1) + beta = (.5 * corner_freq)/(insert_ * freq1); + else + beta = .5/insert_; + } else { + beta = corner_freq/freq1; + n_filter_coeffs_ = static_cast(freq1 * filter_dur) | 1; + } + + /* Generate the symmetric FIR filter coefficients. */ + b = new float[1 + (n_filter_coeffs_ / 2)]; + MakeLinearFir(beta, &n_filter_coeffs_, b); + + if (insert_ > 1) { // Scale up filter coeffs. to maintain + // precision in output. + float fact = insert_; + for (i = n_filter_coeffs_ / 2; i >= 0; i--) b[i] *= fact; + } + } // end else it is not an eq filter. + } // end else (a spectrum shape was not specified). + + n_filter_coeffs_by2_ = n_filter_coeffs_ / 2; + + if (!do_eq_filtering) { /* Is it a simple high- or low-pass filter? */ + MirrorFilter(b, do_highpass); + int nf2 = n_filter_coeffs_ << 1; + fft_size_ = 128; + pow2 = 7; + while (nf2 > fft_size_) { + fft_size_ *= 2; + pow2++; + } + } else { // It is a filter with the magnitude response specified in b. + fft_size_ = n_filter_coeffs_ * 2; + pow2 = 2; + while ((1 << pow2) < fft_size_) + pow2++; + } + + fft_size_by2_ = fft_size_ / 2; + + x_ = new float[fft_size_]; + y_ = new float[fft_size_]; + xf_ = new float[fft_size_]; + yf_ = new float[fft_size_]; + + leftovers_ = new int16_t[fft_size_]; + max_input_ = kIoBufferSize / insert_; + output_delayed_ = new float[(2 * kIoBufferSize)+n_filter_coeffs_+fft_size_]; + + float ftscale = 1.0 / fft_size_; + fft_ = new FFT(pow2); + if (!do_eq_filtering) { + // position the filter kernel to be symmetric about time=0 + // Note that this assumes an odd number of symmetric filter coefficients. + for (i = 0; i <= n_filter_coeffs_by2_; i++) { + xf_[i] = ftscale * filter_coeffs_[i+n_filter_coeffs_by2_]; + yf_[i] = 0.0; + } + for (; i < n_filter_coeffs_; i++) { + xf_[fft_size_ - n_filter_coeffs_ + i] = ftscale * + filter_coeffs_[i - n_filter_coeffs_by2_ - 1]; + yf_[fft_size_ - n_filter_coeffs_ + i] = 0.0; + } + for (i = n_filter_coeffs_by2_; i < (fft_size_-n_filter_coeffs_by2_); i++) + xf_[i] = yf_[i] = 0.0; + fft_->fft(xf_, yf_); + } else { /* Install the magnitude response symmetrically. */ + for (i = 0; i <= n_filter_coeffs_; i++) { + xf_[i] = ftscale * b[i]; + yf_[i] = 0.0; + } + for (; i < fft_size_; i++) { + xf_[i] = xf_[fft_size_ - i]; + yf_[i] = 0.0; + } + } + /* The filter, regardless of its origin, is now in the frequency domain. */ + + if (b_allocated) { + delete [] b; + } +} + +// Destructor +/* ******************************************************************** */ +FdFilter::~FdFilter() { + delete [] input_buffer_; + delete [] output_buffer_; + delete [] x_; + delete [] y_; + delete [] xf_; + delete [] yf_; + delete [] filter_coeffs_; + delete [] leftovers_; + delete [] output_delayed_; + delete fft_; +} + + +// Given the half filter in fc, store the full symmetric kernel in +// filter_coeffs_. +/* ******************************************************************** */ +void FdFilter::MirrorFilter(float *fc, bool invert) { + float *dp1, *dp2, *dp3, sum, integral; + int i, ncoefb2; + + filter_coeffs_ = new float[n_filter_coeffs_]; + ncoefb2 = 1 + n_filter_coeffs_ / 2; + // Copy the half-filter and its mirror image into the coefficient array. + for (i = ncoefb2 - 1, dp3 = fc+ncoefb2 - 1, dp2 = filter_coeffs_, + dp1 = filter_coeffs_ + n_filter_coeffs_ - 1, integral = 0.0; i-- > 0;) { + if (!invert) { + *dp1-- = *dp2++ = *dp3--; + } else { + integral += (sum = *dp3--); + *dp1-- = *dp2++ = -sum; + } + } + if (!invert) { + *dp1 = *dp3; /* point of symmetry */ + } else { + integral *= 2; + integral += *dp3; + *dp1 = integral - *dp3; + } +} + +// This is a complex vector multiply. If the second vector (r2, i2) is +// known to be real, set 'i2' to NULL for faster computation. The +// result is returned in (r3, i3). +/* ******************************************************************** */ +void FdFilter::ComplexDotProduct(int n, float *r1, float *i1, float *r2, + float *i2, float *r3, float *i3) { + float tr1, ti1; + + /* This full complex multiply is only necessary for non-symmetric kernels */ + if (i2) { // Only supply the i2 vector if you need to do a full + // complex multiply. + while (n--) { + tr1 = (*r1 * *r2) - (*i1 * *i2); + ti1 = (*r1++ * *i2++) + (*r2++ * *i1++); + *i3++ = ti1; + *r3++ = tr1; + } + } else { + /* Can do this iff the filter is symmetric, zero phase. */ + while (n--) { + tr1 = (*r1++ * *r2); + ti1 = (*r2++ * *i1++); + *i3++ = ti1; + *r3++ = tr1; + } + } +} + +/* ******************************************************************** */ +// Process samples from 'input' array to 'output' array. 'nIn' +// contains the number of samples available in 'input'. 'maxOut' is +// the maximum number of samples that the caller allows to be +// transferred to 'output' (usually the size of 'output'). Set +// 'first' TRUE if the first sample of a new signal is in 'input'. +// Set 'last' TRUE of the last sample of the signal is in 'input' (to +// cause flushing of processing pipeline). The simplest setup for use +// of this method requires that the caller use an input buffer no +// larger than the size returned by getMaxInputSize(), and an output +// array twice the size returned by getMaxInputSize(). Then, each +// subsequent call to filterArray will use all 'input' samples, and +// will transfer all available samples to 'output'. Examples of this +// and the other case, of arbitrarily small caller buffers can be seen +// in the test harness at the end of this file. +// This method returns the number of output samples transferred to 'output'. +int FdFilter::FilterArray(int16_t *input, int nIn, bool first, bool last, + int16_t *output, int max_to_output) { + int i, j, nLeft = nIn, nOut = 0, nToGo = max_to_output; + int toRead, toWrite, available; + int16_t *p = input, *q, *r = output; + + if (first) { + filter_state_ = 1; // indicate start of new signal + array_leftover_ = 0; + array_index_ = 0; + } + if (array_leftover_) { // First, move any output remaining from the + // previous call. + int toCopy = array_leftover_; + if (toCopy > nToGo) + toCopy = nToGo; + for (i = array_index_, j = 0; j < toCopy; i++, j++) + *r++ = output_buffer_[i]; + nToGo -= toCopy; + nOut += toCopy; + array_leftover_ -= toCopy; + array_index_ = i; + } + + if (nToGo <= 0) { + array_samples_used_ = 0; // Can't process any input this time; no + // room in output array. + return max_to_output; + } + + /* Process data from array to array. */ + while (nLeft > 0) { + toRead = nLeft; + if (toRead > max_input_) + toRead = max_input_; + if (insert_ > 1) { + for (q = input_buffer_, i = 0; i < toRead; i++) { + *q++ = *p++; + for (j = 1; j < insert_; j++) + *q++ = 0; + } + } else { + for (q = input_buffer_, i = 0; i < toRead; i++) + *q++ = *p++; + } + nLeft -= toRead; + if ((nLeft <= 0) && last) + filter_state_ |= 2; // Indicate that end of signal is (also) in + // this bufferful. + FilterBuffer(toRead * insert_, &available); + filter_state_ = 0; // Clear the initialization bit, if any for the + // next iteration. + + toWrite = available; + if (toWrite > nToGo) + toWrite = nToGo; + + for (i = 0; i < toWrite; i++) + *r++ = output_buffer_[i]; + nOut += toWrite; + available -= toWrite; + if (available > 0) { // Ran out of output space; suspend processing + array_leftover_ = available; // Save the remaining output + // samples for the next call. + array_index_ = i; + array_samples_used_ = nIn - nLeft; // Record the number of input + // samples actually used. + return(nOut); + } + } + array_samples_used_ = nIn; + return(nOut); +} + +// Use after a call to filterArray() to determine the number of input +// samples actually processed. +int FdFilter::GetArraySamplesUsed() { + return(array_samples_used_); +} + +// Use after a call to filterArray() to determine how many output +// samples were NOT transferred to caller's output array due to lack +// of space in caller's array. +int FdFilter::GetArrayOutputLeftover() { + return(array_leftover_); +} + +// Given the input stream 'input_stream' and the output stream 'output_stream' +// process all samples until EOF is reached on 'input_stream'. Returns 1 +// on success, 0 on failure. All processing is done in a single call +// to this method. +/* ******************************************************************** */ +int FdFilter::FilterStream(FILE *input_stream, FILE *output_stream) { + int i, j; + int toread, towrite, nread, rVal = 1, testc; + + toread = max_input_; + filter_state_ = 1; // indicate start of new signal + /* process data from a stream */ + while ((nread = fread(input_buffer_, sizeof(*input_buffer_), toread, + input_stream))) { + testc = getc(input_stream); + if (feof(input_stream)) + filter_state_ |= 2; + else + ungetc(testc, input_stream); + if (insert_ > 1) { + int16_t *p, *q; + for (p = input_buffer_ + nread - 1, + q = input_buffer_ + (nread * insert_) - 1, i = nread; i--;) { + for (j = insert_ - 1; j--;) *q-- = 0; + *q-- = *p--; + } + } + FilterBuffer(nread*insert_, &towrite); + if ((i = fwrite(output_buffer_, sizeof(*output_buffer_), towrite, + output_stream)) < towrite) { + fprintf(stderr, "Problems writing output in FilterStream\n"); + rVal = 0; + } + filter_state_ = 0; + } + return(rVal); +} + +// This is a private method that supports FilterStream() and +// FilterArray(). It assumes that the input samples have been +// transferred to this->input_buffer_. It places the filtered results in +// this->output_buffer_, and returns the number of output samples in +// *n_output. +/* ******************************************************************** */ +void FdFilter::FilterBuffer(int n_input, int *n_output) { + int16_t *p, *r, *p2; + float *dp1, *dp2, *q, half = 0.5; + int i, j, k, npass; + int totaln; + + if (filter_state_ & 1) { /* first call with this signal and filter? */ + first_out_ = 0; + to_skip_ = 0; + left_over_ = 0; + for (i = max_input_+n_filter_coeffs_, q = output_delayed_; i--;) + *q++ = 0.0; + } /* end of once-per-filter-invocation initialization */ + + npass = (n_input + left_over_) / fft_size_; + if (!npass && (filter_state_ & 2)) { // if it's the end... + // Append the input to the leftovers, then pad with zeros. + p = input_buffer_; + for (p = input_buffer_, r = leftovers_ + left_over_, i = n_input; i--;) { + *r++ = *p++; /* append to leftovers_ from prev. call */ + } + int to_pad = fft_size_ - (left_over_ + n_input); + for (int i = 0; i < to_pad; ++i) { + *r++ = 0; + } + npass = 1; + } else { + /* This is the normal non-boundary course of action. */ + for (p = input_buffer_, r = leftovers_ + left_over_, + i = fft_size_ - left_over_; i--;) + *r++ = *p++; /* append to leftovers_ from prev. call */ + } + if (!npass && !(filter_state_ & 2)) { // it's not the end, but don't + // have enough data for a loop. + left_over_ += n_input; + *n_output = 0; + first_out_ |= filter_state_ & 1; // flag that start of sig is still here. + return; + } + filter_state_ |= first_out_; + first_out_ = 0; + + /* >>>>>>>>>>>>>> Here's the main processing loop. <<<<<<<<<<<<< */ + for (/* p set up above */ q = output_delayed_, i = 0; i < npass; + i++, q += fft_size_) { + if (i) { + for (r = p + fft_size_by2_, j = fft_size_by2_, dp1 = x_, dp2 = y_; j--;) { + *dp1++ = *p++; + *dp2++ = *r++; + } + p += fft_size_by2_; + } else { + for (p2 = leftovers_, r = p2 + fft_size_by2_, j = fft_size_by2_, + dp1 = x_, dp2 = y_; j--;) { + *dp1++ = *p2++; + *dp2++ = *r++; + } + } + for (j = fft_size_by2_; j--;) + *dp1++ = *dp2++ = 0.0; + + /* Filtering is done in the frequency domain; transform two real arrays. */ + fft_->fft(x_, y_); + ComplexDotProduct(fft_size_, x_, y_, xf_, NULL, x_, y_); + fft_->ifft(x_, y_); + + /* Overlap and add. */ + for (dp2 = q, j = fft_size_ - n_filter_coeffs_by2_; j < fft_size_; j++) + *dp2++ += x_[j]; + for (j = 0, k = n_filter_coeffs_by2_; j < k; j++) + *dp2++ += x_[j]; + for (j = n_filter_coeffs_by2_, k = fft_size_ - n_filter_coeffs_by2_; + j < k; j++) + *dp2++ = x_[j]; + + for (dp2 = q+fft_size_by2_, j = fft_size_ - n_filter_coeffs_by2_; + j < fft_size_; j++) + *dp2++ += y_[j]; + for (j = 0, k = n_filter_coeffs_by2_; j < k; j++) + *dp2++ += y_[j]; + for (j = n_filter_coeffs_by2_, k = fft_size_ - n_filter_coeffs_by2_; + j < k; j++) + *dp2++ = y_[j]; + } /* end of main processing loop */ + + left_over_ = n_input - (p-input_buffer_); + for (i = left_over_, r = leftovers_; i--;) // Save unused input + // samples for next call. + *r++ = *p++; + /* If signal end is here, must process any unused input. */ + if (left_over_ && (filter_state_ & 2)) { // Must do one more zero-pad pass. + for (p2 = leftovers_ + left_over_, i = fft_size_ - left_over_; i--;) + *p2++ = 0; + for (p2 = leftovers_, r = p2 + fft_size_by2_, j = fft_size_by2_, + dp1 = x_, dp2 = y_; j--;) { + *dp1++ = *p2++; + *dp2++ = *r++; + } + for (j = fft_size_by2_; j--;) + *dp1++ = *dp2++ = 0.0; + /* Filtering is done in the frequency domain; transform two real arrays. */ + fft_->fft(x_, y_); + ComplexDotProduct(fft_size_, x_, y_, xf_, NULL, x_, y_); + fft_->ifft(x_, y_); + + /* Overlap and add. */ + for (dp2 = q, j = fft_size_ - n_filter_coeffs_by2_; j < fft_size_; j++) + *dp2++ += x_[j]; + for (j = 0, k = n_filter_coeffs_by2_; j < k; j++) + *dp2++ += x_[j]; + for (j = n_filter_coeffs_by2_, k = fft_size_ - n_filter_coeffs_by2_; + j < k; j++) + *dp2++ = x_[j]; + + for (dp2 = q+fft_size_by2_, j = fft_size_ - n_filter_coeffs_by2_; + j < fft_size_; j++) + *dp2++ += y_[j]; + for (j = 0, k = n_filter_coeffs_by2_; j < k; j++) + *dp2++ += y_[j]; + for (j = n_filter_coeffs_by2_, k = fft_size_ - n_filter_coeffs_by2_; + j < k; j++) + *dp2++ = y_[j]; + } + /* total good output samples in ob: */ + totaln = (((npass * fft_size_) - to_skip_ - + ((1 & filter_state_)? n_filter_coeffs_by2_ : 0)) + + ((filter_state_ & 2)? left_over_ + n_filter_coeffs_by2_ : 0)); + /* number returned to caller: */ + *n_output = 1 + (totaln - 1) / decimate_; // possible decimation for + // downsampling + /* Round, decimate and output the samples. */ + float f_temp; + q = (filter_state_ & 1)? output_delayed_ + (n_filter_coeffs_by2_) : + output_delayed_ + to_skip_; + for (j = decimate_, i = *n_output, p = output_buffer_; i-- ; q += j) { + if ((f_temp = *q) > 32767.0) + f_temp = 32767.0; + if (f_temp < -32768.0) + f_temp = -32768.0; + *p++ = static_cast((f_temp > 0.0) ? half + f_temp : f_temp - half); + } + + for (dp1 = output_delayed_ + npass*fft_size_, j = n_filter_coeffs_, + dp2 = output_delayed_; j--;) /*save mem for next call */ + *dp2++ = *dp1++; + /* If decimating, number to skip on next call. */ + to_skip_ = (*n_output * decimate_) - totaln; +} + +// Return the largest number of samples that can be processed in a +// single call to FdFilter::filterArray(). This can be used to configure +// the caller's buffer sizes to simplify subsequent processing. The +// simplest use of filterArray() is when the caller sends chunks of +// size getMaxInputSize() (or less) as input, and has an output buffer +// of size >= (2 * getMaxInputSize()). In this case, no checking is +// required to synchronize input and output buffering. This, and the +// less ideal case of arbitrary caller buffer sizes are illustrated in +// the test harness at the end of this file. +/* ******************************************************************** */ +int FdFilter::GetMaxInputSize() { + return(max_input_); +} + +// When sample-rate conversion is attempted, it is possible that the +// output frequency realizable with the FdFilter configuration does not +// exactly match the requested rate. getActualOutputFreq() retrieves +// the rate achieved, and allows the caller to decide whether to +// proceed with the filtering or not, and to correctly set the rate og +// the output stream for processes later in the chain. This method +// may be called immediately after instantiation of the FdFilter, or at any +// later time. +float FdFilter::GetActualOutputFreq() { + return(true_output_rate_); +} + +// A private method that finds the closest ratio to the fraction in +// 'a' (0.0 < a < 1.0). The numerator is returned in 'k', the +// denominator in 'l'. The largest allowed denominator is specified +// by 'qlim'. +/* ---------------------------------------------------------- */ +void FdFilter::RationalApproximation(float a, int *k, int *l, int qlim) { + float aa, af, q, em, qq = 1.0, pp = 1.0, ps, e; + int ai, ip, i; + + aa = fabs(a); + ai = static_cast(aa); + i = ai; + af = aa - i; + q = 0; + em = 1.0; + while (++q <= qlim) { + ps = q * af; + ip = static_cast(ps + 0.5); + e = fabs((ps - static_cast(ip)) / q); + if (e < em) { + em = e; + pp = ip; + qq = q; + } + } + *k = static_cast((ai * qq) + pp); + *k = (a > 0)? *k : -(*k); + *l = static_cast(qq); +} + +// A private method to create the coefficients for a symmetric FIR +// lowpass filter using the window technique with a Hanning window. +// Half of the symmetric kernel is returned in ''coef'. The desired +// number of filter coefficients is in 'nf', but is forced to be odd +// by adding one, if the requesred number is even. 'fc' is the +// normalized corner frequency (0 < fc < 1). +/* ---------------------------------------------------------- */ +void FdFilter::MakeLinearFir(float fc, int *nf, float *coef) { + int i, n; + double twopi, fn, c; + + if (((*nf % 2) != 1)) + *nf = *nf + 1; + n = (*nf + 1) / 2; + + /* Compute part of the ideal impulse response (the sin(x)/x kernel). */ + twopi = M_PI * 2.0; + coef[0] = 2.0 * fc; + c = M_PI; + fn = twopi * fc; + for (i = 1; i < n; i++) + coef[i] = sin(i * fn) / (c * i); + + /* Now apply a Hanning window to the (infinite) impulse response. */ + /* (Could use other windows, like Kaiser, Gaussian...) */ + fn = twopi / *nf; + for (i = 0; i < n; i++) + coef[n - i - 1] *= (.5 - (.5 * cos(fn * (i + 0.5)))); +} diff --git a/REAPER/epoch_tracker/fd_filter.h b/REAPER/epoch_tracker/fd_filter.h new file mode 100644 index 0000000000000000000000000000000000000000..6b73411a7244383ef694e8bc0278e7c634befe48 --- /dev/null +++ b/REAPER/epoch_tracker/fd_filter.h @@ -0,0 +1,131 @@ +/* +Copyright 2015 Google Inc. All rights reserved. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ +/* In-Line FIR filter class */ +/* +Author: David Talkin (dtalkin@google.com) +*/ + +#ifndef _FD_FILTER_H_ +#define _FD_FILTER_H_ + +#include +#include + +class FFT; + +class FdFilter { + public: + // Constructor when doing arbitrary FIR filtering using the response + // in file 'spectrum_shape' + FdFilter(float input_freq, char* spectrum_shape); + // Constructor when doing arbitrary FIR filtering using the response + // in array 'spectrum_array' + FdFilter(float input_freq, float* spectrum_rray, int n_magnitudes); + // Constructor when doing highpass or lowpass filtering or when + // doing rate conversion + FdFilter(float input_freq, float corner_freq, bool do_highpass, + float filter_dur, bool do_rate_conversion); + + ~FdFilter(); + + // Read and filter/convert all input from inStream and write to + // outStream until inStream is exhausted. Return 1 for success 0 + // for failure. + int FilterStream(FILE* fIn, FILE* fOut); + + // Process nIn samples from 'input' array into 'output' array. Set + // 'first' true if this is the first call for a new signal. Set + // 'last' true if the end of the signal is in 'input'. The + // number of samples transferred to 'output' is the return value. + // 'maximum_to_output' is the size of caller's output array. + int FilterArray(int16_t* input, int n_input, bool first, bool last, + int16_t* output, int maximum_to_output); + + // Return number of samples left after a call to filterArray() in the + // case where 'maximum_to_output' is smaller than the number of output samples + // produced. + int GetArrayOutputLeftover(); + + // Use after a call to filterArray() to get number of 'input' + // samples actually used (in cases where the caller's output array + // size has limited the number used, or when the caller's input size + // is larger than getMaxInputSize()). + int GetArraySamplesUsed(); + + // Return the largest batch of input samples that can be processed + // with a single call to filterBuffer() + int GetMaxInputSize(); + + // When sample-rate conversion is being done, return the actual + // output frequency, which may differ from that requested. + float GetActualOutputFreq(); + + private: + // The main initialization function. Called by all constructors. + void FdFilterInitialize(float input_freq, float corner_freq, bool do_highpass, + float filter_dur, bool do_rate_conversion, + char* spectrum_shape, float* spectrum_array, + int n_magnitudes); + + // Use the half filter in fc to create the full filter in filter_coeff_ + void MirrorFilter(float* fc, bool invert); + + // Window approach to creating a high- or low-pass FIR kernel + void MakeLinearFir(float fc, int* nf, float* coef); + + // Find the closest integer ratio to the float 'a' + void RationalApproximation(float a, int* k, int* l, int qlim); + + // Complex inner product of length 'n'; result goes to (r3,i3) + void ComplexDotProduct(int n, float* r1, float* i1, float* r2, float* i2, + float* r3, float* i3); + + // Assuming n_input samples are in in_buffer_, process the signal + // into out_buffer_. Returns number transferred to out_buffer_ in + // 'n_output'. + void FilterBuffer(int n_input, int* n_output); + + + int16_t* output_buffer_; // Processing I/O buffers + int16_t* input_buffer_; + float* filter_coeffs_; // becomes the filter coefficient array + int n_filter_coeffs_; // The number of filter coefficients + int n_filter_coeffs_by2_; // Precompute for convenience/speed + int left_over_; // bookkeeping for the OLA filtering operations + int first_out_; // non-zero indicates the first call to the filter kernel + int to_skip_; // saves state for the decimator when downsampling + int array_leftover_; // Bookkeeping for buffered processing. + int array_index_; // internal book keeping + int array_samples_used_; // internal book keeping + int filter_state_; // State of processing WRT input and completion + float true_output_rate_; // For sample rate conversion, this can + // differ from requested freq. + int16_t* leftovers_; // saves residual input samples that are mod fft_size + float* output_delayed_; // saves samples that exceed the caller's output capacity. + float* x_; // FFT processing arrays + float* y_; + float* xf_; + float* yf_; + int fft_size_; // Number of points in the FFTs + int fft_size_by2_; // Precompute for convenience/speed + int insert_; // for sample rate conversion, these are the + // interpolation/decimations + int decimate_; + int max_input_; // maximum allowed input with each call to filterBuffer + FFT* fft_; // The FFT instance used by the filter. +}; + +#endif // _FD_FILTER_H_ diff --git a/REAPER/epoch_tracker/fft.cc b/REAPER/epoch_tracker/fft.cc new file mode 100644 index 0000000000000000000000000000000000000000..3a4b0bd4477571bcdb3ff1409c3f3d4dc92968fd --- /dev/null +++ b/REAPER/epoch_tracker/fft.cc @@ -0,0 +1,181 @@ +/* +Copyright 2015 Google Inc. All rights reserved. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ +// Author: David Talkin (dtalkin@google.com) + +#include "epoch_tracker/fft.h" + +/* Construct a FFT to perform a DFT of size 2^power. */ +FFT::FFT(int power) { + makefttable(power); +} + +FFT::~FFT() { + delete [] fsine; + delete [] fcosine; +} + +/*-----------------------------------------------------------------------*/ +/* z <- (10 * log10(x^2 + y^2)) for n elements */ +bool FFT::flog_mag(float *x, float *y, float *z, int n) { + float *xp, *yp, *zp, t1, t2, ssq; + + if (x && y && z && n) { + for (xp = x + n, yp = y + n, zp = z + n; zp > z;) { + t1 = *--xp; + t2 = *--yp; + ssq = (t1 * t1) + (t2 * t2); + *--zp = (ssq > 0.0)? 10.0 * log10(ssq) : -200.0; + } + return true; + } else { + return false; + } +} + +/*-----------------------------------------------------------------------*/ +float FFT::get_band_rms(float *x, float*y, int first_bin, int last_bin) { + double sum = 0.0; + for (int i = first_bin; i <= last_bin; ++i) { + sum += (x[i] * x[i]) + (y[i] * y[i]); + } + return sqrt(sum / (last_bin - first_bin + 1)); +} + +/*-----------------------------------------------------------------------*/ +int FFT::makefttable(int pow2) { + int lmx, lm; + float *c, *s; + double scl, arg; + + fftSize = 1 << pow2; + fft_ftablesize = lmx = fftSize/2; + fsine = new float[lmx]; + fcosine = new float[lmx]; + scl = (M_PI * 2.0) / fftSize; + for (s = fsine, c = fcosine, lm = 0; lm < lmx; ++lm) { + arg = scl * lm; + *s++ = sin(arg); + *c++ = cos(arg); + } + kbase = (fft_ftablesize * 2) / fftSize; + power2 = pow2; + return(fft_ftablesize); +} + +/*-----------------------------------------------------------------------*/ +/* Compute the discrete Fourier transform of the 2**l complex sequence + * in x (real) and y (imaginary). The DFT is computed in place and the + * Fourier coefficients are returned in x and y. + */ +void FFT::fft(float *x, float *y) { + float c, s, t1, t2; + int j1, j2, li, lix, i; + int lmx, lo, lixnp, lm, j, nv2, k = kbase, im, jm, l = power2; + + for (lmx = fftSize, lo = 0; lo < l; lo++, k *= 2) { + lix = lmx; + lmx /= 2; + lixnp = fftSize - lix; + for (i = 0, lm = 0; lm < lmx; lm++, i += k) { + c = fcosine[i]; + s = fsine[i]; + for (li = lixnp + lm, j1 = lm, j2 = lm + lmx; j1 <= li; + j1 += lix, j2 += lix) { + t1 = x[j1] - x[j2]; + t2 = y[j1] - y[j2]; + x[j1] += x[j2]; + y[j1] += y[j2]; + x[j2] = (c * t1) + (s * t2); + y[j2] = (c * t2) - (s * t1); + } + } + } + + /* Now perform the bit reversal. */ + j = 1; + nv2 = fftSize / 2; + for (i = 1; i < fftSize; i++) { + if (j < i) { + jm = j - 1; + im = i - 1; + t1 = x[jm]; + t2 = y[jm]; + x[jm] = x[im]; + y[jm] = y[im]; + x[im] = t1; + y[im] = t2; + } + k = nv2; + while (j > k) { + j -= k; + k /= 2; + } + j += k; + } +} + +/*-----------------------------------------------------------------------*/ +/* Compute the discrete inverse Fourier transform of the 2**l complex + * sequence in x (real) and y (imaginary). The DFT is computed in + * place and the Fourier coefficients are returned in x and y. Note + * that this DOES NOT scale the result by the inverse FFT size. + */ +void FFT::ifft(float *x, float *y) { + float c, s, t1, t2; + int j1, j2, li, lix, i; + int lmx, lo, lixnp, lm, j, nv2, k = kbase, im, jm, l = power2; + + for (lmx = fftSize, lo = 0; lo < l; lo++, k *= 2) { + lix = lmx; + lmx /= 2; + lixnp = fftSize - lix; + for (i = 0, lm = 0; lm < lmx; lm++, i += k) { + c = fcosine[i]; + s = -fsine[i]; + for (li = lixnp + lm, j1 = lm, j2 = lm + lmx; j1 <= li; + j1 += lix, j2 += lix) { + t1 = x[j1] - x[j2]; + t2 = y[j1] - y[j2]; + x[j1] += x[j2]; + y[j1] += y[j2]; + x[j2] = (c * t1) + (s * t2); + y[j2] = (c * t2) - (s * t1); + } + } + } + + /* Now perform the bit reversal. */ + j = 1; + nv2 = fftSize / 2; + for (i = 1; i < fftSize; i++) { + if (j < i) { + jm = j-1; + im = i-1; + t1 = x[jm]; + t2 = y[jm]; + x[jm] = x[im]; + y[jm] = y[im]; + x[im] = t1; + y[im] = t2; + } + k = nv2; + while (j > k) { + j -= k; + k /= 2; + } + j += k; + } +} diff --git a/REAPER/epoch_tracker/fft.h b/REAPER/epoch_tracker/fft.h new file mode 100644 index 0000000000000000000000000000000000000000..58ce89a44194dca180796ce83d8dc2f6b70383ef --- /dev/null +++ b/REAPER/epoch_tracker/fft.h @@ -0,0 +1,73 @@ +/* +Copyright 2015 Google Inc. All rights reserved. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ +// Author: David Talkin (dtalkin@google.com) + +#ifndef _FFT_H_ +#define _FFT_H_ + +#include +#include +#include + +#ifndef M_PI +#define M_PI 3.1415927 +#endif + +#define TRUE 1 +#define FALSE 0 + +class FFT { + public: + // Constructor: Prepare for radix-2 FFT's of size (1< +#include + +#ifndef M_PI +#define M_PI (3.14159265359) +#endif + +/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ +/* Generate a Hanning window, if one does not already exist. */ +void LpcAnalyzer::HannWindow(const float* din, float* dout, int n, + float preemp) { + int i; + const float *p; + + // Need to create a new Hanning window? */ + if (window_.size() != static_cast(n)) { + double arg, half = 0.5; + window_.resize(n); + for (i = 0, arg = M_PI * 2.0 / n; i < n; ++i) + window_[i] = (half - half * cos((half + i) * arg)); + } + /* If preemphasis is to be performed, this assumes that there are n+1 valid + samples in the input buffer (din). */ + if (preemp != 0.0) { + for (i = 0, p = din + 1; i < n; ++i) + *dout++ = window_[i] * (*p++ - (preemp * *din++)); + } else { + for (i = 0; i < n; ++i) + *dout++ = window_[i] * *din++; + } +} + +/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ +/* Place a time-weighting window of length n in energywind_. +*/ +void LpcAnalyzer::GetWindow(int n) { + // Need to create a new Hanning window? + if (energywind_.size() != static_cast(n)) { + double arg = M_PI * 2.0 / n, half = 0.5; + energywind_.resize(n); + for (int i = 0; i < n; ++i) + energywind_[i] = (half - half * cos((half + i) * arg)); + } +} + +/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ +/* Compute the pp+1 autocorrelation lags of the windowsize samples in s. +* Return the normalized autocorrelation coefficients in r. +* The rms is returned in e. +*/ +void LpcAnalyzer::Autoc(int windowsize, float* s, int p, float* r, float* e) { + int i, j; + float *q, *t, sum, sum0; + + for (i = windowsize, q = s, sum0 = 0.0; i--;) { + sum = *q++; + sum0 += sum*sum; + } + *r = 1.; /* r[0] will always = 1.0 */ + if (sum0 == 0.0) { /* No energy: fake low-energy white noise. */ + *e = 1.; /* Arbitrarily assign 1 to rms. */ + /* Now fake autocorrelation of white noise. */ + for (i = 1; i <= p; i++) { + r[i] = 0.; + } + return; + } + *e = sqrt(sum0 / windowsize); + sum0 = 1.0 / sum0; + for (i = 1; i <= p; i++) { + for (sum = 0.0, j = windowsize - i, q = s, t = s + i; j--;) + sum += (*q++) * (*t++); + *(++r) = sum * sum0; // normalizing by the inverse energy + } +} + +/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ +/* Using Durbin's recursion, convert the autocorrelation sequence in r +* to reflection coefficients in k and predictor coefficients in a. +* The prediction error energy (gain) is left in *ex. +* Note: Durbin returns the coefficients in normal sign format. +* (i.e. a[0] is assumed to be = +1.) +*/ +void LpcAnalyzer::Durbin(float* r, float* k, float* a, int p, float* ex) { + float bb[BIGSORD]; + int i, j; + float e, s, *b = bb; + + e = *r; + *k = -r[1] / e; + *a = *k; + e *= (1.0 - (*k) * (*k)); + for (i = 1; i < p; i++) { + s = 0; + for (j = 0; j < i; j++) { + s -= a[j] * r[i - j]; + } + k[i] = (s - r[i + 1]) / e; + a[i] = k[i]; + for (j = 0; j <= i; j++) { + b[j] = a[j]; + } + for (j = 0; j < i; j++) { + a[j] += k[i] * b[i - j - 1]; + } + e *= (1.0 - (k[i] * k[i])); + } + *ex = e; +} + +/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ +/* Compute the autocorrelations of the p LP coefficients in a. +* (a[0] is assumed to be = 1 and not explicitely accessed.) +* The magnitude of a is returned in c. +* 2* the other autocorrelation coefficients are returned in b. +*/ +void LpcAnalyzer::PcToAutocorPc(float* a, float* b, float* c, int p) { + float s, *ap, *a0; + int i, j; + + for (s = 1., ap = a, i = p; i--; ap++) + s += *ap * *ap; + + *c = s; + for (i = 1; i <= p; i++) { + s = a[i - 1]; + for (a0 = a, ap = a + i, j = p - i; j--;) + s += (*a0++ * *ap++); + *b++ = 2.0 * s; + } +} + +/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ +/* Compute the Itakura LPC distance between the model represented +* by the signal autocorrelation (r) and its residual (gain) and +* the model represented by an LPC autocorrelation (c, b). +* Both models are of order p. +* r is assumed normalized and r[0]=1 is not explicitely accessed. +* Values returned by the function are >= 1. +*/ +float LpcAnalyzer::ItakuraDistance(int p, float* b, float* c, float* r, + float gain) { + float s; + + for (s = *c; p--;) + s += *r++ * *b++; + + return s / gain; +} + +/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ +/* Compute the time-weighted RMS of a size segment of data. The data +* is weighted by a Hanning window before RMS computation. +*/ +float LpcAnalyzer::WindowedRms(float* data, int size) { + float sum, f; + int i; + + GetWindow(size); + for (i = 0, sum = 0.0; i < size; i++) { + f = energywind_[i] * (*data++); + sum += f * f; + } + return sqrt(sum / size); +} + +/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ +// Generic autocorrelation LPC analysis of the floating-point +// sequence in data. +// +// int lpc_ord, /* Analysis order */ +// wsize, /* window size in points */ +// type; /* window type (decoded in window() above) */ +// float noise_floor, /* Simulated white noise floor in dB (SNR). */ +// *lpca, /* if non-NULL, return vector for predictors */ +// *ar, /* if non-NULL, return vector for normalized autoc. */ +// *lpck, /* if non-NULL, return vector for PARCOR's */ +// *normerr, /* return scalar for normalized error */ +// *rms, /* return scalar for energy in preemphasized window */ +// preemp; +// float *data; /* input data sequence; assumed to be wsize+1 long */ +int LpcAnalyzer::ComputeLpc(int lpc_ord, float noise_floor, int wsize, + const float* data, float* lpca, float* ar, + float* lpck, float* normerr, float* rms, + float preemp) { + float rho[BIGSORD+1], k[BIGSORD], a[BIGSORD+1], *r, *kp, *ap, en, er; + + if ((wsize <= 0) || (!data) || (lpc_ord > BIGSORD)) + return false; + + float *dwind = new float[wsize]; + + HannWindow(data, dwind, wsize, preemp); + if (!(r = ar)) r = rho; /* Permit optional return of the various */ + if (!(kp = lpck)) kp = k; /* coefficients and intermediate results. */ + if (!(ap = lpca)) ap = a; + Autoc(wsize, dwind, lpc_ord, r, &en); + if (noise_floor > 1.0) { // Add some to the diagonal to simulate white noise. + int i; + float ffact; + ffact = 1.0 / (1.0 + exp((-noise_floor / 20.0) * log(10.0))); + for (i = 1; i <= lpc_ord; i++) + rho[i] = ffact * r[i]; + *rho = *r; + r = rho; + if (ar) { + for (i = 0; i <= lpc_ord; i++) + ar[i] = r[i]; + } + } + Durbin(r, kp, ap + 1, lpc_ord, &er); + float wfact = .612372; // ratio of Hanning RMS to rectangular RMS + ap[0] = 1.0; + if (rms) + *rms = en / wfact; + if (normerr) + *normerr = er; + delete [] dwind; + return true; +} diff --git a/REAPER/epoch_tracker/lpc_analyzer.h b/REAPER/epoch_tracker/lpc_analyzer.h new file mode 100644 index 0000000000000000000000000000000000000000..56378c6435e819b4d5f8cbcfb36ed9f9e55cdd31 --- /dev/null +++ b/REAPER/epoch_tracker/lpc_analyzer.h @@ -0,0 +1,113 @@ +/* +Copyright 2015 Google Inc. All rights reserved. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// LpcAnalyzer +// A collection of methods commonly used in linear-prediction analysis. + +#ifndef _LPC_ANALYZER_H_ +#define _LPC_ANALYZER_H_ + +#include + +// Largest order allowed for any linear predictor analysis +#define BIGSORD 100 + +class LpcAnalyzer { + public: + LpcAnalyzer(void) { } + + ~LpcAnalyzer(void) { } + + + // Apply Hanning weighting to the input data sequence in data_in, + // put the results in data_out. Array lengths are assumed as + // data_in has windowsize+1 points; data_out has windowsize + // elements. + void HannWindow(const float* data_in, float* data_out, int windowsize, + float preemp); + + + // Compute the order+1 autocorrelation lags of the windowsize + // samples in data_in. Return the normalized autocorrelation + // coefficients in autoc. The rms is returned in rms. + void Autoc(int windowsize, float* data_in, int order, float* autoc, + float* rms); + + + // Using Durbin's recursion, convert the autocorrelation sequence in autocor + // to reflection coefficients in refcof and predictor coefficients in lpc. + // The prediction error energy (gain) is left in *gain. + // Note: Durbin returns the coefficients in normal sign format. + // (i.e. lpca[0] is assumed to be = +1.) + void Durbin(float* autocor, float* refcof, float* lpc, int order, + float* gain); + + + // Compute the autocorrelations of the order LP coefficients in lpc. + // (lpc[0] is assumed to be = 1 and not explicitely accessed.) + // The magnitude of lpc is returned in mag. + // 2* the other autocorrelation coefficients are returned in lpc_auto. + void PcToAutocorPc(float* lpc, float* lpc_auto, float* mag, int order); + + + // Compute the Itakura LPC distance between the model represented + // by the signal autocorrelation (autoc) and its residual (gain) and + // the model represented by an LPC autocorrelation (mag, lpc_auto). + // Both models are of order. + // r is assumed normalized and r[0]=1 is not explicitely accessed. + // Values returned by the function are >= 1. + float ItakuraDistance(int order, float* lpc_auto, float* mag, float* autoc, + float gain); + + + // Compute the time-weighted RMS of a size segment of data. The data + // is weighted by a window of type w_type before RMS computation. w_type + // is decoded above in window(). + float WindowedRms(float* data, int size); + + + // Generic autocorrelation LPC analysis of the floating-point + // sequence in data. + // + // int lpc_ord, /* Analysis order + // wsize; /* window size in points + // float noise_floor, /* To simulate a white noise floor (dB SNR). + // *lpca, /* if non-NULL, return vector for predictors + // *ar, /* if non-NULL, return vector for normalized autoc. + // *lpck, /* if non-NULL, return vector for PARCOR's + // *normerr, /* return scalar for normalized error + // *rms, /* return scalar for energy in preemphasized window + // preemp; + // float *data; /* input data sequence; assumed to be wsize+1 long + int ComputeLpc(int lpc_ord, float noise_floor, int wsize, const float* data, + float* lpca, float* ar, float* lpck, float* normerr, float* rms, + float preemp); + + // Use the standard speech analysis formula to determine the + // appropriate LPC order, given a sample rate. + static int GetLpcOrder(float sample_rate) { + return static_cast(2.5 + (sample_rate / 1000.0)); + } + + private: + // Puts a time-weighting window of length n in energywind. + void GetWindow(int n); + + std::vector energywind_; + std::vector window_; +}; + +#endif // _LPC_ANALYZER_H_ diff --git a/REAPER/epoch_tracker_main.cc b/REAPER/epoch_tracker_main.cc new file mode 100644 index 0000000000000000000000000000000000000000..56fcd35932fcf6505942028eb832fa72c3c6157c --- /dev/null +++ b/REAPER/epoch_tracker_main.cc @@ -0,0 +1,260 @@ +/* +Copyright 2015 Google Inc. All rights reserved. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +#include +#include +#include +#include +#include + +#include "core/file_resource.h" +#include "core/track.h" +#include "epoch_tracker/epoch_tracker.h" +#include "wave/wave.h" + + +const char* kHelp = "Usage: -i " + "[-f -p \\\n" + "-c " + "-t " + "-s " + "-e " + "-x " + "-m \\\n" + "-u " + "-w " + "-a " + "-d ] " + "\n\n Help:\n" + "-t enables a Hilbert transform that may reduce phase distortion\n" + "-s suppress applying high pass filter at 80Hz " + "(rumble-removal highpass filter)\n" + "-e specifies the output frame interval for F0\n" + "-x maximum f0 to look for\n" + "-m minimum f0 to look for\n" + "-u regular inter-mark interval to use in UV pitchmark regions\n" + "-w set the cost for unvoiced segments\n" + " (def. 0.9, the higher the value the more f0 estimates in noise)\n" + "-a saves F0 and PM output in ascii mode\n" + "-d write diagnostic output to this file pattern\n" +"\nOutputs:\n"\ +"The output files specified with -f and -p are Edinburgh Speech Tool\n" +"(EST) style files. These are output as binary by default, ASCII with\n" +"the -a option. The F0 values in the f0_output file are resampled with\n" +"the frame interval specified by option -e (default .005 s).\n" +"The unvoiced regions of the pitchmark file are filled with marks spaced\n" +"by the interval specified with -u (default .01 s).\n" +"\nIt is strongly recommended that the default high-pass filter be\n" +"applied to all input signals to remove DC and low-frequency\n" +"components. For signals that have been recorded using close-talking\n" +"microphones, or those that have been subjected to various other\n" +"non-linear phase distortions in the studio, or in post-production, it\n" +"is often helpful to apply a Hilbert transform (-t option). The .resid\n" +"file output when -d is specified can be examined to determine if the\n" +"voice pulses look anything like the classical glottal-flow derivative,\n" +"and the Hilbert transform enabled, or not.\n" +"\n" +"In the discussion below, the following notation is used:\n" +"Fs: sample rate\n" +"Fs0: sample rate of input file\n" +"nd: n-dimensional vector signal\n" +"ts: time-stamped vector signal; 1st ele. is the time of the sample in sec.\n" +"float, int16, etc.: atomic type of the data in the file\n" +"\nIf -d is specified, the following raw binary output files are produced,\n" +"with the base path as specified in , and the indicated extensions:\n" +".bestcorr 2d float ts the highest NCC value found at each residual peak\n" +".bprms 1d float Fs=500 RMS of 100-1000 Hz bandpassed input signal\n" +".f0ap 3d float ts F0 and NCC value found for each period\n" +".resid 1d float Fs=Fs0 LPC residual of conditioned input signal\n" +".nresid 1d float Fs=Fs0 LPC residual with local gain normalization\n" +".offsetp 1d float Fs=500 pseudo-probability that voicing is terminating\n" +".onsetp 1d float Fs=500 pseudo-probability that voicing is starting\n" +".pvoiced 1d float Fs=500 pseudo-probability that voicing is occurring\n" +".pcm 1d float Fs=Fs0 conditioned input signal\n" +".pmlab ASCII 'xlabel' format file of epoch marks\n" +".pvals 1d float Fs=Fs0 graded residual peak candidates\n"; + +Track* MakeEpochOutput(EpochTracker &et, float unvoiced_pm_interval) { + std::vector times; + std::vector voicing; + et.GetFilledEpochs(unvoiced_pm_interval, ×, &voicing); + Track* pm_track = new Track; + pm_track->resize(times.size()); + for (int32_t i = 0; i < times.size(); ++i) { + pm_track->t(i) = times[i]; + pm_track->set_v(i, voicing[i]); + } + return pm_track; +} + +Track* MakeF0Output(EpochTracker &et, float resample_interval, Track** cor) { + std::vector f0; + std::vector corr; + if (!et.ResampleAndReturnResults(resample_interval, &f0, &corr)) { + return NULL; + } + + Track* f0_track = new Track; + Track* cor_track = new Track; + f0_track->resize(f0.size()); + cor_track->resize(corr.size()); + for (int32_t i = 0; i < f0.size(); ++i) { + float t = resample_interval * i; + f0_track->t(i) = t; + cor_track->t(i) = t; + f0_track->set_v(i, (f0[i] > 0.0) ? true : false); + cor_track->set_v(i, (f0[i] > 0.0) ? true : false); + f0_track->a(i) = (f0[i] > 0.0) ? f0[i] : -1.0; + cor_track->a(i) = corr[i]; + } + *cor = cor_track; + return f0_track; +} + +bool ComputeEpochsAndF0(EpochTracker &et, float unvoiced_pulse_interval, + float external_frame_interval, + Track** pm, Track** f0, Track** corr) { + if (!et.ComputeFeatures()) { + return false; + } + bool tr_result = et.TrackEpochs(); + et.WriteDiagnostics(""); // Try to save them here, even after tracking failure. + if (!tr_result) { + fprintf(stderr, "Problems in TrackEpochs"); + return false; + } + + // create pm and f0 objects, these need to be freed in calling client. + *pm = MakeEpochOutput(et, unvoiced_pulse_interval); + *f0 = MakeF0Output(et, external_frame_interval, corr); + return true; +} + +int main(int argc, char* argv[]) { + int opt = 0; + std::string filename; + std::string f0_output; + std::string pm_output; + std::string corr_output; + bool do_hilbert_transform = kDoHilbertTransform; + bool do_high_pass = kDoHighpass; + float external_frame_interval = kExternalFrameInterval; + float max_f0 = kMaxF0Search; + float min_f0 = kMinF0Search; + float inter_pulse = kUnvoicedPulseInterval; + float unvoiced_cost = kUnvoicedCost; + bool ascii = false; + std::string debug_output; + if (argc < 3) { + fprintf(stdout, "\n%s\n", kHelp); + return 1; + } + while ((opt = getopt(argc, argv, "i:f:p:c:htse:x:m:u:w:ad:")) != -1) { + switch(opt) { + case 'i': + filename = optarg; + break; + case 'f': + f0_output = optarg; + break; + case 'p': + pm_output = optarg; + break; + case 'c': + corr_output = optarg; + break; + case 't': + do_hilbert_transform = true; + break; + case 's': + do_high_pass = false; + break; + case 'e': + external_frame_interval = atof(optarg); + break; + case 'x': + max_f0 = atof(optarg); + break; + case 'm': + min_f0 = atof(optarg); + break; + case 'u': + inter_pulse = atof(optarg); + break; + case 'w': + unvoiced_cost = atof(optarg); + break; + case 'a': + ascii = true; + break; + case 'd': + debug_output = optarg; + break; + case 'h': + fprintf(stdout, "\n%s\n", kHelp); + return 0; + } + } + + // Load input. + Wave wav; + if (!wav.Load(filename)) { + fprintf(stderr, "Failed to load waveform '%s'\n", filename.c_str()); + return 1; + } + + EpochTracker et; + et.set_unvoiced_cost(unvoiced_cost); + int16_t* wave_datap = const_cast(wav.data()->data()); + int32_t n_samples = wav.num_samples(); + float sample_rate = wav.sample_rate(); + if (!et.Init(wave_datap, n_samples, sample_rate, + min_f0, max_f0, do_high_pass, do_hilbert_transform)) { + return 1; + } + if (!debug_output.empty()) { + et.set_debug_name(debug_output); + } + // Compute f0 and pitchmarks. + Track *f0 = NULL; + Track *pm = NULL; + Track *corr = NULL; + if (!ComputeEpochsAndF0(et, inter_pulse, external_frame_interval, &pm, &f0, &corr)) { + fprintf(stderr, "Failed to compute epochs\n"); + return 1; + } + + // Save outputs. + if (!f0_output.empty() && !f0->Save(f0_output, ascii)) { + delete f0; + fprintf(stderr, "Failed to save f0 to '%s'\n", f0_output.c_str()); + return 1; + } + if (!pm_output.empty() && !pm->Save(pm_output, ascii)) { + delete pm; + fprintf(stderr, "Failed to save pitchmarks to '%s'\n", pm_output.c_str()); + return 1; + } + if (!corr_output.empty() && !corr->Save(corr_output, ascii)) { + delete corr; + fprintf(stderr, "Failed to save correlations to '%s'\n", corr_output.c_str()); + return 1; + } + delete f0; + delete pm; + delete corr; + return 0; +} diff --git a/REAPER/wave/codec_api-inl.h b/REAPER/wave/codec_api-inl.h new file mode 100644 index 0000000000000000000000000000000000000000..dc2dd4f626204e9d96e9c1a3f2e09acf3c035efc --- /dev/null +++ b/REAPER/wave/codec_api-inl.h @@ -0,0 +1,135 @@ +/* +Copyright 2015 Google Inc. All rights reserved. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +#ifndef _CODEC_API_INL_H_ +#define _CODEC_API_INL_H_ + +#include "core/file_resource.h" + + +template +inline bool CodecApi::SetHeaderInfo( + int sampling_rate, int num_samples_per_channel) { + bool status = set_sampling_rate(sampling_rate); + status &= set_num_samples_per_channel(num_samples_per_channel); + return status; +} + +template +inline bool CodecApi::GetHeaderInfo( + int *sampling_rate, int *num_samples_per_channel) { + *sampling_rate = sampling_rate_; + *num_samples_per_channel = num_samples_per_channel_; + return true; +} + +template +inline bool CodecApi::ReadHeader(FileResource *fr) { + return codec_.ReadHeader(fr, &num_samples_per_channel_, &sampling_rate_); +} + +template +bool CodecApi::ReadAudioData( + int wave_start, int num_samples, + std::vector *samples, FileResource *fr) { + if (samples == NULL) { + fprintf(stderr, "CodecApi::ReadAudioData: empty pointer was given"); + return true; + } + int64_t offset_audio_container = ftell(fr->fp()); + bool status = codec_.ReadAudioData(wave_start, num_samples, samples, fr); + // Reset the file resource pointer back to the beginning of the + // audio container. + if (fseek(fr->fp(), offset_audio_container, SEEK_SET) != 0) { + fprintf(stderr, "CodecApi::ReadAudioData: error seeking the beginning of the " + "audio container"); + return false; + } + return status; +} + +template +bool CodecApi::ReadAudioContainer( + int container_size_in_bytes, + std::vector *samples, + FileResource *fr) { + int64_t offset_audio_container = ftell(fr->fp()); + bool status = codec_.ReadAudioContainer(container_size_in_bytes, samples, fr); + // Reset the FileResource pointer back to the beginning of the audio container + if (fseek(fr->fp(), offset_audio_container, SEEK_SET) != 0) { + fprintf(stderr, "CodecApi::ReadAudioData: error seeking the beginning of the " + "audio container"); + return false; + } + return status; +} + +template +inline int CodecApi::get_num_samples_per_channel() const { + return num_samples_per_channel_; +} + +template +inline int CodecApi::get_sampling_rate() const { + return sampling_rate_; +} + +template +inline +bool CodecApi::set_num_samples_per_channel(int value) { + num_samples_per_channel_ = value; + return true; +} + +template +inline +bool CodecApi::set_sampling_rate(int value) { + sampling_rate_ = value; + return true; +} + +template +bool CodecApi::Load( + FileResource *fr, std::vector *samples) { + if (!codec_.ReadHeader(fr, &num_samples_per_channel_, &sampling_rate_)) { + return false; + } + samples->resize(num_samples_per_channel_); + return codec_.ReadAudioData( + 0, num_samples_per_channel_, PCM16, samples, fr); +} + +template +template +bool CodecApi::Load( + const std::string &filename, std::vector *samples) { + FileResource *fr = FileResourceType::Open(filename); + if (fr != NULL) { + return Load(fr, samples); + } else { + fprintf(stderr, "CodecApi::Load: Failed to open \"%s\"", filename.c_str()); + return false; + } +} + +template +bool CodecApi::Initialize( + WaveCodingType coding_type) { + return codec_.Initialize(coding_type); +} + + +#endif // SPEECH_PATTS_LIBS_IO_CODEC_API_INL_H_ diff --git a/REAPER/wave/codec_api.h b/REAPER/wave/codec_api.h new file mode 100644 index 0000000000000000000000000000000000000000..09e496c3575201ac7b23eefb60eadbbf61ca5145 --- /dev/null +++ b/REAPER/wave/codec_api.h @@ -0,0 +1,98 @@ +/* +Copyright 2015 Google Inc. All rights reserved. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +#ifndef _CODEC_API_H_ +#define _CODEC_API_H_ + +#include +#include +#include + +#include "wave/codec_riff.h" + + + +class FileResource; + +template +class CodecApi { + public: + CodecApi() { } + ~CodecApi() { } + + // Loads audio samples from a file-resource. It sets the internal header + // parameters. + bool Load(FileResource *fr, std::vector *samples); + + // Loads audio samples from a file. It sets the internal header parameters. + template + bool Load(const std::string &filename, std::vector *samples); + + // Saves audio samples to a file-resource using the internal header + // parameters. + bool Save(const std::vector &samples, FileResource *fr) const; + + // Saves audio samples to a file, using the internal header parameters. + template + bool Save(const std::vector &samples, const std::string &filename) const; + + // Sets generic header information. + bool SetHeaderInfo(int sampling_rate, int num_samples_per_channel); + + // Gets generic header information. + bool GetHeaderInfo(int *sampling_rate, int *num_samples_per_channel); + + // Reads wave header from file-resource. + bool ReadHeader(FileResource *fr); + + // Reads the audio data from the FileResource, under the condition that the + // current position of the FileResource always points to the beginning of the + // audio-container. The latter condition is preserved by this function. When + // a codec with internal-state is used (i.e. iSAC), the internal state is kept + // between sequential reads. The codec is reset prior non-sequential reads. + // By definition, the codecs DO NOT check whether you are trying to read + // beyond the boundaries of the audio-data container, so, be careful. + bool ReadAudioData(int wave_start, int num_samples, + std::vector *samples, FileResource *fr); + + // Reads all audio data contained in the audio container held at the current + // position of the FileResource. The functions assumes and preserves the + // condition that the current position of the FileResource always points to + // the beginning of the audio container. + bool ReadAudioContainer(int container_size_in_bytes, + std::vector *samples, + FileResource *fr); + + int get_num_samples_per_channel() const; + int get_sampling_rate() const; + + bool set_num_samples_per_channel(int value); + bool set_sampling_rate(int value); + + // Initializes the codec for the particular coding type + bool Initialize(WaveCodingType coding_type); + + private: + int num_samples_per_channel_; + int sampling_rate_; + CodecImplementation codec_; + +}; + + +#include "codec_api-inl.h" + +#endif // _CODEC_API_H_ diff --git a/REAPER/wave/codec_riff.cc b/REAPER/wave/codec_riff.cc new file mode 100644 index 0000000000000000000000000000000000000000..91213fc814c1dad1d43361ca132f057fe9928b68 --- /dev/null +++ b/REAPER/wave/codec_riff.cc @@ -0,0 +1,270 @@ +/* +Copyright 2015 Google Inc. All rights reserved. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +#include "wave/codec_riff.h" + +#include + +#include "core/file_resource.h" + +uint8_t UlawCodec::Int16ToUlaw(int16_t pcm_val) const { + int16_t mask; + int16_t seg; + uint8_t uval; + // u-law inverts all bits + // Get the sign and the magnitude of the value. + if (pcm_val < 0) { + pcm_val = -pcm_val; + mask = 0x7f; + } else { + mask = 0xff; + } + if (pcm_val > kClip) { + pcm_val = kClip; // clip the magnitude + } + pcm_val += (kBias >> 2); + // Convert the scaled magnitude to segment number. + seg = SegmentSearch(pcm_val, seg_uend, 8); + // Combine the sign, segment, quantization bits, + // and complement the code word. + if (seg >= 8) { // out of range, return maximum value. + return (uint8_t)(0x7f ^ mask); + } else { + uval = (uint8_t) (seg << 4) | ((pcm_val >> (seg + 1)) & 0xF); + return uval ^ mask; + } +} + +int16_t UlawCodec::SegmentSearch(int16_t val, const int16_t *table, + int size) const { + for (int i = 0; i < size; ++i) { + if (val <= *table++) { + return i; + } + } + return size; +} + +int16_t UlawCodec::UlawToInt16(uint8_t ulaw) const { + // Complement to obtain normal u-law value. + ulaw = ~ulaw; + // Extract and bias the quantization bits. Then + // shift up by the segment number and subtract out the bias. + int16_t t = ((ulaw & kQuantMask) << 3) + kBias; + t <<= ((unsigned)ulaw & kSegMask) >> kSegShift; + return ((ulaw & kSignBit) ? (kBias - t) : (t - kBias)) >> 2; +} + +// +// Table and constants for mu-law coding and decoding: +// +const int16_t UlawCodec::seg_uend[8] = { 0x3f, 0x7f, 0xff, 0x1ff, 0x3ff, 0x7ff, + 0xfff, 0x1fff}; +const int16_t UlawCodec::kBias = 0x84; // Bias for linear code. +const int16_t UlawCodec::kClip = 8159; // max. linear value +const int16_t UlawCodec::kSignBit = 0x80; // Sign bit for a A-law byte. +const int16_t UlawCodec::kQuantMask = 0xf; // Quantization field mask. +const int16_t UlawCodec::kSegShift = 4; // Left shift for segment number. +const int16_t UlawCodec::kSegMask = 0x70; // Segment field mask. + +bool WavRiffCodec::ReadChunk(FileResource *fr, std::string *chunk) const { + if (chunk == NULL) { + return false; + } + char ch[5]; + if (fread(static_cast(&ch), 1, 4, fr->fp()) != 4) { + return false; + } + ch[4] = '\0'; + (*chunk) = ch; + return true; +} + +bool WavRiffCodec::CheckChunk(FileResource *fr, const char *data) const { + std::string chunk; + if (ReadChunk(fr, &chunk)) { + return chunk == data; + } + return false; +} + +bool WavRiffCodec::ReadHeader(FileResource *fr, + int32_t *num_samples_per_channel, + int32_t *sampling_rate) { + if (!CheckChunk(fr, "RIFF")) { + fprintf(stderr, "Invalid file: Expected \"RIFF\" in header"); + return false; + } + // File length minus first 8 bytes of RIFF description, we don't use it + int32_t len = 0; + if (fread(static_cast(&len), 4, 1, fr->fp()) != 1) { + fprintf(stderr, "Failed to read file length"); + return false; + } + + if (!CheckChunk(fr, "WAVE")) { + fprintf(stderr, "Invalid file: Expected \"WAVE\" in header"); + return false; + } + + std::string riff_type; + if (!ReadChunk(fr, &riff_type)) { + fprintf(stderr, "Invalid file: Missing RIFF type header"); + return false; + } + + if (riff_type != "fmt " && riff_type != "bext") { + fprintf(stderr, + "Invalid file: RIFF type must be fmt or bext"); + return false; + } + + // If there is a broadcast format extension, skip it. + if (riff_type == "bext") { + int32_t bext_length; + fread(static_cast(&bext_length), sizeof(bext_length), 1, fr->fp()); + fseek(fr->fp(), bext_length, SEEK_CUR); + std::string sub_type; + if (!CheckChunk(fr, "fmt ")) { + fprintf(stderr, "Invalid file: fmt subtype not found in bext header"); + return false; + } + } + + // Now skip wave format header only reading the number of channels and sample + // rate: + if (fread(static_cast(&len), sizeof(len), 1, fr->fp()) != 1) { + fprintf(stderr, "failed to skip file length"); + return false; + } + if (len < 16) { // bad format chunk length + fprintf(stderr, "Invalid of the wave format buffer"); + return false; + } + + int16_t n_channels = 0; + fseek(fr->fp(), sizeof(n_channels), SEEK_CUR); + if (fread(static_cast(&n_channels), sizeof(n_channels), 1, fr->fp()) != 1) { + fprintf(stderr, "Failed to read number of channels"); + return false; + } + if (n_channels != 1) { + fprintf(stderr, "Attempt to load multi channel audio"); + return false; + } + int32_t sample_rate; + if (fread(&sample_rate, sizeof(sample_rate), 1, fr->fp()) != 1) { + fprintf(stderr, "Failed to read sample rate"); + return false; + } + fseek(fr->fp(), 8, SEEK_CUR); + + // advance in the stream to skip the wave format block + fseek(fr->fp(), len - 16, SEEK_CUR); + + // now go to the end of "data" section, if found + while (!fr->eof()) { + if (fgetc(fr->fp()) == 'd' && + fgetc(fr->fp()) == 'a' && + fgetc(fr->fp()) == 't' && + fgetc(fr->fp()) == 'a') { + break; + } + } + if (fr->eof()) { + fprintf(stderr, "Unexpected end of file: no data"); + return false; + } + + int32_t num_bytes = 0; + if (fread(&num_bytes, sizeof(num_bytes), 1, fr->fp()) != 1) { + fprintf(stderr, "Failed to read number of bytes"); + return false; + } + + *sampling_rate = sample_rate; + *num_samples_per_channel = num_bytes / 2; + return true; +} + +bool WavRiffCodec::ReadAudioData(int32_t wave_start, + int32_t num_samples, + std::vector *samples, + FileResource *fr) { + samples->resize(num_samples); + bool status = true; + switch (coding_type_) { + case PCM16: { + status &= (fseek(fr->fp(), + wave_start * sizeof((*samples)[0]), SEEK_CUR) == 0); + uint32_t read = fread(&(*samples)[0], sizeof(int16_t), num_samples, fr->fp()); + if (read != num_samples) { + fprintf(stderr, "WaveIO::ReadSamples: only %d out of %d values read", + read, num_samples); + status = false; + } + } + break; + case ULAW8: { + UlawCodec sample_codec; + uint8_t *buffer = new uint8_t[num_samples]; + status &= (fseek(fr->fp(), wave_start * sizeof(*buffer), SEEK_CUR) == 0); + uint32_t read = fread(buffer, sizeof(uint8_t), num_samples, fr->fp()); + if (read != num_samples) { + fprintf(stderr, "WaveIO::ReadSamples: only %d out of %d values read", + read, num_samples); + status = false; + } + for (int i = 0 ; i < num_samples; ++i) { + (*samples)[i] = sample_codec.UlawToInt16(buffer[i]); + } + delete [] buffer; + } + break; + default: + fprintf(stderr, "WaveIO::ReadSamples: Unsupported coding type (%d)", + coding_type_); + status = false; + } + return status; +} + +bool WavRiffCodec::ReadAudioContainer(int container_size_in_bytes, + std::vector *samples, + FileResource *fr) { + int number_samples; + switch (coding_type_) { + case PCM16: + number_samples = container_size_in_bytes / 2; + break; + case PCM8: + case ULAW8: + number_samples = container_size_in_bytes; + break; + default: + return false; + } + return ReadAudioData(0, number_samples, samples, fr); +} + +bool WavRiffCodec::Initialize(WaveCodingType coding_type) { + if ((coding_type != PCM16) && (coding_type != PCM8) && + (coding_type != ULAW8)) { + return false; + } + coding_type_ = coding_type; + return true; +} diff --git a/REAPER/wave/codec_riff.h b/REAPER/wave/codec_riff.h new file mode 100644 index 0000000000000000000000000000000000000000..78e3cc1058f8e2c6765cd43d2e408170412dea16 --- /dev/null +++ b/REAPER/wave/codec_riff.h @@ -0,0 +1,91 @@ +/* +Copyright 2015 Google Inc. All rights reserved. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License.*/ + +#ifndef _CODEC_RIFF_H_ +#define _CODEC_RIFF_H_ + +#include +#include +#include + +class FileResource; + +enum WaveCodingType { + PCM16 = 0, + PCM8, + ULAW8, + ISAC_18kbps, + ISAC_20kbps, + ISAC_22kbps, + ISAC_24kbps, + ISAC_26kbps, + ISAC_30kbps +}; + +class WavRiffCodec { + public: + WavRiffCodec() { } + ~WavRiffCodec() { } + + // The header is expected to be in the format: + // + // offset size description value + // 0x00 4 Chunk ID "RIFF" + // 0x04 4 Chunk data size file size - 8 + // 0x08 4 RIFF Type "WAVE" + // 0x10 Wave chunks + // + // A boolean success indicator can be used to check that the header was read. + bool ReadHeader(FileResource *fr, + int32_t *num_samples_per_channel, + int32_t *sample_rate); + + bool ReadAudioData(int32_t wave_start, + int32_t num_samples, + std::vector *samples, + FileResource *fr); + + bool ReadAudioContainer(int container_size_in_bytes, + std::vector *samples, + FileResource *fr); + + bool Initialize(WaveCodingType coding_type); + + private: + bool ReadChunk(FileResource *fr, std::string *chunk) const; + bool CheckChunk(FileResource *fr, const char *data) const; + + WaveCodingType coding_type_; +}; + +class UlawCodec { + public: + uint8_t Int16ToUlaw(int16_t pcm_val) const; + int16_t UlawToInt16(uint8_t ulaw) const; + + private: + int16_t SegmentSearch(int16_t val, const int16_t *table, int size) const; + + // Table and constants for mu-law coding and decoding + static const int16_t seg_uend[8]; + static const int16_t kBias; // Bias for linear code. + static const int16_t kClip; // max. linear value + static const int16_t kSignBit; // Sign bit for a A-law byte. + static const int16_t kQuantMask; // Quantization field mask. + static const int16_t kSegShift; // Left shift for segment number. + static const int16_t kSegMask; // Segment field mask. +}; + +#endif // _CODEC_RIFF_H_ diff --git a/REAPER/wave/wave.cc b/REAPER/wave/wave.cc new file mode 100644 index 0000000000000000000000000000000000000000..74bcb19ba1d5961a80d785da1bb9fc895ad22d5e --- /dev/null +++ b/REAPER/wave/wave.cc @@ -0,0 +1,158 @@ +/* +Copyright 2015 Google Inc. All rights reserved. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +#include "wave/wave.h" + +#include +#include +#include + +#include "core/file_resource.h" +#include "wave/wave_io.h" + + + +WaveData::WaveData() : sample_rate_(16000) { +} +WaveData::~WaveData() { +} + +void WaveData::Set(int number_samples, int sampling_rate, const int16_t *data) { + set_sample_rate(sampling_rate); + resize(number_samples); + for (int n = 0; n < number_samples; ++n) { + (*this)[n] = data[n]; + } +} + +int WaveData::sample_rate(void) const { + return sample_rate_; +} + +void WaveData::set_sample_rate(int sample_rate) { + sample_rate_ = sample_rate; +} + +bool WaveData::Equals(const WaveData &wave_data, int threshold) const { + if (wave_data.size() != size()) { + fprintf(stderr, "Different number of samples"); + return false; + } + if (wave_data.sample_rate() != sample_rate()) { + fprintf(stderr, "Different sample rate"); + return false; + } + for (int i = 0; i < size(); ++i) { + if (abs(wave_data[i] - (*this)[i]) > threshold) { + fprintf(stderr, "Sample %d differs", i); + return false; + } + } + return true; +} + +Wave::Wave() { + data_ = new WaveData; + owner_ = true; +} + +Wave::Wave(const WaveData *data) { + // Shallow copy + data_ = const_cast(data); + owner_ = false; +} + +Wave::~Wave() { + Clear(); +} + +void Wave::Clear() { + if (owner_) { + delete data_; + } + data_ = NULL; + owner_ = true; +} + +void Wave::set_data(const WaveData *data) { + if (owner_) { + delete data_; + } + data_ = const_cast(data); + owner_ = false; +} + +void Wave::copy_data(const WaveData &data) { + if (owner_) { + delete data_; + } + data_ = new WaveData(data); + owner_ = true; +} + +void Wave::resize(int n, bool clear) { + if (!owner_) { + // copy the data to a local copy + WaveData *new_wave_data = new WaveData(*data_); + new_wave_data->set_sample_rate(data_->sample_rate()); + data_ = new_wave_data; + } + data_->resize(n); + owner_ = true; +} + +void Wave::ZeroFill() { + if (!owner_) { + // copy the data to a local copy + WaveData *new_wave_data = new WaveData(*data_); + new_wave_data->set_sample_rate(data_->sample_rate()); + data_ = new_wave_data; + owner_ = true; + } + std::fill(data_->begin(), data_->end(), 0); +} + +bool Wave::Load(FileResource *fr) { + WaveIO wave_io; + std::vector *samples = reinterpret_cast *>(data_); + int sampling_rate; + bool status = wave_io.Load(fr, samples, &sampling_rate); + set_sample_rate(sampling_rate); + return status; +} + +const int16_t Wave::kMaxShort = std::numeric_limits::max() - 1; +const int16_t Wave::kMinShort = std::numeric_limits::min() + 1; + +bool Wave::Amplify(float gain) { + return AmplifyBuffer(gain, &(*data_)[0], data_->size()); +} + +bool Wave::AmplifyBuffer(float gain, int16_t *buf, uint32_t size) { + bool clipped = false; + for (uint32_t i = 0; i < size; ++i) { + float sample = static_cast(buf[i]) * gain; + if (sample > kMaxShort) { + sample = kMaxShort; + clipped = true; + } else if (sample < kMinShort) { + sample = kMinShort; + clipped = true; + } + buf[i] = static_cast(sample); + } + return !clipped; +} diff --git a/REAPER/wave/wave.h b/REAPER/wave/wave.h new file mode 100644 index 0000000000000000000000000000000000000000..6fc2c1199e97f713a2c68e9d62a9913254febbde --- /dev/null +++ b/REAPER/wave/wave.h @@ -0,0 +1,142 @@ +/* +Copyright 2015 Google Inc. All rights reserved. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +#ifndef _WAVE_H_ +#define _WAVE_H_ + +#include "core/file_resource.h" +#include +#include + + + +class WaveData : public std::vector { + public: + WaveData(); + ~WaveData(); + + void Set(int number_samples, int sampling_rate, const int16_t *data); + int sample_rate(void) const; + void set_sample_rate(int sample_rate); + bool Equals(const WaveData &wave_data, int threshold = 0) const; + + private: + int sample_rate_; +}; + +class Wave { + public: + Wave(); + explicit Wave(const WaveData *data); + ~Wave(); + + // Sets internal WaveData to the new object. It loses ownership. + void set_data(const WaveData *data); + + // Sets values of WaveData to the new data. It takes ownership. + void copy_data(const WaveData &data); + + // Returns the number of samples contained in the wave. + int num_samples() const { + return data_->size(); + } + + // Returns the sample rate of the wave. + int sample_rate() const { + return data_->sample_rate(); + } + + // Sets the sample rate for the wave. + void set_sample_rate(int sample_rate) { + data_->set_sample_rate(sample_rate); + } + + // Returns the value of the data at the given offset within the wave. + int16_t get(int f) const { + return (*data_)[f]; + } + + // Sets the wave data at the given position with the given value. + void set(int f, int16_t v) { + (*data_)[f] = v; + } + + // Returns the wave data. + const WaveData *data() const { + return data_; + } + + // Ensures that this wave 'parents' the wave data, + // so deleting it when this instance is deleted. + void adopt() { + owner_ = true; + } + + const int16_t &operator [] (int f) const { + return (*data_)[f]; + } + + int16_t &operator [] (int f) { + return (*data_)[f]; + } + + // Resizes + void resize(int n, bool clear = false); + + // Zero fills the wave data. + void ZeroFill(); + + // Applies the given gain to the wave data, limited to int16_t limits. + // Returns true if no clipping occurred. + // Returns false if the amplification resulted in clipping. + // The gain factor is a simple multiplicative factor, NOT a dB value. + bool Amplify(float gain_factor); + + // Applies the given gain to the given buffer location and the given + // number of entries in that buffer. + // Returns true if no clipping occurred. + // Returns false if the amplification resulted in clipping. + // The gain factor is a simple multiplicative factor, NOT a dB value. + static bool AmplifyBuffer(float gain_factor, + int16_t *buffer, uint32_t num_entries); + + bool Load(const std::string &filename); + bool Load(FileResource *fr); + + protected: + // Clears the audio data down and sets the owner. + void Clear(); + + private: + static const int16_t kMaxShort; + static const int16_t kMinShort; + // The wave data. + WaveData *data_; + // Holds whether this instance is to sole owner of the wave data, allowing + // for correct object deletion. + bool owner_; +}; + +inline bool Wave::Load(const std::string &filename) { + FileResource fr(filename, "rb"); + if (!fr.Get()) { + fprintf(stderr, "Failed to open \"%s\"", filename.c_str()); + return false; + } + return Load(&fr); +} + +#endif // SPEECH_PATTS_ENGINE_LING_ARCH_WAVE_H_ diff --git a/REAPER/wave/wave_io-inl.h b/REAPER/wave/wave_io-inl.h new file mode 100644 index 0000000000000000000000000000000000000000..ddccb3fd4196055807f24739f5990a4b6e0f83c6 --- /dev/null +++ b/REAPER/wave/wave_io-inl.h @@ -0,0 +1,39 @@ +/* +Copyright 2015 Google Inc. All rights reserved. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + +http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +#ifndef _WAVE_IO_INL_H_ +#define _WAVE_IO_INL_H_ + +#include +#include + +inline WaveCodingType WaveIO::get_coding_type() const { + return coding_type_; +} + +template +bool WaveIO::Load(const std::string &filename, + std::vector *samples, + int32_t *sample_rate) { + FileResource fr(filename, "rb"); + if (!fr.Get()) { + fprintf(stderr, "Failed to open \"%s\"", filename.c_str()); + return false; + } + return Load(&fr, samples, sample_rate); +} + +#endif // _WAVE_IO_INL_H_ diff --git a/REAPER/wave/wave_io.cc b/REAPER/wave/wave_io.cc new file mode 100644 index 0000000000000000000000000000000000000000..d34f24a73bd7facbaa433da22e931634f08722e6 --- /dev/null +++ b/REAPER/wave/wave_io.cc @@ -0,0 +1,111 @@ +/* +Copyright 2015 Google Inc. All rights reserved. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +#include "wave/wave_io.h" + +#include + +#include "core/file_resource.h" + + + +WaveIO::WaveIO(void) { + Initialize(PCM16); +} + +WaveIO::WaveIO(WaveCodingType coding_type) { + Initialize(coding_type); +} + +bool WaveIO::ReadAudioData(int32_t wave_start, + int32_t num_samples, + std::vector *samples, + FileResource *fr) { + switch (coding_type_) { + case PCM16: + case PCM8: + case ULAW8: + return codec_riff_.ReadAudioData(wave_start, num_samples, samples, fr); + default: + fprintf(stderr, "WaveIO:ReadAudioData: unknown coding type %d", + coding_type_); + } + return false; +} + +bool WaveIO::ReadAudioContainer(int container_size_in_bytes, + std::vector *samples, + FileResource *fr) { + switch (coding_type_) { + case PCM16: + case PCM8: + case ULAW8: + return codec_riff_.ReadAudioContainer(container_size_in_bytes, + samples, fr); + fprintf(stderr, "WaveIO:ReadAudioData: unknown coding type %d", + coding_type_); + default: + fprintf(stderr, "WaveIO: coding type not supported %d", coding_type_); + return false; + } + return false; +} + +bool WaveIO::ReadHeader(FileResource *fr, + int32_t *num_samples_per_channel, + int32_t *sampling_rate) { + switch (coding_type_) { + case PCM16: + case PCM8: + case ULAW8: { + bool status = codec_riff_.ReadHeader(fr); + if (!status) { + return false; + } + *num_samples_per_channel = codec_riff_.get_num_samples_per_channel(); + *sampling_rate = codec_riff_.get_sampling_rate(); + return true; + } + default: + fprintf(stderr, "WaveIO:ReadHeader: unknown coding type %d", + coding_type_); + } + return false; +} + +bool WaveIO::Load(FileResource *fr, + std::vector *samples, + int32_t *sample_rate) { + int32_t num_samples; + if (!ReadHeader(fr, &num_samples, sample_rate)) { + return false; + } + samples->resize(num_samples); + return ReadAudioData(0, num_samples, samples, fr); +} + +bool WaveIO::Initialize(WaveCodingType coding_type) { + coding_type_ = coding_type; + switch (coding_type_) { + case PCM16: + case PCM8: + case ULAW8: + return codec_riff_.Initialize(coding_type); + default: + fprintf(stderr, "WaveIO:WaveIO: unknown coding type %d", coding_type_); + return false; + } +} diff --git a/REAPER/wave/wave_io.h b/REAPER/wave/wave_io.h new file mode 100644 index 0000000000000000000000000000000000000000..04f80da0fb8289322de0f83e74187b8cd73adbe2 --- /dev/null +++ b/REAPER/wave/wave_io.h @@ -0,0 +1,79 @@ +/* +Copyright 2015 Google Inc. All rights reserved. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +#ifndef _WAVE_IO_H_ +#define _WAVE_IO_H_ + +#include "wave/codec_api.h" +#include "wave/codec_riff.h" + +class FileResource; + +// This class provides the main interface for waveform input/output. The class +// abstracts the implementation of the codec from the rest of the system. +class WaveIO { + public: + WaveIO(); + explicit WaveIO(WaveCodingType coding_type); + ~WaveIO() { } + + template + bool Load(const std::string &filename, + std::vector *samples, + int32_t *sample_rate); + + // Loads the header-info and the audio data from a file, starting from the + // current position of the FileResource. + bool Load(FileResource *fr, + std::vector *samples, + int32_t *sample_rate); + + // Reads the header-info from the FileResource, starting from the current + // position. + bool ReadHeader(FileResource *fr, + int32_t *num_samples_per_channel, + int32_t *sample_rate); + + // Reads the audio data from the FileResource, under the condition that the + // current position of the FileResource always points to the beginning of the + // audio-container. The latter condition is preserved by this function. When + // a codec with internal-state is used (i.e. iSAC), the internal state is kept + // between sequential reads. The codec is reset prior non-sequential reads. + bool ReadAudioData(int32_t wave_start, + int32_t num_samples, + std::vector *samples, + FileResource *fr); + + // Reads all audio data contained in the audio container held at the current + // position of the FileResource. + bool ReadAudioContainer(int container_size_in_bytes, + std::vector *samples, + FileResource *fr); + + // Sets WaveIO to the corresponding codec, and also initializes the codec + // itself. + bool Initialize(WaveCodingType coding_type); + + WaveCodingType get_coding_type() const; + + private: + CodecApi codec_riff_; + WaveCodingType coding_type_; +}; + +#include "wave_io-inl.h" + +#endif // _WAVE_IO_H_