mirror
/
codec2_talkie
kopia lustrzana https://github.com/sh123/codec2_talkie
1
0
Forkuj 0
Kod Zgłoszenia Projekty Wydania Wiki Aktywność

Updated freedv

aprs
sh123 2022-08-11 15:18:11 +03:00
rodzic ed933bc419
commit d2728ca58a
1614 zmienionych plików z 23016 dodań i 87092 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

8
codec2talkie/src/main/res/values/arrays.xml vendored
Wyświetl plik

@ -333,8 +333,8 @@
<item>FreeDV 700C</item>
<item>FreeDV 700D</item>
<!--item>FreeDV 2020</item>
<item>FreeDV 2020B</item>
<item>FreeDV 700E</item-->
<item>FreeDV 2020B</item-->
<item>FreeDV 700E</item>
</string-array>
<string-array name="ports_sound_modem_type_values">
@ -347,8 +347,8 @@
<item>F6</item>
<item>F7</item>
<!--item>F8</item>
<item>F16</item>
<item>F13</item-->
<item>F16</item-->
<item>F13</item>
</string-array>
<string-array name="ports_type_labels">

1
libcodec2-android/build.gradle vendored
Wyświetl plik

@ -82,7 +82,6 @@ task compileCodec2 {
commandLine "/usr/bin/make"
}
for(String abi : rootProject.ext.ABI_FILTERS.split(";")) {
System.out.println("Handle abi " + abi)
exec {

877
libcodec2-android/src/codec2/CMakeLists.txt vendored
Wyświetl plik

Plik diff jest za duży Load Diff

225
libcodec2-android/src/codec2/README.md vendored
Wyświetl plik

@ -8,7 +8,7 @@ Also included:
+ APIs for raw and Ethernet packet data over radio [README_data](README_data.md)
+ High performance coherent OFDM modem for HF channels [README_ofdm](README_ofdm.md)
+ High performance non-coherent FSK modem [README_fsk](README_fsk.md)
+ An STM32 embedded version of FreeDV 1600/700D for the [SM1000](stm32/README.md)
+ An STM32 embedded version of FreeDV 1600/700D/700E for the [SM1000](stm32/README.md)
+ Coherent PSK modem [README_cohpsk](README_cohpsk.md) for HF channels
+ FDMDV DPSK modem [README_fdmdv](README_fdmdv.md) for HF channels
@ -16,96 +16,104 @@ Also included:
1. Install packages (Debian/Ubuntu):
```
$ sudo apt install git build-essential cmake
sudo apt install git build-essential cmake
```
Fedora/RH distros:
```
$ sudo dnf groupinstall "Development Tools" "C Development Tools and Libraries"
$ sudo dnf install cmake
sudo dnf groupinstall "Development Tools" "C Development Tools and Libraries"
sudo dnf install cmake
```
1. Build Codec 2:
```
$ git clone git@github.com:drowe67/codec2.git
$ cd codec2
$ mkdir build_linux
$ cd build_linux
$ cmake ..
$ make
git clone https://github.com/drowe67/codec2.git
cd codec2
mkdir build_linux
cd build_linux
cmake ..
make
```
1. Listen to Codec 2 (run from ```codec2/build_linux```):
1. Listen to Codec 2:
```
$ ./src/c2demo ../raw/hts1a.raw hts1a_c2.raw
$ aplay -f S16_LE ../raw/hts1a.raw
$ aplay -f S16_LE hts1a_c2.raw
cd codec2/build_linux
./demo/c2demo ../raw/hts1a.raw hts1a_c2.raw
aplay -f S16_LE ../raw/hts1a.raw
aplay -f S16_LE hts1a_c2.raw
```
1. Compress, decompress and then play a file using Codec 2 at 2400 bit/s:
```
$ ./src/c2enc 2400 ../raw/hts1a.raw hts1a_c2.bit
$ ./src/c2dec 2400 hts1a_c2.bit hts1a_c2_2400.raw
./src/c2enc 2400 ../raw/hts1a.raw hts1a_c2.bit
./src/c2dec 2400 hts1a_c2.bit hts1a_c2_2400.raw
```
which can be played with:
```
$ aplay -f S16_LE hts1a_c2_2400.raw
aplay -f S16_LE hts1a_c2_2400.raw
```
Or using Codec 2 using 700C (700 bits/s):
```
$ ./src/c2enc 700C ../raw/hts1a.raw hts1a_c2.bit
$ ./src/c2dec 700C hts1a_c2.bit hts1a_c2_700.raw
$ aplay -f S16_LE hts1a_c2_700.raw
./src/c2enc 700C ../raw/hts1a.raw hts1a_c2.bit
./src/c2dec 700C hts1a_c2.bit hts1a_c2_700.raw
aplay -f S16_LE hts1a_c2_700.raw
```
1. If you prefer a one-liner without saving to files:
```
$ ./src/c2enc 1300 ../raw/hts1a.raw - | ./src/c2dec 1300 - - | aplay -f S16_LE
./src/c2enc 1300 ../raw/hts1a.raw - | ./src/c2dec 1300 - - | aplay -f S16_LE
```
1. Or you can use your microphone and headphones to encode and listen to the result on the fly:
```
br=1300; arecord -f S16_LE -c 1 -r 8000 | ./src/c2enc $br - - | ./src/c2dec $br - - | aplay -f S16_LE -
```
## FreeDV 2020 support (building with LPCNet)
1. Build codec2 initially without LPCNet
```
$ cd ~
$ git clone https://github.com/drowe67/codec2.git
$ cd codec2 && mkdir build_linux && cd build_linux
$ cmake ../
$ make
cd ~
git clone https://github.com/drowe67/codec2.git
cd codec2 && mkdir build_linux && cd build_linux
cmake ../
make
```
1. Build LPCNet:
```
$ cd ~
$ git clone https://github.com/drowe67/LPCNet
$ cd LPCNet && mkdir build_linux && cd build_linux
$ cmake -DCODEC2_BUILD_DIR=~/codec2/build_linux ../
$ make
cd ~
git clone https://github.com/drowe67/LPCNet
cd LPCNet && mkdir build_linux && cd build_linux
cmake -DCODEC2_BUILD_DIR=~/codec2/build_linux ../
make
```
1. (Re)build Codec 2 with LPCNet support:
```
$ cd ~/codec2/build_linux && rm -Rf *
$ cmake -DLPCNET_BUILD_DIR=~/LPCNet/build_linux ..
$ make
cd ~/codec2/build_linux && rm -Rf *
cmake -DLPCNET_BUILD_DIR=~/LPCNet/build_linux ..
make
```
## Programs
+ ```c2demo``` encodes a file of speech samples, then decodes them and saves the result.
+ See `demo` directory for simple examples of using Codec and the FreeDV API.
+ ```c2enc``` encodes a file of speech samples to a compressed file of encoded bits. ```c2dec``` decodes a compressed file of bits to a file of speech samples.
+ `c2demo` encodes a file of speech samples, then decodes them and saves the result.
+ ```c2sim``` is a simulation/development version of Codec 2. It allows selective use of the various Codec 2 algorithms. For example switching phase modelling or quantisation on and off.
+ `c2enc` encodes a file of speech samples to a compressed file of encoded bits. `c2dec` decodes a compressed file of bits to a file of speech samples.
+ ```freedv_tx``` & ```freedv_rx``` are command line implementations of the FreeDV protocol, which combines Codec 2, modems, and Forward Error Correction (FEC).
+ `c2sim` is a simulation/development version of Codec 2. It allows selective use of the various Codec 2 algorithms. For example switching phase modelling or quantisation on and off.
+ `freedv_tx` & `freedv_rx` are command line implementations of the FreeDV protocol, which combines Codec 2, modems, and Forward Error Correction (FEC).
+ ```cohpsk_*``` are coherent PSK (COHPSK) HF modem command line programs.
+ `cohpsk_*` are coherent PSK (COHPSK) HF modem command line programs.
+ ```fdmdv_*``` are differential PSK HF modem command line programs (README_fdmdv).
+ `fdmdv_*` are differential PSK HF modem command line programs (README_fdmdv).
+ ```fsk_*``` are command line programs for a non-coherent FSK modem (README_fsk).
+ `fsk_*` are command line programs for a non-coherent FSK modem (README_fsk).
+ ```ldpc_*``` are LDPC encoder/decoder command line programs, based on the CML library.
+ `ldpc_*` are LDPC encoder/decoder command line programs, based on the CML library.
+ ```ofdm_*``` are OFDM PSK HF modem command line programs (README_ofdm).
+ `ofdm_*` are OFDM PSK HF modem command line programs (README_ofdm).
## Building and Running Unit Tests
@ -113,42 +121,48 @@ CTest is used as a test framework, with support from [GNU Octave](https://www.gn
1. Install GNU Octave and libraries on Ubuntu with:
```
$ sudo apt install octave octave-common octave-signal liboctave-dev gnuplot python3-numpy sox valgrind
sudo apt install octave octave-common octave-signal liboctave-dev gnuplot python3-numpy sox valgrind
```
1. Install CML library with instructions at the top of [```octave/ldpc.m```](octave/ldpc.m)
1. To build and run the tests:
```
$ cd ~/codec2
$ rm -Rf build_linux && mkdir build_linux
$ cd build_linux
$ cmake -DCMAKE_BUILD_TYPE=Debug ..
$ make all test
cd ~/codec2
rm -Rf build_linux && mkdir build_linux
cd build_linux
cmake -DUNITTEST=1 ..
make
```
1. To just run tests without rebuilding:
```
$ ctest
ctest
```
1. To get a verbose run (e.g. for test debugging):
```
$ ctest -V
ctest -V
```
1. To just run a single test:
```
$ ctest -R test_OFDM_modem_octave_port
ctest -R test_OFDM_modem_octave_port
```
1. To list the available tests:
```
$ ctest -N
ctest -N
```
1. Many Octave scripts rely on the CML LDPC library. To run these from the Octave CLI, you need to set
the `CML_PATH` environment variable. A convenient way to do this is using a `.octaverc` file
in your `codec/octave` directory. For example on a Linux machine, create a `.octaverc` file:
```
setenv("CML_PATH","../build_linux/cml")
```
## Directories
```
cmake - cmake support files
demo - Simple Codec 2 and FreeDv API demo applications
misc - misc C programs that have been useful in development,
not reqd for Codec 2 release. Part of Debug build.
octave - Octave scripts used to support development
@ -163,30 +177,30 @@ wav - speech files in wave file format
1. To compile with debug symbols for using gdb:
```
$ cd ~/codec2
$ rm -Rf build_linux && mkdir build_linux
$ cd build_linux
$ CFLAGS=-g cmake ..
$ make
cd ~/codec2
rm -Rf build_linux && mkdir build_linux
cd build_linux
CFLAGS=-g cmake ..
make
```
1. For dump file support (dump data from c2sim for input to Octave development scripts):
```
$ cd ~/codec2
$ rm -Rf build_linux && mkdir build_linux
$ cd build_linux
$ CFLAGS=-DDUMP cmake ..
$ make
cd ~/codec2
rm -Rf build_linux && mkdir build_linux
cd build_linux
CFLAGS=-DDUMP cmake ..
make
```
## Building for Windows on a Linux machine
On Ubuntu 17 and above:
```
$ sudo apt-get install mingw-w64
$ mkdir build_windows && cd build_windows
$ cmake .. -DCMAKE_TOOLCHAIN_FILE=/home/david/freedv-dev/cmake/Toolchain-Ubuntu-mingw32.cmake -DUNITTEST=FALSE -DGENERATE_CODEBOOK=/home/david/codec2/build_linux/src/generate_codebook
$ make
sudo apt-get install mingw-w64
mkdir build_windows && cd build_windows
cmake .. -DCMAKE_TOOLCHAIN_FILE=/home/david/freedv-dev/cmake/Toolchain-Ubuntu-mingw32.cmake -DUNITTEST=FALSE -DGENERATE_CODEBOOK=/home/david/codec2/build_linux/src/generate_codebook
make
```
## Building for Windows on a Windows machine
@ -199,3 +213,76 @@ On Ubuntu 17 and above:
wait for it to build.
```
## Including Codec 2 in an Android project
In an Android Studio 'NDK' project (a project that uses 'native' code)
Codec 2 can be added to the project in the following way.
1. Add the Codec 2 source tree to your app (e.g. in app/src/main/codec2)
(e.g. as a git sub-module).
1. Add Codec 2 to the CMakeList.txt (app/src/main/cpp/CMakeLists.txt):
```
# Sets lib_src_DIR to the path of the target CMake project.
set( codec2_src_DIR ../codec2/ )
# Sets lib_build_DIR to the path of the desired output directory.
set( codec2_build_DIR ../codec2/ )
file(MAKE_DIRECTORY ${codec2_build_DIR})
add_subdirectory( ${codec2_src_DIR} ${codec2_build_DIR} )
include_directories(
${codec2_src_DIR}/src
${CMAKE_CURRENT_BINARY_DIR}/../codec2
)
```
1. Add Codec 2 to the target_link_libraries in the same file.
## Building Codec 2 for Microcontrollers
Codec 2 requires a hardware Floating Point Unit (FPU) to run in real time.
Two build options have been added to support building on microcontrollers:
1. Setting the `cmake` variable MICROCONTROLLER_BUILD disables position independent code (-fPIC is not used). This was required for the IMRT1052 used in Teensy 4/4.1).
1. On ARM machines, setting the C Flag \_\_EMBEDDED\_\_ and linking with the ARM CMSIS library will improve performance on ARM-based microcontrollers. \_\_REAL\_\_ and FDV\_ARM\_MATH are additional ARM-specific options that can be set to improve performance if required, especially with OFDM modes.
A CMakeLists.txt example for a microcontroller is below:
```
set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)
set(MICROCONTROLLER_BUILD 1)
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mlittle-endian -ffunction-sections -fdata-sections -g -O3")
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -ffunction-sections -fdata-sections")
add_definitions(-DCORTEX_M7 -D__EMBEDDED__)
add_definitions(-DFREEDV_MODE_EN_DEFAULT=0 -DFREEDV_MODE_1600_EN=1 -DFREEDV_MODE_700D_EN=1 -DFREEDV_MODE_700E_EN=1 -DCODEC2_MODE_EN_DEFAULT=0 -DCODEC2_MODE_1300_EN=1 -DCODEC2_MODE_700C_EN=1)
FetchContent_Declare(codec2
GIT_REPOSITORY https://github.com/drowe67/codec2.git
GIT_TAG origin/master
GIT_SHALLOW ON
GIT_PROGRESS ON
)
FetchContent_GetProperties(codec2)
if(NOT ${codec2_POPULATED})
FetchContent_Populate(codec2)
endif()
set(CMAKE_REQUIRED_FLAGS "")
set(LPCNET OFF CACHE BOOL "")
add_subdirectory(${codec2_SOURCE_DIR} ${codec2_BINARY_DIR} EXCLUDE_FROM_ALL)
```
## Building Debian packages
To build Debian packages, simply run the "cpack" command after running "make". This will generate the following packages:
+ codec2: Contains the .so and .a files for linking/executing applications dependent on Codec2.
* codec2-dev: Contains the header files for development using Codec2.
Once generated, they can be installed with "dpkg -i" (once LPCNet is installed). If LPCNet is not desired, CMakeLists.txt can be modified to remove that dependency.

4
libcodec2-android/src/codec2/README_cohpsk.md vendored
Wyświetl plik

@ -7,7 +7,7 @@
1. BER test in AWGN channel with just less that 2% average bit error rate:
```
$ ./cohpsk_get_test_bits - 5600 | ./cohpsk_mod - - | ./cohpsk_ch - - -30 | ./cohpsk_demod - - | ./cohpsk_put_test_bits -
$ ./cohpsk_get_test_bits - 5600 | ./cohpsk_mod - - | ./ch - - --No -30 --Fs 7500 | ./cohpsk_demod - - | ./cohpsk_put_test_bits -
<snip>
SNR3k(dB): 3.41 C/No: 38.2 PAPR: 8.1
BER: 0.017 Nbits: 5264 Nerrors: 92
@ -18,7 +18,7 @@
```
$ cd build_linux/src
$ ./cohpsk_get_test_bits - 5600 | ./cohpsk_mod - - | ./cohpsk_ch - - -40 -f -20 | ./cohpsk_demod -o cohpsk_demod.txt - - | ./cohpsk_put_test_bits -
$ ./cohpsk_get_test_bits - 5600 | ./cohpsk_mod - - | ./ch - - --No -40 -f -20 --Fs 7500 | ./cohpsk_demod -o cohpsk_demod.txt - - | ./cohpsk_put_test_bits -
$ cd ../../octave
$ octave --no-gui
$ cohpsk_demod_plot("../build_linux/src/cohpsk_demod.txt")

161
libcodec2-android/src/codec2/README_data.md vendored
Wyświetl plik

@ -4,7 +4,7 @@
FreeDV can be used to send data over radio channels. Two APis are supported:
+ VHF packet data channel which uses Ethernet style framing.
+ Raw frames of modem data
+ Raw frames of modem data over VHF and HF channels.
## Credits
@ -24,9 +24,9 @@ VHF packet data API:
You can listen to the modem signal using:
```sh
$ ./src/freedv_data_tx 2400A - --frames 15 | aplay -f S16_LE -r 48000
```
2. Same for 2400B and 800XA
```sh
@ -43,16 +43,13 @@ VHF packet data API:
Raw modem frame API:
1. Let's send two modem frames of 14 bytes using FreeDV 700D:
1. Let's send a 128 byte frame containing some text over the modem:
```sh
$ head -c 28 </dev/urandom > binaryIn.bin
$ ./src/freedv_data_raw_tx 700D binaryIn.bin - | ./src/freedv_data_raw_rx 700D - - | hexdump
bits_per_modem_frame: 112 bytes_per_modem_frame: 14
frames processed: 4 output bytes: 28
$ hexdump binaryIn.bin
0000000 4325 0363 ce1f fb88 8102 7d76 c487 e092
0000010 2ded bc06 7689 eb67 5dfe 43df
padding=$(head -c 115 < /dev/zero | tr '\0' '-'); echo "Hello World" $padding > in.txt
./src/freedv_data_raw_tx --bursts 1 datac3 in.txt - | ./src/freedv_data_raw_rx --framesperburst 1 datac3 - -
Hello World --------
```
Note we've padded the input frame to 126 bytes, the DATAC3 framesize (less CRC).
# VHF Packet Data Channel
@ -169,11 +166,15 @@ A combination of the two methods may also be used. Send data when no voice is ac
# Raw Data using the FreeDV API
The demo programs [freedv_data_raw_tx.c](src/freedv_data_raw_tx.c) and [freedv_data_raw_rx.c](src/freedv_data_raw_rx.c) show how to use the raw data API. The raw data API may lose frames due to channel impairments, loss of sync, or acquisition delays. The caller must handle these situations. The caller is also responsible for segmentation/re-assembly of the modem frames into larger blocks of data.
The raw data API can be used to send frames of bytes over radio channels. The frames are protected with FEC and have a 16-bit checksum to verify correct transmission. However the raw data API may lose frames due to channel impairments, loss of sync, or acquisition delays. The caller must handle these situations. The caller is also responsible for segmentation/re-assembly of the modem frames into larger blocks of data.
Several modes are available which support FSK and OFDM modulation. FSK is aimed at VHF And UHF applications, and the OFDM modes have been optimised for multipath HF radio channels.
For simple examples of how use the FreeDV API with raw data frames, see the demo programs [freedv_data1_tx.c](demo/freedv_data1_tx.c) and [freedv_data1_rx.c](src/freedv_data1_rx.c) The full featured sample programs [freedv_data_raw_tx.c](src/freedv_data_raw_tx.c) and [freedv_data_raw_rx.c](src/freedv_data_raw_rx.c) can be used to experiment with the raw data API.
## FSK LDPC Raw Data Mode
The FSK_LDPC mode uses 2 or 4 FSK in combination with powerful LDPC codes. Parameters such as the number of FSK tones, sample rate, symbol rate, and LDPC code can be selected at initialisation time. The frame format is:
The FSK_LDPC mode uses 2 or 4 FSK in combination with powerful LDPC codes, and was designed for VHF or UHF AWGN channels. Parameters such as the number of FSK tones, sample rate, symbol rate, and LDPC code can be selected at initialisation time. The frame format is:
```
| Preamble | UW | payload data | CRC | parity | UW | payload data | CRC | parity | ........... |
| frame 1 -------------------------| frame 2 -------------------------| ... frame n |
@ -188,12 +189,11 @@ $ echo 'Hello World ' |
./freedv_data_raw_rx FSK_LDPC - - 2>/dev/null |
hexdump -C
00000000 48 65 6c 6c 6f 20 57 6f 72 6c 64 20 20 20 20 20 |Hello World |
00000010 20 20 20 20 20 20 20 20 20 20 20 20 20 20 11 c6 | ..|
00000010 20 20 20 20 20 20 20 20 20 20 20 20 20 20 | ..|
00000020
```
Notes:
1. The input data is padded to 30 bytes. The (512,256) code sends 256 data bits every frame, we reserve 16 for a CRC, so there are 240 bits, or 30 bytes of payload data required for one frame.
1. You can see the `0x11c6` CRC bytes at the end of the hexdump output.
1. The '2>/dev/null' command redirects stderr to nowhere, removing some of the debug information the test programs usually display to make this example easier to read.
When testing, it's convenient to use an internal source of test data. Here is an example where we send a single burst of 10 test frames:
@ -203,9 +203,9 @@ $ ./freedv_data_raw_tx --testframes 10 FSK_LDPC /dev/zero - | ./freedv_data_raw_
Nbits: 50 N: 4000 Ndft: 1024
bits_per_modem_frame: 256 bytes_per_modem_frame: 32
bytes_per_modem_frame: 32
Frequency: Fs: 8.0 kHz Rs: 0.1 kHz Tone1: 1.0 kHz Shift: 0.2 kHz M: 2
Frequency: Fs: 8.0 kHz Rs: 0.1 kHz Tone1: 1.0 kHz Shift: 0.2 kHz M: 2
frames processed: 131 output bytes: 320 output_packets: 10
frames processed: 131 output bytes: 320 output_packets: 10
BER......: 0.0000 Tbits: 5440 Terrs: 0
Coded BER: 0.0000 Tbits: 2560 Terrs: 0
```
@ -213,26 +213,26 @@ The default is 100 bits/s 2FSK. The (512,256) code sends 256 data bits (32 bytes
In real world operation, 16 of the data bits are reserved for a CRC, leaving 240 payload data bits per frame. Taking into account the overhead of the UW, CRC, and parity bits, we send 240 payload data bits for every out of 544, so the payload data rate in this example is (240/512)*(100 bits/s) = 44.1 bits/s.
We can add some channel noise using the `cohpsk_ch` tool and see how it performs:
We can add some channel noise using the `ch` tool and see how it performs:
```
$ ./freedv_data_raw_tx --testframes 1 --bursts 10 FSK_LDPC /dev/zero - |
./cohpsk_ch - - -5 --Fs 8000 --ssbfilt 0 |
./ch - - --No -5 --ssbfilt 0 |
./freedv_data_raw_rx --testframes -v FSK_LDPC - /dev/null
<snip>
frames processed: 336 output bytes: 320 output_packets: 10
frames processed: 336 output bytes: 320 output_packets: 10
BER......: 0.0778 Tbits: 5440 Terrs: 423
SNR3k(dB): -13.00 C/No: 21.8 PAPR: 7.5
SNR3k(dB): -13.00 C/No: 21.8 PAPR: 7.5
Coded BER: 0.0000 Tbits: 2560 Terrs: 0
```
The `cohpsk_ch` stderr reporting is mixed up with the testframes results but we can see that over a channel with a -13dB SNR, we obtained a raw bit error rate of 0.0778 (nearly 8%). However the LDPC code cleaned that up nicely and still received all 10 packets with no errors.
The `ch` stderr reporting is mixed up with the testframes results but we can see that over a channel with a -13dB SNR, we obtained a raw bit error rate of 0.0778 (nearly 8%). However the LDPC code cleaned that up nicely and still received all 10 packets with no errors.
Here is an example running 4FSK at 20000 bits/s (10000 symbols/s), at a sample rate of 200 kHz:
```
$./freedv_data_raw_tx -m 4 --Fs 200000 --Rs 10000 --tone1 10000 --shift 10000 --testframes 100 --bursts 10 FSK_LDPC /dev/zero - |
./cohpsk_ch - - -12 --Fs 8000 --ssbfilt 0 |
./ch - - --No -12 --ssbfilt 0 |
./freedv_data_raw_rx -m 4 --testframes -v --Fs 200000 --Rs 10000 FSK_LDPC --mask 10000 - /dev/null
<snip>
frames processed: 5568 output bytes: 30144 output_packets: 942
frames processed: 5568 output bytes: 30144 output_packets: 942
BER......: 0.0691 Tbits: 528224 Terrs: 36505
Coded BER: 0.0022 Tbits: 248576 Terrs: 535
```
@ -240,18 +240,113 @@ Some notes on this example:
1. We transmit 10 bursts, each of 100 frames in length, 1000 packets total. There are a couple of frames silence between each burst. This gives the acquisition algorithms a good work out.
1. Only 942 packets make it though this rather noisy channel, a 6% Packet Error Rate (PER). In a real world application, a higher protocol layer would need to detect this, and arrange for re-transmission of missing packets. If the SNR was a few dB better, all 1000 packets would likely make it through. If it was 1dB worse, nothing would get through; LDPC codes have a very sharp "knee" in the PER versus SNR curve.
1. Our first tone `--tone` is at 10kHz, and each tone is spaced `--shift` by 10kHz, so we have FSK tones at 10,20,30, and 40 kHz. For good performance, FSK tones must be spaced by at least the symbol rate Rs.
1. Although the `cohpsk_ch` utility is designed for 8kHz sample rate operation, it just operates on sampled signals, so it's OK to use at higher sample rates. It does have some internal filtering so best to keep your signal well away from 0 and (sample rate)/2. The SNR measurement is calibrated to a 3000 Hz noise bandwidth, so won't make much sense at other sample rates. The third argument `-12` sets the noise level of the channel.
1. Although the `ch` utility is designed for 8kHz sample rate operation, it just operates on sampled signals, so it's OK to use at higher sample rates. It does have some internal filtering so best to keep your signal well away from 0 and (sample rate)/2. The SNR measurement is calibrated to a 3000 Hz noise bandwidth, so won't make much sense at other sample rates. The third argument `-12` sets the noise level of the channel.
1. The `--mask` frequency offset algorithm is used, which gives better results on noisy channels, especially for 4FSK.
There are some more example in the [ctests](CMakeLists.txt).
### Reading Further
## HF Raw Data modes
1. Examples in the [ctests](CMakeLists.txt).
1. [FSK_LDPC blog post](http://www.rowetel.com/?p=7467)
The following FreeDV modes are recommended for *preliminary development* using the raw data API. These modes were originally designed for streaming voice rather than data and are not suitable for production HF data applications. They have small payloads, and acquisition algorithms not suitable for packet data over real world HF channels. New modes are being design for HF data at the time of writing (June 2020).
## OFDM Raw Data modes for HF Radio
| FreeDV Mode | RF bandwidth (Hz) | Payload data rate bits/s | bytes/frame | FEC | Min SNR (dB, AWGN) |
| :-: | :-: | :-: | :-: | :-: | :-: |
| 700C | 1100 | 700 | 7 | none | 2 |
| 700D | 1100 | 700 | 14 | rate 0.8 | -2 |
| 2020 | 1500 | 1733 | 39 | rate 0.6 | 2 |
These modes use an OFDM modem with powerful LDPC codes and are designed for sending data over HF radio channels with multipath fading. At the time of writing (April 2021) they are a work in progress, but usable as is. The current modes supported are:
| FreeDV Mode | RF bandwidth (Hz) | Payload data rate bits/s | Payload bytes/frame | FEC | Duration (sec) | MPP test | Use case |
| :-: | :-: | :-: | :-: | :-: | :-: | :-: | :-: |
| DATAC0 | 500 | 291 | 14 | (256,128) | 0.44 | 70/100 at 0dB | Reverse link ACK packets (all SNRs) |
| DATAC1 | 1700 | 980 | 510 | (8192,4096) | 4.18 | 92/100 at 5dB | Forward link data (medium SNR) |
| DATAC3 | 500 | 321 | 126 | (2048,1024) | 3.19 | 74/100 at 0dB | Forward link data (low SNR) |
Notes:
1. 16 bits (2 bytes) per frame are reserved for a 16 bit CRC, e.g. for `datac3` we have 128 byte frames, and 128-2=126 bytes/frame of payload data.
1. SNR is the target operating point SNR for each mode.
1. "MPP test" is the number of packets received/transmitted on a simulated MultiPath Poor channel (1Hz Doppler spread, 2ms delay) at the operating point SNR.
From the callers point of view, the frame format of each burst is:
```
| Preamble | payload data | CRC | payload data | CRC | ........... | Postamble |
| frame 1 -----------| frame 2 -----------| ... frame N |
```
In the next layer down, each frame is comprised of several OFDM "modem frames", that contain pilot, unique word, and FEC symbols to handle syncronisation and error correction over the challenging HF channel. The preamble and postamble are used to locate the burst and estimate it's frequency offset. Having both a pre and postamble increases the probability of successful detection of the burst in a fading channel. Here are some single frame bursts on a MPP channel at 5dB SNR:
![](doc/pre_post_amble_mpp.png)
You can see what a mess the MPP channel makes. Sometimes we find the pre-amble, other times the post-amble. Using both increases the probability of detecting the burst, it's a form of time diversity. If the probability of missing the pre-amble is P(fail)=0.1, then the probability of missing the pre and post-amble is P(fail)*P(fail)=0.01. If we find either we can work out where the burst starts and start demodulating.
Here is an example of sending 3 bursts of 2 frames/burst, a total of 6 frames:
```
./src/freedv_data_raw_tx --framesperburst 2 --bursts 3 --testframes 6 DATAC0 /dev/zero - |
./src/freedv_data_raw_rx --framesperburst 2 --testframes DATAC0 - /dev/null --vv
<snip>
BER......: 0.0000 Tbits: 1536 Terrs: 0
Coded BER: 0.0000 Tbits: 768 Terrs: 0
Coded PER: 0.0000 Tpkts: 6 Tpers: 0
```
Lets add some noise and a 20 Hz frequency offset:
```
./src/freedv_data_raw_tx --framesperburst 2 --bursts 3 --testframes 6 DATAC0 /dev/zero - |
./src/ch - - --No -20 -f 20 |
./src/freedv_data_raw_rx --framesperburst 2 --testframes DATAC0 - /dev/null --vv
<snip>
marks:space: 0.83 SNR offset: -0.79
ch: SNR3k(dB): -0.36 C/No....: 34.42
<snip>
BER......: 0.0195 Tbits: 1536 Terrs: 30
Coded BER: 0.0000 Tbits: 768 Terrs: 0
Coded PER: 0.0000 Tpkts: 6 Tpers: 0
```
We still received 6 frames OK (Tpkts field), but in this case there was a raw BER of about 2% which the FEC cleaned up nicely (Coded BER 0.0). Just above that we can see the "SNR offset" and "ch: SNR3k" fields. In the silence between bursts the modem signal has zero power, which biases the SNR measured by the `ch` channels simulation tool. This bias is the "SNR offset". So the true SNR for this test is actually:
```
SNR = -0.36 - (-0.79) = 0.43 dB
```
In the `raw` directory is a real world off-air sample of a signal sent between Adelaide and Melbourne (800km) using about 20W on 40m. This can be decoded with:
```
./src/freedv_data_raw_rx datac1 --framesperburst 1 --testframes ../raw/test_datac1_006.raw /dev/null --vv
<snip>
BER......: 0.0134 Tbits: 73728 Terrs: 986
Coded BER: 0.0000 Tbits: 36864 Terrs: 0
Coded PER: 0.0000 Tpkts: 9 Tpers: 0
```
It's also useful to listen to the file, you can hear co-channel SSB, the bursts starting and stopping, and some fading:
```
aplay -f S16_LE ../raw/test_datac1_006.raw
```
Here is a spectrogram (waterfall on it's side - time flows from left to right, frequency on the Y axis):
![](doc/test_datac1_006_spectrogram.png)
The multipath channel carves notches out of the signal, and the level rises and falls. The 27 carriers of the `datac1` channel can also be observed. The SSB is the fuzz along the top. The SNR varied between 8 and 16dB. The fading is even more obvious on the scatter diagram:
![](doc/test_datac1_006_scatter.png)
The X shape is due to the level of each carrier changing with the fading. In some cases a carrier is faded down to zero. The FEC helps clean up any errors due to faded carriers.
## SNR estimation and clipping
The modem estimates the SNR of every received packet, which can be useful for selecting the best mode to maximise bit rate while minimising the packet error rate.
Clipping (compression) is enabled by default on each modem waveform to maximise the Peak to Average Power Ratio (PAPR). Power amplifiers are usually rated in terms of peak power (PEP). For a given peak power, clipping increases SNR over the channel by 3-4dB.
Clipping works by introducing controlled distortion, which affects the SNR estimator in the modem. When clipping is enabled, the SNR reported by the datac0 and datac3 modes will start to roll off and reach a plateau at about 8dB with no channel noise. For the same channel SNR, datac1 will return a higher (and more accurate) SNR estimate. If clipping is disabled, the datac0 and datac3 modes will report a more accurate SNR.
This command line demonstrates the effect:
```
./src/freedv_data_raw_tx datac3 /dev/zero - --testframes 10 --bursts 10 --clip 1 | ./src/ch - - --No -100 --fading_dir unittest | ./src/freedv_data_raw_rx datac3 - /dev/null --testframes --framesperburst 1 -v
```
Try adjusting `--clip` and `No` argument of `ch` (noise level) for different modes. Note the SNR estimates returned from `freedv_data_raw_rx` compared to the SNR from the channel simulator `ch`. You will notice clipping also increases the RMS power and reduces the PER for a given noise level.
## Reading Further
Resources:
1. See the raw data example in Quickstart section above.
1. For simple examples of how use the FreeDV API, see the demo programs [freedv_datac1_tx.c](demo/freedv_datac1_tx.c) and [freedv_datac1_rx.c](demo/freedv_datac1_rx.c)
1. [freedv_data_raw_tx.c](src/freedv_data_raw_tx.c) and [freedv_data_raw_rx.c](src/freedv_data_raw_rx.c) are more full deatured example programs.
1. The modem waveforms designs are described in this [spreadsheet](doc/modem_codec_frame_design.ods).
1. Examples in the [ctests](CMakeLists.txt) (look for "FreeDV API raw data")
1. [Codec 2 HF Data Modes Part 1 blog post](http://www.rowetel.com/?p=7167)
1. [HF Data Acquisition](https://github.com/drowe67/codec2/pull/171) GitHub Pull Request

346
libcodec2-android/src/codec2/README_freedv.md vendored
Wyświetl plik

@ -1,6 +1,6 @@
# FreeDV Technology
FreeDV is an open source digital voice protocol that integrates modems, codecs, and FEC.
FreeDV is an open source digital voice protocol that integrates modems, speech codecs, and FEC.
On transmit, FreeDV converts speech to a modem signal you can send over a radio channel. On receive, FreeDV takes off air modem signals and converts them to speech samples.
@ -10,6 +10,201 @@ This document gives an overview of the technology inside FreeDV, and some additi
![FreeDV mode knob](http://www.rowetel.com/images/codec2/mode_dv.jpg)
## FreeDV API
The general programming model is:
```
speech samples -> FreeDV encode -> modulated samples (send over radio) -> FreeDV decode -> speech samples
```
The `codec2/demo` directory provides simple FreeDV API demo programs written in C and Python to help you get started, for example:
```
cd codec2/build_linux
cat ../raw/ve9qrp_10s.raw | ./demo/freedv_700d_tx | ./demo/freedv_700d_rx | aplay -f S16_LE
```
The current demo programs are as follows:
| Program | Description |
| --- | --- |
| [c2demo.c](demo/c2demo.c) | Encode and decode speech with Codec 2 |
| [freedv_700d_tx.c](demo/freedv_700d_tx.c) | Transmit a voice signal using the FreeDV API |
| [freedv_700d_rx.c](demo/freedv_700d_rx.c) | Receive a voice signal using the FreeDV API |
| [freedv_700d_rx.py](demo/freedv_700d_rx.py) | Receive a voice signal using the FreeDV API in Python |
| [freedv_datac1_tx.c](demo/freedv_datac1_tx.c) | Transmit raw data frames using the FreeDV API |
| [freedv_datac1_rx.c](demo/freedv_datac1_rx.c) | Receive raw data frames using the FreeDV API |
| [freedv_datac0c1_tx.c](demo/freedv_datac0c1_tx.c) | Transmit two types of raw data frames using the FreeDV API |
| [freedv_datac0c1_rx.c](demo/freedv_datac0c1_rx.c) | Receive two types of raw data frames using the FreeDV API |
So also [freedv_api.h](src/freedv_api.h) and [freedv_api.c](src/freedv_api.c) for the full list of API functions. Only a small set of these functions are needed for basic FreeDV use, please see the demo programs for minimal examples.
The full featured command line demo programs [freedv_tx.c](src/freedv_tx.c) & [freedv_rx.c](src/freedv_rx.c) demonstrate many features of the API:
```
$ ./freedv_tx 1600 ../../raw/hts1.raw - | ./freedv_rx 1600 - - | aplay -f S16_LE
$ cat freedv_rx_log.txt
```
Speech samples are input to the API as 16 bit signed integers. Modulated samples can be in real 16 bit signed integer or complex float. The expected sample rates can be found with `freedv_get_speech_sample_rate()` and `freedv_get_modem_sample_rate()`. These are typically 8000 Hz but can vary depending on the current FreeDV mode.
## FreeDV HF Modes
These are designed for use with a HF SSB radio.
| Mode | Date | Codec | Modem | RF BW | Raw bits/s | FEC | Text bits/s | SNR min | Multipath |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 1600 | 2012 | Codec2 1300 | 14 DQPSK + 1 DBPSK pilot carrier | 1125 | 1600 | Golay (23,12) | 25 | 4 | poor |
| 700C | 2017 | Codec2 700C | 14 carrier coherent QPSK + diversity | 1500 | 1400 | - | - | 2 | good |
| 700D | 2018 | Codec2 700C | 17 carrier coherent OFDM/QPSK | 1000 | 1900 | LDPC (224,112) | 25 | -2 | fair |
| 700E | 2020 | Codec2 700C | 21 carrier coherent OFDM/QPSK | 1500 | 3000 | LDPC (112,56) | 25 | 1 | good |
| 2020 | 2019 | LPCNet 1733 | 31 carrier coherent OFDM/QPSK | 1600 | 3000 | LDPC (504,396) | 22.2 | 2 | poor |
| 2020A | 2022 | LPCNet 1733 | 31 carrier coherent OFDM/QPSK | 1600 | 3000 | LDPC (504,396) unequal | 22.2 | 2 | fair |
| 2020B | 2022 | LPCNet 1733 | 29 carrier coherent OFDM/QPSK | 2100 | 4100 | LDPC (112,56) unequal | 22.2 | 3 | good |
Notes:
1. *Raw bits/s* is the number of payload bits/s carried over the channel by the modem. This consists of codec frames, FEC parity bits, unprotected text, and synchronisation information such as pilot and unique word bits. The estimates are open to interpretation for the OFDM waveforms due to pilot symbol and cyclic prefix considerations (see spreadsheet).
1. *RF BW* is the bandwidth of the RF signal over the air. FreeDV is more bandwidth efficient than SSB.
1. *Multipath* is the relative resilience of the mode to multipath fading, the biggest problem digital voice faces on HF radio channels. Analog SSB would be rated as "good".
1. *Text* is a side channel for low bit rate text such as your location and call sign. It is generally unprotected by FEC, and encoded with varicode. The exception is if reliable_text support is turned on (see reliable_text.c/h); this results in text protected by LDPC(112,56) FEC with interleaving.
1. *SNR Min* is for an AWGN channel (no multipath/fading).
1. All of the modems use multiple parallel carriers running at a low symbol rate of around 50 Hz. This helps combat the effects of multipath channels.
1. Some of the Codec 2 modes (2400/1300/700C etc) happen to match the name of a FreeDV mode. For example FreeDV 700C uses Codec 2 700C for voice compression. However FreeDV 700D *also* uses Codec 2 700C for voice compression, but has a very different modem waveform to FreeDV 700C. Sorry for the confusing nomenclature.
1. Coherent demodulation gives much better performance than differential, at the cost of some additional complexity. Pilot symbols are transmitted regularly to allow the demod to estimate the reference phase of each carrier.
1. The 1600 and 700C waveforms use parallel tone modems, later modes use OFDM. OFDM gives tighter carrier packing which allows higher bit rates, but tends to suffer more from frequency offsets and delay spread.
1. At medium to high SNRs, FreeDV 700C performs well (better than 700D) on fast fading multipath channels with large delay spread due its parallel tone design and high pilot symbol rate. It employs transmit diversity which delivers BER performance similar to modes using FEC. FreeDV 700C also has a short frame (40ms), so syncs fast with low latency. Fast sync is useful on marginal channels that move between unusable and barely usable.
1. FreeDV 700D uses an OFDM modem and was optimised for low SNR channels, with strong FEC but a low pilot symbol rate and modest (2ms) cyclic prefix which means its performance degrades on multipath channels with fast (> 1Hz) fading. The use of strong FEC makes this mode quite robust to other channel impairments, such as static crashes, urban HF noise, and in-band interference.
1. FEC was added fairly recently to FreeDV modes. The voice codecs we use work OK at bit error rates of a few %, and packet error rates of 10%. Raw bit error rates on multipath channels often exceed 10%. For reasonable latency (say 40ms) we need small codewords. Thus to be useful we require a FEC code that works at over 10% raw BER, has 1% output (coded) bit error rate, and a codeword of around 100 bits. Digital voice has unusual requirements, most FEC codes are designed for data which is intolerant of any bit errors, and few operate over 10% raw BER. Powerful FEC codes have long block lengths (1000's of bits) which leads to long latency. However LDPC codes come close, and can also "clean up" other channel errors caused by static and interference. The use of OFDM means we now have "room" for the extra bits required for FEC, so there is little cost in adding it, apart from latency.
1. 2020A and 2020B use unequal error protection, only 11 bits from each 52 bit vocoder frame are protected by FEC. This provides strong protection of the most important bits. The effect is a gentle "slope" in the speech quality versus SNR curve. These modes will work at lower SNRs that 2020, but will still have some audible errors even at high SNRs. 2020B has a modem waveform similar to 700E - a high pilot symbol rate so it operates on fast fading channels. Compared to 2020 it has a shorter frame duration (90ms), lower latency and faster sync, but requires a few more dB SNR.
## FreeDV VHF Modes
These modes use constant amplitude modulation like FSK or FM, and are designed for VHF and above. However 800XA can be run over HF or VHF on a SSB radio.
| Mode | Date | Codec2 | Modem | RF BW | Raw bits/s | FEC | Text bits/s |
| --- | --- | --- | --- | --- | --- | --- | --- |
| 2400A | 2016 | 1300 | 4FSK | 5kHz | 2400 | Golay (23,12) | 50 |
| 2400B | 2016 | 1300 | baseband/analog FM | analog FM | 2400 | Golay (23,12) | 50 |
| 800XA | 2017 | 700C | 4FSK | 2000 | 800 | - | N |
| FSK_LDPC | 2020 | - | 2 or 4 FSK | user defined | user defined | LDPC | - | - |
The FSK_LDPC mode is used for data, and has user defined bit rate and a variety of LDPC codes available. It is discussed in [README_data](README_data.md)
## FreeDV 2400A and 2400B modes
FreeDV 2400A and FreeDV 2400B are modes designed for VHF radio. FreeDV 2400A is designed for SDR radios (it has a 5 kHz RF bandwidth), however FreeDV 2400B is designed to pass through commodity FM radios.
Demos of FreeDV 2400A and 2400B:
```
$ ./freedv_tx 2400A ../../raw/ve9qrp_10s.raw - | ./freedv_rx 2400A - - | play -t .s16 -r 8000 -
$ ./freedv_tx 2400B ../../raw/ve9qrp_10s.raw - | ./freedv_rx 2400B - - | play -t .s16 -r 8000 -
```
Note for FreeDV 2400A/2400B the modem signal sample rate is 48kHz. To
listen to the modem tones from FreeDV 2400B, or play them into a FM HT
mic input:
```
$ ./freedv_tx 2400B ../../raw/ve9qrp_10s.raw - | play -t .s16 -r 48000 -
```
Simulate FreeDV 2400B passing through a 300 to 3000 Hz audio path using sox to filter:
```
$ ./freedv_tx 2400B ../../raw/ve9qrp_10s.raw - | sox -t .s16 -r 48000 - -t .s16 - sinc 300-3000 | ./freedv_rx 2400B - - | play -t .s16 -r 8000 -
```
## FreeDV 2020 support (building with LPCNet)
1. Build codec2 initially without LPCNet
```
$ cd ~
$ git clone https://github.com/drowe67/codec2.git
$ cd codec2 && mkdir build_linux && cd build_linux
$ cmake ../
$ make
```
1. Build LPCNet:
```
$ cd ~
$ git clone https://github.com/drowe67/LPCNet
$ cd LPCNet && mkdir build_linux && cd build_linux
$ cmake -DCODEC2_BUILD_DIR=~/codec2/build_linux ../
$ make
```
1. (Re)build Codec 2 with LPCNet support:
```
$ cd ~/codec2/build_linux && rm -Rf *
$ cmake -DLPCNET_BUILD_DIR=~/LPCNet/build_linux ..
$ make
```
## FreeDV 2020 tests with FreeDV API
```
$ cat ~/LPCNet/wav/wia.wav | ~/LPCNet/build_linux/src/lpcnet_enc -s | ./ofdm_mod --mode 2020 --ldpc --verbose 1 | ./ofdm_demod --mode 2020 --verbose 1 --ldpc | ~/LPCNet/build_linux/src/lpcnet_dec -s | aplay -f S16_LE -r 16000
```
Listen the reference tx:
```
$ cat ~/LPCNet/wav/wia.wav | ~/LPCNet/build_linux/src/lpcnet_enc -s | ./ofdm_mod --mode 2020 --ldpc --verbose 1 | aplay -f S16_LE
```
Listen the freedv_tx:
```
$ ./freedv_tx 2020 ~/LPCNet/wav/wia.wav - | aplay -f S16_LE
```
FreeDV API tx, with reference rx from above:
```
$ ./freedv_tx 2020 ~/LPCNet/wav/wia.wav - | ./ofdm_demod --mode 2020 --verbose 1 --ldpc | ~/LPCNet/build_linux/src/lpcnet_dec -s | aplay -f S16_LE -r 16000
```
FreeDV API tx and rx:
```
$ ./freedv_tx 2020 ~/LPCNet/wav/all.wav - | ./freedv_rx 2020 - - | aplay -f S16_LE -r 16000
$ ./freedv_tx 2020 ~/LPCNet/wav/all.wav - --testframes | ./freedv_rx 2020 - /dev/null --testframes -vv
```
Simulated HF slow fading channel, 10.8dB SNR:
```
$ ./freedv_tx 2020 ~/LPCNet/wav/all.wav - | ./ch - - --No -30 --slow | ./freedv_rx 2020 - - | aplay -f S16_LE -r 16000
```
It falls down quite a bit with fast fading (--fast):
AWGN (noise but no fading) channel, 2.8dB SNR:
```
$ ./freedv_tx 2020 ~/LPCNet/wav/all.wav - | ./ch - - --No -22 | ./freedv_rx 2020 - - | aplay -f S16_LE -r 16000
```
## Command lines for PER testing 700D/700E PER with clipper
AWGN:
```
$ ./src/freedv_tx 700D ../raw/ve9qrp.raw - --clip 0 --testframes | ./src/ch - - --No -16 | ./src/freedv_rx 700D - /dev/null --testframes
```
MultiPath Poor (MPP):
```
$ ./src/freedv_tx 700D ../raw/ve9qrp.raw - --clip 0 --testframes | ./src/ch - - --No -24 --mpp --fading_dir unittest | ./src/freedv_rx 700D - /dev/null --testframes
```
Adjust `--clip [0|1]` and `No` argument of `ch` to obtain a PER of just less than 0.1, and note the SNR and PAPR reported by `ch`. The use of the `ve9qrp` samples makes the test run for a few minutes, in order to get reasonable multipath channel results.
Low SNR MPP channel 2020B command line:
```
cat ~/LPCNet/wav/all.wav | ~/LPCNet/build_linux/src/lpcnet_enc -x | ./src/ofdm_mod --mode 2020B --ldpc --clip --txbpf | ./src/ch - - --No -22 --mpd | ./src/ofdm_demod --mode 2020B --verbose 1 --ldpc | ~/LPCNet/build_linux/src/lpcnet_dec -x | aplay -f S16_LE -r 16000
```
## Reading Further
1. [FreeDV web site](http://freedv.org)
@ -29,152 +224,3 @@ This document gives an overview of the technology inside FreeDV, and some additi
1. [OFDM modem README](README_ofdm.md)
1. Many blog posts in the [rowetel.com blog archives](http://www.rowetel.com/?page_id=6172)
## FreeDV HF Modes
These are designed for use with a HF SSB radio.
| Mode | Date | Codec | Modem | RF BW | Raw bits/s | FEC | Text | SNR min | Multipath |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 1600 | 2012 | Codec2 1300 | DQPSK + pilot | 1125 | 1600 | Golay (23,12) | Y | 4 | poor |
| 700C | 2017 | Codec2 700C | coherent QPSK + diversity | 1500 | 1400 | - | - | 2 | good |
| 700D | 2018 | Codec2 700C | coherent OFDM/QPSK | 1000 | 1900 | LDPC (224,112) | Y | -2 | fair |
| 2020 | 2019 | LPCNet 1733 | coherent OFDM/QPSK | 1600 | 3000 | LDPC (504,396) | Y | 2 | poor |
Notes:
1. *Raw bits/s* is the number of payload bits/s carried over the channel by the modem. This consists of codec frames, FEC parity bits, unprotected text, and synchronisation information such as pilot and unique word bits. The estimates are open to interpretation for the OFDM waveforms due to pilot symbol and cyclic prefix considerations (see spreadsheet).
1. *RF BW* is the bandwidth of the RF signal over the air. FreeDV is more bandwidth efficient than SSB.
1. *Multipath* is the relative resilience of the mode to multipath fading, the biggest problem digital voice faces on HF radio channels. Analog SSB would be rated as "good".
1. *Text* is a side channel for low bit rate text such as your location and call sign. It is generally unprotected by FEC, and encoded with varicode.
1. *SNR Min* is for an AWGN channel (no multipath/fading).
1. All of the modems use multiple parallel carriers running at a low symbol rate of around 50 Hz. This helps combat the effects of multipath channels.
1. Some of the Codec 2 modes (2400/1300/700C etc) happen to match the name of a FreeDV mode. For example FreeDV 700C uses Codec 2 700C for voice compression. However FreeDV 700D *also* uses Codec 2 700C for voice compression, but has a very different modem waveform to FreeDV 700C. Sorry for the confusing nomenclature.
1. Coherent demodulation gives much better performance than differential, at the cost of some additional complexity. Pilot symbols are transmitted regularly to allow the demod to estimate the reference phase of each carrier.
1. The 1600 and 700C waveforms use parallel tone modems, later modes use OFDM. OFDM gives tighter carrier packing which allows higher bit rates, but tends to suffer more from frequency offsets and delay spread.
1. At medium to high SNRs, FreeDV 700C performs well (better than 700D) on fast fading multipath channels with large delay spread due its parallel tone design and high pilot symbol rate. It employs transmit diversity which delivers BER performance similar to modes using FEC. FreeDV 700C also has a short frame (40ms), so syncs fast with low latency. Fast sync is useful on marginal channels that move between unusable and barely usable.
1. FreeDV 700D uses an OFDM modem and was optimised for low SNR channels, with strong FEC but a low pilot symbol rate and modest (2ms) cyclic prefix which means its performance degrades on multipath channels with fast (> 1Hz) fading. The use of strong FEC makes this mode quite robust to other channel impairments, such as static crashes, urban HF noise, and in-band interference.
1. FEC was added fairly recently to FreeDV modes. The voice codecs we use work OK at bit error rates of a few %, and packet error rates of 10%. Raw bit error rates on multipath channels often exceed 10%. For reasonable latency (say 40ms) we need small codewords. Thus to be useful we require a FEC code that works at over 10% raw BER, has 1% output (coded) bit error rate, and a codeword of around 100 bits. Digital voice has unusual requirements, most FEC codes are designed for data which is intolerant of any bit errors, and few operate over 10% raw BER. Powerful FEC codes have long block lengths (1000's of bits) which leads to long latency. However LDPC codes come close, and can also "clean up" other channel errors caused by static and interference. The use of OFDM means we now have "room" for the extra bits required for FEC, so there is little cost in adding it, apart from latency.
## FreeDV VHF Modes
These modes use constant amplitude modulation like FSK or FM, and are designed for VHF and above. However 800XA can be run over HF or VHF on a SSB radio.
| Mode | Date | Codec2 | Modem | RF BW | Raw bits/s | FEC | Text |
| --- | --- | --- | --- | --- | --- | --- | --- |
| 2400A | 2016 | 1300 | 4FSK | 2400 | 5kHz | Golay (23,12) | Y |
| 2400B | 2016 | 1300 | baseband/analog FM | analog FM | 2400 | Golay (23,12) | Y |
| 800XA | 2017 | 700C | 4FSK | 2000 | 800 | - | N |
| FSK_LDPC | 2020 | - | 2 or 4 FSK | user defined | user defined | LDPC | - | - |
The FSK_LDPC mode is used for data, and has user defined bit rate and a variety of LDPC codes available. It is discussed in [README_data](README_data.md)
## FreeDV API
See [freedv_api.h](src/freedv_api.h) and [freedv_api.c](src/freedv_api.c), and the command line demo programs [freedv_tx.c](src/freedv_tx.c) & [freedv_rx.c](src/freedv_rx.c). Quickstart demo using FreeDV 1600:
```
$ ./freedv_tx 1600 ../../raw/hts1.raw - | ./freedv_rx 1600 - - | play -t raw -r 8000 -s -2 -q -
$ cat freedv_rx_log.txt
```
## FreeDV 2400A and 2400B modes
FreeDV 2400A and FreeDV 2400B are modes designed for VHF radio. FreeDV 2400A is designed for SDR radios (it has a 5 kHz RF bandwidth), however FreeDV 2400B is designed to pass through commodity FM radios.
Demos of FreeDV 2400A and 2400B:
```
$ ./freedv_tx 2400A ../../raw/ve9qrp_10s.raw - | ./freedv_rx 2400A - - | play -t raw -r 8000 -s -2 -
$ ./freedv_tx 2400B ../../raw/ve9qrp_10s.raw - | ./freedv_rx 2400B - - | play -t raw -r 8000 -s -2 -
```
Note for FreeDV 2400A/2400B the modem signal sample rate is 48kHz. To
listen to the modem tones from FreeDV 2400B, or play them into a FM HT
mic input:
```
$ ./freedv_tx 2400B ../../raw/ve9qrp_10s.raw - | play -t raw -r 48000 -s -2 -
```
Simulate FreeDV 2400B passing through a 300 to 3000 Hz audio path using sox to filter:
```
$ ./freedv_tx 2400B ../../raw/ve9qrp_10s.raw - | sox -t raw -r 48000 -s -2 - -t raw - sinc 300-3000 | ./freedv_rx 2400B - - | play -t raw -r 8000 -s -2 -
```
## FreeDV 2020 support (building with LPCNet)
1. Build codec2 initially without LPCNet
```
$ cd ~
$ git clone https://github.com/drowe67/codec2.git
$ cd codec2 && mkdir build_linux && cd build_linux
$ cmake ../
$ make
```
1. Build LPCNet:
```
$ cd ~
$ git clone https://github.com/drowe67/LPCNet
$ cd LPCNet && mkdir build_linux && cd build_linux
$ cmake -DCODEC2_BUILD_DIR=~/codec2/build_linux ../
$ make
```
1. (Re)build Codec 2 with LPCNet support:
```
$ cd ~/codec2/build_linux && rm -Rf *
$ cmake -DLPCNET_BUILD_DIR=~/LPCNet/build_linux ..
$ make
```
## FreeDV 2020 tests with FreeDV API
```
$ cat ~/LPCNet/wav/wia.wav | ~/LPCNet/build_linux/src/lpcnet_enc -s | ./ofdm_mod --mode 2020 --ldpc --verbose 1 -p 312 | ./ofdm_demod --mode 2020 --verbose 1 --ldpc -p 312 | ~/LPCNet/build_linux/src/lpcnet_dec -s | aplay -f S16_LE -r 16000
```
Listen the reference tx:
```
$ cat ~/LPCNet/wav/wia.wav | ~/LPCNet/build_linux/src/lpcnet_enc -s | ./ofdm_mod --mode 2020 --ldpc --verbose 1 -p 312 | aplay -f S16_LE
```
Listen the freedv_tx:
```
$ ./freedv_tx 2020 ~/LPCNet/wav/wia.wav - | aplay -f S16_LE
```
FreeDV API tx, with reference rx from above:
```
$ ./freedv_tx 2020 ~/LPCNet/wav/wia.wav - | ./ofdm_demod --mode 2020 --verbose 1 --ldpc -p 312 | ~/LPCNet/build_linux/src/lpcnet_dec -s | aplay -f S16_LE -r 16000
```
FreeDV API tx and rx:
```
$ ./freedv_tx 2020 ~/LPCNet/wav/all.wav - | ./freedv_rx 2020 - - | aplay -f S16_LE -r 16000
$ ./freedv_tx 2020 ~/LPCNet/wav/all.wav - --testframes | ./freedv_rx 2020 - /dev/null --testframes -vv
```
Simulated HF slow fading channel, 10.8dB SNR:
```
$ ./freedv_tx 2020 ~/LPCNet/wav/all.wav - | ./cohpsk_ch - - -30 --Fs 8000 --slow | ./freedv_rx 2020 - - | aplay -f S16_LE -r 16000
```
It falls down quite a bit with fast fading (--fast):
AWGN (noise but no fading) channel, 2.8dB SNR:
```
$ ./freedv_tx 2020 ~/LPCNet/wav/all.wav - | ./cohpsk_ch - - -22 --Fs 8000 | ./freedv_rx 2020 - - | aplay -f S16_LE -r 16000
```
## Further work
1. ~~Spell check/proofread~~
1. Screen shots of each modes (waterfall and spectrum), discussing aspects of waveforms
1. ~~Link to this doc from freedv-gui user manual, rowetel/codec2 page, freedv.org~~
1. ~~README_fdmdv.txt -> .md~~
1. nice image or two
1. table of source files

6
libcodec2-android/src/codec2/README_fsk.md vendored
Wyświetl plik

@ -49,13 +49,13 @@ The Octave version of the modem was developed by David Rowe. Brady O'Brien port
1. Lets add some channel noise:
```
$ ./fsk_get_test_bits - 10000 | ./fsk_mod 2 8000 100 1200 100 - - | ./cohpsk_ch - - -26 --Fs 8000 | ./fsk_demod 2 8000 100 - - | ./fsk_put_test_bits -b 0.015 -
$ ./fsk_get_test_bits - 10000 | ./fsk_mod 2 8000 100 1200 100 - - | ./ch - - --No -26 | ./fsk_demod 2 8000 100 - - | ./fsk_put_test_bits -b 0.015 -
<snip>
SNR3k(dB): -5.76 C/No: 29.0 PAPR: 3.0
[0099] BER 0.010, bits tested 9900, bit errors 103
PASS
```
The cohpsk_ch utility takes the FSK modulator signal, and adds calibrated noise to it (the -26 value specifies the noise). Try changing the noise level, and note how the Bit Error Rate (BER) changes. The BER is 0.01, which is right on theory for this sort of FSK demodulator at this SNR (2FSK non-coherent demodulator Eb/No=9dB).
The `ch` utility takes the FSK modulator signal, and adds calibrated noise to it (the `--No -26` value specifies the noise). Try changing the noise level, and note how the Bit Error Rate (BER) changes. The BER is 0.01, which is right on theory for this sort of FSK demodulator at this SNR (2FSK non-coherent demodulator Eb/No=9dB).
The SNR is calculated using the signal power divided by the noise power in 3000 Hz. The C/No value is the same thing, but uses a noise bandwidth of 1 Hz. There is less noise power when you look at just 1Hz, so C/No is higher. Peak to Average Power ratio (PAPR) is 3dB as a FSK signal is just a single sine wave, and a sine wave peak is 3dB higher than it's average.
@ -77,7 +77,7 @@ The Octave version of the modem was developed by David Rowe. Brady O'Brien port
$ cd ~/codec2/build_linux/src
$ ./ldpc_enc /dev/zero - --code H_256_512_4 --testframes 200 |
./framer - - 512 5186 | ./fsk_mod 4 8000 100 1000 100 - - |
./cohpsk_ch - - -24 --Fs 8000 |
./ch - - --No -24 |
./fsk_demod -s 4 8000 100 - - |
./deframer - - 512 5186 |
./ldpc_dec - /dev/null --code H_256_512_4 --testframes

84
libcodec2-android/src/codec2/README_ofdm.md vendored
Wyświetl plik

@ -33,7 +33,7 @@ Built as part of codec2-dev, see [README](README.md) for build instructions.
```
$ build_linux/src$ ./ofdm_mod --in /dev/zero --testframes 10 | play --type s16 --rate 8000 --channels 2 -
```
1. Generate 10 seconds of uncoded test frame bits, modulate, demodulate, count errors:
```
$ build_linux/src$ ./ofdm_mod --in /dev/zero --testframes 10 | ./ofdm_demod --out /dev/null --testframes --verbose 1 --log demod_dump.txt
@ -44,7 +44,7 @@ Built as part of codec2-dev, see [README](README.md) for build instructions.
$ octave --no-gui
octave:1> ofdm_demod_c("../build_linux/src/demod_dump.txt")
```
1. Run Octave versions of mod and demod (called tx and rx to avoid namespace clashes in Octave):
```
$ cd ~/octave
@ -71,59 +71,50 @@ Built as part of codec2-dev, see [README](README.md) for build instructions.
```
build_linux/src$ ./ofdm_demod --in ../../octave/ofdm_test.raw --out /dev/null --verbose 1 --testframes --ldpc
```
1. Pass Codec 2 700C compressed speech through OFDM modem:
```
build_linux/src$ ./c2enc 700C ../../raw/ve9qrp_10s.raw - --bitperchar | ./ofdm_mod --ldpc | ./ofdm_demod --ldpc | ./c2dec 700C - - --bitperchar | play --type s16 --rate 8000 --channels 1 -
```
1. Listen to signal through simulated fading channel in C:
```
build_linux/src$ ./c2enc 700C ../../raw/ve9qrp_10s.raw - --bitperchar | ./ofdm_mod --ldpc | ./cohpsk_ch - - -20 --Fs 8000 --slow -f -5 | aplay -f S16
build_linux/src$ ./c2enc 700C ../../raw/ve9qrp_10s.raw - --bitperchar | ./ofdm_mod --ldpc | ./ch - - --No -20 --mpg -f -5 | aplay -f S16
```
1. Run test frames through simulated channel in C:
```
build_linux/src$ ./ofdm_mod --in /dev/zero --ldpc --testframes 20 | ./cohpsk_ch - - -24 --Fs 8000 -f -10 --fast | ./ofdm_demod --out /dev/null --testframes --verbose 1 --ldpc
build_linux/src$ ./ofdm_mod --in /dev/zero --ldpc --testframes 20 | ./ch - - --No -24 -f -10 --mpp | ./ofdm_demod --out /dev/null --testframes --verbose 1 --ldpc
```
1. Run codec voice through simulated fast fading channel, just where it starts to fall over:
1. Run codec voice through simulated fast fading channel, just where it starts to fall over:
```
build_linux/src$ ./c2enc 700C ../../raw/ve9qrp.raw - --bitperchar | ./ofdm_mod --ldpc | ./cohpsk_ch - - -24 --Fs 8000 -f -10 --fast | ./ofdm_demod --ldpc --verbose 1 | ./c2dec 700C - - --bitperchar | aplay -f S16
build_linux/src$ ./c2enc 700C ../../raw/ve9qrp.raw - --bitperchar | ./ofdm_mod --ldpc | ./ch - - --No -24 -f -10 --mpp | ./ofdm_demod --ldpc --verbose 1 | ./c2dec 700C - - --bitperchar | aplay -f S16
```
1. FreeDV 1600 on the same channel conditions, roughly same quality at 8dB higher SNR:
```
build_linux/src$ ./freedv_tx 1600 ../../raw/ve9qrp_10s.raw - | ./cohpsk_ch - - -30 --Fs 8000 -f -10 --fast | ./freedv_rx 1600 - - | aplay -f S16
build_linux/src$ ./freedv_tx 1600 ../../raw/ve9qrp_10s.raw - | ./ch - - --No -30 -f -10 --mpp | ./freedv_rx 1600 - - | aplay -f S16
```
1. Using FreeDV API test programs:
```
```
build_linux/src$ ./freedv_tx 700D ../../raw/hts1a.raw - --testframes | ./freedv_rx 700D - /dev/null --testframes
build_linux/src$ ./freedv_tx 700D ../../raw/hts1a.raw - | ./freedv_rx 700D - - | aplay -f S16
build_linux/src$ ./freedv_tx 700D ../../raw/ve9qrp.raw - | ./cohpsk_ch - - -26 --Fs 8000 -f -10 --fast | ./freedv_rx 700D - - | aplay -f S16
build_linux/src$ ./freedv_tx 700D ../../raw/ve9qrp.raw - | ./ch - - --No -26 -f -10 --mpp | ./freedv_rx 700D - - | aplay -f S16
```
## FreeDV 2020 extensions
1. 37 Carrier waveform with a (504,396) code:
```
build_linux/src$ nc=37; ./ofdm_mod --in /dev/zero --testframes 300 --mode 2020 --nc $nc --ldpc --verbose 1 | ./cohpsk_ch - - -22.5 --Fs 8000 -f 10 --ssbfilt 1 | ./ofdm_demod --out /dev/null --testframes --mode 2020 --nc $nc --verbose 1 --ldpc
SNR3k(dB): 4.05 C/No: 38.8 PAPR: 10.8
BER......: 0.0348 Tbits: 1044792 Terrs: 36345
Coded BER: 0.0094 Tbits: 820908 Terrs: 7717
```
1. 20.5ms symbol period, 31 carrier waveform, (504,396) code, but only 312 data bits used, so we don't send unused data bits. This means we need less carriers (so more power per carrier), and code rate is increased slightly (sorta). Anyhoo, it works about 1.5dB better:
1. 20.5ms symbol period, 31 carrier waveform, (504,396) code, but only 312 data bits used, so we don't send unused data bits. This means we need less carriers (so more power per carrier), and code rate is increased slightly:
```
build_linux/src$ ./ofdm_mod --in /dev/zero --testframes 300 --mode 2020 --ldpc 1 --verbose 1 -p 312 | ./cohpsk_ch - - -22 --Fs 8000 -f 10 --ssbfilt 1 | ./ofdm_demod --out /dev/null --testframes --mode 2020 --verbose 1 --ldpc -p 312
build_linux/src$ ./ofdm_mod --in /dev/zero --testframes 300 --mode 2020 --ldpc 1 --verbose 1 | ./ch - - --No -22 -f 10 --ssbfilt 1 | ./ofdm_demod --out /dev/null --testframes --mode 2020 --verbose 1 --ldpc
SNR3k(dB): 2.21 C/No: 37.0 PAPR: 9.6
SNR3k(dB): 2.21 C/No: 37.0 PAPR: 9.6
BER......: 0.0505 Tbits: 874020 Terrs: 44148
Coded BER: 0.0096 Tbits: 649272 Terrs: 6230
```
## Acquisition tests
1. Acquisition (getting sync) can be problematic in fading channels. Some special tests have been developed, that measure acquisition time on off air 700D samples at different time offsets:
@ -138,7 +129,7 @@ Built as part of codec2-dev, see [README](README.md) for build instructions.
<snip>
pass: 30 fails: 0 mean: 1.35 var 0.51
```
## Octave Acceptance Tests
Here are some useful tests for the Octave, uncoded modem.
@ -151,38 +142,53 @@ The rate 1/2 LDPC code can correct up to about 10% raw BER, so a good test is to
octave:581> ofdm_rx("ofdm_test.raw")
BER2.: 0.0803 Tbits: 84728 Terrs: 6803
```
1. AWGN:
```
octave:582> ofdm_tx("ofdm_test.raw","700D",60,-2,'awgn')
octave:583> ofdm_rx("ofdm_test.raw")
BER2.: 0.0885 Tbits: 84252 Terrs: 7459
```
## C Acceptance Tests
Here are some useful tests for the LDPC coded C version of the modem, useful to verify any changes.
1. AWGN channel, -2dB:
```
./ofdm_mod --in /dev/zero --ldpc --testframes 60 --txbpf | ./cohpsk_ch - - -20 --Fs 8000 -f -10 | ./ofdm_demod --out /dev/null --testframes --verbose 1 --ldpc
./ofdm_mod --in /dev/zero --ldpc --testframes 60 --txbpf | ./ch - - --No -20 -f -10 | ./ofdm_demod --out /dev/null --testframes --verbose 1 --ldpc
SNR3k(dB): -1.85 C/No: 32.9 PAPR: 9.8
BER......: 0.0815 Tbits: 98532 Terrs: 8031
Coded BER: 0.0034 Tbits: 46368 Terrs: 157
```
1. Fading HF channel:
```
./ofdm_mod --in /dev/zero --ldpc --testframes 60 --txbpf | ./cohpsk_ch - - -24 --Fs 8000 -f -10 --fast | ./ofdm_demod --out /dev/null --testframes --verbose 1 --ldpc
./ofdm_mod --in /dev/zero --ldpc --testframes 60 --txbpf | ./ch - - --No -24 -f -10 --fast | ./ofdm_demod --out /dev/null --testframes --verbose 1 --ldpc
SNR3k(dB): 2.15 C/No: 36.9 PAPR: 9.8
BER......: 0.1015 Tbits: 88774 Terrs: 9012
Coded BER: 0.0445 Tbits: 41776 Terrs: 1860
```
Note: 10% Raw BER operating point on both channels, as per design.
# Data Modes
The OFDM modem can also support datac1/datac2/datac3 modes for packet data. The OFDM modem was originally designed for very short (28 bit) voice codec packets. For data, packets of hundreds to thousands of bits a desirable so we can use long, powerful FEC codewords, and reduce overhead. The datac1/datac2/datac3 QPSK modes are currently under development.
Here is an example of running the datac3 mode in a low SNR AWGN channel:
```
./src/ofdm_mod --mode datac3 --ldpc --in /dev/zero --testframes 60 --verbose 1 | ./src/ch - - --No -20 | ./src/ofdm_demod --mode datac3 --ldpc --out /dev/null --testframes -v 1
<snip>
SNR3k(dB): -3.54 C/No: 31.2 PAPR: 10.4
BER......: 0.1082 Tbits: 36096 Terrs: 3905 Tpackets: 47
Coded BER: 0.0000 Tbits: 12032 Terrs: 0
```
Note despite the raw BER of 10%, 47/50 packets are received error free.
# C Code
| File | Description |
@ -194,17 +200,17 @@ Here are some useful tests for the LDPC coded C version of the modem, useful to
| ofdm_demod | OFDM demodulator command line program, supports uncoded (raw) and LDPC coded test frames, LDPC decoding of codec data, and can output LLRs to external LDPC decoder |
| ofdm_put_test_bits | Measure BER in OFDM test frames |
| unittest/tofdm | Run C port of modem to compare with octave version (see octave/tofdm) |
| cohpsk_ch | From COHPSK modem development, useful C channel simulator |
| ch | C channel simulator |
# Octave Scripts
| File | Description |
| :-- | :-- |
| ofdm_lib | OFDM library |
| ofdm_lib | OFDM library |
| ofdm_dev | Used for modem development, run various simulations |
| ofdm_tx | Modulate test frames to a file of sample, cam add channel impairments |
| ofdm_rx | Demod from a sample file and count errors |
| tofdm | Compares Octave and C ports of modem |
| tofdm | Compares Octave and C ports of modem |
| ofdm_ldpc_tx | OFDM modulator with LDPC FEC |
| ofdm_ldpc_rx | OFDM demodulator with LDPC FEC |

571
libcodec2-android/src/codec2/build_linux/CMakeCache.txt vendored
Wyświetl plik

@ -1,571 +0,0 @@
# This is the CMakeCache file.
# For build in directory: /home/sh/Downloads/hackrf/codec2/build_linux
# It was generated by CMake: /usr/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
########################
//Build shared library. Set to OFF for static library.
BUILD_SHARED_LIBS:BOOL=ON
//Build the testing tree.
BUILD_TESTING:BOOL=ON
//Path to a program.
BZRCOMMAND:FILEPATH=BZRCOMMAND-NOTFOUND
//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
//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-8
//A wrapper around 'ranlib' adding the appropriate '--plugin' option
// for the GCC compiler
CMAKE_C_COMPILER_RANLIB:FILEPATH=/usr/bin/gcc-ranlib-8
//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
//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=OFF
//User executables (bin)
CMAKE_INSTALL_BINDIR:PATH=bin
//Read-only architecture-independent data (DATAROOTDIR)
CMAKE_INSTALL_DATADIR:PATH=
//Read-only architecture-independent data root (share)
CMAKE_INSTALL_DATAROOTDIR:PATH=share
//Documentation root (DATAROOTDIR/doc/PROJECT_NAME)
CMAKE_INSTALL_DOCDIR:PATH=
//C header files (include)
CMAKE_INSTALL_INCLUDEDIR:PATH=include
//Info documentation (DATAROOTDIR/info)
CMAKE_INSTALL_INFODIR:PATH=
//Object code libraries (lib)
CMAKE_INSTALL_LIBDIR:PATH=lib
//Program executables (libexec)
CMAKE_INSTALL_LIBEXECDIR:PATH=libexec
//Locale-dependent data (DATAROOTDIR/locale)
CMAKE_INSTALL_LOCALEDIR:PATH=
//Modifiable single-machine data (var)
CMAKE_INSTALL_LOCALSTATEDIR:PATH=var
//Man documentation (DATAROOTDIR/man)
CMAKE_INSTALL_MANDIR:PATH=
//C header files for non-gcc (/usr/include)
CMAKE_INSTALL_OLDINCLUDEDIR:PATH=/usr/include
//Install path prefix, prepended onto install directories.
CMAKE_INSTALL_PREFIX:PATH=/opt/install/codec2
//Run-time variable data (LOCALSTATEDIR/run)
CMAKE_INSTALL_RUNSTATEDIR:PATH=
//System admin executables (sbin)
CMAKE_INSTALL_SBINDIR:PATH=sbin
//Modifiable architecture-independent data (com)
CMAKE_INSTALL_SHAREDSTATEDIR:PATH=com
//Read-only single-machine data (etc)
CMAKE_INSTALL_SYSCONFDIR:PATH=etc
//Path to a program.
CMAKE_LINKER:FILEPATH=/usr/bin/ld
//Path to a program.
CMAKE_MAKE_PROGRAM:FILEPATH=/usr/bin/make
//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
//Minimum OS X deployment version
CMAKE_OSX_DEPLOYMENT_TARGET:STRING=10.9
//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=codec2
//Path to a program.
CMAKE_RANLIB:FILEPATH=/usr/bin/ranlib
//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
//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
//Path to the coverage program that CTest uses for performing coverage
// inspection
COVERAGE_COMMAND:FILEPATH=/usr/bin/gcov
//Extra command line flags to pass to the coverage tool
COVERAGE_EXTRA_FLAGS:STRING=-l
//How many times to retry timed-out CTest submissions.
CTEST_SUBMIT_RETRY_COUNT:STRING=3
//How long to wait between timed-out CTest submissions.
CTEST_SUBMIT_RETRY_DELAY:STRING=5
//Path to a program.
CVSCOMMAND:FILEPATH=CVSCOMMAND-NOTFOUND
//Options passed to the cvs update command.
CVS_UPDATE_OPTIONS:STRING=-d -A -P
//Maximum time allowed before CTest will kill the test.
DART_TESTING_TIMEOUT:STRING=1500
//Path to a program.
GITCOMMAND:FILEPATH=/usr/bin/git
//Git command line client
GIT_EXECUTABLE:FILEPATH=/usr/bin/git
//Path to a program.
HGCOMMAND:FILEPATH=HGCOMMAND-NOTFOUND
//Install example code.
INSTALL_EXAMPLES:BOOL=OFF
//Build codec2 with LPCNet support.
LPCNET:BOOL=OFF
//Location of lpcnet build tree.
LPCNET_BUILD_DIR:PATH=FALSE
//Command to build the project
MAKECOMMAND:STRING=/usr/bin/cmake --build . --config "${CTEST_CONFIGURATION_TYPE}" -- -i
//Path to the memory checking command, used for memory error detection.
MEMORYCHECK_COMMAND:FILEPATH=MEMORYCHECK_COMMAND-NOTFOUND
//File that contains suppressions for the memory checker
MEMORYCHECK_SUPPRESSIONS_FILE:FILEPATH=
//Path to a program.
P4COMMAND:FILEPATH=P4COMMAND-NOTFOUND
//Path to scp command, used by CTest for submitting results to
// a Dart server
SCPCOMMAND:FILEPATH=/usr/bin/scp
//Name of the computer/site where compile is being run
SITE:STRING=chiliagon
//Path to the SLURM sbatch executable
SLURM_SBATCH_COMMAND:FILEPATH=SLURM_SBATCH_COMMAND-NOTFOUND
//Path to the SLURM srun executable
SLURM_SRUN_COMMAND:FILEPATH=SLURM_SRUN_COMMAND-NOTFOUND
//Path to a program.
SVNCOMMAND:FILEPATH=/usr/bin/svn
//Build unittest binaries.
UNITTEST:BOOL=ON
//Value Computed by CMake
codec2_BINARY_DIR:STATIC=/home/sh/Downloads/hackrf/codec2/build_linux
//Dependencies for the target
codec2_LIB_DEPENDS:STATIC=general;m;
//Value Computed by CMake
codec2_SOURCE_DIR:STATIC=/home/sh/Downloads/hackrf/codec2
########################
# INTERNAL cache entries
########################
//ADVANCED property for variable: BZRCOMMAND
BZRCOMMAND-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=/home/sh/Downloads/hackrf/codec2/build_linux
//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=13
//Patch version of cmake used to create the current loaded cache
CMAKE_CACHE_PATCH_VERSION:INTERNAL=4
//ADVANCED property for variable: CMAKE_COLOR_MAKEFILE
CMAKE_COLOR_MAKEFILE-ADVANCED:INTERNAL=1
//Path to CMake executable.
CMAKE_COMMAND:INTERNAL=/usr/bin/cmake
//Path to cpack program executable.
CMAKE_CPACK_COMMAND:INTERNAL=/usr/bin/cpack
//ADVANCED property for variable: CMAKE_CTEST_COMMAND
CMAKE_CTEST_COMMAND-ADVANCED:INTERNAL=1
//Path to ctest program executable.
CMAKE_CTEST_COMMAND:INTERNAL=/usr/bin/ctest
//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
//Whether to issue deprecation errors for macros and functions.
CMAKE_ERROR_DEPRECATED:INTERNAL=FALSE
//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=
//Have symbol pthread_create
CMAKE_HAVE_LIBC_CREATE:INTERNAL=
//Have library pthreads
CMAKE_HAVE_PTHREADS_CREATE:INTERNAL=
//Have library pthread
CMAKE_HAVE_PTHREAD_CREATE:INTERNAL=1
//Have include pthread.h
CMAKE_HAVE_PTHREAD_H:INTERNAL=1
//Source directory with the top level CMakeLists.txt file for this
// project
CMAKE_HOME_DIRECTORY:INTERNAL=/home/sh/Downloads/hackrf/codec2
//ADVANCED property for variable: CMAKE_INSTALL_BINDIR
CMAKE_INSTALL_BINDIR-ADVANCED:INTERNAL=0
//ADVANCED property for variable: CMAKE_INSTALL_DATADIR
CMAKE_INSTALL_DATADIR-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_INSTALL_DATAROOTDIR
CMAKE_INSTALL_DATAROOTDIR-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_INSTALL_DOCDIR
CMAKE_INSTALL_DOCDIR-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_INSTALL_INCLUDEDIR
CMAKE_INSTALL_INCLUDEDIR-ADVANCED:INTERNAL=0
//ADVANCED property for variable: CMAKE_INSTALL_INFODIR
CMAKE_INSTALL_INFODIR-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_INSTALL_LIBDIR
CMAKE_INSTALL_LIBDIR-ADVANCED:INTERNAL=0
//ADVANCED property for variable: CMAKE_INSTALL_LIBEXECDIR
CMAKE_INSTALL_LIBEXECDIR-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_INSTALL_LOCALEDIR
CMAKE_INSTALL_LOCALEDIR-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_INSTALL_LOCALSTATEDIR
CMAKE_INSTALL_LOCALSTATEDIR-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_INSTALL_MANDIR
CMAKE_INSTALL_MANDIR-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_INSTALL_OLDINCLUDEDIR
CMAKE_INSTALL_OLDINCLUDEDIR-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_INSTALL_RUNSTATEDIR
CMAKE_INSTALL_RUNSTATEDIR-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_INSTALL_SBINDIR
CMAKE_INSTALL_SBINDIR-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_INSTALL_SHAREDSTATEDIR
CMAKE_INSTALL_SHAREDSTATEDIR-ADVANCED:INTERNAL=1
//Install .so files without execute permission.
CMAKE_INSTALL_SO_NO_EXE:INTERNAL=1
//ADVANCED property for variable: CMAKE_INSTALL_SYSCONFDIR
CMAKE_INSTALL_SYSCONFDIR-ADVANCED: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=4
//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
//Path to CMake installation.
CMAKE_ROOT:INTERNAL=/usr/share/cmake-3.13
//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
//Suppress errors that are meant for the author of the CMakeLists.txt
// files.
CMAKE_SUPPRESS_DEVELOPER_ERRORS:INTERNAL=TRUE
//Suppress Warnings that are meant for the author of the CMakeLists.txt
// files.
CMAKE_SUPPRESS_DEVELOPER_WARNINGS:INTERNAL=TRUE
//uname command
CMAKE_UNAME:INTERNAL=/bin/uname
//ADVANCED property for variable: CMAKE_VERBOSE_MAKEFILE
CMAKE_VERBOSE_MAKEFILE-ADVANCED:INTERNAL=1
//Whether to issue warnings for deprecated functionality.
CMAKE_WARN_DEPRECATED:INTERNAL=FALSE
//Test COMPILER_SUPPORTS_GNU11
COMPILER_SUPPORTS_GNU11:INTERNAL=1
//Test COMPILER_SUPPORTS_GNU99
COMPILER_SUPPORTS_GNU99:INTERNAL=1
//ADVANCED property for variable: COVERAGE_COMMAND
COVERAGE_COMMAND-ADVANCED:INTERNAL=1
//ADVANCED property for variable: COVERAGE_EXTRA_FLAGS
COVERAGE_EXTRA_FLAGS-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CTEST_SUBMIT_RETRY_COUNT
CTEST_SUBMIT_RETRY_COUNT-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CTEST_SUBMIT_RETRY_DELAY
CTEST_SUBMIT_RETRY_DELAY-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CVSCOMMAND
CVSCOMMAND-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CVS_UPDATE_OPTIONS
CVS_UPDATE_OPTIONS-ADVANCED:INTERNAL=1
//ADVANCED property for variable: DART_TESTING_TIMEOUT
DART_TESTING_TIMEOUT-ADVANCED:INTERNAL=1
//Details about finding Git
FIND_PACKAGE_MESSAGE_DETAILS_Git:INTERNAL=[/usr/bin/git][v2.20.1()]
//Details about finding Threads
FIND_PACKAGE_MESSAGE_DETAILS_Threads:INTERNAL=[TRUE][v()]
//ADVANCED property for variable: GITCOMMAND
GITCOMMAND-ADVANCED:INTERNAL=1
//ADVANCED property for variable: GIT_EXECUTABLE
GIT_EXECUTABLE-ADVANCED:INTERNAL=1
//Have symbol atan2
HAVE_ATAN2:INTERNAL=
//Have symbol ceil
HAVE_CEIL:INTERNAL=
//Have symbol cos
HAVE_COS:INTERNAL=
//Have symbol floor
HAVE_FLOOR:INTERNAL=
//Have symbol getopt
HAVE_GETOPT:INTERNAL=
//Have symbol log10
HAVE_LOG10:INTERNAL=
//Have symbol pow
HAVE_POW:INTERNAL=
//Have symbol round
HAVE_ROUND:INTERNAL=
//Have symbol sin
HAVE_SIN:INTERNAL=
//Have symbol sqrt
HAVE_SQRT:INTERNAL=
//Have include stdlib.h
HAVE_STDLIB_H:INTERNAL=1
//Have include string.h
HAVE_STRING_H:INTERNAL=1
//ADVANCED property for variable: HGCOMMAND
HGCOMMAND-ADVANCED:INTERNAL=1
//ADVANCED property for variable: MAKECOMMAND
MAKECOMMAND-ADVANCED:INTERNAL=1
//ADVANCED property for variable: MEMORYCHECK_COMMAND
MEMORYCHECK_COMMAND-ADVANCED:INTERNAL=1
//ADVANCED property for variable: MEMORYCHECK_SUPPRESSIONS_FILE
MEMORYCHECK_SUPPRESSIONS_FILE-ADVANCED:INTERNAL=1
//ADVANCED property for variable: P4COMMAND
P4COMMAND-ADVANCED:INTERNAL=1
//ADVANCED property for variable: SCPCOMMAND
SCPCOMMAND-ADVANCED:INTERNAL=1
//ADVANCED property for variable: SITE
SITE-ADVANCED:INTERNAL=1
//ADVANCED property for variable: SLURM_SBATCH_COMMAND
SLURM_SBATCH_COMMAND-ADVANCED:INTERNAL=1
//ADVANCED property for variable: SLURM_SRUN_COMMAND
SLURM_SRUN_COMMAND-ADVANCED:INTERNAL=1
//ADVANCED property for variable: SVNCOMMAND
SVNCOMMAND-ADVANCED:INTERNAL=1
//CMAKE_INSTALL_PREFIX during last run
_GNUInstallDirs_LAST_CMAKE_INSTALL_PREFIX:INTERNAL=/opt/install/codec2
//Have symbol __GNU_LIBRARY__
_GNU_SOURCE:INTERNAL=1

73
libcodec2-android/src/codec2/build_linux/CMakeFiles/3.13.4/CMakeCCompiler.cmake vendored
Wyświetl plik

@ -1,73 +0,0 @@
set(CMAKE_C_COMPILER "/usr/bin/cc")
set(CMAKE_C_COMPILER_ARG1 "")
set(CMAKE_C_COMPILER_ID "GNU")
set(CMAKE_C_COMPILER_VERSION "8.3.0")
set(CMAKE_C_COMPILER_VERSION_INTERNAL "")
set(CMAKE_C_COMPILER_WRAPPER "")
set(CMAKE_C_STANDARD_COMPUTED_DEFAULT "11")
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")
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_C_PLATFORM_ID "Linux")
set(CMAKE_C_SIMULATE_ID "")
set(CMAKE_C_SIMULATE_VERSION "")
set(CMAKE_AR "/usr/bin/ar")
set(CMAKE_C_COMPILER_AR "/usr/bin/gcc-ar-8")
set(CMAKE_RANLIB "/usr/bin/ranlib")
set(CMAKE_C_COMPILER_RANLIB "/usr/bin/gcc-ranlib-8")
set(CMAKE_LINKER "/usr/bin/ld")
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_COMPILER_IS_MINGW )
set(CMAKE_COMPILER_IS_CYGWIN )
if(CMAKE_COMPILER_IS_CYGWIN)
set(CYGWIN 1)
set(UNIX 1)
endif()
set(CMAKE_C_COMPILER_ENV_VAR "CC")
if(CMAKE_COMPILER_IS_MINGW)
set(MINGW 1)
endif()
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)
# Save compiler ABI information.
set(CMAKE_C_SIZEOF_DATA_PTR "8")
set(CMAKE_C_COMPILER_ABI "ELF")
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_LINK_LIBRARIES "gcc;gcc_s;c;gcc;gcc_s")
set(CMAKE_C_IMPLICIT_LINK_DIRECTORIES "/usr/lib/gcc/x86_64-linux-gnu/8;/usr/lib/x86_64-linux-gnu;/usr/lib;/lib/x86_64-linux-gnu;/lib")
set(CMAKE_C_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES "")

BIN
libcodec2-android/src/codec2/build_linux/CMakeFiles/3.13.4/CMakeDetermineCompilerABI_C.bin vendored
Wyświetl plik

Plik binarny nie jest wyświetlany.

15
libcodec2-android/src/codec2/build_linux/CMakeFiles/3.13.4/CMakeSystem.cmake vendored
Wyświetl plik

@ -1,15 +0,0 @@
set(CMAKE_HOST_SYSTEM "Linux-4.19.0-6-amd64")
set(CMAKE_HOST_SYSTEM_NAME "Linux")
set(CMAKE_HOST_SYSTEM_VERSION "4.19.0-6-amd64")
set(CMAKE_HOST_SYSTEM_PROCESSOR "x86_64")
set(CMAKE_SYSTEM "Linux-4.19.0-6-amd64")
set(CMAKE_SYSTEM_NAME "Linux")
set(CMAKE_SYSTEM_VERSION "4.19.0-6-amd64")
set(CMAKE_SYSTEM_PROCESSOR "x86_64")
set(CMAKE_CROSSCOMPILING "FALSE")
set(CMAKE_SYSTEM_LOADED 1)

623
libcodec2-android/src/codec2/build_linux/CMakeFiles/3.13.4/CompilerIdC/CMakeCCompilerId.c vendored
Wyświetl plik

@ -1,623 +0,0 @@
#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
/* 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
/* __INTEL_COMPILER = VRP */
# 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
# 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
#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"
# if defined(__ibmxl__)
# 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__)
# else
/* __IBMC__ = VRP */
# define COMPILER_VERSION_MAJOR DEC(__IBMC__/100)
# define COMPILER_VERSION_MINOR DEC(__IBMC__/10 % 10)
# define COMPILER_VERSION_PATCH DEC(__IBMC__ % 10)
# endif
#elif defined(__ibmxl__) || (defined(__IBMC__) && !defined(__COMPILER_VER__) && __IBMC__ >= 800)
# define COMPILER_ID "XL"
# if defined(__ibmxl__)
# 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__)
# else
/* __IBMC__ = VRP */
# define COMPILER_VERSION_MAJOR DEC(__IBMC__/100)
# define COMPILER_VERSION_MINOR DEC(__IBMC__/10 % 10)
# define COMPILER_VERSION_PATCH DEC(__IBMC__ % 10)
# endif
#elif defined(__IBMC__) && !defined(__COMPILER_VER__) && __IBMC__ < 800
# define COMPILER_ID "VisualAge"
# if defined(__ibmxl__)
# 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__)
# else
/* __IBMC__ = VRP */
# define COMPILER_VERSION_MAJOR DEC(__IBMC__/100)
# define COMPILER_VERSION_MINOR DEC(__IBMC__/10 % 10)
# define COMPILER_VERSION_PATCH DEC(__IBMC__ % 10)
# 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(__FUJITSU) || defined(__FCC_VERSION) || defined(__fcc_version)
# define COMPILER_ID "Fujitsu"
#elif defined(__TINYC__)
# define COMPILER_ID "TinyCC"
#elif defined(__BCC__)
# define COMPILER_ID "Bruce"
#elif defined(__SCO_VERSION__)
# define COMPILER_ID "SCO"
#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__)
# 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(__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(__VISUALDSPVERSION__) || defined(__ADSPBLACKFIN__) || defined(__ADSPTS__) || defined(__ADSP21000__)
# define COMPILER_ID "ADSP"
#if defined(__VISUALDSPVERSION__)
/* __VISUALDSPVERSION__ = 0xVVRRPP00 */
# define COMPILER_VERSION_MAJOR HEX(__VISUALDSPVERSION__>>24)
# define COMPILER_VERSION_MINOR HEX(__VISUALDSPVERSION__>>16 & 0xFF)
# define COMPILER_VERSION_PATCH HEX(__VISUALDSPVERSION__>>8 & 0xFF)
#endif
#elif defined(__IAR_SYSTEMS_ICC__) || defined(__IAR_SYSTEMS_ICC)
# define COMPILER_ID "IAR"
# if defined(__VER__)
# 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__)
# endif
#elif defined(__ARMCC_VERSION)
# 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(__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
#elif defined(_SGI_COMPILER_VERSION) || defined(_COMPILER_VERSION)
# define COMPILER_ID "MIPSpro"
# if defined(_SGI_COMPILER_VERSION)
/* _SGI_COMPILER_VERSION = VRP */
# define COMPILER_VERSION_MAJOR DEC(_SGI_COMPILER_VERSION/100)
# define COMPILER_VERSION_MINOR DEC(_SGI_COMPILER_VERSION/10 % 10)
# define COMPILER_VERSION_PATCH DEC(_SGI_COMPILER_VERSION % 10)
# else
/* _COMPILER_VERSION = VRP */
# define COMPILER_VERSION_MAJOR DEC(_COMPILER_VERSION/100)
# define COMPILER_VERSION_MINOR DEC(_COMPILER_VERSION/10 % 10)
# define COMPILER_VERSION_PATCH DEC(_COMPILER_VERSION % 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(__sgi)
# define COMPILER_ID "MIPSpro"
#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(__CRAYXE) || defined(__CRAYXC)
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(__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(__sgi) || defined(__sgi__) || defined(_SGI)
# define PLATFORM_ID "IRIX"
#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"
# else /* unknown platform */
# define PLATFORM_ID
# endif
#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_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(__ICCAVR__)
# define ARCHITECTURE_ID "AVR"
# else /* unknown architecture */
# 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 components. */
#ifdef 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'};
#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__)
# if (defined(_MSC_VER) && !defined(__clang__)) \
|| (defined(__ibmxl__) || defined(__IBMC__))
# define C_DIALECT "90"
# else
# define C_DIALECT
# endif
#elif __STDC_VERSION__ >= 201000L
# define C_DIALECT "11"
#elif __STDC_VERSION__ >= 199901L
# define C_DIALECT "99"
#else
# define C_DIALECT "90"
#endif
const char* info_language_dialect_default =
"INFO" ":" "dialect_default[" C_DIALECT "]";
/*--------------------------------------------------------------------------*/
#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(__CRAYXE) || defined(__CRAYXC)
require += info_cray[argc];
#endif
require += info_language_dialect_default[argc];
(void)argv;
return require;
}
#endif

BIN
libcodec2-android/src/codec2/build_linux/CMakeFiles/3.13.4/CompilerIdC/a.out vendored
Wyświetl plik

Plik binarny nie jest wyświetlany.

16
libcodec2-android/src/codec2/build_linux/CMakeFiles/CMakeDirectoryInformation.cmake vendored
Wyświetl plik

@ -1,16 +0,0 @@
# CMAKE generated file: DO NOT EDIT!
# Generated by "Unix Makefiles" Generator, CMake Version 3.13
# Relative path conversion top directories.
set(CMAKE_RELATIVE_PATH_TOP_SOURCE "/home/sh/Downloads/hackrf/codec2")
set(CMAKE_RELATIVE_PATH_TOP_BINARY "/home/sh/Downloads/hackrf/codec2/build_linux")
# 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})

380
libcodec2-android/src/codec2/build_linux/CMakeFiles/CMakeError.log vendored
Wyświetl plik

@ -1,380 +0,0 @@
Determining if the floor exist failed with the following output:
Change Dir: /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp
Run Build Command:"/usr/bin/make" "cmTC_dd8dd/fast"
/usr/bin/make -f CMakeFiles/cmTC_dd8dd.dir/build.make CMakeFiles/cmTC_dd8dd.dir/build
make[1]: Entering directory '/home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp'
Building C object CMakeFiles/cmTC_dd8dd.dir/CheckSymbolExists.c.o
/usr/bin/cc -Wall -Wno-strict-overflow -std=gnu11 -fPIC -o CMakeFiles/cmTC_dd8dd.dir/CheckSymbolExists.c.o -c /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp/CheckSymbolExists.c
Linking C executable cmTC_dd8dd
/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_dd8dd.dir/link.txt --verbose=1
/usr/bin/cc -Wall -Wno-strict-overflow -std=gnu11 -fPIC -rdynamic CMakeFiles/cmTC_dd8dd.dir/CheckSymbolExists.c.o -o cmTC_dd8dd
/usr/bin/ld: CMakeFiles/cmTC_dd8dd.dir/CheckSymbolExists.c.o: in function `main':
CheckSymbolExists.c:(.text+0x1b): undefined reference to `floor'
collect2: error: ld returned 1 exit status
make[1]: *** [CMakeFiles/cmTC_dd8dd.dir/build.make:87: cmTC_dd8dd] Error 1
make[1]: Leaving directory '/home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp'
make: *** [Makefile:121: cmTC_dd8dd/fast] Error 2
File /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp/CheckSymbolExists.c:
/* */
#include <math.h>
int main(int argc, char** argv)
{
(void)argv;
#ifndef floor
return ((int*)(&floor))[argc];
#else
(void)argc;
return 0;
#endif
}
Determining if the ceil exist failed with the following output:
Change Dir: /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp
Run Build Command:"/usr/bin/make" "cmTC_6c64a/fast"
/usr/bin/make -f CMakeFiles/cmTC_6c64a.dir/build.make CMakeFiles/cmTC_6c64a.dir/build
make[1]: Entering directory '/home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp'
Building C object CMakeFiles/cmTC_6c64a.dir/CheckSymbolExists.c.o
/usr/bin/cc -Wall -Wno-strict-overflow -std=gnu11 -fPIC -o CMakeFiles/cmTC_6c64a.dir/CheckSymbolExists.c.o -c /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp/CheckSymbolExists.c
Linking C executable cmTC_6c64a
/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_6c64a.dir/link.txt --verbose=1
/usr/bin/cc -Wall -Wno-strict-overflow -std=gnu11 -fPIC -rdynamic CMakeFiles/cmTC_6c64a.dir/CheckSymbolExists.c.o -o cmTC_6c64a
/usr/bin/ld: CMakeFiles/cmTC_6c64a.dir/CheckSymbolExists.c.o: in function `main':
CheckSymbolExists.c:(.text+0x1b): undefined reference to `ceil'
collect2: error: ld returned 1 exit status
make[1]: *** [CMakeFiles/cmTC_6c64a.dir/build.make:87: cmTC_6c64a] Error 1
make[1]: Leaving directory '/home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp'
make: *** [Makefile:121: cmTC_6c64a/fast] Error 2
File /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp/CheckSymbolExists.c:
/* */
#include <math.h>
int main(int argc, char** argv)
{
(void)argv;
#ifndef ceil
return ((int*)(&ceil))[argc];
#else
(void)argc;
return 0;
#endif
}
Determining if the pow exist failed with the following output:
Change Dir: /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp
Run Build Command:"/usr/bin/make" "cmTC_b7d1e/fast"
/usr/bin/make -f CMakeFiles/cmTC_b7d1e.dir/build.make CMakeFiles/cmTC_b7d1e.dir/build
make[1]: Entering directory '/home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp'
Building C object CMakeFiles/cmTC_b7d1e.dir/CheckSymbolExists.c.o
/usr/bin/cc -Wall -Wno-strict-overflow -std=gnu11 -fPIC -o CMakeFiles/cmTC_b7d1e.dir/CheckSymbolExists.c.o -c /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp/CheckSymbolExists.c
Linking C executable cmTC_b7d1e
/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_b7d1e.dir/link.txt --verbose=1
/usr/bin/cc -Wall -Wno-strict-overflow -std=gnu11 -fPIC -rdynamic CMakeFiles/cmTC_b7d1e.dir/CheckSymbolExists.c.o -o cmTC_b7d1e
/usr/bin/ld: CMakeFiles/cmTC_b7d1e.dir/CheckSymbolExists.c.o: in function `main':
CheckSymbolExists.c:(.text+0x1b): undefined reference to `pow'
collect2: error: ld returned 1 exit status
make[1]: *** [CMakeFiles/cmTC_b7d1e.dir/build.make:87: cmTC_b7d1e] Error 1
make[1]: Leaving directory '/home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp'
make: *** [Makefile:121: cmTC_b7d1e/fast] Error 2
File /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp/CheckSymbolExists.c:
/* */
#include <math.h>
int main(int argc, char** argv)
{
(void)argv;
#ifndef pow
return ((int*)(&pow))[argc];
#else
(void)argc;
return 0;
#endif
}
Determining if the sqrt exist failed with the following output:
Change Dir: /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp
Run Build Command:"/usr/bin/make" "cmTC_5c615/fast"
/usr/bin/make -f CMakeFiles/cmTC_5c615.dir/build.make CMakeFiles/cmTC_5c615.dir/build
make[1]: Entering directory '/home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp'
Building C object CMakeFiles/cmTC_5c615.dir/CheckSymbolExists.c.o
/usr/bin/cc -Wall -Wno-strict-overflow -std=gnu11 -fPIC -o CMakeFiles/cmTC_5c615.dir/CheckSymbolExists.c.o -c /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp/CheckSymbolExists.c
Linking C executable cmTC_5c615
/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_5c615.dir/link.txt --verbose=1
/usr/bin/cc -Wall -Wno-strict-overflow -std=gnu11 -fPIC -rdynamic CMakeFiles/cmTC_5c615.dir/CheckSymbolExists.c.o -o cmTC_5c615
/usr/bin/ld: CMakeFiles/cmTC_5c615.dir/CheckSymbolExists.c.o: in function `main':
CheckSymbolExists.c:(.text+0x1b): undefined reference to `sqrt'
collect2: error: ld returned 1 exit status
make[1]: *** [CMakeFiles/cmTC_5c615.dir/build.make:87: cmTC_5c615] Error 1
make[1]: Leaving directory '/home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp'
make: *** [Makefile:121: cmTC_5c615/fast] Error 2
File /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp/CheckSymbolExists.c:
/* */
#include <math.h>
int main(int argc, char** argv)
{
(void)argv;
#ifndef sqrt
return ((int*)(&sqrt))[argc];
#else
(void)argc;
return 0;
#endif
}
Determining if the sin exist failed with the following output:
Change Dir: /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp
Run Build Command:"/usr/bin/make" "cmTC_f86c3/fast"
/usr/bin/make -f CMakeFiles/cmTC_f86c3.dir/build.make CMakeFiles/cmTC_f86c3.dir/build
make[1]: Entering directory '/home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp'
Building C object CMakeFiles/cmTC_f86c3.dir/CheckSymbolExists.c.o
/usr/bin/cc -Wall -Wno-strict-overflow -std=gnu11 -fPIC -o CMakeFiles/cmTC_f86c3.dir/CheckSymbolExists.c.o -c /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp/CheckSymbolExists.c
Linking C executable cmTC_f86c3
/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_f86c3.dir/link.txt --verbose=1
/usr/bin/cc -Wall -Wno-strict-overflow -std=gnu11 -fPIC -rdynamic CMakeFiles/cmTC_f86c3.dir/CheckSymbolExists.c.o -o cmTC_f86c3
/usr/bin/ld: CMakeFiles/cmTC_f86c3.dir/CheckSymbolExists.c.o: in function `main':
CheckSymbolExists.c:(.text+0x1b): undefined reference to `sin'
collect2: error: ld returned 1 exit status
make[1]: *** [CMakeFiles/cmTC_f86c3.dir/build.make:87: cmTC_f86c3] Error 1
make[1]: Leaving directory '/home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp'
make: *** [Makefile:121: cmTC_f86c3/fast] Error 2
File /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp/CheckSymbolExists.c:
/* */
#include <math.h>
int main(int argc, char** argv)
{
(void)argv;
#ifndef sin
return ((int*)(&sin))[argc];
#else
(void)argc;
return 0;
#endif
}
Determining if the cos exist failed with the following output:
Change Dir: /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp
Run Build Command:"/usr/bin/make" "cmTC_2509b/fast"
/usr/bin/make -f CMakeFiles/cmTC_2509b.dir/build.make CMakeFiles/cmTC_2509b.dir/build
make[1]: Entering directory '/home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp'
Building C object CMakeFiles/cmTC_2509b.dir/CheckSymbolExists.c.o
/usr/bin/cc -Wall -Wno-strict-overflow -std=gnu11 -fPIC -o CMakeFiles/cmTC_2509b.dir/CheckSymbolExists.c.o -c /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp/CheckSymbolExists.c
Linking C executable cmTC_2509b
/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_2509b.dir/link.txt --verbose=1
/usr/bin/cc -Wall -Wno-strict-overflow -std=gnu11 -fPIC -rdynamic CMakeFiles/cmTC_2509b.dir/CheckSymbolExists.c.o -o cmTC_2509b
/usr/bin/ld: CMakeFiles/cmTC_2509b.dir/CheckSymbolExists.c.o: in function `main':
CheckSymbolExists.c:(.text+0x1b): undefined reference to `cos'
collect2: error: ld returned 1 exit status
make[1]: *** [CMakeFiles/cmTC_2509b.dir/build.make:87: cmTC_2509b] Error 1
make[1]: Leaving directory '/home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp'
make: *** [Makefile:121: cmTC_2509b/fast] Error 2
File /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp/CheckSymbolExists.c:
/* */
#include <math.h>
int main(int argc, char** argv)
{
(void)argv;
#ifndef cos
return ((int*)(&cos))[argc];
#else
(void)argc;
return 0;
#endif
}
Determining if the atan2 exist failed with the following output:
Change Dir: /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp
Run Build Command:"/usr/bin/make" "cmTC_c93e3/fast"
/usr/bin/make -f CMakeFiles/cmTC_c93e3.dir/build.make CMakeFiles/cmTC_c93e3.dir/build
make[1]: Entering directory '/home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp'
Building C object CMakeFiles/cmTC_c93e3.dir/CheckSymbolExists.c.o
/usr/bin/cc -Wall -Wno-strict-overflow -std=gnu11 -fPIC -o CMakeFiles/cmTC_c93e3.dir/CheckSymbolExists.c.o -c /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp/CheckSymbolExists.c
Linking C executable cmTC_c93e3
/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_c93e3.dir/link.txt --verbose=1
/usr/bin/cc -Wall -Wno-strict-overflow -std=gnu11 -fPIC -rdynamic CMakeFiles/cmTC_c93e3.dir/CheckSymbolExists.c.o -o cmTC_c93e3
/usr/bin/ld: CMakeFiles/cmTC_c93e3.dir/CheckSymbolExists.c.o: in function `main':
CheckSymbolExists.c:(.text+0x1b): undefined reference to `atan2'
collect2: error: ld returned 1 exit status
make[1]: *** [CMakeFiles/cmTC_c93e3.dir/build.make:87: cmTC_c93e3] Error 1
make[1]: Leaving directory '/home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp'
make: *** [Makefile:121: cmTC_c93e3/fast] Error 2
File /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp/CheckSymbolExists.c:
/* */
#include <math.h>
int main(int argc, char** argv)
{
(void)argv;
#ifndef atan2
return ((int*)(&atan2))[argc];
#else
(void)argc;
return 0;
#endif
}
Determining if the log10 exist failed with the following output:
Change Dir: /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp
Run Build Command:"/usr/bin/make" "cmTC_6a5ee/fast"
/usr/bin/make -f CMakeFiles/cmTC_6a5ee.dir/build.make CMakeFiles/cmTC_6a5ee.dir/build
make[1]: Entering directory '/home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp'
Building C object CMakeFiles/cmTC_6a5ee.dir/CheckSymbolExists.c.o
/usr/bin/cc -Wall -Wno-strict-overflow -std=gnu11 -fPIC -o CMakeFiles/cmTC_6a5ee.dir/CheckSymbolExists.c.o -c /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp/CheckSymbolExists.c
Linking C executable cmTC_6a5ee
/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_6a5ee.dir/link.txt --verbose=1
/usr/bin/cc -Wall -Wno-strict-overflow -std=gnu11 -fPIC -rdynamic CMakeFiles/cmTC_6a5ee.dir/CheckSymbolExists.c.o -o cmTC_6a5ee
/usr/bin/ld: CMakeFiles/cmTC_6a5ee.dir/CheckSymbolExists.c.o: in function `main':
CheckSymbolExists.c:(.text+0x1b): undefined reference to `log10'
collect2: error: ld returned 1 exit status
make[1]: *** [CMakeFiles/cmTC_6a5ee.dir/build.make:87: cmTC_6a5ee] Error 1
make[1]: Leaving directory '/home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp'
make: *** [Makefile:121: cmTC_6a5ee/fast] Error 2
File /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp/CheckSymbolExists.c:
/* */
#include <math.h>
int main(int argc, char** argv)
{
(void)argv;
#ifndef log10
return ((int*)(&log10))[argc];
#else
(void)argc;
return 0;
#endif
}
Determining if the round exist failed with the following output:
Change Dir: /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp
Run Build Command:"/usr/bin/make" "cmTC_4b5c4/fast"
/usr/bin/make -f CMakeFiles/cmTC_4b5c4.dir/build.make CMakeFiles/cmTC_4b5c4.dir/build
make[1]: Entering directory '/home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp'
Building C object CMakeFiles/cmTC_4b5c4.dir/CheckSymbolExists.c.o
/usr/bin/cc -Wall -Wno-strict-overflow -std=gnu11 -fPIC -o CMakeFiles/cmTC_4b5c4.dir/CheckSymbolExists.c.o -c /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp/CheckSymbolExists.c
Linking C executable cmTC_4b5c4
/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_4b5c4.dir/link.txt --verbose=1
/usr/bin/cc -Wall -Wno-strict-overflow -std=gnu11 -fPIC -rdynamic CMakeFiles/cmTC_4b5c4.dir/CheckSymbolExists.c.o -o cmTC_4b5c4
/usr/bin/ld: CMakeFiles/cmTC_4b5c4.dir/CheckSymbolExists.c.o: in function `main':
CheckSymbolExists.c:(.text+0x1b): undefined reference to `round'
collect2: error: ld returned 1 exit status
make[1]: *** [CMakeFiles/cmTC_4b5c4.dir/build.make:87: cmTC_4b5c4] Error 1
make[1]: Leaving directory '/home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp'
make: *** [Makefile:121: cmTC_4b5c4/fast] Error 2
File /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp/CheckSymbolExists.c:
/* */
#include <math.h>
int main(int argc, char** argv)
{
(void)argv;
#ifndef round
return ((int*)(&round))[argc];
#else
(void)argc;
return 0;
#endif
}
Determining if the getopt exist failed with the following output:
Change Dir: /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp
Run Build Command:"/usr/bin/make" "cmTC_645d4/fast"
/usr/bin/make -f CMakeFiles/cmTC_645d4.dir/build.make CMakeFiles/cmTC_645d4.dir/build
make[1]: Entering directory '/home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp'
Building C object CMakeFiles/cmTC_645d4.dir/CheckSymbolExists.c.o
/usr/bin/cc -Wall -Wno-strict-overflow -std=gnu11 -fPIC -o CMakeFiles/cmTC_645d4.dir/CheckSymbolExists.c.o -c /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp/CheckSymbolExists.c
/home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp/CheckSymbolExists.c: In function ‘main’:
/home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp/CheckSymbolExists.c:8:19: error: ‘getopt’ undeclared (first use in this function)
return ((int*)(&getopt))[argc];
^~~~~~
/home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp/CheckSymbolExists.c:8:19: note: each undeclared identifier is reported only once for each function it appears in
make[1]: *** [CMakeFiles/cmTC_645d4.dir/build.make:66: CMakeFiles/cmTC_645d4.dir/CheckSymbolExists.c.o] Error 1
make[1]: Leaving directory '/home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp'
make: *** [Makefile:121: cmTC_645d4/fast] Error 2
File /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp/CheckSymbolExists.c:
/* */
#include <math.h>
int main(int argc, char** argv)
{
(void)argv;
#ifndef getopt
return ((int*)(&getopt))[argc];
#else
(void)argc;
return 0;
#endif
}
Determining if the pthread_create exist failed with the following output:
Change Dir: /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp
Run Build Command:"/usr/bin/make" "cmTC_1dce1/fast"
/usr/bin/make -f CMakeFiles/cmTC_1dce1.dir/build.make CMakeFiles/cmTC_1dce1.dir/build
make[1]: Entering directory '/home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp'
Building C object CMakeFiles/cmTC_1dce1.dir/CheckSymbolExists.c.o
/usr/bin/cc -Wall -Wno-strict-overflow -std=gnu11 -fPIC -o CMakeFiles/cmTC_1dce1.dir/CheckSymbolExists.c.o -c /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp/CheckSymbolExists.c
Linking C executable cmTC_1dce1
/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_1dce1.dir/link.txt --verbose=1
/usr/bin/cc -Wall -Wno-strict-overflow -std=gnu11 -fPIC -rdynamic CMakeFiles/cmTC_1dce1.dir/CheckSymbolExists.c.o -o cmTC_1dce1
/usr/bin/ld: CMakeFiles/cmTC_1dce1.dir/CheckSymbolExists.c.o: in function `main':
CheckSymbolExists.c:(.text+0x1b): undefined reference to `pthread_create'
collect2: error: ld returned 1 exit status
make[1]: *** [CMakeFiles/cmTC_1dce1.dir/build.make:87: cmTC_1dce1] Error 1
make[1]: Leaving directory '/home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp'
make: *** [Makefile:121: cmTC_1dce1/fast] Error 2
File /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp/CheckSymbolExists.c:
/* */
#include <pthread.h>
int main(int argc, char** argv)
{
(void)argv;
#ifndef pthread_create
return ((int*)(&pthread_create))[argc];
#else
(void)argc;
return 0;
#endif
}
Determining if the function pthread_create exists in the pthreads failed with the following output:
Change Dir: /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp
Run Build Command:"/usr/bin/make" "cmTC_2446c/fast"
/usr/bin/make -f CMakeFiles/cmTC_2446c.dir/build.make CMakeFiles/cmTC_2446c.dir/build
make[1]: Entering directory '/home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp'
Building C object CMakeFiles/cmTC_2446c.dir/CheckFunctionExists.c.o
/usr/bin/cc -Wall -Wno-strict-overflow -std=gnu11 -fPIC -DCHECK_FUNCTION_EXISTS=pthread_create -o CMakeFiles/cmTC_2446c.dir/CheckFunctionExists.c.o -c /usr/share/cmake-3.13/Modules/CheckFunctionExists.c
Linking C executable cmTC_2446c
/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_2446c.dir/link.txt --verbose=1
/usr/bin/cc -Wall -Wno-strict-overflow -std=gnu11 -fPIC -DCHECK_FUNCTION_EXISTS=pthread_create -rdynamic CMakeFiles/cmTC_2446c.dir/CheckFunctionExists.c.o -o cmTC_2446c -lpthreads
/usr/bin/ld: cannot find -lpthreads
collect2: error: ld returned 1 exit status
make[1]: *** [CMakeFiles/cmTC_2446c.dir/build.make:87: cmTC_2446c] Error 1
make[1]: Leaving directory '/home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp'
make: *** [Makefile:121: cmTC_2446c/fast] Error 2

314
libcodec2-android/src/codec2/build_linux/CMakeFiles/CMakeOutput.log vendored
Wyświetl plik

@ -1,314 +0,0 @@
The system is: Linux - 4.19.0-6-amd64 - x86_64
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 "/home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/3.13.4/CompilerIdC/a.out"
Determining if the C compiler works passed with the following output:
Change Dir: /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp
Run Build Command:"/usr/bin/make" "cmTC_1ddae/fast"
/usr/bin/make -f CMakeFiles/cmTC_1ddae.dir/build.make CMakeFiles/cmTC_1ddae.dir/build
make[1]: Entering directory '/home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp'
Building C object CMakeFiles/cmTC_1ddae.dir/testCCompiler.c.o
/usr/bin/cc -o CMakeFiles/cmTC_1ddae.dir/testCCompiler.c.o -c /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp/testCCompiler.c
Linking C executable cmTC_1ddae
/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_1ddae.dir/link.txt --verbose=1
/usr/bin/cc -rdynamic CMakeFiles/cmTC_1ddae.dir/testCCompiler.c.o -o cmTC_1ddae
make[1]: Leaving directory '/home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp'
Detecting C compiler ABI info compiled with the following output:
Change Dir: /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp
Run Build Command:"/usr/bin/make" "cmTC_832d9/fast"
/usr/bin/make -f CMakeFiles/cmTC_832d9.dir/build.make CMakeFiles/cmTC_832d9.dir/build
make[1]: Entering directory '/home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp'
Building C object CMakeFiles/cmTC_832d9.dir/CMakeCCompilerABI.c.o
/usr/bin/cc -o CMakeFiles/cmTC_832d9.dir/CMakeCCompilerABI.c.o -c /usr/share/cmake-3.13/Modules/CMakeCCompilerABI.c
Linking C executable cmTC_832d9
/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_832d9.dir/link.txt --verbose=1
/usr/bin/cc -v -rdynamic CMakeFiles/cmTC_832d9.dir/CMakeCCompilerABI.c.o -o cmTC_832d9
Using built-in specs.
COLLECT_GCC=/usr/bin/cc
COLLECT_LTO_WRAPPER=/usr/lib/gcc/x86_64-linux-gnu/8/lto-wrapper
OFFLOAD_TARGET_NAMES=nvptx-none
OFFLOAD_TARGET_DEFAULT=1
Target: x86_64-linux-gnu
Configured with: ../src/configure -v --with-pkgversion='Debian 8.3.0-6' --with-bugurl=file:///usr/share/doc/gcc-8/README.Bugs --enable-languages=c,ada,c++,go,brig,d,fortran,objc,obj-c++ --prefix=/usr --with-gcc-major-version-only --program-suffix=-8 --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-libmpx --enable-plugin --enable-default-pie --with-system-zlib --with-target-system-zlib --enable-objc-gc=auto --enable-multiarch --disable-werror --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32,m64,mx32 --enable-multilib --with-tune=generic --enable-offload-targets=nvptx-none --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu
Thread model: posix
gcc version 8.3.0 (Debian 8.3.0-6)
COMPILER_PATH=/usr/lib/gcc/x86_64-linux-gnu/8/:/usr/lib/gcc/x86_64-linux-gnu/8/:/usr/lib/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/8/:/usr/lib/gcc/x86_64-linux-gnu/
LIBRARY_PATH=/usr/lib/gcc/x86_64-linux-gnu/8/:/usr/lib/gcc/x86_64-linux-gnu/8/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/8/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-linux-gnu/8/../../../:/lib/:/usr/lib/
COLLECT_GCC_OPTIONS='-v' '-rdynamic' '-o' 'cmTC_832d9' '-mtune=generic' '-march=x86-64'
/usr/lib/gcc/x86_64-linux-gnu/8/collect2 -plugin /usr/lib/gcc/x86_64-linux-gnu/8/liblto_plugin.so -plugin-opt=/usr/lib/gcc/x86_64-linux-gnu/8/lto-wrapper -plugin-opt=-fresolution=/tmp/user/1000/ccEIB3tk.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 -export-dynamic -dynamic-linker /lib64/ld-linux-x86-64.so.2 -pie -o cmTC_832d9 /usr/lib/gcc/x86_64-linux-gnu/8/../../../x86_64-linux-gnu/Scrt1.o /usr/lib/gcc/x86_64-linux-gnu/8/../../../x86_64-linux-gnu/crti.o /usr/lib/gcc/x86_64-linux-gnu/8/crtbeginS.o -L/usr/lib/gcc/x86_64-linux-gnu/8 -L/usr/lib/gcc/x86_64-linux-gnu/8/../../../x86_64-linux-gnu -L/usr/lib/gcc/x86_64-linux-gnu/8/../../../../lib -L/lib/x86_64-linux-gnu -L/lib/../lib -L/usr/lib/x86_64-linux-gnu -L/usr/lib/../lib -L/usr/lib/gcc/x86_64-linux-gnu/8/../../.. CMakeFiles/cmTC_832d9.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/8/crtendS.o /usr/lib/gcc/x86_64-linux-gnu/8/../../../x86_64-linux-gnu/crtn.o
COLLECT_GCC_OPTIONS='-v' '-rdynamic' '-o' 'cmTC_832d9' '-mtune=generic' '-march=x86-64'
make[1]: Leaving directory '/home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp'
Parsed C implicit link information from above output:
link line regex: [^( *|.*[/\])(ld|CMAKE_LINK_STARTFILE-NOTFOUND|([^/\]+-)?ld|collect2)[^/\]*( |$)]
ignore line: [Change Dir: /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp]
ignore line: []
ignore line: [Run Build Command:"/usr/bin/make" "cmTC_832d9/fast"]
ignore line: [/usr/bin/make -f CMakeFiles/cmTC_832d9.dir/build.make CMakeFiles/cmTC_832d9.dir/build]
ignore line: [make[1]: Entering directory '/home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp']
ignore line: [Building C object CMakeFiles/cmTC_832d9.dir/CMakeCCompilerABI.c.o]
ignore line: [/usr/bin/cc -o CMakeFiles/cmTC_832d9.dir/CMakeCCompilerABI.c.o -c /usr/share/cmake-3.13/Modules/CMakeCCompilerABI.c]
ignore line: [Linking C executable cmTC_832d9]
ignore line: [/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_832d9.dir/link.txt --verbose=1]
ignore line: [/usr/bin/cc -v -rdynamic CMakeFiles/cmTC_832d9.dir/CMakeCCompilerABI.c.o -o cmTC_832d9 ]
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/8/lto-wrapper]
ignore line: [OFFLOAD_TARGET_NAMES=nvptx-none]
ignore line: [OFFLOAD_TARGET_DEFAULT=1]
ignore line: [Target: x86_64-linux-gnu]
ignore line: [Configured with: ../src/configure -v --with-pkgversion='Debian 8.3.0-6' --with-bugurl=file:///usr/share/doc/gcc-8/README.Bugs --enable-languages=c,ada,c++,go,brig,d,fortran,objc,obj-c++ --prefix=/usr --with-gcc-major-version-only --program-suffix=-8 --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-libmpx --enable-plugin --enable-default-pie --with-system-zlib --with-target-system-zlib --enable-objc-gc=auto --enable-multiarch --disable-werror --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32,m64,mx32 --enable-multilib --with-tune=generic --enable-offload-targets=nvptx-none --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu]
ignore line: [Thread model: posix]
ignore line: [gcc version 8.3.0 (Debian 8.3.0-6) ]
ignore line: [COMPILER_PATH=/usr/lib/gcc/x86_64-linux-gnu/8/:/usr/lib/gcc/x86_64-linux-gnu/8/:/usr/lib/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/8/:/usr/lib/gcc/x86_64-linux-gnu/]
ignore line: [LIBRARY_PATH=/usr/lib/gcc/x86_64-linux-gnu/8/:/usr/lib/gcc/x86_64-linux-gnu/8/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/8/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-linux-gnu/8/../../../:/lib/:/usr/lib/]
ignore line: [COLLECT_GCC_OPTIONS='-v' '-rdynamic' '-o' 'cmTC_832d9' '-mtune=generic' '-march=x86-64']
link line: [ /usr/lib/gcc/x86_64-linux-gnu/8/collect2 -plugin /usr/lib/gcc/x86_64-linux-gnu/8/liblto_plugin.so -plugin-opt=/usr/lib/gcc/x86_64-linux-gnu/8/lto-wrapper -plugin-opt=-fresolution=/tmp/user/1000/ccEIB3tk.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 -export-dynamic -dynamic-linker /lib64/ld-linux-x86-64.so.2 -pie -o cmTC_832d9 /usr/lib/gcc/x86_64-linux-gnu/8/../../../x86_64-linux-gnu/Scrt1.o /usr/lib/gcc/x86_64-linux-gnu/8/../../../x86_64-linux-gnu/crti.o /usr/lib/gcc/x86_64-linux-gnu/8/crtbeginS.o -L/usr/lib/gcc/x86_64-linux-gnu/8 -L/usr/lib/gcc/x86_64-linux-gnu/8/../../../x86_64-linux-gnu -L/usr/lib/gcc/x86_64-linux-gnu/8/../../../../lib -L/lib/x86_64-linux-gnu -L/lib/../lib -L/usr/lib/x86_64-linux-gnu -L/usr/lib/../lib -L/usr/lib/gcc/x86_64-linux-gnu/8/../../.. CMakeFiles/cmTC_832d9.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/8/crtendS.o /usr/lib/gcc/x86_64-linux-gnu/8/../../../x86_64-linux-gnu/crtn.o]
arg [/usr/lib/gcc/x86_64-linux-gnu/8/collect2] ==> ignore
arg [-plugin] ==> ignore
arg [/usr/lib/gcc/x86_64-linux-gnu/8/liblto_plugin.so] ==> ignore
arg [-plugin-opt=/usr/lib/gcc/x86_64-linux-gnu/8/lto-wrapper] ==> ignore
arg [-plugin-opt=-fresolution=/tmp/user/1000/ccEIB3tk.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 [-export-dynamic] ==> ignore
arg [-dynamic-linker] ==> ignore
arg [/lib64/ld-linux-x86-64.so.2] ==> ignore
arg [-pie] ==> ignore
arg [-o] ==> ignore
arg [cmTC_832d9] ==> ignore
arg [/usr/lib/gcc/x86_64-linux-gnu/8/../../../x86_64-linux-gnu/Scrt1.o] ==> ignore
arg [/usr/lib/gcc/x86_64-linux-gnu/8/../../../x86_64-linux-gnu/crti.o] ==> ignore
arg [/usr/lib/gcc/x86_64-linux-gnu/8/crtbeginS.o] ==> ignore
arg [-L/usr/lib/gcc/x86_64-linux-gnu/8] ==> dir [/usr/lib/gcc/x86_64-linux-gnu/8]
arg [-L/usr/lib/gcc/x86_64-linux-gnu/8/../../../x86_64-linux-gnu] ==> dir [/usr/lib/gcc/x86_64-linux-gnu/8/../../../x86_64-linux-gnu]
arg [-L/usr/lib/gcc/x86_64-linux-gnu/8/../../../../lib] ==> dir [/usr/lib/gcc/x86_64-linux-gnu/8/../../../../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/lib/gcc/x86_64-linux-gnu/8/../../..] ==> dir [/usr/lib/gcc/x86_64-linux-gnu/8/../../..]
arg [CMakeFiles/cmTC_832d9.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/8/crtendS.o] ==> ignore
arg [/usr/lib/gcc/x86_64-linux-gnu/8/../../../x86_64-linux-gnu/crtn.o] ==> ignore
collapse library dir [/usr/lib/gcc/x86_64-linux-gnu/8] ==> [/usr/lib/gcc/x86_64-linux-gnu/8]
collapse library dir [/usr/lib/gcc/x86_64-linux-gnu/8/../../../x86_64-linux-gnu] ==> [/usr/lib/x86_64-linux-gnu]
collapse library dir [/usr/lib/gcc/x86_64-linux-gnu/8/../../../../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/lib/gcc/x86_64-linux-gnu/8/../../..] ==> [/usr/lib]
implicit libs: [gcc;gcc_s;c;gcc;gcc_s]
implicit dirs: [/usr/lib/gcc/x86_64-linux-gnu/8;/usr/lib/x86_64-linux-gnu;/usr/lib;/lib/x86_64-linux-gnu;/lib]
implicit fwks: []
Detecting C [-std=c11] compiler features compiled with the following output:
Change Dir: /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp
Run Build Command:"/usr/bin/make" "cmTC_216c5/fast"
/usr/bin/make -f CMakeFiles/cmTC_216c5.dir/build.make CMakeFiles/cmTC_216c5.dir/build
make[1]: Entering directory '/home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp'
Building C object CMakeFiles/cmTC_216c5.dir/feature_tests.c.o
/usr/bin/cc -std=c11 -o CMakeFiles/cmTC_216c5.dir/feature_tests.c.o -c /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/feature_tests.c
Linking C executable cmTC_216c5
/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_216c5.dir/link.txt --verbose=1
/usr/bin/cc -rdynamic CMakeFiles/cmTC_216c5.dir/feature_tests.c.o -o cmTC_216c5
make[1]: Leaving directory '/home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp'
Feature record: C_FEATURE:1c_function_prototypes
Feature record: C_FEATURE:1c_restrict
Feature record: C_FEATURE:1c_static_assert
Feature record: C_FEATURE:1c_variadic_macros
Detecting C [-std=c99] compiler features compiled with the following output:
Change Dir: /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp
Run Build Command:"/usr/bin/make" "cmTC_0d4de/fast"
/usr/bin/make -f CMakeFiles/cmTC_0d4de.dir/build.make CMakeFiles/cmTC_0d4de.dir/build
make[1]: Entering directory '/home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp'
Building C object CMakeFiles/cmTC_0d4de.dir/feature_tests.c.o
/usr/bin/cc -std=c99 -o CMakeFiles/cmTC_0d4de.dir/feature_tests.c.o -c /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/feature_tests.c
Linking C executable cmTC_0d4de
/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_0d4de.dir/link.txt --verbose=1
/usr/bin/cc -rdynamic CMakeFiles/cmTC_0d4de.dir/feature_tests.c.o -o cmTC_0d4de
make[1]: Leaving directory '/home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp'
Feature record: C_FEATURE:1c_function_prototypes
Feature record: C_FEATURE:1c_restrict
Feature record: C_FEATURE:0c_static_assert
Feature record: C_FEATURE:1c_variadic_macros
Detecting C [-std=c90] compiler features compiled with the following output:
Change Dir: /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp
Run Build Command:"/usr/bin/make" "cmTC_124f1/fast"
/usr/bin/make -f CMakeFiles/cmTC_124f1.dir/build.make CMakeFiles/cmTC_124f1.dir/build
make[1]: Entering directory '/home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp'
Building C object CMakeFiles/cmTC_124f1.dir/feature_tests.c.o
/usr/bin/cc -std=c90 -o CMakeFiles/cmTC_124f1.dir/feature_tests.c.o -c /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/feature_tests.c
Linking C executable cmTC_124f1
/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_124f1.dir/link.txt --verbose=1
/usr/bin/cc -rdynamic CMakeFiles/cmTC_124f1.dir/feature_tests.c.o -o cmTC_124f1
make[1]: Leaving directory '/home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp'
Feature record: C_FEATURE:1c_function_prototypes
Feature record: C_FEATURE:0c_restrict
Feature record: C_FEATURE:0c_static_assert
Feature record: C_FEATURE:0c_variadic_macros
Performing C SOURCE FILE Test COMPILER_SUPPORTS_GNU11 succeeded with the following output:
Change Dir: /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp
Run Build Command:"/usr/bin/make" "cmTC_cf9e6/fast"
/usr/bin/make -f CMakeFiles/cmTC_cf9e6.dir/build.make CMakeFiles/cmTC_cf9e6.dir/build
make[1]: Entering directory '/home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp'
Building C object CMakeFiles/cmTC_cf9e6.dir/src.c.o
/usr/bin/cc -Wall -Wno-strict-overflow -DCOMPILER_SUPPORTS_GNU11 -std=gnu11 -o CMakeFiles/cmTC_cf9e6.dir/src.c.o -c /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp/src.c
Linking C executable cmTC_cf9e6
/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_cf9e6.dir/link.txt --verbose=1
/usr/bin/cc -Wall -Wno-strict-overflow -DCOMPILER_SUPPORTS_GNU11 -rdynamic CMakeFiles/cmTC_cf9e6.dir/src.c.o -o cmTC_cf9e6
make[1]: Leaving directory '/home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp'
Source file was:
int main(void) { return 0; }
Performing C SOURCE FILE Test COMPILER_SUPPORTS_GNU99 succeeded with the following output:
Change Dir: /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp
Run Build Command:"/usr/bin/make" "cmTC_31e8b/fast"
/usr/bin/make -f CMakeFiles/cmTC_31e8b.dir/build.make CMakeFiles/cmTC_31e8b.dir/build
make[1]: Entering directory '/home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp'
Building C object CMakeFiles/cmTC_31e8b.dir/src.c.o
/usr/bin/cc -Wall -Wno-strict-overflow -DCOMPILER_SUPPORTS_GNU99 -std=gnu99 -o CMakeFiles/cmTC_31e8b.dir/src.c.o -c /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp/src.c
Linking C executable cmTC_31e8b
/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_31e8b.dir/link.txt --verbose=1
/usr/bin/cc -Wall -Wno-strict-overflow -DCOMPILER_SUPPORTS_GNU99 -rdynamic CMakeFiles/cmTC_31e8b.dir/src.c.o -o cmTC_31e8b
make[1]: Leaving directory '/home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp'
Source file was:
int main(void) { return 0; }
Determining if files stdlib.h exist passed with the following output:
Change Dir: /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp
Run Build Command:"/usr/bin/make" "cmTC_03207/fast"
/usr/bin/make -f CMakeFiles/cmTC_03207.dir/build.make CMakeFiles/cmTC_03207.dir/build
make[1]: Entering directory '/home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp'
Building C object CMakeFiles/cmTC_03207.dir/HAVE_STDLIB_H.c.o
/usr/bin/cc -Wall -Wno-strict-overflow -std=gnu11 -fPIC -o CMakeFiles/cmTC_03207.dir/HAVE_STDLIB_H.c.o -c /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CheckIncludeFiles/HAVE_STDLIB_H.c
Linking C executable cmTC_03207
/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_03207.dir/link.txt --verbose=1
/usr/bin/cc -Wall -Wno-strict-overflow -std=gnu11 -fPIC -rdynamic CMakeFiles/cmTC_03207.dir/HAVE_STDLIB_H.c.o -o cmTC_03207
make[1]: Leaving directory '/home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp'
Determining if files string.h exist passed with the following output:
Change Dir: /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp
Run Build Command:"/usr/bin/make" "cmTC_e3f48/fast"
/usr/bin/make -f CMakeFiles/cmTC_e3f48.dir/build.make CMakeFiles/cmTC_e3f48.dir/build
make[1]: Entering directory '/home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp'
Building C object CMakeFiles/cmTC_e3f48.dir/HAVE_STRING_H.c.o
/usr/bin/cc -Wall -Wno-strict-overflow -std=gnu11 -fPIC -o CMakeFiles/cmTC_e3f48.dir/HAVE_STRING_H.c.o -c /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CheckIncludeFiles/HAVE_STRING_H.c
Linking C executable cmTC_e3f48
/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_e3f48.dir/link.txt --verbose=1
/usr/bin/cc -Wall -Wno-strict-overflow -std=gnu11 -fPIC -rdynamic CMakeFiles/cmTC_e3f48.dir/HAVE_STRING_H.c.o -o cmTC_e3f48
make[1]: Leaving directory '/home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp'
Determining if the __GNU_LIBRARY__ exist passed with the following output:
Change Dir: /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp
Run Build Command:"/usr/bin/make" "cmTC_969e3/fast"
/usr/bin/make -f CMakeFiles/cmTC_969e3.dir/build.make CMakeFiles/cmTC_969e3.dir/build
make[1]: Entering directory '/home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp'
Building C object CMakeFiles/cmTC_969e3.dir/CheckSymbolExists.c.o
/usr/bin/cc -Wall -Wno-strict-overflow -std=gnu11 -fPIC -o CMakeFiles/cmTC_969e3.dir/CheckSymbolExists.c.o -c /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp/CheckSymbolExists.c
Linking C executable cmTC_969e3
/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_969e3.dir/link.txt --verbose=1
/usr/bin/cc -Wall -Wno-strict-overflow -std=gnu11 -fPIC -rdynamic CMakeFiles/cmTC_969e3.dir/CheckSymbolExists.c.o -o cmTC_969e3
make[1]: Leaving directory '/home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp'
File /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp/CheckSymbolExists.c:
/* */
#include <features.h>
int main(int argc, char** argv)
{
(void)argv;
#ifndef __GNU_LIBRARY__
return ((int*)(&__GNU_LIBRARY__))[argc];
#else
(void)argc;
return 0;
#endif
}
Determining if the include file pthread.h exists passed with the following output:
Change Dir: /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp
Run Build Command:"/usr/bin/make" "cmTC_0e7c0/fast"
/usr/bin/make -f CMakeFiles/cmTC_0e7c0.dir/build.make CMakeFiles/cmTC_0e7c0.dir/build
make[1]: Entering directory '/home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp'
Building C object CMakeFiles/cmTC_0e7c0.dir/CheckIncludeFile.c.o
/usr/bin/cc -Wall -Wno-strict-overflow -std=gnu11 -fPIC -o CMakeFiles/cmTC_0e7c0.dir/CheckIncludeFile.c.o -c /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp/CheckIncludeFile.c
Linking C executable cmTC_0e7c0
/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_0e7c0.dir/link.txt --verbose=1
/usr/bin/cc -Wall -Wno-strict-overflow -std=gnu11 -fPIC -rdynamic CMakeFiles/cmTC_0e7c0.dir/CheckIncludeFile.c.o -o cmTC_0e7c0
make[1]: Leaving directory '/home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp'
Determining if the function pthread_create exists in the pthread passed with the following output:
Change Dir: /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp
Run Build Command:"/usr/bin/make" "cmTC_b8dfa/fast"
/usr/bin/make -f CMakeFiles/cmTC_b8dfa.dir/build.make CMakeFiles/cmTC_b8dfa.dir/build
make[1]: Entering directory '/home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp'
Building C object CMakeFiles/cmTC_b8dfa.dir/CheckFunctionExists.c.o
/usr/bin/cc -Wall -Wno-strict-overflow -std=gnu11 -fPIC -DCHECK_FUNCTION_EXISTS=pthread_create -o CMakeFiles/cmTC_b8dfa.dir/CheckFunctionExists.c.o -c /usr/share/cmake-3.13/Modules/CheckFunctionExists.c
Linking C executable cmTC_b8dfa
/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_b8dfa.dir/link.txt --verbose=1
/usr/bin/cc -Wall -Wno-strict-overflow -std=gnu11 -fPIC -DCHECK_FUNCTION_EXISTS=pthread_create -rdynamic CMakeFiles/cmTC_b8dfa.dir/CheckFunctionExists.c.o -o cmTC_b8dfa -lpthread
make[1]: Leaving directory '/home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/CMakeTmp'

39
libcodec2-android/src/codec2/build_linux/CMakeFiles/CMakeRuleHashes.txt vendored
Wyświetl plik

@ -1,39 +0,0 @@
# Hashes of file build rules.
7c7dfb587d456c225070aad6d4774a2c CMakeFiles/Continuous
11844d0b58c459d3f36a2c0f0f13e8f1 CMakeFiles/ContinuousBuild
d96d2a7ab144609a2be5ebf2cf7024be CMakeFiles/ContinuousConfigure
19c67e8cd461a1340c70de888ae017c1 CMakeFiles/ContinuousCoverage
d3be82eee8132bc4a8f669f976bbc8e8 CMakeFiles/ContinuousMemCheck
87b0fbd676b729b1fc58faab74263a5f CMakeFiles/ContinuousStart
468b5267626cb347270dc32893c9c3c2 CMakeFiles/ContinuousSubmit
7d2cdc4cb0df64f4547cf13dbebee0fa CMakeFiles/ContinuousTest
85ced87e901d8daf28c29e175e60ea99 CMakeFiles/ContinuousUpdate
df392eb54c865301c8527f36d05e8b2d CMakeFiles/Experimental
27d3850f918a9816dcadc90e37cf8578 CMakeFiles/ExperimentalBuild
8f29e8a48947c80cb2f52c89bbefcfe6 CMakeFiles/ExperimentalConfigure
ddc7ce17306c478b2bfcd561445b2f9c CMakeFiles/ExperimentalCoverage
9d8c1adf4182e1b4771f98b1a479c2e4 CMakeFiles/ExperimentalMemCheck
2da7cdc534668bda44615c833e984bef CMakeFiles/ExperimentalStart
a0d015a3c5a29611e444b20e80f0efac CMakeFiles/ExperimentalSubmit
e2c873dd97394d864ce1ba319f2c44c7 CMakeFiles/ExperimentalTest
b886d29641efe9c6142554137416ec7b CMakeFiles/ExperimentalUpdate
ddda079ac1c2f2be072446a1fc540266 CMakeFiles/Nightly
f2990e4c67de97767cf93674db260653 CMakeFiles/NightlyBuild
1a0ca39e1bc7e6b5148f64c27ef69bd3 CMakeFiles/NightlyConfigure
b8870f620396ddfc0156c323b565d674 CMakeFiles/NightlyCoverage
996808e72c1af0cbb1937df7d569a06c CMakeFiles/NightlyMemCheck
119279ccd8eb9897dfe18e1afa790680 CMakeFiles/NightlyMemoryCheck
69dfdabc976a6c05e592c8ced7bb3439 CMakeFiles/NightlyStart
ac576456475853dae621396fc2c8b955 CMakeFiles/NightlySubmit
a1135a96c4573d829189818b6cdc260d CMakeFiles/NightlyTest
63ca02bc64f3f3b9932311ef45ff98e8 CMakeFiles/NightlyUpdate
a8f1a91997b82f40a588ba7ebf5bbdc6 src/codebook.c
8da91890bd96ec6db12ae69342986ae9 src/codebookd.c
b109cbebb4fa303397d7935cdb38a76e src/codebookge.c
d6392c6d9a85b253f662b07783eb6927 src/codebookjvm.c
91095f198e2009a3e3b9045858112473 src/codebooklspmelvq.c
d3da0d232ce8f81825bf8c397af60579 src/codebookmel.c
c027462884f527c0b94b9887503195c5 src/codebooknewamp1.c
525689982bbf5718618586b912c561ef src/codebooknewamp1_energy.c
59ecb79a2132f3a3e085942ab74dc994 src/codebooknewamp2.c
8af163fc838995589c524aab35db69d1 src/codebooknewamp2_energy.c

6
libcodec2-android/src/codec2/build_linux/CMakeFiles/CheckIncludeFiles/HAVE_STDLIB_H.c vendored
Wyświetl plik

@ -1,6 +0,0 @@
/* */
#include <stdlib.h>
int main(void){return 0;}

6
libcodec2-android/src/codec2/build_linux/CMakeFiles/CheckIncludeFiles/HAVE_STRING_H.c vendored
Wyświetl plik

@ -1,6 +0,0 @@
/* */
#include <string.h>
int main(void){return 0;}

11
libcodec2-android/src/codec2/build_linux/CMakeFiles/Continuous.dir/DependInfo.cmake vendored
Wyświetl plik

@ -1,11 +0,0 @@
# The set of languages for which implicit dependencies are needed:
set(CMAKE_DEPENDS_LANGUAGES
)
# The set of files for implicit dependencies of each language:
# Targets to which this target links.
set(CMAKE_TARGET_LINKED_INFO_FILES
)
# Fortran module output directory.
set(CMAKE_Fortran_TARGET_MODULE_DIR "")

76
libcodec2-android/src/codec2/build_linux/CMakeFiles/Continuous.dir/build.make vendored
Wyświetl plik

@ -1,76 +0,0 @@
# CMAKE generated file: DO NOT EDIT!
# Generated by "Unix Makefiles" Generator, CMake Version 3.13
# Delete rule output on recipe failure.
.DELETE_ON_ERROR:
#=============================================================================
# Special targets provided by cmake.
# Disable implicit rules so canonical targets will work.
.SUFFIXES:
# Remove some rules from gmake that .SUFFIXES does not remove.
SUFFIXES =
.SUFFIXES: .hpux_make_needs_suffix_list
# 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/bin/cmake
# The command to remove a file.
RM = /usr/bin/cmake -E remove -f
# Escaping for special characters.
EQUALS = =
# The top-level source directory on which CMake was run.
CMAKE_SOURCE_DIR = /home/sh/Downloads/hackrf/codec2
# The top-level build directory on which CMake was run.
CMAKE_BINARY_DIR = /home/sh/Downloads/hackrf/codec2/build_linux
# Utility rule file for Continuous.
# Include the progress variables for this target.
include CMakeFiles/Continuous.dir/progress.make
CMakeFiles/Continuous:
/usr/bin/ctest -D Continuous
Continuous: CMakeFiles/Continuous
Continuous: CMakeFiles/Continuous.dir/build.make
.PHONY : Continuous
# Rule to build all files generated by this target.
CMakeFiles/Continuous.dir/build: Continuous
.PHONY : CMakeFiles/Continuous.dir/build
CMakeFiles/Continuous.dir/clean:
$(CMAKE_COMMAND) -P CMakeFiles/Continuous.dir/cmake_clean.cmake
.PHONY : CMakeFiles/Continuous.dir/clean
CMakeFiles/Continuous.dir/depend:
cd /home/sh/Downloads/hackrf/codec2/build_linux && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /home/sh/Downloads/hackrf/codec2 /home/sh/Downloads/hackrf/codec2 /home/sh/Downloads/hackrf/codec2/build_linux /home/sh/Downloads/hackrf/codec2/build_linux /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/Continuous.dir/DependInfo.cmake --color=$(COLOR)
.PHONY : CMakeFiles/Continuous.dir/depend

8
libcodec2-android/src/codec2/build_linux/CMakeFiles/Continuous.dir/cmake_clean.cmake vendored
Wyświetl plik

@ -1,8 +0,0 @@
file(REMOVE_RECURSE
"CMakeFiles/Continuous"
)
# Per-language clean rules from dependency scanning.
foreach(lang )
include(CMakeFiles/Continuous.dir/cmake_clean_${lang}.cmake OPTIONAL)
endforeach()

1
libcodec2-android/src/codec2/build_linux/CMakeFiles/Continuous.dir/progress.make vendored
Wyświetl plik

@ -1 +0,0 @@

11
libcodec2-android/src/codec2/build_linux/CMakeFiles/ContinuousBuild.dir/DependInfo.cmake vendored
Wyświetl plik

@ -1,11 +0,0 @@
# The set of languages for which implicit dependencies are needed:
set(CMAKE_DEPENDS_LANGUAGES
)
# The set of files for implicit dependencies of each language:
# Targets to which this target links.
set(CMAKE_TARGET_LINKED_INFO_FILES
)
# Fortran module output directory.
set(CMAKE_Fortran_TARGET_MODULE_DIR "")

76
libcodec2-android/src/codec2/build_linux/CMakeFiles/ContinuousBuild.dir/build.make vendored
Wyświetl plik

@ -1,76 +0,0 @@
# CMAKE generated file: DO NOT EDIT!
# Generated by "Unix Makefiles" Generator, CMake Version 3.13
# Delete rule output on recipe failure.
.DELETE_ON_ERROR:
#=============================================================================
# Special targets provided by cmake.
# Disable implicit rules so canonical targets will work.
.SUFFIXES:
# Remove some rules from gmake that .SUFFIXES does not remove.
SUFFIXES =
.SUFFIXES: .hpux_make_needs_suffix_list
# 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/bin/cmake
# The command to remove a file.
RM = /usr/bin/cmake -E remove -f
# Escaping for special characters.
EQUALS = =
# The top-level source directory on which CMake was run.
CMAKE_SOURCE_DIR = /home/sh/Downloads/hackrf/codec2
# The top-level build directory on which CMake was run.
CMAKE_BINARY_DIR = /home/sh/Downloads/hackrf/codec2/build_linux
# Utility rule file for ContinuousBuild.
# Include the progress variables for this target.
include CMakeFiles/ContinuousBuild.dir/progress.make
CMakeFiles/ContinuousBuild:
/usr/bin/ctest -D ContinuousBuild
ContinuousBuild: CMakeFiles/ContinuousBuild
ContinuousBuild: CMakeFiles/ContinuousBuild.dir/build.make
.PHONY : ContinuousBuild
# Rule to build all files generated by this target.
CMakeFiles/ContinuousBuild.dir/build: ContinuousBuild
.PHONY : CMakeFiles/ContinuousBuild.dir/build
CMakeFiles/ContinuousBuild.dir/clean:
$(CMAKE_COMMAND) -P CMakeFiles/ContinuousBuild.dir/cmake_clean.cmake
.PHONY : CMakeFiles/ContinuousBuild.dir/clean
CMakeFiles/ContinuousBuild.dir/depend:
cd /home/sh/Downloads/hackrf/codec2/build_linux && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /home/sh/Downloads/hackrf/codec2 /home/sh/Downloads/hackrf/codec2 /home/sh/Downloads/hackrf/codec2/build_linux /home/sh/Downloads/hackrf/codec2/build_linux /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/ContinuousBuild.dir/DependInfo.cmake --color=$(COLOR)
.PHONY : CMakeFiles/ContinuousBuild.dir/depend

8
libcodec2-android/src/codec2/build_linux/CMakeFiles/ContinuousBuild.dir/cmake_clean.cmake vendored
Wyświetl plik

@ -1,8 +0,0 @@
file(REMOVE_RECURSE
"CMakeFiles/ContinuousBuild"
)
# Per-language clean rules from dependency scanning.
foreach(lang )
include(CMakeFiles/ContinuousBuild.dir/cmake_clean_${lang}.cmake OPTIONAL)
endforeach()

1
libcodec2-android/src/codec2/build_linux/CMakeFiles/ContinuousBuild.dir/progress.make vendored
Wyświetl plik

@ -1 +0,0 @@

11
libcodec2-android/src/codec2/build_linux/CMakeFiles/ContinuousConfigure.dir/DependInfo.cmake vendored
Wyświetl plik

@ -1,11 +0,0 @@
# The set of languages for which implicit dependencies are needed:
set(CMAKE_DEPENDS_LANGUAGES
)
# The set of files for implicit dependencies of each language:
# Targets to which this target links.
set(CMAKE_TARGET_LINKED_INFO_FILES
)
# Fortran module output directory.
set(CMAKE_Fortran_TARGET_MODULE_DIR "")

76
libcodec2-android/src/codec2/build_linux/CMakeFiles/ContinuousConfigure.dir/build.make vendored
Wyświetl plik

@ -1,76 +0,0 @@
# CMAKE generated file: DO NOT EDIT!
# Generated by "Unix Makefiles" Generator, CMake Version 3.13
# Delete rule output on recipe failure.
.DELETE_ON_ERROR:
#=============================================================================
# Special targets provided by cmake.
# Disable implicit rules so canonical targets will work.
.SUFFIXES:
# Remove some rules from gmake that .SUFFIXES does not remove.
SUFFIXES =
.SUFFIXES: .hpux_make_needs_suffix_list
# 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/bin/cmake
# The command to remove a file.
RM = /usr/bin/cmake -E remove -f
# Escaping for special characters.
EQUALS = =
# The top-level source directory on which CMake was run.
CMAKE_SOURCE_DIR = /home/sh/Downloads/hackrf/codec2
# The top-level build directory on which CMake was run.
CMAKE_BINARY_DIR = /home/sh/Downloads/hackrf/codec2/build_linux
# Utility rule file for ContinuousConfigure.
# Include the progress variables for this target.
include CMakeFiles/ContinuousConfigure.dir/progress.make
CMakeFiles/ContinuousConfigure:
/usr/bin/ctest -D ContinuousConfigure
ContinuousConfigure: CMakeFiles/ContinuousConfigure
ContinuousConfigure: CMakeFiles/ContinuousConfigure.dir/build.make
.PHONY : ContinuousConfigure
# Rule to build all files generated by this target.
CMakeFiles/ContinuousConfigure.dir/build: ContinuousConfigure
.PHONY : CMakeFiles/ContinuousConfigure.dir/build
CMakeFiles/ContinuousConfigure.dir/clean:
$(CMAKE_COMMAND) -P CMakeFiles/ContinuousConfigure.dir/cmake_clean.cmake
.PHONY : CMakeFiles/ContinuousConfigure.dir/clean
CMakeFiles/ContinuousConfigure.dir/depend:
cd /home/sh/Downloads/hackrf/codec2/build_linux && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /home/sh/Downloads/hackrf/codec2 /home/sh/Downloads/hackrf/codec2 /home/sh/Downloads/hackrf/codec2/build_linux /home/sh/Downloads/hackrf/codec2/build_linux /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/ContinuousConfigure.dir/DependInfo.cmake --color=$(COLOR)
.PHONY : CMakeFiles/ContinuousConfigure.dir/depend

8
libcodec2-android/src/codec2/build_linux/CMakeFiles/ContinuousConfigure.dir/cmake_clean.cmake vendored
Wyświetl plik

@ -1,8 +0,0 @@
file(REMOVE_RECURSE
"CMakeFiles/ContinuousConfigure"
)
# Per-language clean rules from dependency scanning.
foreach(lang )
include(CMakeFiles/ContinuousConfigure.dir/cmake_clean_${lang}.cmake OPTIONAL)
endforeach()

1
libcodec2-android/src/codec2/build_linux/CMakeFiles/ContinuousConfigure.dir/progress.make vendored
Wyświetl plik

@ -1 +0,0 @@

11
libcodec2-android/src/codec2/build_linux/CMakeFiles/ContinuousCoverage.dir/DependInfo.cmake vendored
Wyświetl plik

@ -1,11 +0,0 @@
# The set of languages for which implicit dependencies are needed:
set(CMAKE_DEPENDS_LANGUAGES
)
# The set of files for implicit dependencies of each language:
# Targets to which this target links.
set(CMAKE_TARGET_LINKED_INFO_FILES
)
# Fortran module output directory.
set(CMAKE_Fortran_TARGET_MODULE_DIR "")

76
libcodec2-android/src/codec2/build_linux/CMakeFiles/ContinuousCoverage.dir/build.make vendored
Wyświetl plik

@ -1,76 +0,0 @@
# CMAKE generated file: DO NOT EDIT!
# Generated by "Unix Makefiles" Generator, CMake Version 3.13
# Delete rule output on recipe failure.
.DELETE_ON_ERROR:
#=============================================================================
# Special targets provided by cmake.
# Disable implicit rules so canonical targets will work.
.SUFFIXES:
# Remove some rules from gmake that .SUFFIXES does not remove.
SUFFIXES =
.SUFFIXES: .hpux_make_needs_suffix_list
# 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/bin/cmake
# The command to remove a file.
RM = /usr/bin/cmake -E remove -f
# Escaping for special characters.
EQUALS = =
# The top-level source directory on which CMake was run.
CMAKE_SOURCE_DIR = /home/sh/Downloads/hackrf/codec2
# The top-level build directory on which CMake was run.
CMAKE_BINARY_DIR = /home/sh/Downloads/hackrf/codec2/build_linux
# Utility rule file for ContinuousCoverage.
# Include the progress variables for this target.
include CMakeFiles/ContinuousCoverage.dir/progress.make
CMakeFiles/ContinuousCoverage:
/usr/bin/ctest -D ContinuousCoverage
ContinuousCoverage: CMakeFiles/ContinuousCoverage
ContinuousCoverage: CMakeFiles/ContinuousCoverage.dir/build.make
.PHONY : ContinuousCoverage
# Rule to build all files generated by this target.
CMakeFiles/ContinuousCoverage.dir/build: ContinuousCoverage
.PHONY : CMakeFiles/ContinuousCoverage.dir/build
CMakeFiles/ContinuousCoverage.dir/clean:
$(CMAKE_COMMAND) -P CMakeFiles/ContinuousCoverage.dir/cmake_clean.cmake
.PHONY : CMakeFiles/ContinuousCoverage.dir/clean
CMakeFiles/ContinuousCoverage.dir/depend:
cd /home/sh/Downloads/hackrf/codec2/build_linux && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /home/sh/Downloads/hackrf/codec2 /home/sh/Downloads/hackrf/codec2 /home/sh/Downloads/hackrf/codec2/build_linux /home/sh/Downloads/hackrf/codec2/build_linux /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/ContinuousCoverage.dir/DependInfo.cmake --color=$(COLOR)
.PHONY : CMakeFiles/ContinuousCoverage.dir/depend

8
libcodec2-android/src/codec2/build_linux/CMakeFiles/ContinuousCoverage.dir/cmake_clean.cmake vendored
Wyświetl plik

@ -1,8 +0,0 @@
file(REMOVE_RECURSE
"CMakeFiles/ContinuousCoverage"
)
# Per-language clean rules from dependency scanning.
foreach(lang )
include(CMakeFiles/ContinuousCoverage.dir/cmake_clean_${lang}.cmake OPTIONAL)
endforeach()

1
libcodec2-android/src/codec2/build_linux/CMakeFiles/ContinuousCoverage.dir/progress.make vendored
Wyświetl plik

@ -1 +0,0 @@

11
libcodec2-android/src/codec2/build_linux/CMakeFiles/ContinuousMemCheck.dir/DependInfo.cmake vendored
Wyświetl plik

@ -1,11 +0,0 @@
# The set of languages for which implicit dependencies are needed:
set(CMAKE_DEPENDS_LANGUAGES
)
# The set of files for implicit dependencies of each language:
# Targets to which this target links.
set(CMAKE_TARGET_LINKED_INFO_FILES
)
# Fortran module output directory.
set(CMAKE_Fortran_TARGET_MODULE_DIR "")

76
libcodec2-android/src/codec2/build_linux/CMakeFiles/ContinuousMemCheck.dir/build.make vendored
Wyświetl plik

@ -1,76 +0,0 @@
# CMAKE generated file: DO NOT EDIT!
# Generated by "Unix Makefiles" Generator, CMake Version 3.13
# Delete rule output on recipe failure.
.DELETE_ON_ERROR:
#=============================================================================
# Special targets provided by cmake.
# Disable implicit rules so canonical targets will work.
.SUFFIXES:
# Remove some rules from gmake that .SUFFIXES does not remove.
SUFFIXES =
.SUFFIXES: .hpux_make_needs_suffix_list
# 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/bin/cmake
# The command to remove a file.
RM = /usr/bin/cmake -E remove -f
# Escaping for special characters.
EQUALS = =
# The top-level source directory on which CMake was run.
CMAKE_SOURCE_DIR = /home/sh/Downloads/hackrf/codec2
# The top-level build directory on which CMake was run.
CMAKE_BINARY_DIR = /home/sh/Downloads/hackrf/codec2/build_linux
# Utility rule file for ContinuousMemCheck.
# Include the progress variables for this target.
include CMakeFiles/ContinuousMemCheck.dir/progress.make
CMakeFiles/ContinuousMemCheck:
/usr/bin/ctest -D ContinuousMemCheck
ContinuousMemCheck: CMakeFiles/ContinuousMemCheck
ContinuousMemCheck: CMakeFiles/ContinuousMemCheck.dir/build.make
.PHONY : ContinuousMemCheck
# Rule to build all files generated by this target.
CMakeFiles/ContinuousMemCheck.dir/build: ContinuousMemCheck
.PHONY : CMakeFiles/ContinuousMemCheck.dir/build
CMakeFiles/ContinuousMemCheck.dir/clean:
$(CMAKE_COMMAND) -P CMakeFiles/ContinuousMemCheck.dir/cmake_clean.cmake
.PHONY : CMakeFiles/ContinuousMemCheck.dir/clean
CMakeFiles/ContinuousMemCheck.dir/depend:
cd /home/sh/Downloads/hackrf/codec2/build_linux && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /home/sh/Downloads/hackrf/codec2 /home/sh/Downloads/hackrf/codec2 /home/sh/Downloads/hackrf/codec2/build_linux /home/sh/Downloads/hackrf/codec2/build_linux /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/ContinuousMemCheck.dir/DependInfo.cmake --color=$(COLOR)
.PHONY : CMakeFiles/ContinuousMemCheck.dir/depend

8
libcodec2-android/src/codec2/build_linux/CMakeFiles/ContinuousMemCheck.dir/cmake_clean.cmake vendored
Wyświetl plik

@ -1,8 +0,0 @@
file(REMOVE_RECURSE
"CMakeFiles/ContinuousMemCheck"
)
# Per-language clean rules from dependency scanning.
foreach(lang )
include(CMakeFiles/ContinuousMemCheck.dir/cmake_clean_${lang}.cmake OPTIONAL)
endforeach()

1
libcodec2-android/src/codec2/build_linux/CMakeFiles/ContinuousMemCheck.dir/progress.make vendored
Wyświetl plik

@ -1 +0,0 @@

11
libcodec2-android/src/codec2/build_linux/CMakeFiles/ContinuousStart.dir/DependInfo.cmake vendored
Wyświetl plik

@ -1,11 +0,0 @@
# The set of languages for which implicit dependencies are needed:
set(CMAKE_DEPENDS_LANGUAGES
)
# The set of files for implicit dependencies of each language:
# Targets to which this target links.
set(CMAKE_TARGET_LINKED_INFO_FILES
)
# Fortran module output directory.
set(CMAKE_Fortran_TARGET_MODULE_DIR "")

76
libcodec2-android/src/codec2/build_linux/CMakeFiles/ContinuousStart.dir/build.make vendored
Wyświetl plik

@ -1,76 +0,0 @@
# CMAKE generated file: DO NOT EDIT!
# Generated by "Unix Makefiles" Generator, CMake Version 3.13
# Delete rule output on recipe failure.
.DELETE_ON_ERROR:
#=============================================================================
# Special targets provided by cmake.
# Disable implicit rules so canonical targets will work.
.SUFFIXES:
# Remove some rules from gmake that .SUFFIXES does not remove.
SUFFIXES =
.SUFFIXES: .hpux_make_needs_suffix_list
# 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/bin/cmake
# The command to remove a file.
RM = /usr/bin/cmake -E remove -f
# Escaping for special characters.
EQUALS = =
# The top-level source directory on which CMake was run.
CMAKE_SOURCE_DIR = /home/sh/Downloads/hackrf/codec2
# The top-level build directory on which CMake was run.
CMAKE_BINARY_DIR = /home/sh/Downloads/hackrf/codec2/build_linux
# Utility rule file for ContinuousStart.
# Include the progress variables for this target.
include CMakeFiles/ContinuousStart.dir/progress.make
CMakeFiles/ContinuousStart:
/usr/bin/ctest -D ContinuousStart
ContinuousStart: CMakeFiles/ContinuousStart
ContinuousStart: CMakeFiles/ContinuousStart.dir/build.make
.PHONY : ContinuousStart
# Rule to build all files generated by this target.
CMakeFiles/ContinuousStart.dir/build: ContinuousStart
.PHONY : CMakeFiles/ContinuousStart.dir/build
CMakeFiles/ContinuousStart.dir/clean:
$(CMAKE_COMMAND) -P CMakeFiles/ContinuousStart.dir/cmake_clean.cmake
.PHONY : CMakeFiles/ContinuousStart.dir/clean
CMakeFiles/ContinuousStart.dir/depend:
cd /home/sh/Downloads/hackrf/codec2/build_linux && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /home/sh/Downloads/hackrf/codec2 /home/sh/Downloads/hackrf/codec2 /home/sh/Downloads/hackrf/codec2/build_linux /home/sh/Downloads/hackrf/codec2/build_linux /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/ContinuousStart.dir/DependInfo.cmake --color=$(COLOR)
.PHONY : CMakeFiles/ContinuousStart.dir/depend

8
libcodec2-android/src/codec2/build_linux/CMakeFiles/ContinuousStart.dir/cmake_clean.cmake vendored
Wyświetl plik

@ -1,8 +0,0 @@
file(REMOVE_RECURSE
"CMakeFiles/ContinuousStart"
)
# Per-language clean rules from dependency scanning.
foreach(lang )
include(CMakeFiles/ContinuousStart.dir/cmake_clean_${lang}.cmake OPTIONAL)
endforeach()

1
libcodec2-android/src/codec2/build_linux/CMakeFiles/ContinuousStart.dir/progress.make vendored
Wyświetl plik

@ -1 +0,0 @@

11
libcodec2-android/src/codec2/build_linux/CMakeFiles/ContinuousSubmit.dir/DependInfo.cmake vendored
Wyświetl plik

@ -1,11 +0,0 @@
# The set of languages for which implicit dependencies are needed:
set(CMAKE_DEPENDS_LANGUAGES
)
# The set of files for implicit dependencies of each language:
# Targets to which this target links.
set(CMAKE_TARGET_LINKED_INFO_FILES
)
# Fortran module output directory.
set(CMAKE_Fortran_TARGET_MODULE_DIR "")

76
libcodec2-android/src/codec2/build_linux/CMakeFiles/ContinuousSubmit.dir/build.make vendored
Wyświetl plik

@ -1,76 +0,0 @@
# CMAKE generated file: DO NOT EDIT!
# Generated by "Unix Makefiles" Generator, CMake Version 3.13
# Delete rule output on recipe failure.
.DELETE_ON_ERROR:
#=============================================================================
# Special targets provided by cmake.
# Disable implicit rules so canonical targets will work.
.SUFFIXES:
# Remove some rules from gmake that .SUFFIXES does not remove.
SUFFIXES =
.SUFFIXES: .hpux_make_needs_suffix_list
# 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/bin/cmake
# The command to remove a file.
RM = /usr/bin/cmake -E remove -f
# Escaping for special characters.
EQUALS = =
# The top-level source directory on which CMake was run.
CMAKE_SOURCE_DIR = /home/sh/Downloads/hackrf/codec2
# The top-level build directory on which CMake was run.
CMAKE_BINARY_DIR = /home/sh/Downloads/hackrf/codec2/build_linux
# Utility rule file for ContinuousSubmit.
# Include the progress variables for this target.
include CMakeFiles/ContinuousSubmit.dir/progress.make
CMakeFiles/ContinuousSubmit:
/usr/bin/ctest -D ContinuousSubmit
ContinuousSubmit: CMakeFiles/ContinuousSubmit
ContinuousSubmit: CMakeFiles/ContinuousSubmit.dir/build.make
.PHONY : ContinuousSubmit
# Rule to build all files generated by this target.
CMakeFiles/ContinuousSubmit.dir/build: ContinuousSubmit
.PHONY : CMakeFiles/ContinuousSubmit.dir/build
CMakeFiles/ContinuousSubmit.dir/clean:
$(CMAKE_COMMAND) -P CMakeFiles/ContinuousSubmit.dir/cmake_clean.cmake
.PHONY : CMakeFiles/ContinuousSubmit.dir/clean
CMakeFiles/ContinuousSubmit.dir/depend:
cd /home/sh/Downloads/hackrf/codec2/build_linux && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /home/sh/Downloads/hackrf/codec2 /home/sh/Downloads/hackrf/codec2 /home/sh/Downloads/hackrf/codec2/build_linux /home/sh/Downloads/hackrf/codec2/build_linux /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/ContinuousSubmit.dir/DependInfo.cmake --color=$(COLOR)
.PHONY : CMakeFiles/ContinuousSubmit.dir/depend

8
libcodec2-android/src/codec2/build_linux/CMakeFiles/ContinuousSubmit.dir/cmake_clean.cmake vendored
Wyświetl plik

@ -1,8 +0,0 @@
file(REMOVE_RECURSE
"CMakeFiles/ContinuousSubmit"
)
# Per-language clean rules from dependency scanning.
foreach(lang )
include(CMakeFiles/ContinuousSubmit.dir/cmake_clean_${lang}.cmake OPTIONAL)
endforeach()

1
libcodec2-android/src/codec2/build_linux/CMakeFiles/ContinuousSubmit.dir/progress.make vendored
Wyświetl plik

@ -1 +0,0 @@

11
libcodec2-android/src/codec2/build_linux/CMakeFiles/ContinuousTest.dir/DependInfo.cmake vendored
Wyświetl plik

@ -1,11 +0,0 @@
# The set of languages for which implicit dependencies are needed:
set(CMAKE_DEPENDS_LANGUAGES
)
# The set of files for implicit dependencies of each language:
# Targets to which this target links.
set(CMAKE_TARGET_LINKED_INFO_FILES
)
# Fortran module output directory.
set(CMAKE_Fortran_TARGET_MODULE_DIR "")

76
libcodec2-android/src/codec2/build_linux/CMakeFiles/ContinuousTest.dir/build.make vendored
Wyświetl plik

@ -1,76 +0,0 @@
# CMAKE generated file: DO NOT EDIT!
# Generated by "Unix Makefiles" Generator, CMake Version 3.13
# Delete rule output on recipe failure.
.DELETE_ON_ERROR:
#=============================================================================
# Special targets provided by cmake.
# Disable implicit rules so canonical targets will work.
.SUFFIXES:
# Remove some rules from gmake that .SUFFIXES does not remove.
SUFFIXES =
.SUFFIXES: .hpux_make_needs_suffix_list
# 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/bin/cmake
# The command to remove a file.
RM = /usr/bin/cmake -E remove -f
# Escaping for special characters.
EQUALS = =
# The top-level source directory on which CMake was run.
CMAKE_SOURCE_DIR = /home/sh/Downloads/hackrf/codec2
# The top-level build directory on which CMake was run.
CMAKE_BINARY_DIR = /home/sh/Downloads/hackrf/codec2/build_linux
# Utility rule file for ContinuousTest.
# Include the progress variables for this target.
include CMakeFiles/ContinuousTest.dir/progress.make
CMakeFiles/ContinuousTest:
/usr/bin/ctest -D ContinuousTest
ContinuousTest: CMakeFiles/ContinuousTest
ContinuousTest: CMakeFiles/ContinuousTest.dir/build.make
.PHONY : ContinuousTest
# Rule to build all files generated by this target.
CMakeFiles/ContinuousTest.dir/build: ContinuousTest
.PHONY : CMakeFiles/ContinuousTest.dir/build
CMakeFiles/ContinuousTest.dir/clean:
$(CMAKE_COMMAND) -P CMakeFiles/ContinuousTest.dir/cmake_clean.cmake
.PHONY : CMakeFiles/ContinuousTest.dir/clean
CMakeFiles/ContinuousTest.dir/depend:
cd /home/sh/Downloads/hackrf/codec2/build_linux && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /home/sh/Downloads/hackrf/codec2 /home/sh/Downloads/hackrf/codec2 /home/sh/Downloads/hackrf/codec2/build_linux /home/sh/Downloads/hackrf/codec2/build_linux /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/ContinuousTest.dir/DependInfo.cmake --color=$(COLOR)
.PHONY : CMakeFiles/ContinuousTest.dir/depend

8
libcodec2-android/src/codec2/build_linux/CMakeFiles/ContinuousTest.dir/cmake_clean.cmake vendored
Wyświetl plik

@ -1,8 +0,0 @@
file(REMOVE_RECURSE
"CMakeFiles/ContinuousTest"
)
# Per-language clean rules from dependency scanning.
foreach(lang )
include(CMakeFiles/ContinuousTest.dir/cmake_clean_${lang}.cmake OPTIONAL)
endforeach()

1
libcodec2-android/src/codec2/build_linux/CMakeFiles/ContinuousTest.dir/progress.make vendored
Wyświetl plik

@ -1 +0,0 @@

11
libcodec2-android/src/codec2/build_linux/CMakeFiles/ContinuousUpdate.dir/DependInfo.cmake vendored
Wyświetl plik

@ -1,11 +0,0 @@
# The set of languages for which implicit dependencies are needed:
set(CMAKE_DEPENDS_LANGUAGES
)
# The set of files for implicit dependencies of each language:
# Targets to which this target links.
set(CMAKE_TARGET_LINKED_INFO_FILES
)
# Fortran module output directory.
set(CMAKE_Fortran_TARGET_MODULE_DIR "")

76
libcodec2-android/src/codec2/build_linux/CMakeFiles/ContinuousUpdate.dir/build.make vendored
Wyświetl plik

@ -1,76 +0,0 @@
# CMAKE generated file: DO NOT EDIT!
# Generated by "Unix Makefiles" Generator, CMake Version 3.13
# Delete rule output on recipe failure.
.DELETE_ON_ERROR:
#=============================================================================
# Special targets provided by cmake.
# Disable implicit rules so canonical targets will work.
.SUFFIXES:
# Remove some rules from gmake that .SUFFIXES does not remove.
SUFFIXES =
.SUFFIXES: .hpux_make_needs_suffix_list
# 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/bin/cmake
# The command to remove a file.
RM = /usr/bin/cmake -E remove -f
# Escaping for special characters.
EQUALS = =
# The top-level source directory on which CMake was run.
CMAKE_SOURCE_DIR = /home/sh/Downloads/hackrf/codec2
# The top-level build directory on which CMake was run.
CMAKE_BINARY_DIR = /home/sh/Downloads/hackrf/codec2/build_linux
# Utility rule file for ContinuousUpdate.
# Include the progress variables for this target.
include CMakeFiles/ContinuousUpdate.dir/progress.make
CMakeFiles/ContinuousUpdate:
/usr/bin/ctest -D ContinuousUpdate
ContinuousUpdate: CMakeFiles/ContinuousUpdate
ContinuousUpdate: CMakeFiles/ContinuousUpdate.dir/build.make
.PHONY : ContinuousUpdate
# Rule to build all files generated by this target.
CMakeFiles/ContinuousUpdate.dir/build: ContinuousUpdate
.PHONY : CMakeFiles/ContinuousUpdate.dir/build
CMakeFiles/ContinuousUpdate.dir/clean:
$(CMAKE_COMMAND) -P CMakeFiles/ContinuousUpdate.dir/cmake_clean.cmake
.PHONY : CMakeFiles/ContinuousUpdate.dir/clean
CMakeFiles/ContinuousUpdate.dir/depend:
cd /home/sh/Downloads/hackrf/codec2/build_linux && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /home/sh/Downloads/hackrf/codec2 /home/sh/Downloads/hackrf/codec2 /home/sh/Downloads/hackrf/codec2/build_linux /home/sh/Downloads/hackrf/codec2/build_linux /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/ContinuousUpdate.dir/DependInfo.cmake --color=$(COLOR)
.PHONY : CMakeFiles/ContinuousUpdate.dir/depend

8
libcodec2-android/src/codec2/build_linux/CMakeFiles/ContinuousUpdate.dir/cmake_clean.cmake vendored
Wyświetl plik

@ -1,8 +0,0 @@
file(REMOVE_RECURSE
"CMakeFiles/ContinuousUpdate"
)
# Per-language clean rules from dependency scanning.
foreach(lang )
include(CMakeFiles/ContinuousUpdate.dir/cmake_clean_${lang}.cmake OPTIONAL)
endforeach()

1
libcodec2-android/src/codec2/build_linux/CMakeFiles/ContinuousUpdate.dir/progress.make vendored
Wyświetl plik

@ -1 +0,0 @@

11
libcodec2-android/src/codec2/build_linux/CMakeFiles/Experimental.dir/DependInfo.cmake vendored
Wyświetl plik

@ -1,11 +0,0 @@
# The set of languages for which implicit dependencies are needed:
set(CMAKE_DEPENDS_LANGUAGES
)
# The set of files for implicit dependencies of each language:
# Targets to which this target links.
set(CMAKE_TARGET_LINKED_INFO_FILES
)
# Fortran module output directory.
set(CMAKE_Fortran_TARGET_MODULE_DIR "")

76
libcodec2-android/src/codec2/build_linux/CMakeFiles/Experimental.dir/build.make vendored
Wyświetl plik

@ -1,76 +0,0 @@
# CMAKE generated file: DO NOT EDIT!
# Generated by "Unix Makefiles" Generator, CMake Version 3.13
# Delete rule output on recipe failure.
.DELETE_ON_ERROR:
#=============================================================================
# Special targets provided by cmake.
# Disable implicit rules so canonical targets will work.
.SUFFIXES:
# Remove some rules from gmake that .SUFFIXES does not remove.
SUFFIXES =
.SUFFIXES: .hpux_make_needs_suffix_list
# 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/bin/cmake
# The command to remove a file.
RM = /usr/bin/cmake -E remove -f
# Escaping for special characters.
EQUALS = =
# The top-level source directory on which CMake was run.
CMAKE_SOURCE_DIR = /home/sh/Downloads/hackrf/codec2
# The top-level build directory on which CMake was run.
CMAKE_BINARY_DIR = /home/sh/Downloads/hackrf/codec2/build_linux
# Utility rule file for Experimental.
# Include the progress variables for this target.
include CMakeFiles/Experimental.dir/progress.make
CMakeFiles/Experimental:
/usr/bin/ctest -D Experimental
Experimental: CMakeFiles/Experimental
Experimental: CMakeFiles/Experimental.dir/build.make
.PHONY : Experimental
# Rule to build all files generated by this target.
CMakeFiles/Experimental.dir/build: Experimental
.PHONY : CMakeFiles/Experimental.dir/build
CMakeFiles/Experimental.dir/clean:
$(CMAKE_COMMAND) -P CMakeFiles/Experimental.dir/cmake_clean.cmake
.PHONY : CMakeFiles/Experimental.dir/clean
CMakeFiles/Experimental.dir/depend:
cd /home/sh/Downloads/hackrf/codec2/build_linux && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /home/sh/Downloads/hackrf/codec2 /home/sh/Downloads/hackrf/codec2 /home/sh/Downloads/hackrf/codec2/build_linux /home/sh/Downloads/hackrf/codec2/build_linux /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/Experimental.dir/DependInfo.cmake --color=$(COLOR)
.PHONY : CMakeFiles/Experimental.dir/depend

8
libcodec2-android/src/codec2/build_linux/CMakeFiles/Experimental.dir/cmake_clean.cmake vendored
Wyświetl plik

@ -1,8 +0,0 @@
file(REMOVE_RECURSE
"CMakeFiles/Experimental"
)
# Per-language clean rules from dependency scanning.
foreach(lang )
include(CMakeFiles/Experimental.dir/cmake_clean_${lang}.cmake OPTIONAL)
endforeach()

1
libcodec2-android/src/codec2/build_linux/CMakeFiles/Experimental.dir/progress.make vendored
Wyświetl plik

@ -1 +0,0 @@

11
libcodec2-android/src/codec2/build_linux/CMakeFiles/ExperimentalBuild.dir/DependInfo.cmake vendored
Wyświetl plik

@ -1,11 +0,0 @@
# The set of languages for which implicit dependencies are needed:
set(CMAKE_DEPENDS_LANGUAGES
)
# The set of files for implicit dependencies of each language:
# Targets to which this target links.
set(CMAKE_TARGET_LINKED_INFO_FILES
)
# Fortran module output directory.
set(CMAKE_Fortran_TARGET_MODULE_DIR "")

76
libcodec2-android/src/codec2/build_linux/CMakeFiles/ExperimentalBuild.dir/build.make vendored
Wyświetl plik

@ -1,76 +0,0 @@
# CMAKE generated file: DO NOT EDIT!
# Generated by "Unix Makefiles" Generator, CMake Version 3.13
# Delete rule output on recipe failure.
.DELETE_ON_ERROR:
#=============================================================================
# Special targets provided by cmake.
# Disable implicit rules so canonical targets will work.
.SUFFIXES:
# Remove some rules from gmake that .SUFFIXES does not remove.
SUFFIXES =
.SUFFIXES: .hpux_make_needs_suffix_list
# 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/bin/cmake
# The command to remove a file.
RM = /usr/bin/cmake -E remove -f
# Escaping for special characters.
EQUALS = =
# The top-level source directory on which CMake was run.
CMAKE_SOURCE_DIR = /home/sh/Downloads/hackrf/codec2
# The top-level build directory on which CMake was run.
CMAKE_BINARY_DIR = /home/sh/Downloads/hackrf/codec2/build_linux
# Utility rule file for ExperimentalBuild.
# Include the progress variables for this target.
include CMakeFiles/ExperimentalBuild.dir/progress.make
CMakeFiles/ExperimentalBuild:
/usr/bin/ctest -D ExperimentalBuild
ExperimentalBuild: CMakeFiles/ExperimentalBuild
ExperimentalBuild: CMakeFiles/ExperimentalBuild.dir/build.make
.PHONY : ExperimentalBuild
# Rule to build all files generated by this target.
CMakeFiles/ExperimentalBuild.dir/build: ExperimentalBuild
.PHONY : CMakeFiles/ExperimentalBuild.dir/build
CMakeFiles/ExperimentalBuild.dir/clean:
$(CMAKE_COMMAND) -P CMakeFiles/ExperimentalBuild.dir/cmake_clean.cmake
.PHONY : CMakeFiles/ExperimentalBuild.dir/clean
CMakeFiles/ExperimentalBuild.dir/depend:
cd /home/sh/Downloads/hackrf/codec2/build_linux && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /home/sh/Downloads/hackrf/codec2 /home/sh/Downloads/hackrf/codec2 /home/sh/Downloads/hackrf/codec2/build_linux /home/sh/Downloads/hackrf/codec2/build_linux /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/ExperimentalBuild.dir/DependInfo.cmake --color=$(COLOR)
.PHONY : CMakeFiles/ExperimentalBuild.dir/depend

8
libcodec2-android/src/codec2/build_linux/CMakeFiles/ExperimentalBuild.dir/cmake_clean.cmake vendored
Wyświetl plik

@ -1,8 +0,0 @@
file(REMOVE_RECURSE
"CMakeFiles/ExperimentalBuild"
)
# Per-language clean rules from dependency scanning.
foreach(lang )
include(CMakeFiles/ExperimentalBuild.dir/cmake_clean_${lang}.cmake OPTIONAL)
endforeach()

1
libcodec2-android/src/codec2/build_linux/CMakeFiles/ExperimentalBuild.dir/progress.make vendored
Wyświetl plik

@ -1 +0,0 @@

11
libcodec2-android/src/codec2/build_linux/CMakeFiles/ExperimentalConfigure.dir/DependInfo.cmake vendored
Wyświetl plik

@ -1,11 +0,0 @@
# The set of languages for which implicit dependencies are needed:
set(CMAKE_DEPENDS_LANGUAGES
)
# The set of files for implicit dependencies of each language:
# Targets to which this target links.
set(CMAKE_TARGET_LINKED_INFO_FILES
)
# Fortran module output directory.
set(CMAKE_Fortran_TARGET_MODULE_DIR "")

76
libcodec2-android/src/codec2/build_linux/CMakeFiles/ExperimentalConfigure.dir/build.make vendored
Wyświetl plik

@ -1,76 +0,0 @@
# CMAKE generated file: DO NOT EDIT!
# Generated by "Unix Makefiles" Generator, CMake Version 3.13
# Delete rule output on recipe failure.
.DELETE_ON_ERROR:
#=============================================================================
# Special targets provided by cmake.
# Disable implicit rules so canonical targets will work.
.SUFFIXES:
# Remove some rules from gmake that .SUFFIXES does not remove.
SUFFIXES =
.SUFFIXES: .hpux_make_needs_suffix_list
# 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/bin/cmake
# The command to remove a file.
RM = /usr/bin/cmake -E remove -f
# Escaping for special characters.
EQUALS = =
# The top-level source directory on which CMake was run.
CMAKE_SOURCE_DIR = /home/sh/Downloads/hackrf/codec2
# The top-level build directory on which CMake was run.
CMAKE_BINARY_DIR = /home/sh/Downloads/hackrf/codec2/build_linux
# Utility rule file for ExperimentalConfigure.
# Include the progress variables for this target.
include CMakeFiles/ExperimentalConfigure.dir/progress.make
CMakeFiles/ExperimentalConfigure:
/usr/bin/ctest -D ExperimentalConfigure
ExperimentalConfigure: CMakeFiles/ExperimentalConfigure
ExperimentalConfigure: CMakeFiles/ExperimentalConfigure.dir/build.make
.PHONY : ExperimentalConfigure
# Rule to build all files generated by this target.
CMakeFiles/ExperimentalConfigure.dir/build: ExperimentalConfigure
.PHONY : CMakeFiles/ExperimentalConfigure.dir/build
CMakeFiles/ExperimentalConfigure.dir/clean:
$(CMAKE_COMMAND) -P CMakeFiles/ExperimentalConfigure.dir/cmake_clean.cmake
.PHONY : CMakeFiles/ExperimentalConfigure.dir/clean
CMakeFiles/ExperimentalConfigure.dir/depend:
cd /home/sh/Downloads/hackrf/codec2/build_linux && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /home/sh/Downloads/hackrf/codec2 /home/sh/Downloads/hackrf/codec2 /home/sh/Downloads/hackrf/codec2/build_linux /home/sh/Downloads/hackrf/codec2/build_linux /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/ExperimentalConfigure.dir/DependInfo.cmake --color=$(COLOR)
.PHONY : CMakeFiles/ExperimentalConfigure.dir/depend

8
libcodec2-android/src/codec2/build_linux/CMakeFiles/ExperimentalConfigure.dir/cmake_clean.cmake vendored
Wyświetl plik

@ -1,8 +0,0 @@
file(REMOVE_RECURSE
"CMakeFiles/ExperimentalConfigure"
)
# Per-language clean rules from dependency scanning.
foreach(lang )
include(CMakeFiles/ExperimentalConfigure.dir/cmake_clean_${lang}.cmake OPTIONAL)
endforeach()

1
libcodec2-android/src/codec2/build_linux/CMakeFiles/ExperimentalConfigure.dir/progress.make vendored
Wyświetl plik

@ -1 +0,0 @@

11
libcodec2-android/src/codec2/build_linux/CMakeFiles/ExperimentalCoverage.dir/DependInfo.cmake vendored
Wyświetl plik

@ -1,11 +0,0 @@
# The set of languages for which implicit dependencies are needed:
set(CMAKE_DEPENDS_LANGUAGES
)
# The set of files for implicit dependencies of each language:
# Targets to which this target links.
set(CMAKE_TARGET_LINKED_INFO_FILES
)
# Fortran module output directory.
set(CMAKE_Fortran_TARGET_MODULE_DIR "")

76
libcodec2-android/src/codec2/build_linux/CMakeFiles/ExperimentalCoverage.dir/build.make vendored
Wyświetl plik

@ -1,76 +0,0 @@
# CMAKE generated file: DO NOT EDIT!
# Generated by "Unix Makefiles" Generator, CMake Version 3.13
# Delete rule output on recipe failure.
.DELETE_ON_ERROR:
#=============================================================================
# Special targets provided by cmake.
# Disable implicit rules so canonical targets will work.
.SUFFIXES:
# Remove some rules from gmake that .SUFFIXES does not remove.
SUFFIXES =
.SUFFIXES: .hpux_make_needs_suffix_list
# 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/bin/cmake
# The command to remove a file.
RM = /usr/bin/cmake -E remove -f
# Escaping for special characters.
EQUALS = =
# The top-level source directory on which CMake was run.
CMAKE_SOURCE_DIR = /home/sh/Downloads/hackrf/codec2
# The top-level build directory on which CMake was run.
CMAKE_BINARY_DIR = /home/sh/Downloads/hackrf/codec2/build_linux
# Utility rule file for ExperimentalCoverage.
# Include the progress variables for this target.
include CMakeFiles/ExperimentalCoverage.dir/progress.make
CMakeFiles/ExperimentalCoverage:
/usr/bin/ctest -D ExperimentalCoverage
ExperimentalCoverage: CMakeFiles/ExperimentalCoverage
ExperimentalCoverage: CMakeFiles/ExperimentalCoverage.dir/build.make
.PHONY : ExperimentalCoverage
# Rule to build all files generated by this target.
CMakeFiles/ExperimentalCoverage.dir/build: ExperimentalCoverage
.PHONY : CMakeFiles/ExperimentalCoverage.dir/build
CMakeFiles/ExperimentalCoverage.dir/clean:
$(CMAKE_COMMAND) -P CMakeFiles/ExperimentalCoverage.dir/cmake_clean.cmake
.PHONY : CMakeFiles/ExperimentalCoverage.dir/clean
CMakeFiles/ExperimentalCoverage.dir/depend:
cd /home/sh/Downloads/hackrf/codec2/build_linux && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /home/sh/Downloads/hackrf/codec2 /home/sh/Downloads/hackrf/codec2 /home/sh/Downloads/hackrf/codec2/build_linux /home/sh/Downloads/hackrf/codec2/build_linux /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/ExperimentalCoverage.dir/DependInfo.cmake --color=$(COLOR)
.PHONY : CMakeFiles/ExperimentalCoverage.dir/depend

8
libcodec2-android/src/codec2/build_linux/CMakeFiles/ExperimentalCoverage.dir/cmake_clean.cmake vendored
Wyświetl plik

@ -1,8 +0,0 @@
file(REMOVE_RECURSE
"CMakeFiles/ExperimentalCoverage"
)
# Per-language clean rules from dependency scanning.
foreach(lang )
include(CMakeFiles/ExperimentalCoverage.dir/cmake_clean_${lang}.cmake OPTIONAL)
endforeach()

1
libcodec2-android/src/codec2/build_linux/CMakeFiles/ExperimentalCoverage.dir/progress.make vendored
Wyświetl plik

@ -1 +0,0 @@

11
libcodec2-android/src/codec2/build_linux/CMakeFiles/ExperimentalMemCheck.dir/DependInfo.cmake vendored
Wyświetl plik

@ -1,11 +0,0 @@
# The set of languages for which implicit dependencies are needed:
set(CMAKE_DEPENDS_LANGUAGES
)
# The set of files for implicit dependencies of each language:
# Targets to which this target links.
set(CMAKE_TARGET_LINKED_INFO_FILES
)
# Fortran module output directory.
set(CMAKE_Fortran_TARGET_MODULE_DIR "")

76
libcodec2-android/src/codec2/build_linux/CMakeFiles/ExperimentalMemCheck.dir/build.make vendored
Wyświetl plik

@ -1,76 +0,0 @@
# CMAKE generated file: DO NOT EDIT!
# Generated by "Unix Makefiles" Generator, CMake Version 3.13
# Delete rule output on recipe failure.
.DELETE_ON_ERROR:
#=============================================================================
# Special targets provided by cmake.
# Disable implicit rules so canonical targets will work.
.SUFFIXES:
# Remove some rules from gmake that .SUFFIXES does not remove.
SUFFIXES =
.SUFFIXES: .hpux_make_needs_suffix_list
# 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/bin/cmake
# The command to remove a file.
RM = /usr/bin/cmake -E remove -f
# Escaping for special characters.
EQUALS = =
# The top-level source directory on which CMake was run.
CMAKE_SOURCE_DIR = /home/sh/Downloads/hackrf/codec2
# The top-level build directory on which CMake was run.
CMAKE_BINARY_DIR = /home/sh/Downloads/hackrf/codec2/build_linux
# Utility rule file for ExperimentalMemCheck.
# Include the progress variables for this target.
include CMakeFiles/ExperimentalMemCheck.dir/progress.make
CMakeFiles/ExperimentalMemCheck:
/usr/bin/ctest -D ExperimentalMemCheck
ExperimentalMemCheck: CMakeFiles/ExperimentalMemCheck
ExperimentalMemCheck: CMakeFiles/ExperimentalMemCheck.dir/build.make
.PHONY : ExperimentalMemCheck
# Rule to build all files generated by this target.
CMakeFiles/ExperimentalMemCheck.dir/build: ExperimentalMemCheck
.PHONY : CMakeFiles/ExperimentalMemCheck.dir/build
CMakeFiles/ExperimentalMemCheck.dir/clean:
$(CMAKE_COMMAND) -P CMakeFiles/ExperimentalMemCheck.dir/cmake_clean.cmake
.PHONY : CMakeFiles/ExperimentalMemCheck.dir/clean
CMakeFiles/ExperimentalMemCheck.dir/depend:
cd /home/sh/Downloads/hackrf/codec2/build_linux && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /home/sh/Downloads/hackrf/codec2 /home/sh/Downloads/hackrf/codec2 /home/sh/Downloads/hackrf/codec2/build_linux /home/sh/Downloads/hackrf/codec2/build_linux /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/ExperimentalMemCheck.dir/DependInfo.cmake --color=$(COLOR)
.PHONY : CMakeFiles/ExperimentalMemCheck.dir/depend

8
libcodec2-android/src/codec2/build_linux/CMakeFiles/ExperimentalMemCheck.dir/cmake_clean.cmake vendored
Wyświetl plik

@ -1,8 +0,0 @@
file(REMOVE_RECURSE
"CMakeFiles/ExperimentalMemCheck"
)
# Per-language clean rules from dependency scanning.
foreach(lang )
include(CMakeFiles/ExperimentalMemCheck.dir/cmake_clean_${lang}.cmake OPTIONAL)
endforeach()

1
libcodec2-android/src/codec2/build_linux/CMakeFiles/ExperimentalMemCheck.dir/progress.make vendored
Wyświetl plik

@ -1 +0,0 @@

11
libcodec2-android/src/codec2/build_linux/CMakeFiles/ExperimentalStart.dir/DependInfo.cmake vendored
Wyświetl plik

@ -1,11 +0,0 @@
# The set of languages for which implicit dependencies are needed:
set(CMAKE_DEPENDS_LANGUAGES
)
# The set of files for implicit dependencies of each language:
# Targets to which this target links.
set(CMAKE_TARGET_LINKED_INFO_FILES
)
# Fortran module output directory.
set(CMAKE_Fortran_TARGET_MODULE_DIR "")

76
libcodec2-android/src/codec2/build_linux/CMakeFiles/ExperimentalStart.dir/build.make vendored
Wyświetl plik

@ -1,76 +0,0 @@
# CMAKE generated file: DO NOT EDIT!
# Generated by "Unix Makefiles" Generator, CMake Version 3.13
# Delete rule output on recipe failure.
.DELETE_ON_ERROR:
#=============================================================================
# Special targets provided by cmake.
# Disable implicit rules so canonical targets will work.
.SUFFIXES:
# Remove some rules from gmake that .SUFFIXES does not remove.
SUFFIXES =
.SUFFIXES: .hpux_make_needs_suffix_list
# 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/bin/cmake
# The command to remove a file.
RM = /usr/bin/cmake -E remove -f
# Escaping for special characters.
EQUALS = =
# The top-level source directory on which CMake was run.
CMAKE_SOURCE_DIR = /home/sh/Downloads/hackrf/codec2
# The top-level build directory on which CMake was run.
CMAKE_BINARY_DIR = /home/sh/Downloads/hackrf/codec2/build_linux
# Utility rule file for ExperimentalStart.
# Include the progress variables for this target.
include CMakeFiles/ExperimentalStart.dir/progress.make
CMakeFiles/ExperimentalStart:
/usr/bin/ctest -D ExperimentalStart
ExperimentalStart: CMakeFiles/ExperimentalStart
ExperimentalStart: CMakeFiles/ExperimentalStart.dir/build.make
.PHONY : ExperimentalStart
# Rule to build all files generated by this target.
CMakeFiles/ExperimentalStart.dir/build: ExperimentalStart
.PHONY : CMakeFiles/ExperimentalStart.dir/build
CMakeFiles/ExperimentalStart.dir/clean:
$(CMAKE_COMMAND) -P CMakeFiles/ExperimentalStart.dir/cmake_clean.cmake
.PHONY : CMakeFiles/ExperimentalStart.dir/clean
CMakeFiles/ExperimentalStart.dir/depend:
cd /home/sh/Downloads/hackrf/codec2/build_linux && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /home/sh/Downloads/hackrf/codec2 /home/sh/Downloads/hackrf/codec2 /home/sh/Downloads/hackrf/codec2/build_linux /home/sh/Downloads/hackrf/codec2/build_linux /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/ExperimentalStart.dir/DependInfo.cmake --color=$(COLOR)
.PHONY : CMakeFiles/ExperimentalStart.dir/depend

8
libcodec2-android/src/codec2/build_linux/CMakeFiles/ExperimentalStart.dir/cmake_clean.cmake vendored
Wyświetl plik

@ -1,8 +0,0 @@
file(REMOVE_RECURSE
"CMakeFiles/ExperimentalStart"
)
# Per-language clean rules from dependency scanning.
foreach(lang )
include(CMakeFiles/ExperimentalStart.dir/cmake_clean_${lang}.cmake OPTIONAL)
endforeach()

1
libcodec2-android/src/codec2/build_linux/CMakeFiles/ExperimentalStart.dir/progress.make vendored
Wyświetl plik

@ -1 +0,0 @@

11
libcodec2-android/src/codec2/build_linux/CMakeFiles/ExperimentalSubmit.dir/DependInfo.cmake vendored
Wyświetl plik

@ -1,11 +0,0 @@
# The set of languages for which implicit dependencies are needed:
set(CMAKE_DEPENDS_LANGUAGES
)
# The set of files for implicit dependencies of each language:
# Targets to which this target links.
set(CMAKE_TARGET_LINKED_INFO_FILES
)
# Fortran module output directory.
set(CMAKE_Fortran_TARGET_MODULE_DIR "")

76
libcodec2-android/src/codec2/build_linux/CMakeFiles/ExperimentalSubmit.dir/build.make vendored
Wyświetl plik

@ -1,76 +0,0 @@
# CMAKE generated file: DO NOT EDIT!
# Generated by "Unix Makefiles" Generator, CMake Version 3.13
# Delete rule output on recipe failure.
.DELETE_ON_ERROR:
#=============================================================================
# Special targets provided by cmake.
# Disable implicit rules so canonical targets will work.
.SUFFIXES:
# Remove some rules from gmake that .SUFFIXES does not remove.
SUFFIXES =
.SUFFIXES: .hpux_make_needs_suffix_list
# 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/bin/cmake
# The command to remove a file.
RM = /usr/bin/cmake -E remove -f
# Escaping for special characters.
EQUALS = =
# The top-level source directory on which CMake was run.
CMAKE_SOURCE_DIR = /home/sh/Downloads/hackrf/codec2
# The top-level build directory on which CMake was run.
CMAKE_BINARY_DIR = /home/sh/Downloads/hackrf/codec2/build_linux
# Utility rule file for ExperimentalSubmit.
# Include the progress variables for this target.
include CMakeFiles/ExperimentalSubmit.dir/progress.make
CMakeFiles/ExperimentalSubmit:
/usr/bin/ctest -D ExperimentalSubmit
ExperimentalSubmit: CMakeFiles/ExperimentalSubmit
ExperimentalSubmit: CMakeFiles/ExperimentalSubmit.dir/build.make
.PHONY : ExperimentalSubmit
# Rule to build all files generated by this target.
CMakeFiles/ExperimentalSubmit.dir/build: ExperimentalSubmit
.PHONY : CMakeFiles/ExperimentalSubmit.dir/build
CMakeFiles/ExperimentalSubmit.dir/clean:
$(CMAKE_COMMAND) -P CMakeFiles/ExperimentalSubmit.dir/cmake_clean.cmake
.PHONY : CMakeFiles/ExperimentalSubmit.dir/clean
CMakeFiles/ExperimentalSubmit.dir/depend:
cd /home/sh/Downloads/hackrf/codec2/build_linux && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /home/sh/Downloads/hackrf/codec2 /home/sh/Downloads/hackrf/codec2 /home/sh/Downloads/hackrf/codec2/build_linux /home/sh/Downloads/hackrf/codec2/build_linux /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/ExperimentalSubmit.dir/DependInfo.cmake --color=$(COLOR)
.PHONY : CMakeFiles/ExperimentalSubmit.dir/depend

8
libcodec2-android/src/codec2/build_linux/CMakeFiles/ExperimentalSubmit.dir/cmake_clean.cmake vendored
Wyświetl plik

@ -1,8 +0,0 @@
file(REMOVE_RECURSE
"CMakeFiles/ExperimentalSubmit"
)
# Per-language clean rules from dependency scanning.
foreach(lang )
include(CMakeFiles/ExperimentalSubmit.dir/cmake_clean_${lang}.cmake OPTIONAL)
endforeach()

1
libcodec2-android/src/codec2/build_linux/CMakeFiles/ExperimentalSubmit.dir/progress.make vendored
Wyświetl plik

@ -1 +0,0 @@

11
libcodec2-android/src/codec2/build_linux/CMakeFiles/ExperimentalTest.dir/DependInfo.cmake vendored
Wyświetl plik

@ -1,11 +0,0 @@
# The set of languages for which implicit dependencies are needed:
set(CMAKE_DEPENDS_LANGUAGES
)
# The set of files for implicit dependencies of each language:
# Targets to which this target links.
set(CMAKE_TARGET_LINKED_INFO_FILES
)
# Fortran module output directory.
set(CMAKE_Fortran_TARGET_MODULE_DIR "")

76
libcodec2-android/src/codec2/build_linux/CMakeFiles/ExperimentalTest.dir/build.make vendored
Wyświetl plik

@ -1,76 +0,0 @@
# CMAKE generated file: DO NOT EDIT!
# Generated by "Unix Makefiles" Generator, CMake Version 3.13
# Delete rule output on recipe failure.
.DELETE_ON_ERROR:
#=============================================================================
# Special targets provided by cmake.
# Disable implicit rules so canonical targets will work.
.SUFFIXES:
# Remove some rules from gmake that .SUFFIXES does not remove.
SUFFIXES =
.SUFFIXES: .hpux_make_needs_suffix_list
# 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/bin/cmake
# The command to remove a file.
RM = /usr/bin/cmake -E remove -f
# Escaping for special characters.
EQUALS = =
# The top-level source directory on which CMake was run.
CMAKE_SOURCE_DIR = /home/sh/Downloads/hackrf/codec2
# The top-level build directory on which CMake was run.
CMAKE_BINARY_DIR = /home/sh/Downloads/hackrf/codec2/build_linux
# Utility rule file for ExperimentalTest.
# Include the progress variables for this target.
include CMakeFiles/ExperimentalTest.dir/progress.make
CMakeFiles/ExperimentalTest:
/usr/bin/ctest -D ExperimentalTest
ExperimentalTest: CMakeFiles/ExperimentalTest
ExperimentalTest: CMakeFiles/ExperimentalTest.dir/build.make
.PHONY : ExperimentalTest
# Rule to build all files generated by this target.
CMakeFiles/ExperimentalTest.dir/build: ExperimentalTest
.PHONY : CMakeFiles/ExperimentalTest.dir/build
CMakeFiles/ExperimentalTest.dir/clean:
$(CMAKE_COMMAND) -P CMakeFiles/ExperimentalTest.dir/cmake_clean.cmake
.PHONY : CMakeFiles/ExperimentalTest.dir/clean
CMakeFiles/ExperimentalTest.dir/depend:
cd /home/sh/Downloads/hackrf/codec2/build_linux && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /home/sh/Downloads/hackrf/codec2 /home/sh/Downloads/hackrf/codec2 /home/sh/Downloads/hackrf/codec2/build_linux /home/sh/Downloads/hackrf/codec2/build_linux /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/ExperimentalTest.dir/DependInfo.cmake --color=$(COLOR)
.PHONY : CMakeFiles/ExperimentalTest.dir/depend

8
libcodec2-android/src/codec2/build_linux/CMakeFiles/ExperimentalTest.dir/cmake_clean.cmake vendored
Wyświetl plik

@ -1,8 +0,0 @@
file(REMOVE_RECURSE
"CMakeFiles/ExperimentalTest"
)
# Per-language clean rules from dependency scanning.
foreach(lang )
include(CMakeFiles/ExperimentalTest.dir/cmake_clean_${lang}.cmake OPTIONAL)
endforeach()

1
libcodec2-android/src/codec2/build_linux/CMakeFiles/ExperimentalTest.dir/progress.make vendored
Wyświetl plik

@ -1 +0,0 @@

11
libcodec2-android/src/codec2/build_linux/CMakeFiles/ExperimentalUpdate.dir/DependInfo.cmake vendored
Wyświetl plik

@ -1,11 +0,0 @@
# The set of languages for which implicit dependencies are needed:
set(CMAKE_DEPENDS_LANGUAGES
)
# The set of files for implicit dependencies of each language:
# Targets to which this target links.
set(CMAKE_TARGET_LINKED_INFO_FILES
)
# Fortran module output directory.
set(CMAKE_Fortran_TARGET_MODULE_DIR "")

76
libcodec2-android/src/codec2/build_linux/CMakeFiles/ExperimentalUpdate.dir/build.make vendored
Wyświetl plik

@ -1,76 +0,0 @@
# CMAKE generated file: DO NOT EDIT!
# Generated by "Unix Makefiles" Generator, CMake Version 3.13
# Delete rule output on recipe failure.
.DELETE_ON_ERROR:
#=============================================================================
# Special targets provided by cmake.
# Disable implicit rules so canonical targets will work.
.SUFFIXES:
# Remove some rules from gmake that .SUFFIXES does not remove.
SUFFIXES =
.SUFFIXES: .hpux_make_needs_suffix_list
# 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/bin/cmake
# The command to remove a file.
RM = /usr/bin/cmake -E remove -f
# Escaping for special characters.
EQUALS = =
# The top-level source directory on which CMake was run.
CMAKE_SOURCE_DIR = /home/sh/Downloads/hackrf/codec2
# The top-level build directory on which CMake was run.
CMAKE_BINARY_DIR = /home/sh/Downloads/hackrf/codec2/build_linux
# Utility rule file for ExperimentalUpdate.
# Include the progress variables for this target.
include CMakeFiles/ExperimentalUpdate.dir/progress.make
CMakeFiles/ExperimentalUpdate:
/usr/bin/ctest -D ExperimentalUpdate
ExperimentalUpdate: CMakeFiles/ExperimentalUpdate
ExperimentalUpdate: CMakeFiles/ExperimentalUpdate.dir/build.make
.PHONY : ExperimentalUpdate
# Rule to build all files generated by this target.
CMakeFiles/ExperimentalUpdate.dir/build: ExperimentalUpdate
.PHONY : CMakeFiles/ExperimentalUpdate.dir/build
CMakeFiles/ExperimentalUpdate.dir/clean:
$(CMAKE_COMMAND) -P CMakeFiles/ExperimentalUpdate.dir/cmake_clean.cmake
.PHONY : CMakeFiles/ExperimentalUpdate.dir/clean
CMakeFiles/ExperimentalUpdate.dir/depend:
cd /home/sh/Downloads/hackrf/codec2/build_linux && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /home/sh/Downloads/hackrf/codec2 /home/sh/Downloads/hackrf/codec2 /home/sh/Downloads/hackrf/codec2/build_linux /home/sh/Downloads/hackrf/codec2/build_linux /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/ExperimentalUpdate.dir/DependInfo.cmake --color=$(COLOR)
.PHONY : CMakeFiles/ExperimentalUpdate.dir/depend

8
libcodec2-android/src/codec2/build_linux/CMakeFiles/ExperimentalUpdate.dir/cmake_clean.cmake vendored
Wyświetl plik

@ -1,8 +0,0 @@
file(REMOVE_RECURSE
"CMakeFiles/ExperimentalUpdate"
)
# Per-language clean rules from dependency scanning.
foreach(lang )
include(CMakeFiles/ExperimentalUpdate.dir/cmake_clean_${lang}.cmake OPTIONAL)
endforeach()

1
libcodec2-android/src/codec2/build_linux/CMakeFiles/ExperimentalUpdate.dir/progress.make vendored
Wyświetl plik

@ -1 +0,0 @@

188
libcodec2-android/src/codec2/build_linux/CMakeFiles/Makefile.cmake vendored
Wyświetl plik

@ -1,188 +0,0 @@
# CMAKE generated file: DO NOT EDIT!
# Generated by "Unix Makefiles" Generator, CMake Version 3.13
# 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"
"../CMakeLists.txt"
"CMakeFiles/3.13.4/CMakeCCompiler.cmake"
"CMakeFiles/3.13.4/CMakeSystem.cmake"
"../cmake/config.h.in"
"../cmake/version.h.in"
"../codec2.pc.in"
"../misc/CMakeLists.txt"
"../src/CMakeLists.txt"
"../unittest/CMakeLists.txt"
"../unittest/est_n0.sh.in"
"../unittest/ofdm_fade.sh.in"
"../unittest/test_700c_eq.sh.in"
"/usr/share/cmake-3.13/Modules/CMakeCInformation.cmake"
"/usr/share/cmake-3.13/Modules/CMakeCheckCompilerFlagCommonPatterns.cmake"
"/usr/share/cmake-3.13/Modules/CMakeCommonLanguageInclude.cmake"
"/usr/share/cmake-3.13/Modules/CMakeGenericSystem.cmake"
"/usr/share/cmake-3.13/Modules/CMakeInitializeConfigs.cmake"
"/usr/share/cmake-3.13/Modules/CMakeLanguageInformation.cmake"
"/usr/share/cmake-3.13/Modules/CMakeSystemSpecificInformation.cmake"
"/usr/share/cmake-3.13/Modules/CMakeSystemSpecificInitialize.cmake"
"/usr/share/cmake-3.13/Modules/CTest.cmake"
"/usr/share/cmake-3.13/Modules/CTestTargets.cmake"
"/usr/share/cmake-3.13/Modules/CTestUseLaunchers.cmake"
"/usr/share/cmake-3.13/Modules/CheckCCompilerFlag.cmake"
"/usr/share/cmake-3.13/Modules/CheckCSourceCompiles.cmake"
"/usr/share/cmake-3.13/Modules/CheckIncludeFile.cmake"
"/usr/share/cmake-3.13/Modules/CheckIncludeFiles.cmake"
"/usr/share/cmake-3.13/Modules/CheckLibraryExists.cmake"
"/usr/share/cmake-3.13/Modules/CheckSymbolExists.cmake"
"/usr/share/cmake-3.13/Modules/Compiler/CMakeCommonCompilerMacros.cmake"
"/usr/share/cmake-3.13/Modules/Compiler/GNU-C.cmake"
"/usr/share/cmake-3.13/Modules/Compiler/GNU.cmake"
"/usr/share/cmake-3.13/Modules/DartConfiguration.tcl.in"
"/usr/share/cmake-3.13/Modules/FindGit.cmake"
"/usr/share/cmake-3.13/Modules/FindPackageHandleStandardArgs.cmake"
"/usr/share/cmake-3.13/Modules/FindPackageMessage.cmake"
"/usr/share/cmake-3.13/Modules/FindThreads.cmake"
"/usr/share/cmake-3.13/Modules/GNUInstallDirs.cmake"
"/usr/share/cmake-3.13/Modules/Platform/Linux-GNU-C.cmake"
"/usr/share/cmake-3.13/Modules/Platform/Linux-GNU.cmake"
"/usr/share/cmake-3.13/Modules/Platform/Linux.cmake"
"/usr/share/cmake-3.13/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
"config.h"
"codec2/version.h"
"codec2.pc"
"DartConfiguration.tcl"
"unittest/ofdm_fade.sh"
"unittest/est_n0.sh"
"unittest/test_700c_eq.sh"
"CMakeFiles/CMakeDirectoryInformation.cmake"
"src/CMakeFiles/CMakeDirectoryInformation.cmake"
"unittest/CMakeFiles/CMakeDirectoryInformation.cmake"
"misc/CMakeFiles/CMakeDirectoryInformation.cmake"
)
# Dependency information for all targets:
set(CMAKE_DEPEND_INFO_FILES
"CMakeFiles/ContinuousSubmit.dir/DependInfo.cmake"
"CMakeFiles/ContinuousMemCheck.dir/DependInfo.cmake"
"CMakeFiles/ContinuousConfigure.dir/DependInfo.cmake"
"CMakeFiles/ExperimentalSubmit.dir/DependInfo.cmake"
"CMakeFiles/ExperimentalMemCheck.dir/DependInfo.cmake"
"CMakeFiles/ExperimentalTest.dir/DependInfo.cmake"
"CMakeFiles/NightlyUpdate.dir/DependInfo.cmake"
"CMakeFiles/NightlyStart.dir/DependInfo.cmake"
"CMakeFiles/NightlyMemoryCheck.dir/DependInfo.cmake"
"CMakeFiles/NightlyBuild.dir/DependInfo.cmake"
"CMakeFiles/ExperimentalUpdate.dir/DependInfo.cmake"
"CMakeFiles/ContinuousBuild.dir/DependInfo.cmake"
"CMakeFiles/Continuous.dir/DependInfo.cmake"
"CMakeFiles/Experimental.dir/DependInfo.cmake"
"CMakeFiles/ExperimentalConfigure.dir/DependInfo.cmake"
"CMakeFiles/NightlyTest.dir/DependInfo.cmake"
"CMakeFiles/NightlyCoverage.dir/DependInfo.cmake"
"CMakeFiles/ExperimentalCoverage.dir/DependInfo.cmake"
"CMakeFiles/NightlyMemCheck.dir/DependInfo.cmake"
"CMakeFiles/ContinuousStart.dir/DependInfo.cmake"
"CMakeFiles/NightlySubmit.dir/DependInfo.cmake"
"CMakeFiles/ContinuousCoverage.dir/DependInfo.cmake"
"CMakeFiles/Nightly.dir/DependInfo.cmake"
"CMakeFiles/NightlyConfigure.dir/DependInfo.cmake"
"CMakeFiles/ExperimentalStart.dir/DependInfo.cmake"
"CMakeFiles/ContinuousTest.dir/DependInfo.cmake"
"CMakeFiles/ContinuousUpdate.dir/DependInfo.cmake"
"CMakeFiles/ExperimentalBuild.dir/DependInfo.cmake"
"src/CMakeFiles/ldpc_dec.dir/DependInfo.cmake"
"src/CMakeFiles/ldpc_enc.dir/DependInfo.cmake"
"src/CMakeFiles/ldpc_noise.dir/DependInfo.cmake"
"src/CMakeFiles/tollr.dir/DependInfo.cmake"
"src/CMakeFiles/cohpsk_ch.dir/DependInfo.cmake"
"src/CMakeFiles/cohpsk_put_test_bits.dir/DependInfo.cmake"
"src/CMakeFiles/cohpsk_get_test_bits.dir/DependInfo.cmake"
"src/CMakeFiles/cohpsk_demod.dir/DependInfo.cmake"
"src/CMakeFiles/vhf_frame_c2.dir/DependInfo.cmake"
"src/CMakeFiles/freedv_data_raw_rx.dir/DependInfo.cmake"
"src/CMakeFiles/insert_errors.dir/DependInfo.cmake"
"src/CMakeFiles/fm_demod.dir/DependInfo.cmake"
"src/CMakeFiles/fdmdv_channel.dir/DependInfo.cmake"
"src/CMakeFiles/freedv_data_raw_tx.dir/DependInfo.cmake"
"src/CMakeFiles/cohpsk_mod.dir/DependInfo.cmake"
"src/CMakeFiles/c2dec.dir/DependInfo.cmake"
"src/CMakeFiles/freedv_rx.dir/DependInfo.cmake"
"src/CMakeFiles/fdmdv_get_test_bits.dir/DependInfo.cmake"
"src/CMakeFiles/c2demo.dir/DependInfo.cmake"
"src/CMakeFiles/fdmdv_put_test_bits.dir/DependInfo.cmake"
"src/CMakeFiles/codec2.dir/DependInfo.cmake"
"src/CMakeFiles/ofdm_get_test_bits.dir/DependInfo.cmake"
"src/CMakeFiles/freedv_tx.dir/DependInfo.cmake"
"src/CMakeFiles/c2enc.dir/DependInfo.cmake"
"src/CMakeFiles/generate_codebook.dir/DependInfo.cmake"
"src/CMakeFiles/freedv_mixed_tx.dir/DependInfo.cmake"
"src/CMakeFiles/c2sim.dir/DependInfo.cmake"
"src/CMakeFiles/fdmdv_demod.dir/DependInfo.cmake"
"src/CMakeFiles/vhf_deframe_c2.dir/DependInfo.cmake"
"src/CMakeFiles/fsk_mod.dir/DependInfo.cmake"
"src/CMakeFiles/fsk_put_test_bits.dir/DependInfo.cmake"
"src/CMakeFiles/freedv_data_tx.dir/DependInfo.cmake"
"src/CMakeFiles/freedv_data_rx.dir/DependInfo.cmake"
"src/CMakeFiles/freedv_mixed_rx.dir/DependInfo.cmake"
"src/CMakeFiles/fmfsk_demod.dir/DependInfo.cmake"
"src/CMakeFiles/fsk_mod_ext_vco.dir/DependInfo.cmake"
"src/CMakeFiles/fsk_demod.dir/DependInfo.cmake"
"src/CMakeFiles/fsk_get_test_bits.dir/DependInfo.cmake"
"src/CMakeFiles/framer.dir/DependInfo.cmake"
"src/CMakeFiles/deframer.dir/DependInfo.cmake"
"src/CMakeFiles/ofdm_mod.dir/DependInfo.cmake"
"src/CMakeFiles/fdmdv_mod.dir/DependInfo.cmake"
"src/CMakeFiles/ofdm_demod.dir/DependInfo.cmake"
"src/CMakeFiles/ofdm_put_test_bits.dir/DependInfo.cmake"
"src/CMakeFiles/fmfsk_mod.dir/DependInfo.cmake"
"unittest/CMakeFiles/tqam16.dir/DependInfo.cmake"
"unittest/CMakeFiles/tfsk_llr.dir/DependInfo.cmake"
"unittest/CMakeFiles/tfreedv_2400B_rawdata.dir/DependInfo.cmake"
"unittest/CMakeFiles/tfreedv_2400A_rawdata.dir/DependInfo.cmake"
"unittest/CMakeFiles/thash.dir/DependInfo.cmake"
"unittest/CMakeFiles/tfreedv_800XA_rawdata.dir/DependInfo.cmake"
"unittest/CMakeFiles/tfreedv_data_channel.dir/DependInfo.cmake"
"unittest/CMakeFiles/tofdm.dir/DependInfo.cmake"
"unittest/CMakeFiles/tvq_mbest.dir/DependInfo.cmake"
"unittest/CMakeFiles/tdeframer.dir/DependInfo.cmake"
"unittest/CMakeFiles/ofdm_stack.dir/DependInfo.cmake"
"unittest/CMakeFiles/tfsk.dir/DependInfo.cmake"
"unittest/CMakeFiles/fdmdv_mem.dir/DependInfo.cmake"
"unittest/CMakeFiles/tfdmdv.dir/DependInfo.cmake"
"unittest/CMakeFiles/tcohpsk.dir/DependInfo.cmake"
"unittest/CMakeFiles/tfifo.dir/DependInfo.cmake"
"unittest/CMakeFiles/ofdm_mem.dir/DependInfo.cmake"
"unittest/CMakeFiles/tfmfsk.dir/DependInfo.cmake"
"unittest/CMakeFiles/function_trace.dir/DependInfo.cmake"
"unittest/CMakeFiles/tnewamp1.dir/DependInfo.cmake"
"unittest/CMakeFiles/compare_ints.dir/DependInfo.cmake"
"unittest/CMakeFiles/tst_codec2_fft_init.dir/DependInfo.cmake"
"unittest/CMakeFiles/compare_floats.dir/DependInfo.cmake"
"unittest/CMakeFiles/test_phi0.dir/DependInfo.cmake"
"misc/CMakeFiles/extract.dir/DependInfo.cmake"
"misc/CMakeFiles/tdec.dir/DependInfo.cmake"
"misc/CMakeFiles/16_8_short.dir/DependInfo.cmake"
"misc/CMakeFiles/t16_8.dir/DependInfo.cmake"
"misc/CMakeFiles/t16_8_short.dir/DependInfo.cmake"
"misc/CMakeFiles/mksine.dir/DependInfo.cmake"
"misc/CMakeFiles/tnlp.dir/DependInfo.cmake"
"misc/CMakeFiles/vqtrain.dir/DependInfo.cmake"
"misc/CMakeFiles/tlininterp.dir/DependInfo.cmake"
"misc/CMakeFiles/pre.dir/DependInfo.cmake"
"misc/CMakeFiles/raw2h.dir/DependInfo.cmake"
"misc/CMakeFiles/timpulse.dir/DependInfo.cmake"
"misc/CMakeFiles/est_n0.dir/DependInfo.cmake"
"misc/CMakeFiles/vq_mbest.dir/DependInfo.cmake"
)

4257
libcodec2-android/src/codec2/build_linux/CMakeFiles/Makefile2 vendored
Wyświetl plik

Plik diff jest za duży Load Diff

11
libcodec2-android/src/codec2/build_linux/CMakeFiles/Nightly.dir/DependInfo.cmake vendored
Wyświetl plik

@ -1,11 +0,0 @@
# The set of languages for which implicit dependencies are needed:
set(CMAKE_DEPENDS_LANGUAGES
)
# The set of files for implicit dependencies of each language:
# Targets to which this target links.
set(CMAKE_TARGET_LINKED_INFO_FILES
)
# Fortran module output directory.
set(CMAKE_Fortran_TARGET_MODULE_DIR "")

76
libcodec2-android/src/codec2/build_linux/CMakeFiles/Nightly.dir/build.make vendored
Wyświetl plik

@ -1,76 +0,0 @@
# CMAKE generated file: DO NOT EDIT!
# Generated by "Unix Makefiles" Generator, CMake Version 3.13
# Delete rule output on recipe failure.
.DELETE_ON_ERROR:
#=============================================================================
# Special targets provided by cmake.
# Disable implicit rules so canonical targets will work.
.SUFFIXES:
# Remove some rules from gmake that .SUFFIXES does not remove.
SUFFIXES =
.SUFFIXES: .hpux_make_needs_suffix_list
# 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/bin/cmake
# The command to remove a file.
RM = /usr/bin/cmake -E remove -f
# Escaping for special characters.
EQUALS = =
# The top-level source directory on which CMake was run.
CMAKE_SOURCE_DIR = /home/sh/Downloads/hackrf/codec2
# The top-level build directory on which CMake was run.
CMAKE_BINARY_DIR = /home/sh/Downloads/hackrf/codec2/build_linux
# Utility rule file for Nightly.
# Include the progress variables for this target.
include CMakeFiles/Nightly.dir/progress.make
CMakeFiles/Nightly:
/usr/bin/ctest -D Nightly
Nightly: CMakeFiles/Nightly
Nightly: CMakeFiles/Nightly.dir/build.make
.PHONY : Nightly
# Rule to build all files generated by this target.
CMakeFiles/Nightly.dir/build: Nightly
.PHONY : CMakeFiles/Nightly.dir/build
CMakeFiles/Nightly.dir/clean:
$(CMAKE_COMMAND) -P CMakeFiles/Nightly.dir/cmake_clean.cmake
.PHONY : CMakeFiles/Nightly.dir/clean
CMakeFiles/Nightly.dir/depend:
cd /home/sh/Downloads/hackrf/codec2/build_linux && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /home/sh/Downloads/hackrf/codec2 /home/sh/Downloads/hackrf/codec2 /home/sh/Downloads/hackrf/codec2/build_linux /home/sh/Downloads/hackrf/codec2/build_linux /home/sh/Downloads/hackrf/codec2/build_linux/CMakeFiles/Nightly.dir/DependInfo.cmake --color=$(COLOR)
.PHONY : CMakeFiles/Nightly.dir/depend

8
libcodec2-android/src/codec2/build_linux/CMakeFiles/Nightly.dir/cmake_clean.cmake vendored
Wyświetl plik

@ -1,8 +0,0 @@
file(REMOVE_RECURSE
"CMakeFiles/Nightly"
)
# Per-language clean rules from dependency scanning.
foreach(lang )
include(CMakeFiles/Nightly.dir/cmake_clean_${lang}.cmake OPTIONAL)
endforeach()

1
libcodec2-android/src/codec2/build_linux/CMakeFiles/Nightly.dir/progress.make vendored
Wyświetl plik

@ -1 +0,0 @@

11
libcodec2-android/src/codec2/build_linux/CMakeFiles/NightlyBuild.dir/DependInfo.cmake vendored
Wyświetl plik

@ -1,11 +0,0 @@
# The set of languages for which implicit dependencies are needed:
set(CMAKE_DEPENDS_LANGUAGES
)
# The set of files for implicit dependencies of each language:
# Targets to which this target links.
set(CMAKE_TARGET_LINKED_INFO_FILES
)
# Fortran module output directory.
set(CMAKE_Fortran_TARGET_MODULE_DIR "")

Some files were not shown because too many files have changed in this diff Show More