build.gradle

/*
 * Copyright 2020 natanbc
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

plugins {
    id 'cpp'
    id 'c'
}

def versionObj = new Version(major: 0, minor: 1, revision: 1)
version "${versionObj}"

apply from: 'toolchains.gradle'

model {
    //noinspection GroovyAssignabilityCheck
    components {
        fdk_aac(NativeLibrarySpec) {
            targets.each { targetPlatform it }
            sources {
                cpp {
                    source {
                        srcDir "src/fdk-aac/libAACdec/src"
                        srcDir "src/fdk-aac/libFDK/src"
                        srcDir "src/fdk-aac/libSYS/src"
                        srcDir "src/fdk-aac/libMpegTPDec/src"
                        srcDir "src/fdk-aac/libArithCoding/src"
                        srcDir "src/fdk-aac/libSBRdec/src"
                        srcDir "src/fdk-aac/libPCMutils/src"
                        srcDir "src/fdk-aac/libDRCdec/src"
                        srcDir "src/fdk-aac/libSACdec/src"
                        include "*.cpp"
                    }
                    exportedHeaders {
                        srcDir "src/fdk-aac/libAACdec/include"
                        srcDir "src/fdk-aac/libFDK/include"
                        srcDir "src/fdk-aac/libSYS/include"
                        srcDir "src/fdk-aac/libMpegTPDec/include"
                        srcDir "src/fdk-aac/libArithCoding/include"
                        srcDir "src/fdk-aac/libSBRdec/include"
                        srcDir "src/fdk-aac/libPCMutils/include"
                        srcDir "src/fdk-aac/libDRCdec/include"
                        srcDir "src/fdk-aac/libSACdec/include"
                    }
                }
            }
        }
        opus(NativeLibrarySpec) {
            targets.each { targetPlatform it }
            sources {
                c {
                    source {
                        srcDir "src/opus/src"
                        srcDir "src/opus/celt"
                        srcDir "src/opus/silk"
                        srcDir "src/opus/silk/float"
                        include "*.c"
                        exclude "opus_demo.c", "repacketizer_demo.c", "opus_compare.c", "opus_custom_demo.c"
                    }
                    exportedHeaders {
                        srcDir "src/opus/include"
                        srcDir "src/opus/celt"
                        srcDir "src/opus"
                        srcDir "src/opus/silk"
                        srcDir "src/opus/silk/float"
                        srcDir "fuck_autotools/opus"
                    }
                }
            }
            binaries.all {
                cCompiler.define "HAVE_CONFIG_H"
                def target = isX86(targetPlatform) ? "x86" : isArm(targetPlatform) ? "arm" : null
                if(target != null) {
                    sources {
                        "$target"(CSourceSet) {
                            source {
                                srcDir "src/opus/celt/$target"
                                srcDir "src/opus/silk/$target"
                                include "*.c"
                                exclude "*_ne10.c"
                            }
                            exportedHeaders {
                                srcDir "src/opus/silk/fixed"
                            }
                        }
                    }
                    sources[target].lib component.sources.c
                }
            }
        }
        samplerate(NativeLibrarySpec) {
            targets.each { targetPlatform it }
            sources {
                c {
                    source {
                        srcDir "src/libsamplerate/src"
                        include "*.c"
                    }
                    exportedHeaders {
                        srcDir "src/libsamplerate/src"
                        srcDir "fuck_autotools/samplerate"
                    }
                }
            }
        }
        vorbis(NativeLibrarySpec) {
            targets.each { targetPlatform it }
            sources {
                c {
                    source {
                        srcDir "src/libvorbis/lib"
                        srcDir "src/libogg/src"
                        include "*.c"
                        exclude "psytune.c", "tone.c"
                    }
                    exportedHeaders {
                        srcDir "src/libvorbis/include"
                        srcDir "src/libvorbis/lib"
                        srcDir "src/libogg/include"
                        srcDir "fuck_autotools/vorbis"
                    }
                }
            }
        }
        connector(NativeLibrarySpec) {
            targets.each { targetPlatform it }
            sources {
                connector(CSourceSet) {
                    source {
                        srcDir "src/connector"
                        include "fdk-aac.c"
                        include "opus.c"
                        include "samplerate.c"
                        include "vorbis.c"
                    }
                }
                mp3(CSourceSet) {
                    source {
                        srcDir "src/mp3"
                        include "mp3.c"
                    }
                    exportedHeaders {
                        srcDir "src/mp3/minimp3"
                        srcDir "src/connector"
                    }
                }
            }
            binaries.all {
                lib library: 'jni',        linkage: 'api'
                lib library: 'fdk_aac',    linkage: 'static'
                lib library: 'opus',       linkage: 'static'
                lib library: 'samplerate', linkage: 'static'
                lib library: 'vorbis',     linkage: 'static'

                def target = isLinux(targetPlatform) ? "linux"
                        : isWindows(targetPlatform) ? "win" : null
                if(target != null) {
                    sources {
                        statistics(CSourceSet) {
                            source {
                                srcDir "src/connector/$target"
                                include "*.c"
                            }
                        }
                    }
                }
            }
        }
        udpqueue(NativeLibrarySpec) {
            targets.each { targetPlatform it }
            sources {
                udpqueue(CSourceSet) {
                    source {
                        srcDir "src/udpqueue"
                        include "*.c"
                    }
                    exportedHeaders {
                        srcDir "src/udpqueue"
                    }
                }
            }
            binaries.all {
                lib library: 'jni', linkage: 'api'
                //BSD has clock_gettime/nanosleep
                def target = isLinux(targetPlatform) || isFreebsd(targetPlatform) ? "linux"
                        : isWindows(targetPlatform) ? "win"
                        : isDarwin(targetPlatform) ? "darwin" : null
                if(target != null) {
                    sources {
                        "$target"(CSourceSet) {
                            source {
                                srcDir "src/udpqueue/$target"
                                include "*.c"
                            }
                        }
                    }
                    sources[target].lib component.sources.udpqueue
                }
                if(isWindows(targetPlatform)) {
                    sources {
                        link_winsock(CSourceSet) {
                            source {
                                srcDir "fuck_autotools/udpqueue"
                                include "*.c"
                            }
                        }
                    }
                }
            }
        }
    }
    binaries {
        all {
            if(toolChain in VisualCpp) {
                cppCompiler.args '/std:c++17'
                cppCompiler.args "/Ox", "/MT"
                cCompiler.args "/Ox", "/MT"
            } else if(toolChain in Gcc || toolChain in Clang) {
                cppCompiler.args '-std=c++17'
                cppCompiler.define "NDEBUG"
                cppCompiler.args "-O3", "-fvisibility=hidden"
                cCompiler.define "NDEBUG"
                cCompiler.args "-O3", "-fvisibility=hidden"
                if(isDarwin(it.targetPlatform)) {
                    linker.args "-Wl,-dead_strip"
                } else if(isLinux(it.targetPlatform)) {
                    linker.args "-Wl,--gc-sections", "-Wl,--exclude-libs,ALL", "-Wl,--strip-all"
                }
            }
            if(toolChain in Gcc || toolChain in Clang) {
                cCompiler.args "-fPIC"
                cppCompiler.args "-fPIC"
                if(isX86(it.targetPlatform)) {
                    cCompiler.define "OPUS_X86_PRESUME_SSE4_1"
                    cCompiler.args "-msse4.1"
                    cppCompiler.define "OPUS_X86_PRESUME_SSE4_1"
                    cppCompiler.args "-msse4.1"
                } else if(isArm32(it.targetPlatform)) {
                    cCompiler.define "OPUS_ARM_PRESUME_NEON_INTR"
                    cCompiler.args "-mfpu=neon"
                    cppCompiler.define "OPUS_ARM_PRESUME_NEON_INTR"
                    cppCompiler.args "-mfpu=neon"
                }
            }

            if(isWindows(targetPlatform)) {
                cCompiler.define   "__FUCK_AUTOTOOLS_OPUS_REAL_CONFIG_H", "config_win.h"
                cppCompiler.define "__FUCK_AUTOTOOLS_OPUS_REAL_CONFIG_H", "config_win.h"
            } else {
                cCompiler.define   "__FUCK_AUTOTOOLS_OPUS_REAL_CONFIG_H", "config_linux.h"
                cppCompiler.define "__FUCK_AUTOTOOLS_OPUS_REAL_CONFIG_H", "config_linux.h"
                if(isLinux(targetPlatform) || isFreebsd(targetPlatform)) {
                    cCompiler.define   "__FUCK_AUTOTOOLS_OGG_REAL_CONFIG_TYPES_H", "ogg/config_types_linux.h"
                    cppCompiler.define "__FUCK_AUTOTOOLS_OGG_REAL_CONFIG_TYPES_H", "ogg/config_types_linux.h"
                }
            }
            if(isFreebsd(targetPlatform)) {
                //this breaks immintrin.h so just leave host includes there,
                //the freebsd_headers lib has higher precedence so it'll be used
                //when present
//                it.tasks.withType(AbstractNativeSourceCompileTask) { t ->
//                    t.systemIncludes.setFrom()
//                }
                it.lib library: 'freebsd_headers', linkage: 'api'
            }
            if(isGlibc(targetPlatform)) {
                def suffix = isX86_64(targetPlatform) ? "x86-64"
                            : isX86_32(targetPlatform) ? "x86" : null
                if(suffix != null) {
                    def path = new File(project.projectDir, "glibc/force_link_glibc_2.22_${suffix}.h").getAbsolutePath()
                    cCompiler.args << "-include" << path
                    cppCompiler.args << "-include" << path
                }
            }
        }
    }
}

tasks.withType(LinkSharedLibrary) {
    if(!it.installName.get().contains("connector") && !it.installName.get().contains("udpqueue")) {
        return
    }
    def filename = it.installName.get()
    def arch = targetDirectoryName(it.targetPlatform.get())
    if(arch.contains("darwin")) {
        filename = filename.replace(".so", ".dylib")
    }
    def newPath = new File(rootProject.projectDir, "natives/" + arch + "/" + filename).getAbsoluteFile()
    newPath.getParentFile().mkdirs()
    it.linkedFile.set(newPath)
    taskForTarget(it.targetPlatform.get()).dependsOn it
}

class Version {
    String major, minor, revision


    String toString() {
        "${major}.${minor}" + (revision == "0" ? "" : ".${revision}")
    }
}