zig: build opus codec · tsiry-sandratraina.com/rockbox-zig@51d01da

tsiry-sandratraina.com / rockbox-zig

fork atom

A modern Music Player Daemon based on Rockbox open source high quality audio player

libadwaita audio rust zig deno mpris rockbox mpd

fork atom

zig: build opus codec

tsiry-sandratraina.com 2 years ago 51d01dac 605c9c80

+705 -1406

2 changed files

expand all

build.zig

lib

rbcodec

codecs

opus.c

+701 -1406

build.zig

··· 1 1 const std = @import("std"); 2 2 3 + pub const BuildOptions = struct { 4 + name: []const u8, 5 + sources: []const []const u8, 6 + link_libraries: []const *std.Build.Step.Compile, 7 + target: std.Build.ResolvedTarget, 8 + optimize: std.builtin.OptimizeMode, 9 + macros: []const []const u8 = &[_][]const u8{"CODEC"}, 10 + cflags: []const []const u8 = &cflags, 11 + }; 12 + 3 13 // Although this function looks imperative, note that its job is to 4 14 // declaratively construct a build graph that will be executed by an external 5 15 // runner. ··· 130 140 131 141 libspeex_voice.addCSourceFiles(.{ 132 142 .files = &libspeex_voice_sources, 133 - .flags = &cflags, 143 + .flags = &[_][]const u8{ 144 + "-W", 145 + "-Wall", 146 + "-Wextra", 147 + "-Os", 148 + "-Wstrict-prototypes", 149 + "-pipe", 150 + "-std=gnu11", 151 + "-Wno-gnu", 152 + "-fPIC", 153 + "-fvisibility=hidden", 154 + "-Wno-pointer-to-int-cast", 155 + "-fno-delete-null-pointer-checks", 156 + "-fno-strict-overflow", 157 + "-fno-builtin", 158 + "-g", 159 + "-Wno-unused-result", 160 + "-Wno-pointer-sign", 161 + "-Wno-override-init", 162 + "-Wno-shift-negative-value", 163 + "-Wno-unused-const-variable", 164 + "-Wno-unused-variable", 165 + "-Wno-unused-but-set-variable", 166 + "-O2", 167 + "-Wno-tautological-compare", 168 + "-Wno-expansion-to-defined", 169 + "-I./lib/rbcodec/codecs/libspeex", 170 + }, 134 171 }); 135 172 136 173 libspeex_voice.defineCMacro("HAVE_CONFIG_H", null); ··· 236 273 defineCMacros(libtlsf); 237 274 addIncludePaths(libtlsf); 238 275 239 - // const libopus = b.addStaticLibrary(.{ 240 - // .name = "opus", 241 - // .target = target, 242 - // .optimize = optimize, 243 - // }); 244 - 245 - // b.installArtifact(libopus); 246 - 247 - // libopus.addCSourceFiles(.{ 248 - // .files = &libopus_sources, 249 - // .flags = &cflags, 250 - // }); 276 + build_codec(b, .{ 277 + .name = "opus", 278 + .target = target, 279 + .optimize = optimize, 280 + .sources = &libopus_sources, 281 + .link_libraries = &[_]*std.Build.Step.Compile{ 282 + libcodec, 283 + libfixedpoint, 284 + }, 285 + .macros = &[_][]const u8{ 286 + "CODEC", 287 + "HAVE_CONFIG_H", 288 + }, 289 + .cflags = &[_][]const u8{ 290 + "-W", 291 + "-Wall", 292 + "-Wextra", 293 + "-Os", 294 + "-Wstrict-prototypes", 295 + "-pipe", 296 + "-std=gnu11", 297 + "-Wno-gnu", 298 + "-fPIC", 299 + "-fvisibility=hidden", 300 + "-Wno-pointer-to-int-cast", 301 + "-fno-delete-null-pointer-checks", 302 + "-fno-strict-overflow", 303 + "-fno-builtin", 304 + "-g", 305 + "-Wno-unused-result", 306 + "-Wno-pointer-sign", 307 + "-Wno-override-init", 308 + "-Wno-shift-negative-value", 309 + "-Wno-unused-const-variable", 310 + "-Wno-unused-variable", 311 + "-Wno-unused-but-set-variable", 312 + "-O2", 313 + "-Wno-tautological-compare", 314 + "-Wno-expansion-to-defined", 315 + "-I./lib/rbcodec/codecs/libopus/celt", 316 + "-I./lib/rbcodec/codecs/libopus/silk", 317 + "-include", 318 + "./lib/rbcodec/codecs/libopus/config.h", 319 + }, 320 + }); 251 321 252 - // libopus.defineCMacro("CODEC", null); 253 - // libopus.defineCMacro("HAVE_CONFIG_H", null); 254 - // libopus.defineCMacro("ENABLE_ASSERTIONS", null); 255 - // libopus.defineCMacro("VAR_ARRAYS", null); 256 - // libopus.defineCMacro("USE_ALLOCA", null); 257 - // defineCMacros(libopus); 258 - // addIncludePaths(libopus); 322 + build_codec(b, .{ 323 + .name = "vorbis", 324 + .target = target, 325 + .optimize = optimize, 326 + .sources = &[_][]const u8{ 327 + "lib/rbcodec/codecs/vorbis.c", 328 + "lib/rbcodec/codecs/libtremor/bitwise.c", 329 + "lib/rbcodec/codecs/libtremor/block.c", 330 + "lib/rbcodec/codecs/libtremor/codebook.c", 331 + "lib/rbcodec/codecs/libtremor/floor0.c", 332 + "lib/rbcodec/codecs/libtremor/floor1.c", 333 + "lib/rbcodec/codecs/libtremor/framing.c", 334 + "lib/rbcodec/codecs/libtremor/info.c", 335 + "lib/rbcodec/codecs/libtremor/mapping0.c", 336 + "lib/rbcodec/codecs/libtremor/registry.c", 337 + "lib/rbcodec/codecs/libtremor/res012.c", 338 + "lib/rbcodec/codecs/libtremor/sharedbook.c", 339 + "lib/rbcodec/codecs/libtremor/synthesis.c", 340 + "lib/rbcodec/codecs/libtremor/vorbisfile.c", 341 + "lib/rbcodec/codecs/libtremor/window.c", 342 + "lib/rbcodec/codecs/libtremor/ctype.c", 343 + "lib/rbcodec/codecs/libtremor/oggmalloc.c", 344 + }, 345 + .link_libraries = &[_]*std.Build.Step.Compile{ 346 + libcodec, 347 + libfixedpoint, 348 + }, 349 + }); 259 350 260 351 const libmad = b.addStaticLibrary(.{ 261 352 .name = "mad", ··· 294 385 defineCMacros(libasf); 295 386 addIncludePaths(libasf); 296 387 297 - const mpa_codec = b.addSharedLibrary(.{ 388 + build_codec(b, .{ 298 389 .name = "mpa", 299 390 .target = target, 300 391 .optimize = optimize, 301 - }); 302 - 303 - b.installArtifact(mpa_codec); 304 - 305 - mpa_codec.addCSourceFiles(.{ 306 - .files = &[_][]const u8{ 307 - "lib/rbcodec/codecs/codec_crt0.c", 392 + .sources = &[_][]const u8{ 393 + "lib/rbcodec/codecs/mpa.c", 394 + }, 395 + .link_libraries = &[_]*std.Build.Step.Compile{ 396 + libcodec, 397 + libfixedpoint, 398 + libmad, 399 + libasf, 308 400 }, 309 - .flags = &cflags, 310 401 }); 311 402 312 - mpa_codec.defineCMacro("CODEC", null); 313 - defineCMacros(mpa_codec); 314 - addIncludePaths(mpa_codec); 315 - 316 - mpa_codec.linkLibrary(libcodec); 317 - mpa_codec.linkLibrary(libmad); 318 - mpa_codec.linkLibrary(libasf); 319 - mpa_codec.linkLibrary(libfixedpoint); 320 - 321 - const flac = b.addStaticLibrary(.{ 322 - .name = "flac", 403 + const libffmpegFLAC = b.addStaticLibrary(.{ 404 + .name = "ffmpegFLAC", 323 405 .target = target, 324 406 .optimize = optimize, 325 407 }); 326 408 327 - b.installArtifact(flac); 409 + b.installArtifact(libffmpegFLAC); 328 410 329 - flac.addCSourceFiles(.{ 411 + libffmpegFLAC.addCSourceFiles(.{ 330 412 .files = &[_][]const u8{ 331 - "lib/rbcodec/codecs/flac.c", 332 413 "lib/rbcodec/codecs/libffmpegFLAC/decoder.c", 333 414 "lib/rbcodec/codecs/libffmpegFLAC/shndec.c", 334 415 }, 335 416 .flags = &cflags, 336 417 }); 337 418 338 - flac.defineCMacro("CODEC", null); 339 - defineCMacros(flac); 340 - addIncludePaths(flac); 419 + libffmpegFLAC.defineCMacro("CODEC", null); 420 + defineCMacros(libffmpegFLAC); 421 + addIncludePaths(libffmpegFLAC); 341 422 342 - const flac_codec = b.addSharedLibrary(.{ 423 + build_codec(b, .{ 343 424 .name = "flac", 344 425 .target = target, 345 426 .optimize = optimize, 346 - }); 347 - 348 - b.installArtifact(flac_codec); 349 - 350 - flac_codec.addCSourceFiles(.{ 351 - .files = &[_][]const u8{ 352 - "lib/rbcodec/codecs/codec_crt0.c", 427 + .sources = &[_][]const u8{ 428 + "lib/rbcodec/codecs/flac.c", 429 + }, 430 + .link_libraries = &[_]*std.Build.Step.Compile{ 431 + libcodec, 432 + libfixedpoint, 433 + libffmpegFLAC, 353 434 }, 354 - .flags = &cflags, 355 435 }); 356 - 357 - flac_codec.defineCMacro("CODEC", null); 358 - defineCMacros(flac_codec); 359 - addIncludePaths(flac_codec); 360 - 361 - flac_codec.linkLibrary(libcodec); 362 - flac_codec.linkLibrary(flac); 363 - flac_codec.linkLibrary(libfixedpoint); 364 436 365 437 const libpcm = b.addStaticLibrary(.{ 366 438 .name = "pcm", ··· 391 463 defineCMacros(libpcm); 392 464 addIncludePaths(libpcm); 393 465 394 - const wav = b.addStaticLibrary(.{ 466 + build_codec(b, .{ 395 467 .name = "wav", 396 468 .target = target, 397 469 .optimize = optimize, 398 - }); 399 - 400 - b.installArtifact(wav); 401 - 402 - wav.addCSourceFiles(.{ 403 - .files = &[_][]const u8{ 470 + .sources = &[_][]const u8{ 404 471 "lib/rbcodec/codecs/wav.c", 405 472 }, 406 - .flags = &cflags, 407 - }); 408 - 409 - wav.defineCMacro("CODEC", null); 410 - defineCMacros(wav); 411 - addIncludePaths(wav); 412 - 413 - const wav_codec = b.addSharedLibrary(.{ 414 - .name = "wav", 415 - .target = target, 416 - .optimize = optimize, 417 - }); 418 - 419 - b.installArtifact(wav_codec); 420 - defineCMacros(wav_codec); 421 - addIncludePaths(wav_codec); 422 - 423 - wav_codec.addCSourceFiles(.{ 424 - .files = &[_][]const u8{ 425 - "lib/rbcodec/codecs/codec_crt0.c", 473 + .link_libraries = &[_]*std.Build.Step.Compile{ 474 + libcodec, 475 + libfixedpoint, 476 + libpcm, 426 477 }, 427 - .flags = &cflags, 428 478 }); 429 - 430 - wav_codec.linkLibrary(libcodec); 431 - wav_codec.linkLibrary(wav); 432 - wav_codec.linkLibrary(libfixedpoint); 433 - wav_codec.linkLibrary(libpcm); 434 479 435 480 const librm = b.addStaticLibrary(.{ 436 481 .name = "rm", ··· 448 493 defineCMacros(librm); 449 494 addIncludePaths(librm); 450 495 451 - const liba52 = b.addStaticLibrary(.{ 496 + build_codec(b, .{ 452 497 .name = "a52", 453 498 .target = target, 454 499 .optimize = optimize, 455 - }); 456 - 457 - b.installArtifact(liba52); 458 - 459 - liba52.addCSourceFiles(.{ 460 - .files = &[_][]const u8{ 500 + .sources = &[_][]const u8{ 461 501 "lib/rbcodec/codecs/a52.c", 462 502 "lib/rbcodec/codecs/liba52/bit_allocate.c", 463 503 "lib/rbcodec/codecs/liba52/bitstream.c", ··· 465 505 "lib/rbcodec/codecs/liba52/imdct.c", 466 506 "lib/rbcodec/codecs/liba52/parse.c", 467 507 }, 468 - .flags = &cflags, 469 - }); 470 - 471 - liba52.defineCMacro("CODEC", null); 472 - defineCMacros(liba52); 473 - addIncludePaths(liba52); 474 - 475 - const a52_codec = b.addSharedLibrary(.{ 476 - .name = "a52", 477 - .target = target, 478 - .optimize = optimize, 479 - }); 480 - 481 - b.installArtifact(a52_codec); 482 - 483 - a52_codec.addCSourceFiles(.{ 484 - .files = &[_][]const u8{ 485 - "lib/rbcodec/codecs/codec_crt0.c", 508 + .link_libraries = &[_]*std.Build.Step.Compile{ 509 + libcodec, 510 + libfixedpoint, 511 + librm, 486 512 }, 487 - .flags = &cflags, 488 513 }); 489 514 490 - a52_codec.defineCMacro("CODEC", null); 491 - defineCMacros(a52_codec); 492 - addIncludePaths(a52_codec); 493 - 494 - a52_codec.linkLibrary(libcodec); 495 - a52_codec.linkLibrary(liba52); 496 - a52_codec.linkLibrary(libfixedpoint); 497 - a52_codec.linkLibrary(librm); 498 - 499 - const libwavpack = b.addStaticLibrary(.{ 515 + build_codec(b, .{ 500 516 .name = "wavpack", 501 517 .target = target, 502 518 .optimize = optimize, 503 - }); 504 - 505 - b.installArtifact(libwavpack); 506 - 507 - libwavpack.addCSourceFiles(.{ 508 - .files = &[_][]const u8{ 519 + .sources = &[_][]const u8{ 509 520 "lib/rbcodec/codecs/wavpack.c", 510 521 "lib/rbcodec/codecs/libwavpack/bits.c", 511 522 "lib/rbcodec/codecs/libwavpack/float.c", ··· 515 526 "lib/rbcodec/codecs/libwavpack/words.c", 516 527 "lib/rbcodec/codecs/libwavpack/wputils.c", 517 528 }, 518 - .flags = &cflags, 519 - }); 520 - 521 - libwavpack.defineCMacro("CODEC", null); 522 - defineCMacros(libwavpack); 523 - addIncludePaths(libwavpack); 524 - 525 - const wavpack_codec = b.addSharedLibrary(.{ 526 - .name = "wavpack", 527 - .target = target, 528 - .optimize = optimize, 529 - }); 530 - 531 - b.installArtifact(wavpack_codec); 532 - 533 - wavpack_codec.addCSourceFiles(.{ 534 - .files = &[_][]const u8{ 535 - "lib/rbcodec/codecs/codec_crt0.c", 529 + .link_libraries = &[_]*std.Build.Step.Compile{ 530 + libcodec, 531 + libfixedpoint, 536 532 }, 537 - .flags = &cflags, 538 533 }); 539 534 540 - wavpack_codec.defineCMacro("CODEC", null); 541 - defineCMacros(wavpack_codec); 542 - addIncludePaths(wavpack_codec); 543 - 544 - wavpack_codec.linkLibrary(libcodec); 545 - wavpack_codec.linkLibrary(libwavpack); 546 - wavpack_codec.linkLibrary(libfixedpoint); 547 - 548 - const alac = b.addStaticLibrary(.{ 535 + build_codec(b, .{ 549 536 .name = "alac", 550 537 .target = target, 551 538 .optimize = optimize, 552 - }); 553 - 554 - b.installArtifact(alac); 555 - 556 - alac.addCSourceFiles(.{ 557 - .files = &[_][]const u8{ 539 + .sources = &[_][]const u8{ 558 540 "lib/rbcodec/codecs/alac.c", 559 541 "lib/rbcodec/codecs/libalac/alac.c", 560 542 }, 561 - .flags = &cflags, 562 - }); 563 - 564 - alac.defineCMacro("CODEC", null); 565 - defineCMacros(alac); 566 - addIncludePaths(alac); 567 - 568 - const alac_codec = b.addSharedLibrary(.{ 569 - .name = "alac", 570 - .target = target, 571 - .optimize = optimize, 572 - }); 573 - 574 - b.installArtifact(alac_codec); 575 - 576 - alac_codec.addCSourceFiles(.{ 577 - .files = &[_][]const u8{ 578 - "lib/rbcodec/codecs/codec_crt0.c", 543 + .link_libraries = &[_]*std.Build.Step.Compile{ 544 + libcodec, 545 + libfixedpoint, 579 546 }, 580 - .flags = &cflags, 581 547 }); 582 548 583 - alac_codec.defineCMacro("CODEC", null); 584 - defineCMacros(alac_codec); 585 - addIncludePaths(alac_codec); 586 - 587 - alac_codec.linkLibrary(libcodec); 588 - alac_codec.linkLibrary(alac); 589 - alac_codec.linkLibrary(libfixedpoint); 590 - 591 - const libm4a = b.addStaticLibrary(.{ 592 - .name = "m4a", 593 - .target = target, 594 - .optimize = optimize, 595 - }); 596 - 597 - b.installArtifact(libm4a); 598 - 599 - libm4a.addCSourceFiles(.{ .files = &[_][]const u8{ 600 - "lib/rbcodec/codecs/libm4a/m4a.c", 601 - "lib/rbcodec/codecs/libm4a/demux.c", 602 - }, .flags = &cflags }); 603 - 604 - libm4a.defineCMacro("CODEC", null); 605 - defineCMacros(libm4a); 606 - addIncludePaths(libm4a); 607 - 608 - const m4a_codec = b.addSharedLibrary(.{ 549 + build_codec(b, .{ 609 550 .name = "m4a", 610 551 .target = target, 611 552 .optimize = optimize, 553 + .sources = &[_][]const u8{ 554 + "lib/rbcodec/codecs/libm4a/m4a.c", 555 + "lib/rbcodec/codecs/libm4a/demux.c", 556 + }, 557 + .link_libraries = &[_]*std.Build.Step.Compile{ 558 + libcodec, 559 + libfixedpoint, 560 + }, 612 561 }); 613 562 614 - b.installArtifact(m4a_codec); 615 - 616 - m4a_codec.addCSourceFiles(.{ .files = &[_][]const u8{ 617 - "lib/rbcodec/codecs/codec_crt0.c", 618 - }, .flags = &cflags }); 619 - 620 - m4a_codec.defineCMacro("CODEC", null); 621 - defineCMacros(m4a_codec); 622 - addIncludePaths(m4a_codec); 623 - 624 - m4a_codec.linkLibrary(libcodec); 625 - m4a_codec.linkLibrary(libm4a); 626 - m4a_codec.linkLibrary(libfixedpoint); 627 - 628 - const libcook = b.addStaticLibrary(.{ 563 + build_codec(b, .{ 629 564 .name = "cook", 630 565 .target = target, 631 566 .optimize = optimize, 567 + .sources = &[_][]const u8{ 568 + "lib/rbcodec/codecs/cook.c", 569 + "lib/rbcodec/codecs/libcook/cook.c", 570 + }, 571 + .link_libraries = &[_]*std.Build.Step.Compile{ 572 + libcodec, 573 + libfixedpoint, 574 + librm, 575 + }, 632 576 }); 633 577 634 - b.installArtifact(libcook); 635 - 636 - libcook.addCSourceFiles(.{ .files = &[_][]const u8{ 637 - "./lib/rbcodec/codecs/cook.c", 638 - "./lib/rbcodec/codecs/libcook/cook.c", 639 - }, .flags = &cflags }); 640 - 641 - libcook.defineCMacro("CODEC", null); 642 - defineCMacros(libcook); 643 - addIncludePaths(libcook); 644 - 645 - const cook_codec = b.addSharedLibrary(.{ 646 - .name = "cook", 647 - .target = target, 648 - .optimize = optimize, 649 - }); 650 - 651 - b.installArtifact(cook_codec); 652 - 653 - cook_codec.addCSourceFiles(.{ .files = &[_][]const u8{ 654 - "lib/rbcodec/codecs/codec_crt0.c", 655 - }, .flags = &cflags }); 656 - 657 - cook_codec.defineCMacro("CODEC", null); 658 - defineCMacros(cook_codec); 659 - addIncludePaths(cook_codec); 660 - 661 - cook_codec.linkLibrary(libcodec); 662 - cook_codec.linkLibrary(libcook); 663 - cook_codec.linkLibrary(libfixedpoint); 664 - cook_codec.linkLibrary(librm); 665 - 666 578 const libfaad = b.addStaticLibrary(.{ 667 579 .name = "faad", 668 580 .target = target, ··· 671 583 672 584 b.installArtifact(libfaad); 673 585 674 - libfaad.addCSourceFiles(.{ .files = &[_][]const u8{ 675 - "lib/rbcodec/codecs/raac.c", 676 - "lib/rbcodec/codecs/libfaad/bits.c", 677 - "lib/rbcodec/codecs/libfaad/common.c", 678 - "lib/rbcodec/codecs/libfaad/decoder.c", 679 - "lib/rbcodec/codecs/libfaad/drc.c", 680 - "lib/rbcodec/codecs/libfaad/error.c", 681 - "lib/rbcodec/codecs/libfaad/filtbank.c", 682 - "lib/rbcodec/codecs/libfaad/huffman.c", 683 - "lib/rbcodec/codecs/libfaad/is.c", 684 - "lib/rbcodec/codecs/libfaad/mp4.c", 685 - "lib/rbcodec/codecs/libfaad/ms.c", 686 - "lib/rbcodec/codecs/libfaad/pns.c", 687 - "lib/rbcodec/codecs/libfaad/ps_dec.c", 688 - "lib/rbcodec/codecs/libfaad/ps_syntax.c", 689 - "lib/rbcodec/codecs/libfaad/pulse.c", 690 - "lib/rbcodec/codecs/libfaad/sbr_dct.c", 691 - "lib/rbcodec/codecs/libfaad/sbr_dec.c", 692 - "lib/rbcodec/codecs/libfaad/sbr_e_nf.c", 693 - "lib/rbcodec/codecs/libfaad/sbr_fbt.c", 694 - "lib/rbcodec/codecs/libfaad/sbr_hfadj.c", 695 - "lib/rbcodec/codecs/libfaad/sbr_hfgen.c", 696 - "lib/rbcodec/codecs/libfaad/sbr_huff.c", 697 - "lib/rbcodec/codecs/libfaad/sbr_qmf.c", 698 - "lib/rbcodec/codecs/libfaad/sbr_syntax.c", 699 - "lib/rbcodec/codecs/libfaad/sbr_tf_grid.c", 700 - "lib/rbcodec/codecs/libfaad/specrec.c", 701 - "lib/rbcodec/codecs/libfaad/syntax.c", 702 - "lib/rbcodec/codecs/libfaad/tns.c", 703 - }, .flags = &cflags }); 586 + libfaad.addCSourceFiles(.{ 587 + .files = &[_][]const u8{ 588 + "lib/rbcodec/codecs/raac.c", 589 + "lib/rbcodec/codecs/libfaad/bits.c", 590 + "lib/rbcodec/codecs/libfaad/common.c", 591 + "lib/rbcodec/codecs/libfaad/decoder.c", 592 + "lib/rbcodec/codecs/libfaad/drc.c", 593 + "lib/rbcodec/codecs/libfaad/error.c", 594 + "lib/rbcodec/codecs/libfaad/filtbank.c", 595 + "lib/rbcodec/codecs/libfaad/huffman.c", 596 + "lib/rbcodec/codecs/libfaad/is.c", 597 + "lib/rbcodec/codecs/libfaad/mp4.c", 598 + "lib/rbcodec/codecs/libfaad/ms.c", 599 + "lib/rbcodec/codecs/libfaad/pns.c", 600 + "lib/rbcodec/codecs/libfaad/ps_dec.c", 601 + "lib/rbcodec/codecs/libfaad/ps_syntax.c", 602 + "lib/rbcodec/codecs/libfaad/pulse.c", 603 + "lib/rbcodec/codecs/libfaad/sbr_dct.c", 604 + "lib/rbcodec/codecs/libfaad/sbr_dec.c", 605 + "lib/rbcodec/codecs/libfaad/sbr_e_nf.c", 606 + "lib/rbcodec/codecs/libfaad/sbr_fbt.c", 607 + "lib/rbcodec/codecs/libfaad/sbr_hfadj.c", 608 + "lib/rbcodec/codecs/libfaad/sbr_hfgen.c", 609 + "lib/rbcodec/codecs/libfaad/sbr_huff.c", 610 + "lib/rbcodec/codecs/libfaad/sbr_qmf.c", 611 + "lib/rbcodec/codecs/libfaad/sbr_syntax.c", 612 + "lib/rbcodec/codecs/libfaad/sbr_tf_grid.c", 613 + "lib/rbcodec/codecs/libfaad/specrec.c", 614 + "lib/rbcodec/codecs/libfaad/syntax.c", 615 + "lib/rbcodec/codecs/libfaad/tns.c", 616 + }, 617 + .flags = &[_][]const u8{ 618 + "-W", 619 + "-Wall", 620 + "-Wextra", 621 + "-Os", 622 + "-Wstrict-prototypes", 623 + "-pipe", 624 + "-std=gnu11", 625 + "-Wno-gnu", 626 + "-fPIC", 627 + "-fvisibility=hidden", 628 + "-Wno-pointer-to-int-cast", 629 + "-fno-delete-null-pointer-checks", 630 + "-fno-strict-overflow", 631 + "-fno-builtin", 632 + "-g", 633 + "-Wno-unused-result", 634 + "-Wno-pointer-sign", 635 + "-Wno-override-init", 636 + "-Wno-shift-negative-value", 637 + "-Wno-unused-const-variable", 638 + "-Wno-unused-variable", 639 + "-Wno-unused-but-set-variable", 640 + "-O2", 641 + "-Wno-tautological-compare", 642 + "-Wno-expansion-to-defined", 643 + "-I./lib/rbcodec/codecs/libfaad", 644 + }, 645 + }); 704 646 705 647 libfaad.defineCMacro("CODEC", null); 706 648 defineCMacros(libfaad); 707 649 addIncludePaths(libfaad); 708 650 709 - const faad_codec = b.addSharedLibrary(.{ 651 + build_codec(b, .{ 710 652 .name = "faad", 711 653 .target = target, 712 654 .optimize = optimize, 713 - }); 714 - 715 - b.installArtifact(faad_codec); 716 - 717 - faad_codec.addCSourceFiles(.{ .files = &[_][]const u8{ 718 - "lib/rbcodec/codecs/codec_crt0.c", 719 - }, .flags = &cflags }); 720 - 721 - faad_codec.defineCMacro("CODEC", null); 722 - defineCMacros(faad_codec); 723 - addIncludePaths(faad_codec); 724 - 725 - faad_codec.linkLibrary(libcodec); 726 - faad_codec.linkLibrary(libfaad); 727 - faad_codec.linkLibrary(libfixedpoint); 728 - faad_codec.linkLibrary(librm); 729 - 730 - const raac = b.addStaticLibrary(.{ 731 - .name = "raac", 732 - .target = target, 733 - .optimize = optimize, 655 + .sources = &[_][]const u8{ 656 + "lib/rbcodec/codecs/raac.c", 657 + "lib/rbcodec/codecs/libfaad/bits.c", 658 + "lib/rbcodec/codecs/libfaad/common.c", 659 + "lib/rbcodec/codecs/libfaad/decoder.c", 660 + "lib/rbcodec/codecs/libfaad/drc.c", 661 + "lib/rbcodec/codecs/libfaad/error.c", 662 + "lib/rbcodec/codecs/libfaad/filtbank.c", 663 + "lib/rbcodec/codecs/libfaad/huffman.c", 664 + "lib/rbcodec/codecs/libfaad/is.c", 665 + "lib/rbcodec/codecs/libfaad/mp4.c", 666 + "lib/rbcodec/codecs/libfaad/ms.c", 667 + "lib/rbcodec/codecs/libfaad/pns.c", 668 + "lib/rbcodec/codecs/libfaad/ps_dec.c", 669 + "lib/rbcodec/codecs/libfaad/ps_syntax.c", 670 + "lib/rbcodec/codecs/libfaad/pulse.c", 671 + "lib/rbcodec/codecs/libfaad/sbr_dct.c", 672 + "lib/rbcodec/codecs/libfaad/sbr_dec.c", 673 + "lib/rbcodec/codecs/libfaad/sbr_e_nf.c", 674 + "lib/rbcodec/codecs/libfaad/sbr_fbt.c", 675 + "lib/rbcodec/codecs/libfaad/sbr_hfadj.c", 676 + "lib/rbcodec/codecs/libfaad/sbr_hfgen.c", 677 + "lib/rbcodec/codecs/libfaad/sbr_huff.c", 678 + "lib/rbcodec/codecs/libfaad/sbr_qmf.c", 679 + "lib/rbcodec/codecs/libfaad/sbr_syntax.c", 680 + "lib/rbcodec/codecs/libfaad/sbr_tf_grid.c", 681 + "lib/rbcodec/codecs/libfaad/specrec.c", 682 + "lib/rbcodec/codecs/libfaad/syntax.c", 683 + "lib/rbcodec/codecs/libfaad/tns.c", 684 + }, 685 + .link_libraries = &[_]*std.Build.Step.Compile{ 686 + libcodec, 687 + libfixedpoint, 688 + librm, 689 + }, 690 + .cflags = &[_][]const u8{ 691 + "-W", 692 + "-Wall", 693 + "-Wextra", 694 + "-Os", 695 + "-Wstrict-prototypes", 696 + "-pipe", 697 + "-std=gnu11", 698 + "-Wno-gnu", 699 + "-fPIC", 700 + "-fvisibility=hidden", 701 + "-Wno-pointer-to-int-cast", 702 + "-fno-delete-null-pointer-checks", 703 + "-fno-strict-overflow", 704 + "-fno-builtin", 705 + "-g", 706 + "-Wno-unused-result", 707 + "-Wno-pointer-sign", 708 + "-Wno-override-init", 709 + "-Wno-shift-negative-value", 710 + "-Wno-unused-const-variable", 711 + "-Wno-unused-variable", 712 + "-Wno-unused-but-set-variable", 713 + "-O2", 714 + "-Wno-tautological-compare", 715 + "-Wno-expansion-to-defined", 716 + "-I./lib/rbcodec/codecs/libfaad", 717 + }, 734 718 }); 735 719 736 - b.installArtifact(raac); 737 - 738 - raac.addCSourceFiles(.{ .files = &[_][]const u8{ 739 - "lib/rbcodec/codecs/raac.c", 740 - }, .flags = &cflags }); 741 - 742 - raac.defineCMacro("CODEC", null); 743 - defineCMacros(raac); 744 - addIncludePaths(raac); 745 - 746 - const raac_codec = b.addSharedLibrary(.{ 720 + build_codec(b, .{ 747 721 .name = "raac", 748 722 .target = target, 749 723 .optimize = optimize, 750 - }); 751 - 752 - b.installArtifact(raac_codec); 753 - 754 - raac_codec.addCSourceFiles(.{ .files = &[_][]const u8{ 755 - "lib/rbcodec/codecs/codec_crt0.c", 756 - }, .flags = &cflags }); 757 - 758 - raac_codec.defineCMacro("CODEC", null); 759 - defineCMacros(raac_codec); 760 - addIncludePaths(raac_codec); 761 - 762 - raac_codec.linkLibrary(libcodec); 763 - raac_codec.linkLibrary(raac); 764 - raac_codec.linkLibrary(libfixedpoint); 765 - raac_codec.linkLibrary(librm); 766 - raac_codec.linkLibrary(libfaad); 767 - 768 - const a52_rm = b.addStaticLibrary(.{ 769 - .name = "a52_rm", 770 - .target = target, 771 - .optimize = optimize, 724 + .sources = &[_][]const u8{ 725 + "lib/rbcodec/codecs/raac.c", 726 + }, 727 + .link_libraries = &[_]*std.Build.Step.Compile{ 728 + libcodec, 729 + libfixedpoint, 730 + libfaad, 731 + librm, 732 + }, 733 + .cflags = &[_][]const u8{ 734 + "-W", 735 + "-Wall", 736 + "-Wextra", 737 + "-Os", 738 + "-Wstrict-prototypes", 739 + "-pipe", 740 + "-std=gnu11", 741 + "-Wno-gnu", 742 + "-fPIC", 743 + "-fvisibility=hidden", 744 + "-Wno-pointer-to-int-cast", 745 + "-fno-delete-null-pointer-checks", 746 + "-fno-strict-overflow", 747 + "-fno-builtin", 748 + "-g", 749 + "-Wno-unused-result", 750 + "-Wno-pointer-sign", 751 + "-Wno-override-init", 752 + "-Wno-shift-negative-value", 753 + "-Wno-unused-const-variable", 754 + "-Wno-unused-variable", 755 + "-Wno-unused-but-set-variable", 756 + "-O2", 757 + "-Wno-tautological-compare", 758 + "-Wno-expansion-to-defined", 759 + "-I./lib/rbcodec/codecs/libfaad", 760 + }, 772 761 }); 773 762 774 - b.installArtifact(a52_rm); 775 - 776 - a52_rm.addCSourceFiles(.{ .files = &[_][]const u8{ 777 - "lib/rbcodec/codecs/a52_rm.c", 778 - }, .flags = &cflags }); 779 - 780 - a52_rm.defineCMacro("CODEC", null); 781 - defineCMacros(a52_rm); 782 - addIncludePaths(a52_rm); 783 - 784 - const a52_rm_codec = b.addSharedLibrary(.{ 763 + build_codec(b, .{ 785 764 .name = "a52_rm", 786 765 .target = target, 787 766 .optimize = optimize, 788 - }); 789 - 790 - b.installArtifact(a52_rm_codec); 791 - 792 - a52_rm_codec.addCSourceFiles(.{ .files = &[_][]const u8{ 793 - "lib/rbcodec/codecs/codec_crt0.c", 794 - }, .flags = &cflags }); 795 - 796 - a52_rm_codec.defineCMacro("CODEC", null); 797 - defineCMacros(a52_rm_codec); 798 - addIncludePaths(a52_rm_codec); 799 - 800 - a52_rm_codec.linkLibrary(libcodec); 801 - a52_rm_codec.linkLibrary(a52_rm); 802 - a52_rm_codec.linkLibrary(libfixedpoint); 803 - a52_rm_codec.linkLibrary(librm); 804 - 805 - const libatrac = b.addStaticLibrary(.{ 806 - .name = "atrac", 807 - .target = target, 808 - .optimize = optimize, 767 + .sources = &[_][]const u8{ 768 + "lib/rbcodec/codecs/a52_rm.c", 769 + }, 770 + .link_libraries = &[_]*std.Build.Step.Compile{ 771 + libcodec, 772 + libfixedpoint, 773 + librm, 774 + }, 809 775 }); 810 776 811 - b.installArtifact(libatrac); 812 - 813 - libatrac.addCSourceFiles(.{ .files = &[_][]const u8{ 814 - "lib/rbcodec/codecs/atrac3_rm.c", 815 - "lib/rbcodec/codecs/libatrac/atrac3.c", 816 - }, .flags = &cflags }); 817 - 818 - libatrac.defineCMacro("CODEC", null); 819 - defineCMacros(libatrac); 820 - addIncludePaths(libatrac); 821 - 822 - const atrac_codec = b.addSharedLibrary(.{ 823 - .name = "atrac", 777 + build_codec(b, .{ 778 + .name = "atrac3_rm", 824 779 .target = target, 825 780 .optimize = optimize, 781 + .sources = &[_][]const u8{ 782 + "lib/rbcodec/codecs/atrac3_rm.c", 783 + "lib/rbcodec/codecs/libatrac/atrac3.c", 784 + }, 785 + .link_libraries = &[_]*std.Build.Step.Compile{ 786 + libcodec, 787 + libfixedpoint, 788 + librm, 789 + }, 826 790 }); 827 791 828 - b.installArtifact(atrac_codec); 829 - 830 - atrac_codec.addCSourceFiles(.{ .files = &[_][]const u8{ 831 - "lib/rbcodec/codecs/codec_crt0.c", 832 - }, .flags = &cflags }); 833 - 834 - atrac_codec.defineCMacro("CODEC", null); 835 - defineCMacros(atrac_codec); 836 - addIncludePaths(atrac_codec); 837 - 838 - atrac_codec.linkLibrary(libcodec); 839 - atrac_codec.linkLibrary(libatrac); 840 - atrac_codec.linkLibrary(libfixedpoint); 841 - atrac_codec.linkLibrary(librm); 842 - 843 - const atrac3_oma = b.addStaticLibrary(.{ 792 + build_codec(b, .{ 844 793 .name = "atrac3_oma", 845 794 .target = target, 846 795 .optimize = optimize, 796 + .sources = &[_][]const u8{ 797 + "lib/rbcodec/codecs/atrac3_oma.c", 798 + }, 799 + .link_libraries = &[_]*std.Build.Step.Compile{ 800 + libcodec, 801 + libfixedpoint, 802 + }, 847 803 }); 848 804 849 - b.installArtifact(atrac3_oma); 850 - 851 - atrac3_oma.addCSourceFiles(.{ .files = &[_][]const u8{ 852 - "lib/rbcodec/codecs/atrac3_oma.c", 853 - }, .flags = &cflags }); 854 - 855 - atrac3_oma.defineCMacro("CODEC", null); 856 - defineCMacros(atrac3_oma); 857 - addIncludePaths(atrac3_oma); 858 - 859 - const atrac3_oma_codec = b.addSharedLibrary(.{ 860 - .name = "atrac3_oma", 861 - .target = target, 862 - .optimize = optimize, 863 - }); 864 - 865 - b.installArtifact(atrac3_oma_codec); 866 - 867 - atrac3_oma_codec.addCSourceFiles(.{ .files = &[_][]const u8{ 868 - "lib/rbcodec/codecs/codec_crt0.c", 869 - }, .flags = &cflags }); 870 - 871 - atrac3_oma_codec.defineCMacro("CODEC", null); 872 - defineCMacros(atrac3_oma_codec); 873 - addIncludePaths(atrac3_oma_codec); 874 - 875 - atrac3_oma_codec.linkLibrary(libcodec); 876 - atrac3_oma_codec.linkLibrary(atrac3_oma); 877 - atrac3_oma_codec.linkLibrary(libfixedpoint); 878 - 879 - const musepack = b.addStaticLibrary(.{ 880 - .name = "musepack", 881 - .target = target, 882 - .optimize = optimize, 883 - }); 884 - 885 - b.installArtifact(musepack); 886 - 887 - musepack.addCSourceFiles(.{ .files = &[_][]const u8{ 888 - "lib/rbcodec/codecs/mpc.c", 889 - "lib/rbcodec/codecs/libmusepack/crc32.c", 890 - "lib/rbcodec/codecs/libmusepack/huffman.c", 891 - "lib/rbcodec/codecs/libmusepack/mpc_bits_reader.c", 892 - "lib/rbcodec/codecs/libmusepack/mpc_decoder.c", 893 - "lib/rbcodec/codecs/libmusepack/mpc_demux.c", 894 - "lib/rbcodec/codecs/libmusepack/requant.c", 895 - "lib/rbcodec/codecs/libmusepack/streaminfo.c", 896 - "lib/rbcodec/codecs/libmusepack/synth_filter.c", 897 - }, .flags = &cflags }); 898 - 899 - musepack.defineCMacro("CODEC", null); 900 - defineCMacros(musepack); 901 - addIncludePaths(musepack); 902 - 903 - const mpc_codec = b.addSharedLibrary(.{ 805 + build_codec(b, .{ 904 806 .name = "mpc", 905 807 .target = target, 906 808 .optimize = optimize, 907 - }); 908 - 909 - b.installArtifact(mpc_codec); 910 - 911 - mpc_codec.addCSourceFiles(.{ .files = &[_][]const u8{ 912 - "lib/rbcodec/codecs/codec_crt0.c", 913 - }, .flags = &cflags }); 914 - 915 - mpc_codec.defineCMacro("CODEC", null); 916 - defineCMacros(mpc_codec); 917 - addIncludePaths(mpc_codec); 918 - 919 - mpc_codec.linkLibrary(libcodec); 920 - mpc_codec.linkLibrary(musepack); 921 - mpc_codec.linkLibrary(libfixedpoint); 922 - 923 - const wma = b.addStaticLibrary(.{ 924 - .name = "wma", 925 - .target = target, 926 - .optimize = optimize, 809 + .sources = &[_][]const u8{ 810 + "lib/rbcodec/codecs/mpc.c", 811 + "lib/rbcodec/codecs/libmusepack/crc32.c", 812 + "lib/rbcodec/codecs/libmusepack/huffman.c", 813 + "lib/rbcodec/codecs/libmusepack/mpc_bits_reader.c", 814 + "lib/rbcodec/codecs/libmusepack/mpc_decoder.c", 815 + "lib/rbcodec/codecs/libmusepack/mpc_demux.c", 816 + "lib/rbcodec/codecs/libmusepack/requant.c", 817 + "lib/rbcodec/codecs/libmusepack/streaminfo.c", 818 + "lib/rbcodec/codecs/libmusepack/synth_filter.c", 819 + }, 820 + .link_libraries = &[_]*std.Build.Step.Compile{ 821 + libcodec, 822 + libfixedpoint, 823 + }, 927 824 }); 928 825 929 - b.installArtifact(wma); 930 - 931 - wma.addCSourceFiles(.{ .files = &[_][]const u8{ 932 - "lib/rbcodec/codecs/wma.c", 933 - "lib/rbcodec/codecs/libwma/wmadeci.c", 934 - "lib/rbcodec/codecs/libwma/wmafixed.c", 935 - }, .flags = &cflags }); 936 - 937 - wma.defineCMacro("CODEC", null); 938 - defineCMacros(wma); 939 - addIncludePaths(wma); 940 - 941 - const wma_codec = b.addSharedLibrary(.{ 826 + build_codec(b, .{ 942 827 .name = "wma", 943 828 .target = target, 944 829 .optimize = optimize, 830 + .sources = &[_][]const u8{ 831 + "lib/rbcodec/codecs/wma.c", 832 + "lib/rbcodec/codecs/libwma/wmadeci.c", 833 + "lib/rbcodec/codecs/libwma/wmafixed.c", 834 + }, 835 + .link_libraries = &[_]*std.Build.Step.Compile{ 836 + libcodec, 837 + libfixedpoint, 838 + }, 945 839 }); 946 840 947 - b.installArtifact(wma_codec); 948 - 949 - wma_codec.addCSourceFiles(.{ .files = &[_][]const u8{ 950 - "lib/rbcodec/codecs/codec_crt0.c", 951 - }, .flags = &cflags }); 952 - 953 - wma_codec.defineCMacro("CODEC", null); 954 - defineCMacros(wma_codec); 955 - addIncludePaths(wma_codec); 956 - 957 - wma_codec.linkLibrary(libcodec); 958 - wma_codec.linkLibrary(wma); 959 - wma_codec.linkLibrary(libfixedpoint); 960 - 961 841 const libdemac = b.addStaticLibrary(.{ 962 842 .name = "demac", 963 843 .target = target, ··· 966 846 967 847 b.installArtifact(libdemac); 968 848 969 - const ape = b.addStaticLibrary(.{ 970 - .name = "ape", 971 - .target = target, 972 - .optimize = optimize, 973 - }); 974 - 975 - b.installArtifact(ape); 976 - 977 - ape.addCSourceFiles(.{ .files = &[_][]const u8{ 978 - "lib/rbcodec/codecs/ape.c", 979 - }, .flags = &cflags }); 980 - 981 - ape.defineCMacro("CODEC", null); 982 - defineCMacros(ape); 983 - addIncludePaths(ape); 984 - 985 - const ape_codec = b.addSharedLibrary(.{ 986 - .name = "ape", 987 - .target = target, 988 - .optimize = optimize, 989 - }); 990 - 991 - b.installArtifact(ape_codec); 992 - 993 - ape_codec.addCSourceFiles(.{ .files = &[_][]const u8{ 994 - "lib/rbcodec/codecs/codec_crt0.c", 995 - }, .flags = &cflags }); 996 - 997 - ape_codec.defineCMacro("CODEC", null); 998 - defineCMacros(ape_codec); 999 - addIncludePaths(ape_codec); 1000 - 1001 - ape_codec.linkLibrary(libcodec); 1002 - ape_codec.linkLibrary(ape); 1003 - ape_codec.linkLibrary(libfixedpoint); 1004 - 1005 849 libdemac.addCSourceFiles(.{ .files = &[_][]const u8{ 1006 850 "lib/rbcodec/codecs/ape.c", 1007 851 "lib/rbcodec/codecs/demac/libdemac/predictor.c", ··· 1019 863 defineCMacros(libdemac); 1020 864 addIncludePaths(libdemac); 1021 865 1022 - const libasap = b.addStaticLibrary(.{ 1023 - .name = "asap", 866 + build_codec(b, .{ 867 + .name = "ape", 1024 868 .target = target, 1025 869 .optimize = optimize, 870 + .sources = &[_][]const u8{ 871 + "lib/rbcodec/codecs/ape.c", 872 + }, 873 + .link_libraries = &[_]*std.Build.Step.Compile{ 874 + libcodec, 875 + libfixedpoint, 876 + }, 1026 877 }); 1027 878 1028 - b.installArtifact(libasap); 1029 - 1030 - libasap.addCSourceFiles(.{ .files = &[_][]const u8{ 1031 - "lib/rbcodec/codecs/asap.c", 1032 - "lib/rbcodec/codecs/libasap/acpu.c", 1033 - "lib/rbcodec/codecs/libasap/asap.c", 1034 - "lib/rbcodec/codecs/libasap/apokeysnd.c", 1035 - }, .flags = &cflags }); 1036 - 1037 - libasap.defineCMacro("CODEC", null); 1038 - defineCMacros(libasap); 1039 - addIncludePaths(libasap); 1040 - 1041 - const asap_codec = b.addSharedLibrary(.{ 879 + build_codec(b, .{ 1042 880 .name = "asap", 1043 881 .target = target, 1044 882 .optimize = optimize, 883 + .sources = &[_][]const u8{ 884 + "lib/rbcodec/codecs/asap.c", 885 + "lib/rbcodec/codecs/libasap/acpu.c", 886 + "lib/rbcodec/codecs/libasap/asap.c", 887 + "lib/rbcodec/codecs/libasap/apokeysnd.c", 888 + }, 889 + .link_libraries = &[_]*std.Build.Step.Compile{ 890 + libcodec, 891 + libfixedpoint, 892 + }, 1045 893 }); 1046 894 1047 - b.installArtifact(asap_codec); 1048 - 1049 - asap_codec.addCSourceFiles(.{ .files = &[_][]const u8{ 1050 - "lib/rbcodec/codecs/codec_crt0.c", 1051 - }, .flags = &cflags }); 1052 - 1053 - asap_codec.defineCMacro("CODEC", null); 1054 - defineCMacros(asap_codec); 1055 - addIncludePaths(asap_codec); 1056 - 1057 - asap_codec.linkLibrary(libcodec); 1058 - asap_codec.linkLibrary(libasap); 1059 - asap_codec.linkLibrary(libfixedpoint); 1060 - 1061 - const aac = b.addStaticLibrary(.{ 895 + build_codec(b, .{ 1062 896 .name = "aac", 1063 897 .target = target, 1064 898 .optimize = optimize, 1065 - }); 1066 - 1067 - b.installArtifact(aac); 1068 - 1069 - aac.addCSourceFiles(.{ 1070 - .files = &[_][]const u8{"lib/rbcodec/codecs/aac.c"}, 1071 - .flags = &cflags, 1072 - }); 1073 - 1074 - aac.defineCMacro("CODEC", null); 1075 - defineCMacros(aac); 1076 - addIncludePaths(aac); 1077 - 1078 - const aac_codec = b.addSharedLibrary(.{ 1079 - .name = "aac", 1080 - .target = target, 1081 - .optimize = optimize, 1082 - }); 1083 - 1084 - b.installArtifact(aac_codec); 1085 - 1086 - aac_codec.addCSourceFiles(.{ 1087 - .files = &[_][]const u8{ 1088 - "lib/rbcodec/codecs/codec_crt0.c", 899 + .sources = &[_][]const u8{ 900 + "lib/rbcodec/codecs/aac.c", 901 + }, 902 + .link_libraries = &[_]*std.Build.Step.Compile{ 903 + libcodec, 904 + libfixedpoint, 1089 905 }, 1090 - .flags = &cflags, 1091 906 }); 1092 907 1093 - aac_codec.defineCMacro("CODEC", null); 1094 - defineCMacros(aac_codec); 1095 - addIncludePaths(aac_codec); 1096 - 1097 - aac_codec.linkLibrary(libcodec); 1098 - aac_codec.linkLibrary(aac); 1099 - aac_codec.linkLibrary(libfixedpoint); 1100 - 1101 - const libspc = b.addStaticLibrary(.{ 908 + build_codec(b, .{ 1102 909 .name = "spc", 1103 910 .target = target, 1104 911 .optimize = optimize, 1105 - }); 1106 - 1107 - b.installArtifact(libspc); 1108 - 1109 - libspc.addCSourceFiles(.{ 1110 - .files = &[_][]const u8{ 912 + .sources = &[_][]const u8{ 1111 913 "lib/rbcodec/codecs/spc.c", 1112 914 "lib/rbcodec/codecs/libspc/spc_cpu.c", 1113 915 "lib/rbcodec/codecs/libspc/spc_dsp.c", 1114 916 "lib/rbcodec/codecs/libspc/spc_emu.c", 1115 917 "lib/rbcodec/codecs/libspc/spc_profiler.c", 1116 918 }, 1117 - .flags = &cflags, 1118 - }); 1119 - 1120 - libspc.defineCMacro("CODEC", null); 1121 - defineCMacros(libspc); 1122 - addIncludePaths(libspc); 1123 - 1124 - const spc_codec = b.addSharedLibrary(.{ 1125 - .name = "spc", 1126 - .target = target, 1127 - .optimize = optimize, 1128 - }); 1129 - 1130 - b.installArtifact(spc_codec); 1131 - 1132 - spc_codec.addCSourceFiles(.{ 1133 - .files = &[_][]const u8{ 1134 - "lib/rbcodec/codecs/codec_crt0.c", 919 + .link_libraries = &[_]*std.Build.Step.Compile{ 920 + libcodec, 921 + libfixedpoint, 1135 922 }, 1136 - .flags = &cflags, 1137 923 }); 1138 924 1139 - spc_codec.defineCMacro("CODEC", null); 1140 - defineCMacros(spc_codec); 1141 - addIncludePaths(spc_codec); 1142 - 1143 - spc_codec.linkLibrary(libcodec); 1144 - spc_codec.linkLibrary(libspc); 1145 - spc_codec.linkLibrary(libfixedpoint); 1146 - 1147 - const mod = b.addStaticLibrary(.{ 925 + build_codec(b, .{ 1148 926 .name = "mod", 1149 927 .target = target, 1150 928 .optimize = optimize, 1151 - }); 1152 - 1153 - b.installArtifact(mod); 1154 - 1155 - mod.addCSourceFiles(.{ 1156 - .files = &[_][]const u8{ 929 + .sources = &[_][]const u8{ 1157 930 "lib/rbcodec/codecs/mod.c", 1158 931 }, 1159 - .flags = &cflags, 1160 - }); 1161 - 1162 - mod.defineCMacro("CODEC", null); 1163 - defineCMacros(mod); 1164 - addIncludePaths(mod); 1165 - 1166 - const mod_codec = b.addSharedLibrary(.{ 1167 - .name = "mod", 1168 - .target = target, 1169 - .optimize = optimize, 1170 - }); 1171 - 1172 - b.installArtifact(mod_codec); 1173 - 1174 - mod_codec.addCSourceFiles(.{ 1175 - .files = &[_][]const u8{ 1176 - "lib/rbcodec/codecs/codec_crt0.c", 932 + .link_libraries = &[_]*std.Build.Step.Compile{ 933 + libcodec, 934 + libfixedpoint, 1177 935 }, 1178 - .flags = &cflags, 1179 936 }); 1180 937 1181 - mod_codec.defineCMacro("CODEC", null); 1182 - defineCMacros(mod_codec); 1183 - addIncludePaths(mod_codec); 1184 - 1185 - mod_codec.linkLibrary(libcodec); 1186 - mod_codec.linkLibrary(mod); 1187 - mod_codec.linkLibrary(libfixedpoint); 1188 - 1189 - const shorten = b.addStaticLibrary(.{ 938 + build_codec(b, .{ 1190 939 .name = "shorten", 1191 940 .target = target, 1192 941 .optimize = optimize, 1193 - }); 1194 - 1195 - b.installArtifact(shorten); 1196 - 1197 - shorten.addCSourceFiles(.{ 1198 - .files = &[_][]const u8{ 942 + .sources = &[_][]const u8{ 1199 943 "lib/rbcodec/codecs/shorten.c", 1200 944 }, 1201 - .flags = &cflags, 1202 - }); 1203 - 1204 - shorten.defineCMacro("CODEC", null); 1205 - defineCMacros(shorten); 1206 - addIncludePaths(shorten); 1207 - 1208 - const shorten_codec = b.addSharedLibrary(.{ 1209 - .name = "shorten", 1210 - .target = target, 1211 - .optimize = optimize, 1212 - }); 1213 - 1214 - b.installArtifact(shorten_codec); 1215 - 1216 - shorten_codec.addCSourceFiles(.{ 1217 - .files = &[_][]const u8{ 1218 - "lib/rbcodec/codecs/codec_crt0.c", 1219 - "lib/rbcodec/codecs/libffmpegFLAC/decoder.c", 1220 - "lib/rbcodec/codecs/libffmpegFLAC/shndec.c", 945 + .link_libraries = &[_]*std.Build.Step.Compile{ 946 + libcodec, 947 + libfixedpoint, 948 + libffmpegFLAC, 1221 949 }, 1222 - .flags = &cflags, 1223 950 }); 1224 951 1225 - shorten_codec.defineCMacro("CODEC", null); 1226 - defineCMacros(shorten_codec); 1227 - addIncludePaths(shorten_codec); 1228 - 1229 - shorten_codec.linkLibrary(libcodec); 1230 - shorten_codec.linkLibrary(shorten); 1231 - shorten_codec.linkLibrary(libfixedpoint); 1232 - 1233 - const aiff = b.addStaticLibrary(.{ 952 + build_codec(b, .{ 1234 953 .name = "aiff", 1235 954 .target = target, 1236 955 .optimize = optimize, 1237 - }); 1238 - 1239 - b.installArtifact(aiff); 1240 - 1241 - aiff.addCSourceFiles(.{ 1242 - .files = &[_][]const u8{ 956 + .sources = &[_][]const u8{ 1243 957 "lib/rbcodec/codecs/aiff.c", 1244 958 }, 1245 - .flags = &cflags, 1246 - }); 1247 - 1248 - aiff.defineCMacro("CODEC", null); 1249 - defineCMacros(aiff); 1250 - addIncludePaths(aiff); 1251 - 1252 - const aiff_codec = b.addSharedLibrary(.{ 1253 - .name = "aiff", 1254 - .target = target, 1255 - .optimize = optimize, 1256 - }); 1257 - 1258 - b.installArtifact(aiff_codec); 1259 - 1260 - aiff_codec.addCSourceFiles(.{ 1261 - .files = &[_][]const u8{ 1262 - "lib/rbcodec/codecs/codec_crt0.c", 959 + .link_libraries = &[_]*std.Build.Step.Compile{ 960 + libcodec, 961 + libfixedpoint, 962 + libpcm, 1263 963 }, 1264 - .flags = &cflags, 1265 964 }); 1266 965 1267 - aiff_codec.defineCMacro("CODEC", null); 1268 - defineCMacros(aiff_codec); 1269 - addIncludePaths(aiff_codec); 1270 - 1271 - aiff_codec.linkLibrary(libcodec); 1272 - aiff_codec.linkLibrary(aiff); 1273 - aiff_codec.linkLibrary(libfixedpoint); 1274 - aiff_codec.linkLibrary(libpcm); 1275 - 1276 - const libspeex = b.addStaticLibrary(.{ 966 + build_codec(b, .{ 1277 967 .name = "speex", 1278 968 .target = target, 1279 969 .optimize = optimize, 1280 - }); 1281 - 1282 - b.installArtifact(libspeex); 1283 - 1284 - libspeex.addCSourceFiles(.{ 1285 - .files = &libspeex_sources, 1286 - .flags = &cflags, 1287 - }); 1288 - 1289 - libspeex.defineCMacro("CODEC", null); 1290 - libspeex.defineCMacro("HAVE_CONFIG_H", null); 1291 - libspeex.defineCMacro("SPEEX_DISABLE_ENCODER", null); 1292 - 1293 - defineCMacros(libspeex); 1294 - addIncludePaths(libspeex); 1295 - 1296 - const speex_codec = b.addSharedLibrary(.{ 1297 - .name = "speex", 1298 - .target = target, 1299 - .optimize = optimize, 1300 - }); 1301 - 1302 - b.installArtifact(speex_codec); 1303 - 1304 - speex_codec.addCSourceFiles(.{ 1305 - .files = &[_][]const u8{ 1306 - "lib/rbcodec/codecs/codec_crt0.c", 970 + .sources = &libspeex_sources, 971 + .link_libraries = &[_]*std.Build.Step.Compile{ 972 + libcodec, 973 + libfixedpoint, 974 + }, 975 + .macros = &[_][]const u8{ 976 + "CODEC", 977 + "HAVE_CONFIG_H", 978 + "SPEEX_DISABLE_ENCODER", 1307 979 }, 1308 - .flags = &cflags, 980 + .cflags = &[_][]const u8{ 981 + "-W", 982 + "-Wall", 983 + "-Wextra", 984 + "-Os", 985 + "-Wstrict-prototypes", 986 + "-pipe", 987 + "-std=gnu11", 988 + "-Wno-gnu", 989 + "-fPIC", 990 + "-fvisibility=hidden", 991 + "-Wno-pointer-to-int-cast", 992 + "-fno-delete-null-pointer-checks", 993 + "-fno-strict-overflow", 994 + "-fno-builtin", 995 + "-g", 996 + "-Wno-unused-result", 997 + "-Wno-pointer-sign", 998 + "-Wno-override-init", 999 + "-Wno-shift-negative-value", 1000 + "-Wno-unused-const-variable", 1001 + "-Wno-unused-variable", 1002 + "-Wno-unused-but-set-variable", 1003 + "-O2", 1004 + "-Wno-tautological-compare", 1005 + "-Wno-expansion-to-defined", 1006 + "-I./lib/rbcodec/codecs/libspeex", 1007 + }, 1309 1008 }); 1310 1009 1311 - speex_codec.defineCMacro("CODEC", null); 1312 - speex_codec.defineCMacro("HAVE_CONFIG_H", null); 1313 - speex_codec.defineCMacro("SPEEX_DISABLE_ENCODER", null); 1314 - defineCMacros(speex_codec); 1315 - addIncludePaths(speex_codec); 1316 - 1317 - speex_codec.linkLibrary(libcodec); 1318 - speex_codec.linkLibrary(libspeex); 1319 - speex_codec.linkLibrary(libfixedpoint); 1320 - 1321 - const adx = b.addStaticLibrary(.{ 1010 + build_codec(b, .{ 1322 1011 .name = "adx", 1323 1012 .target = target, 1324 1013 .optimize = optimize, 1325 - }); 1326 - 1327 - b.installArtifact(adx); 1328 - 1329 - adx.addCSourceFiles(.{ 1330 - .files = &[_][]const u8{ 1014 + .sources = &[_][]const u8{ 1331 1015 "lib/rbcodec/codecs/adx.c", 1332 1016 }, 1333 - .flags = &cflags, 1334 - }); 1335 - 1336 - adx.defineCMacro("CODEC", null); 1337 - defineCMacros(adx); 1338 - addIncludePaths(adx); 1339 - 1340 - const adx_codec = b.addSharedLibrary(.{ 1341 - .name = "adx", 1342 - .target = target, 1343 - .optimize = optimize, 1344 - }); 1345 - 1346 - b.installArtifact(adx_codec); 1347 - 1348 - adx_codec.addCSourceFiles(.{ 1349 - .files = &[_][]const u8{ 1350 - "lib/rbcodec/codecs/codec_crt0.c", 1017 + .link_libraries = &[_]*std.Build.Step.Compile{ 1018 + libcodec, 1019 + libfixedpoint, 1351 1020 }, 1352 - .flags = &cflags, 1353 1021 }); 1354 1022 1355 - adx_codec.defineCMacro("CODEC", null); 1356 - defineCMacros(adx_codec); 1357 - addIncludePaths(adx_codec); 1358 - 1359 - adx_codec.linkLibrary(libcodec); 1360 - adx_codec.linkLibrary(adx); 1361 - adx_codec.linkLibrary(libfixedpoint); 1362 - 1363 - const smaf = b.addStaticLibrary(.{ 1023 + build_codec(b, .{ 1364 1024 .name = "smaf", 1365 1025 .target = target, 1366 1026 .optimize = optimize, 1367 - }); 1368 - 1369 - b.installArtifact(smaf); 1370 - 1371 - smaf.addCSourceFiles(.{ 1372 - .files = &[_][]const u8{ 1027 + .sources = &[_][]const u8{ 1373 1028 "lib/rbcodec/codecs/smaf.c", 1374 1029 }, 1375 - .flags = &cflags, 1376 - }); 1377 - 1378 - smaf.defineCMacro("CODEC", null); 1379 - defineCMacros(smaf); 1380 - addIncludePaths(smaf); 1381 - 1382 - const smaf_codec = b.addSharedLibrary(.{ 1383 - .name = "smaf", 1384 - .target = target, 1385 - .optimize = optimize, 1386 - }); 1387 - 1388 - b.installArtifact(smaf_codec); 1389 - 1390 - smaf_codec.addCSourceFiles(.{ 1391 - .files = &[_][]const u8{ 1392 - "lib/rbcodec/codecs/codec_crt0.c", 1030 + .link_libraries = &[_]*std.Build.Step.Compile{ 1031 + libcodec, 1032 + libfixedpoint, 1033 + libpcm, 1393 1034 }, 1394 - .flags = &cflags, 1395 1035 }); 1396 1036 1397 - smaf_codec.defineCMacro("CODEC", null); 1398 - defineCMacros(smaf_codec); 1399 - addIncludePaths(smaf_codec); 1400 - 1401 - smaf_codec.linkLibrary(libcodec); 1402 - smaf_codec.linkLibrary(smaf); 1403 - smaf_codec.linkLibrary(libfixedpoint); 1404 - smaf_codec.linkLibrary(libpcm); 1405 - 1406 - const au = b.addStaticLibrary(.{ 1037 + build_codec(b, .{ 1407 1038 .name = "au", 1408 1039 .target = target, 1409 1040 .optimize = optimize, 1410 - }); 1411 - 1412 - b.installArtifact(au); 1413 - 1414 - au.addCSourceFiles(.{ 1415 - .files = &[_][]const u8{ 1041 + .sources = &[_][]const u8{ 1416 1042 "lib/rbcodec/codecs/au.c", 1417 1043 }, 1418 - .flags = &cflags, 1419 - }); 1420 - 1421 - au.defineCMacro("CODEC", null); 1422 - defineCMacros(au); 1423 - addIncludePaths(au); 1424 - 1425 - const au_codec = b.addSharedLibrary(.{ 1426 - .name = "au", 1427 - .target = target, 1428 - .optimize = optimize, 1429 - }); 1430 - 1431 - b.installArtifact(au_codec); 1432 - 1433 - au_codec.addCSourceFiles(.{ 1434 - .files = &[_][]const u8{ 1435 - "lib/rbcodec/codecs/codec_crt0.c", 1044 + .link_libraries = &[_]*std.Build.Step.Compile{ 1045 + libcodec, 1046 + libfixedpoint, 1047 + libpcm, 1436 1048 }, 1437 - .flags = &cflags, 1438 1049 }); 1439 1050 1440 - au_codec.defineCMacro("CODEC", null); 1441 - defineCMacros(au_codec); 1442 - addIncludePaths(au_codec); 1443 - 1444 - au_codec.linkLibrary(libcodec); 1445 - au_codec.linkLibrary(au); 1446 - au_codec.linkLibrary(libfixedpoint); 1447 - au_codec.linkLibrary(libpcm); 1448 - 1449 - const vox = b.addStaticLibrary(.{ 1051 + build_codec(b, .{ 1450 1052 .name = "vox", 1451 1053 .target = target, 1452 1054 .optimize = optimize, 1453 - }); 1454 - 1455 - b.installArtifact(vox); 1456 - 1457 - vox.addCSourceFiles(.{ 1458 - .files = &[_][]const u8{ 1055 + .sources = &[_][]const u8{ 1459 1056 "lib/rbcodec/codecs/vox.c", 1460 1057 }, 1461 - .flags = &cflags, 1462 - }); 1463 - 1464 - vox.defineCMacro("CODEC", null); 1465 - defineCMacros(vox); 1466 - addIncludePaths(vox); 1467 - 1468 - const vox_codec = b.addSharedLibrary(.{ 1469 - .name = "vox", 1470 - .target = target, 1471 - .optimize = optimize, 1472 - }); 1473 - 1474 - b.installArtifact(vox_codec); 1475 - 1476 - vox_codec.addCSourceFiles(.{ 1477 - .files = &[_][]const u8{ 1478 - "lib/rbcodec/codecs/codec_crt0.c", 1058 + .link_libraries = &[_]*std.Build.Step.Compile{ 1059 + libcodec, 1060 + libfixedpoint, 1061 + libpcm, 1479 1062 }, 1480 - .flags = &cflags, 1481 1063 }); 1482 1064 1483 - vox_codec.defineCMacro("CODEC", null); 1484 - defineCMacros(vox_codec); 1485 - addIncludePaths(vox_codec); 1486 - 1487 - vox_codec.linkLibrary(libcodec); 1488 - vox_codec.linkLibrary(vox); 1489 - vox_codec.linkLibrary(libfixedpoint); 1490 - vox_codec.linkLibrary(libpcm); 1491 - 1492 - const wav64 = b.addStaticLibrary(.{ 1065 + build_codec(b, .{ 1493 1066 .name = "wav64", 1494 1067 .target = target, 1495 1068 .optimize = optimize, 1496 - }); 1497 - 1498 - b.installArtifact(wav64); 1499 - 1500 - wav64.addCSourceFiles(.{ 1501 - .files = &[_][]const u8{ 1069 + .sources = &[_][]const u8{ 1502 1070 "lib/rbcodec/codecs/wav64.c", 1503 1071 }, 1504 - .flags = &cflags, 1505 - }); 1506 - 1507 - wav64.defineCMacro("CODEC", null); 1508 - defineCMacros(wav64); 1509 - addIncludePaths(wav64); 1510 - 1511 - const wav64_codec = b.addSharedLibrary(.{ 1512 - .name = "wav64", 1513 - .target = target, 1514 - .optimize = optimize, 1515 - }); 1516 - 1517 - b.installArtifact(wav64_codec); 1518 - 1519 - wav64_codec.addCSourceFiles(.{ 1520 - .files = &[_][]const u8{ 1521 - "lib/rbcodec/codecs/codec_crt0.c", 1072 + .link_libraries = &[_]*std.Build.Step.Compile{ 1073 + libcodec, 1074 + libfixedpoint, 1075 + libpcm, 1522 1076 }, 1523 - .flags = &cflags, 1524 1077 }); 1525 1078 1526 - wav64_codec.defineCMacro("CODEC", null); 1527 - defineCMacros(wav64_codec); 1528 - addIncludePaths(wav64_codec); 1529 - 1530 - wav64_codec.linkLibrary(libcodec); 1531 - wav64_codec.linkLibrary(wav64); 1532 - wav64_codec.linkLibrary(libfixedpoint); 1533 - wav64_codec.linkLibrary(libpcm); 1534 - 1535 - const tta = b.addStaticLibrary(.{ 1079 + build_codec(b, .{ 1536 1080 .name = "tta", 1537 1081 .target = target, 1538 1082 .optimize = optimize, 1539 - }); 1540 - 1541 - b.installArtifact(tta); 1542 - 1543 - tta.addCSourceFiles(.{ 1544 - .files = &[_][]const u8{ 1083 + .sources = &[_][]const u8{ 1545 1084 "lib/rbcodec/codecs/tta.c", 1546 1085 "lib/rbcodec/codecs/libtta/ttadec.c", 1547 1086 }, 1548 - .flags = &cflags, 1549 - }); 1550 - 1551 - tta.defineCMacro("CODEC", null); 1552 - defineCMacros(tta); 1553 - addIncludePaths(tta); 1554 - 1555 - const tta_codec = b.addSharedLibrary(.{ 1556 - .name = "tta", 1557 - .target = target, 1558 - .optimize = optimize, 1559 - }); 1560 - 1561 - b.installArtifact(tta_codec); 1562 - 1563 - tta_codec.addCSourceFiles(.{ 1564 - .files = &[_][]const u8{ 1565 - "lib/rbcodec/codecs/codec_crt0.c", 1087 + .link_libraries = &[_]*std.Build.Step.Compile{ 1088 + libcodec, 1089 + libfixedpoint, 1566 1090 }, 1567 - .flags = &cflags, 1568 1091 }); 1569 1092 1570 - tta_codec.defineCMacro("CODEC", null); 1571 - defineCMacros(tta_codec); 1572 - addIncludePaths(tta_codec); 1573 - 1574 - tta_codec.linkLibrary(libcodec); 1575 - tta_codec.linkLibrary(tta); 1576 - tta_codec.linkLibrary(libfixedpoint); 1577 - 1578 - const wmapro = b.addStaticLibrary(.{ 1093 + build_codec(b, .{ 1579 1094 .name = "wmapro", 1580 1095 .target = target, 1581 1096 .optimize = optimize, 1582 - }); 1583 - 1584 - b.installArtifact(wmapro); 1585 - 1586 - wmapro.addCSourceFiles(.{ 1587 - .files = &[_][]const u8{ 1097 + .sources = &[_][]const u8{ 1588 1098 "lib/rbcodec/codecs/wmapro.c", 1589 1099 "lib/rbcodec/codecs/libwmapro/wmaprodec.c", 1590 1100 "lib/rbcodec/codecs/libwmapro/wma.c", 1591 1101 "lib/rbcodec/codecs/libwmapro/mdct_tables.c", 1592 1102 }, 1593 - .flags = &cflags, 1594 - }); 1595 - 1596 - wmapro.defineCMacro("CODEC", null); 1597 - defineCMacros(wmapro); 1598 - addIncludePaths(wmapro); 1599 - 1600 - const wmapro_codec = b.addSharedLibrary(.{ 1601 - .name = "wmapro", 1602 - .target = target, 1603 - .optimize = optimize, 1604 - }); 1605 - 1606 - b.installArtifact(wmapro_codec); 1607 - 1608 - wmapro_codec.addCSourceFiles(.{ 1609 - .files = &[_][]const u8{ 1610 - "lib/rbcodec/codecs/codec_crt0.c", 1103 + .link_libraries = &[_]*std.Build.Step.Compile{ 1104 + libcodec, 1105 + libfixedpoint, 1611 1106 }, 1612 - .flags = &cflags, 1613 1107 }); 1614 1108 1615 - wmapro_codec.defineCMacro("CODEC", null); 1616 - defineCMacros(wmapro_codec); 1617 - addIncludePaths(wmapro_codec); 1618 - 1619 - wmapro_codec.linkLibrary(libcodec); 1620 - wmapro_codec.linkLibrary(wmapro); 1621 - wmapro_codec.linkLibrary(libfixedpoint); 1622 - 1623 - const libay = b.addStaticLibrary(.{ 1109 + build_codec(b, .{ 1624 1110 .name = "ay", 1625 1111 .target = target, 1626 1112 .optimize = optimize, 1627 - }); 1628 - 1629 - b.installArtifact(libay); 1630 - 1631 - libay.addCSourceFiles(.{ 1632 - .files = &[_][]const u8{ 1113 + .sources = &[_][]const u8{ 1633 1114 "lib/rbcodec/codecs/ay.c", 1634 1115 "lib/rbcodec/codecs/libgme/ay_apu.c", 1635 1116 "lib/rbcodec/codecs/libgme/ay_cpu.c", ··· 1639 1120 "lib/rbcodec/codecs/libgme/track_filter.c", 1640 1121 "lib/rbcodec/codecs/libgme/z80_cpu.c", 1641 1122 }, 1642 - .flags = &cflags, 1643 - }); 1644 - 1645 - libay.defineCMacro("CODEC", null); 1646 - defineCMacros(libay); 1647 - addIncludePaths(libay); 1648 - 1649 - const ay_codec = b.addSharedLibrary(.{ 1650 - .name = "ay", 1651 - .target = target, 1652 - .optimize = optimize, 1653 - }); 1654 - 1655 - b.installArtifact(ay_codec); 1656 - 1657 - ay_codec.addCSourceFiles(.{ 1658 - .files = &[_][]const u8{ 1659 - "lib/rbcodec/codecs/codec_crt0.c", 1123 + .link_libraries = &[_]*std.Build.Step.Compile{ 1124 + libcodec, 1125 + libfixedpoint, 1660 1126 }, 1661 - .flags = &cflags, 1662 1127 }); 1663 1128 1664 - ay_codec.defineCMacro("CODEC", null); 1665 - defineCMacros(ay_codec); 1666 - addIncludePaths(ay_codec); 1667 - 1668 - ay_codec.linkLibrary(libcodec); 1669 - ay_codec.linkLibrary(libay); 1670 - ay_codec.linkLibrary(libfixedpoint); 1671 - 1672 - const libayumi = b.addStaticLibrary(.{ 1673 - .name = "ayumi", 1129 + build_codec(b, .{ 1130 + .name = "vtx", 1674 1131 .target = target, 1675 1132 .optimize = optimize, 1676 - }); 1677 - 1678 - b.installArtifact(libayumi); 1679 - 1680 - libayumi.addCSourceFiles(.{ 1681 - .files = &[_][]const u8{ 1133 + .sources = &[_][]const u8{ 1682 1134 "lib/rbcodec/codecs/vtx.c", 1683 1135 "lib/rbcodec/codecs/libayumi/ayumi_render.c", 1684 1136 "lib/rbcodec/codecs/libayumi/ayumi.c", 1685 1137 "lib/rbcodec/codecs/libayumi/lzh.c", 1686 1138 }, 1687 - .flags = &cflags, 1688 - }); 1689 - 1690 - libayumi.defineCMacro("CODEC", null); 1691 - defineCMacros(libayumi); 1692 - addIncludePaths(libayumi); 1693 - 1694 - const vtx_codec = b.addSharedLibrary(.{ 1695 - .name = "vtx", 1696 - .target = target, 1697 - .optimize = optimize, 1698 - }); 1699 - 1700 - b.installArtifact(vtx_codec); 1701 - 1702 - vtx_codec.addCSourceFiles(.{ 1703 - .files = &[_][]const u8{ 1704 - "lib/rbcodec/codecs/codec_crt0.c", 1139 + .link_libraries = &[_]*std.Build.Step.Compile{ 1140 + libcodec, 1141 + libfixedpoint, 1705 1142 }, 1706 - .flags = &cflags, 1707 1143 }); 1708 1144 1709 - vtx_codec.defineCMacro("CODEC", null); 1710 - defineCMacros(vtx_codec); 1711 - addIncludePaths(vtx_codec); 1712 - 1713 - vtx_codec.linkLibrary(libcodec); 1714 - vtx_codec.linkLibrary(libayumi); 1715 - vtx_codec.linkLibrary(libfixedpoint); 1716 - 1717 - const libgbs = b.addStaticLibrary(.{ 1145 + build_codec(b, .{ 1718 1146 .name = "gbs", 1719 1147 .target = target, 1720 1148 .optimize = optimize, 1721 - }); 1722 - 1723 - b.installArtifact(libgbs); 1724 - 1725 - libgbs.addCSourceFiles(.{ 1726 - .files = &[_][]const u8{ 1149 + .sources = &[_][]const u8{ 1727 1150 "lib/rbcodec/codecs/gbs.c", 1728 1151 "lib/rbcodec/codecs/libgme/gb_apu.c", 1729 1152 "lib/rbcodec/codecs/libgme/gb_cpu.c", ··· 1732 1155 "lib/rbcodec/codecs/libgme/gbs_emu.c", 1733 1156 "lib/rbcodec/codecs/libgme/rom_data.c", 1734 1157 }, 1735 - .flags = &cflags, 1736 - }); 1737 - 1738 - libgbs.defineCMacro("CODEC", null); 1739 - defineCMacros(libgbs); 1740 - addIncludePaths(libgbs); 1741 - 1742 - const gbs_codec = b.addSharedLibrary(.{ 1743 - .name = "gbs", 1744 - .target = target, 1745 - .optimize = optimize, 1746 - }); 1747 - 1748 - b.installArtifact(gbs_codec); 1749 - 1750 - gbs_codec.addCSourceFiles(.{ 1751 - .files = &[_][]const u8{ 1752 - "lib/rbcodec/codecs/codec_crt0.c", 1158 + .link_libraries = &[_]*std.Build.Step.Compile{ 1159 + libcodec, 1160 + libfixedpoint, 1753 1161 }, 1754 - .flags = &cflags, 1755 1162 }); 1756 1163 1757 - gbs_codec.defineCMacro("CODEC", null); 1758 - defineCMacros(gbs_codec); 1759 - addIncludePaths(gbs_codec); 1760 - 1761 - gbs_codec.linkLibrary(libcodec); 1762 - gbs_codec.linkLibrary(libgbs); 1763 - gbs_codec.linkLibrary(libfixedpoint); 1764 - 1765 - const libhes = b.addStaticLibrary(.{ 1164 + build_codec(b, .{ 1766 1165 .name = "hes", 1767 1166 .target = target, 1768 1167 .optimize = optimize, 1769 - }); 1770 - 1771 - b.installArtifact(libhes); 1772 - 1773 - libhes.addCSourceFiles(.{ 1774 - .files = &[_][]const u8{ 1168 + .sources = &[_][]const u8{ 1775 1169 "lib/rbcodec/codecs/hes.c", 1776 1170 "lib/rbcodec/codecs/libgme/hes_apu.c", 1777 1171 "lib/rbcodec/codecs/libgme/hes_apu_adpcm.c", 1778 1172 "lib/rbcodec/codecs/libgme/hes_cpu.c", 1779 1173 "lib/rbcodec/codecs/libgme/hes_emu.c", 1780 1174 }, 1781 - .flags = &cflags, 1175 + .link_libraries = &[_]*std.Build.Step.Compile{ 1176 + libcodec, 1177 + libfixedpoint, 1178 + }, 1782 1179 }); 1783 1180 1784 - libhes.defineCMacro("CODEC", null); 1785 - defineCMacros(libhes); 1786 - addIncludePaths(libhes); 1787 - 1788 - const hes_codec = b.addSharedLibrary(.{ 1789 - .name = "hes", 1181 + const libemu2413 = b.addStaticLibrary(.{ 1182 + .name = "emu2413", 1790 1183 .target = target, 1791 1184 .optimize = optimize, 1792 1185 }); 1793 1186 1794 - b.installArtifact(hes_codec); 1187 + b.installArtifact(libemu2413); 1795 1188 1796 - hes_codec.addCSourceFiles(.{ 1189 + libemu2413.addCSourceFiles(.{ 1797 1190 .files = &[_][]const u8{ 1798 - "lib/rbcodec/codecs/codec_crt0.c", 1191 + "lib/rbcodec/codecs/libgme/sms_apu.c", 1192 + "lib/rbcodec/codecs/libgme/sms_fm_apu.c", 1193 + "lib/rbcodec/codecs/libgme/emu2413.c", 1194 + "lib/rbcodec/codecs/libgme/ym2413_emu.c", 1799 1195 }, 1800 1196 .flags = &cflags, 1801 1197 }); 1802 1198 1803 - hes_codec.defineCMacro("CODEC", null); 1804 - defineCMacros(hes_codec); 1805 - addIncludePaths(hes_codec); 1806 - 1807 - hes_codec.linkLibrary(libcodec); 1808 - hes_codec.linkLibrary(libhes); 1809 - hes_codec.linkLibrary(libfixedpoint); 1199 + libemu2413.defineCMacro("CODEC", null); 1200 + defineCMacros(libemu2413); 1201 + addIncludePaths(libemu2413); 1810 1202 1811 - const libnsf = b.addStaticLibrary(.{ 1203 + build_codec(b, .{ 1812 1204 .name = "nsf", 1813 1205 .target = target, 1814 1206 .optimize = optimize, 1815 - }); 1816 - 1817 - b.installArtifact(libnsf); 1818 - 1819 - libnsf.addCSourceFiles(.{ 1820 - .files = &[_][]const u8{ 1207 + .sources = &[_][]const u8{ 1821 1208 "lib/rbcodec/codecs/nsf.c", 1822 1209 "lib/rbcodec/codecs/libgme/nes_apu.c", 1823 1210 "lib/rbcodec/codecs/libgme/nes_cpu.c", ··· 1830 1217 "lib/rbcodec/codecs/libgme/nsf_cpu.c", 1831 1218 "lib/rbcodec/codecs/libgme/nsf_emu.c", 1832 1219 "lib/rbcodec/codecs/libgme/nsfe_info.c", 1833 - }, 1834 - .flags = &cflags, 1835 - }); 1836 - 1837 - libnsf.defineCMacro("CODEC", null); 1838 - defineCMacros(libnsf); 1839 - addIncludePaths(libnsf); 1840 - 1841 - const libemu2413 = b.addStaticLibrary(.{ 1842 - .name = "emu2413", 1843 - .target = target, 1844 - .optimize = optimize, 1845 - }); 1846 - 1847 - b.installArtifact(libemu2413); 1848 - 1849 - libemu2413.addCSourceFiles(.{ 1850 - .files = &[_][]const u8{ 1851 1220 "lib/rbcodec/codecs/libgme/sms_apu.c", 1852 1221 "lib/rbcodec/codecs/libgme/sms_fm_apu.c", 1853 1222 "lib/rbcodec/codecs/libgme/emu2413.c", 1854 1223 "lib/rbcodec/codecs/libgme/ym2413_emu.c", 1855 1224 }, 1856 - .flags = &cflags, 1857 - }); 1858 - 1859 - libemu2413.defineCMacro("CODEC", null); 1860 - defineCMacros(libemu2413); 1861 - addIncludePaths(libemu2413); 1862 - 1863 - const nsf_codec = b.addSharedLibrary(.{ 1864 - .name = "nsf", 1865 - .target = target, 1866 - .optimize = optimize, 1867 - }); 1868 - 1869 - b.installArtifact(nsf_codec); 1870 - 1871 - nsf_codec.addCSourceFiles(.{ 1872 - .files = &[_][]const u8{ 1873 - "lib/rbcodec/codecs/codec_crt0.c", 1225 + .link_libraries = &[_]*std.Build.Step.Compile{ 1226 + libcodec, 1227 + libfixedpoint, 1228 + libemu2413, 1874 1229 }, 1875 - .flags = &cflags, 1876 1230 }); 1877 1231 1878 - nsf_codec.defineCMacro("CODEC", null); 1879 - defineCMacros(nsf_codec); 1880 - addIncludePaths(nsf_codec); 1881 - 1882 - nsf_codec.linkLibrary(libcodec); 1883 - nsf_codec.linkLibrary(libnsf); 1884 - nsf_codec.linkLibrary(libfixedpoint); 1885 - nsf_codec.linkLibrary(libemu2413); 1886 - 1887 - const libsgc = b.addStaticLibrary(.{ 1232 + build_codec(b, .{ 1888 1233 .name = "sgc", 1889 1234 .target = target, 1890 1235 .optimize = optimize, 1891 - }); 1892 - 1893 - b.installArtifact(libsgc); 1894 - 1895 - libsgc.addCSourceFiles(.{ 1896 - .files = &[_][]const u8{ 1236 + .sources = &[_][]const u8{ 1897 1237 "lib/rbcodec/codecs/sgc.c", 1898 1238 "lib/rbcodec/codecs/libgme/sgc_cpu.c", 1899 1239 "lib/rbcodec/codecs/libgme/sgc_emu.c", 1900 1240 }, 1901 - .flags = &cflags, 1902 - }); 1903 - 1904 - libsgc.defineCMacro("CODEC", null); 1905 - defineCMacros(libsgc); 1906 - addIncludePaths(libsgc); 1907 - 1908 - const sgc_codec = b.addSharedLibrary(.{ 1909 - .name = "sgc", 1910 - .target = target, 1911 - .optimize = optimize, 1912 - }); 1913 - 1914 - b.installArtifact(sgc_codec); 1915 - 1916 - sgc_codec.addCSourceFiles(.{ 1917 - .files = &[_][]const u8{ 1918 - "lib/rbcodec/codecs/codec_crt0.c", 1241 + .link_libraries = &[_]*std.Build.Step.Compile{ 1242 + libcodec, 1243 + libfixedpoint, 1919 1244 }, 1920 - .flags = &cflags, 1921 1245 }); 1922 1246 1923 - sgc_codec.defineCMacro("CODEC", null); 1924 - defineCMacros(sgc_codec); 1925 - addIncludePaths(sgc_codec); 1926 - 1927 - sgc_codec.linkLibrary(libcodec); 1928 - sgc_codec.linkLibrary(libsgc); 1929 - sgc_codec.linkLibrary(libfixedpoint); 1930 - 1931 - const libvgm = b.addStaticLibrary(.{ 1247 + build_codec(b, .{ 1932 1248 .name = "vgm", 1933 1249 .target = target, 1934 1250 .optimize = optimize, 1935 - }); 1936 - 1937 - b.installArtifact(libvgm); 1938 - 1939 - libvgm.addCSourceFiles(.{ 1940 - .files = &[_][]const u8{ 1251 + .sources = &[_][]const u8{ 1941 1252 "lib/rbcodec/codecs/vgm.c", 1942 1253 "lib/rbcodec/codecs/libgme/resampler.c", 1943 1254 "lib/rbcodec/codecs/libgme/vgm_emu.c", ··· 1947 1258 "lib/rbcodec/codecs/libgme/inflate/mallocer.c", 1948 1259 "lib/rbcodec/codecs/libgme/inflate/mbreader.c", 1949 1260 }, 1950 - .flags = &cflags, 1951 - }); 1952 - 1953 - libvgm.defineCMacro("CODEC", null); 1954 - defineCMacros(libvgm); 1955 - addIncludePaths(libvgm); 1956 - 1957 - const vgm_codec = b.addSharedLibrary(.{ 1958 - .name = "vgm", 1959 - .target = target, 1960 - .optimize = optimize, 1961 - }); 1962 - 1963 - b.installArtifact(vgm_codec); 1964 - 1965 - vgm_codec.addCSourceFiles(.{ 1966 - .files = &[_][]const u8{ 1967 - "lib/rbcodec/codecs/codec_crt0.c", 1261 + .link_libraries = &[_]*std.Build.Step.Compile{ 1262 + libcodec, 1263 + libfixedpoint, 1968 1264 }, 1969 - .flags = &cflags, 1970 1265 }); 1971 1266 1972 - vgm_codec.defineCMacro("CODEC", null); 1973 - defineCMacros(vgm_codec); 1974 - addIncludePaths(vgm_codec); 1975 - 1976 - vgm_codec.linkLibrary(libcodec); 1977 - vgm_codec.linkLibrary(libvgm); 1978 - vgm_codec.linkLibrary(libfixedpoint); 1979 - 1980 1267 //const sid = b.addStaticLibrary(.{ 1981 1268 // .name = "cRSID", 1982 1269 // .target = target, ··· 1997 1284 // defineCMacros(sid); 1998 1285 // addIncludePaths(sid); 1999 1286 2000 - defineCMacros(exe); 2001 - addIncludePaths(exe); 2002 - 2003 - const libkss = b.addStaticLibrary(.{ 1287 + build_codec(b, .{ 2004 1288 .name = "kss", 2005 1289 .target = target, 2006 1290 .optimize = optimize, 2007 - }); 2008 - 2009 - b.installArtifact(libkss); 2010 - 2011 - libkss.addCSourceFiles(.{ 2012 - .files = &[_][]const u8{ 1291 + .sources = &[_][]const u8{ 2013 1292 "lib/rbcodec/codecs/kss.c", 2014 1293 "lib/rbcodec/codecs/libgme/kss_cpu.c", 2015 1294 "lib/rbcodec/codecs/libgme/kss_emu.c", ··· 2018 1297 "lib/rbcodec/codecs/libgme/emu8950.c", 2019 1298 "lib/rbcodec/codecs/libgme/emuadpcm.c", 2020 1299 }, 2021 - .flags = &cflags, 2022 - }); 2023 - 2024 - libkss.defineCMacro("CODEC", null); 2025 - defineCMacros(libkss); 2026 - addIncludePaths(libkss); 2027 - 2028 - const kss_codec = b.addSharedLibrary(.{ 2029 - .name = "kss", 2030 - .target = target, 2031 - .optimize = optimize, 2032 - }); 2033 - 2034 - b.installArtifact(kss_codec); 2035 - 2036 - kss_codec.addCSourceFiles(.{ 2037 - .files = &[_][]const u8{ 2038 - "lib/rbcodec/codecs/codec_crt0.c", 1300 + .link_libraries = &[_]*std.Build.Step.Compile{ 1301 + libcodec, 1302 + libfixedpoint, 2039 1303 }, 2040 - .flags = &cflags, 2041 1304 }); 2042 1305 2043 - kss_codec.defineCMacro("CODEC", null); 2044 - defineCMacros(kss_codec); 2045 - addIncludePaths(kss_codec); 2046 - 2047 - kss_codec.linkLibrary(libcodec); 2048 - kss_codec.linkLibrary(libkss); 2049 - kss_codec.linkLibrary(libfixedpoint); 2050 - 2051 - const aac_bsf = b.addStaticLibrary(.{ 1306 + build_codec(b, .{ 2052 1307 .name = "aac_bsf", 2053 1308 .target = target, 2054 1309 .optimize = optimize, 2055 - }); 2056 - 2057 - b.installArtifact(aac_bsf); 2058 - 2059 - aac_bsf.addCSourceFiles(.{ 2060 - .files = &[_][]const u8{ 1310 + .sources = &[_][]const u8{ 2061 1311 "lib/rbcodec/codecs/aac_bsf.c", 2062 1312 }, 2063 - .flags = &cflags, 2064 - }); 2065 - 2066 - aac_bsf.defineCMacro("CODEC", null); 2067 - defineCMacros(aac_bsf); 2068 - addIncludePaths(aac_bsf); 2069 - 2070 - const aac_bsf_codec = b.addSharedLibrary(.{ 2071 - .name = "aac_bsf", 2072 - .target = target, 2073 - .optimize = optimize, 2074 - }); 2075 - 2076 - b.installArtifact(aac_bsf_codec); 2077 - 2078 - aac_bsf_codec.addCSourceFiles(.{ 2079 - .files = &[_][]const u8{ 2080 - "lib/rbcodec/codecs/codec_crt0.c", 1313 + .link_libraries = &[_]*std.Build.Step.Compile{ 1314 + libcodec, 1315 + libfixedpoint, 2081 1316 }, 2082 - .flags = &cflags, 2083 1317 }); 2084 - 2085 - aac_bsf_codec.defineCMacro("CODEC", null); 2086 - defineCMacros(aac_bsf_codec); 2087 - addIncludePaths(aac_bsf_codec); 2088 - 2089 - aac_bsf_codec.linkLibrary(libcodec); 2090 - aac_bsf_codec.linkLibrary(aac_bsf); 2091 - aac_bsf_codec.linkLibrary(libfixedpoint); 2092 1318 2093 1319 const libplugin = b.addStaticLibrary(.{ 2094 1320 .name = "plugin", ··· 2224 1450 defineCMacros(libpluginbitmaps); 2225 1451 addPluginIncludePaths(libpluginbitmaps); 2226 1452 2227 - const chopper = b.addSharedLibrary(.{ 1453 + build_plugin(b, .{ 2228 1454 .name = "chopper", 2229 1455 .target = target, 2230 1456 .optimize = optimize, 2231 - .strip = true, 2232 - }); 2233 - 2234 - b.installArtifact(chopper); 2235 - 2236 - chopper.addCSourceFiles(.{ 2237 - .files = &[_][]const u8{ 1457 + .sources = &[_][]const u8{ 2238 1458 "apps/plugins/chopper.c", 2239 1459 "apps/plugins/plugin_crt0.c", 2240 1460 }, 2241 - .flags = &cflags, 1461 + .link_libraries = &[_]*std.Build.Step.Compile{ 1462 + libplugin, 1463 + libpluginbitmaps, 1464 + libfixedpoint, 1465 + }, 2242 1466 }); 2243 1467 2244 - chopper.defineCMacro("PLUGIN", null); 2245 - defineCMacros(chopper); 2246 - addPluginIncludePaths(chopper); 2247 - 2248 - chopper.linkLibrary(libplugin); 2249 - chopper.linkLibrary(libpluginbitmaps); 2250 - chopper.linkLibrary(libfixedpoint); 2251 - 2252 - const clix = b.addSharedLibrary(.{ 1468 + build_plugin(b, .{ 2253 1469 .name = "clix", 2254 1470 .target = target, 2255 1471 .optimize = optimize, 2256 - .strip = true, 2257 - }); 2258 - 2259 - b.installArtifact(clix); 2260 - 2261 - clix.addCSourceFiles(.{ 2262 - .files = &[_][]const u8{ 1472 + .sources = &[_][]const u8{ 2263 1473 "apps/plugins/clix.c", 2264 1474 "apps/plugins/plugin_crt0.c", 2265 1475 }, 2266 - .flags = &cflags, 1476 + .link_libraries = &[_]*std.Build.Step.Compile{ 1477 + libplugin, 1478 + libpluginbitmaps, 1479 + libfixedpoint, 1480 + }, 2267 1481 }); 2268 1482 2269 - clix.defineCMacro("PLUGIN", null); 2270 - defineCMacros(clix); 2271 - addPluginIncludePaths(clix); 2272 - 2273 - clix.linkLibrary(libplugin); 2274 - clix.linkLibrary(libpluginbitmaps); 2275 - clix.linkLibrary(libfixedpoint); 2276 - 2277 - const credits = b.addSharedLibrary(.{ 1483 + build_plugin(b, .{ 2278 1484 .name = "credits", 2279 1485 .target = target, 2280 1486 .optimize = optimize, 2281 - .strip = true, 2282 - }); 2283 - 2284 - b.installArtifact(credits); 2285 - 2286 - credits.addCSourceFiles(.{ 2287 - .files = &[_][]const u8{ 1487 + .sources = &[_][]const u8{ 2288 1488 "apps/plugins/credits.c", 2289 1489 "apps/plugins/plugin_crt0.c", 2290 1490 }, 2291 - .flags = &cflags, 1491 + .link_libraries = &[_]*std.Build.Step.Compile{ 1492 + libplugin, 1493 + libpluginbitmaps, 1494 + libfixedpoint, 1495 + }, 2292 1496 }); 2293 1497 2294 - credits.defineCMacro("PLUGIN", null); 2295 - defineCMacros(credits); 2296 - addPluginIncludePaths(credits); 2297 - 2298 - credits.linkLibrary(libplugin); 2299 - credits.linkLibrary(libpluginbitmaps); 2300 - credits.linkLibrary(libfixedpoint); 1498 + defineCMacros(exe); 1499 + addIncludePaths(exe); 2301 1500 2302 1501 exe.linkLibrary(libfirmware); 2303 1502 exe.linkLibrary(libspeex_voice); ··· 2309 1508 exe.linkLibC(); 2310 1509 } 2311 1510 1511 + fn build_codec(b: *std.Build, options: BuildOptions) void { 1512 + const codec_lib = b.addStaticLibrary(.{ 1513 + .name = options.name, 1514 + .target = options.target, 1515 + .optimize = options.optimize, 1516 + }); 1517 + 1518 + b.installArtifact(codec_lib); 1519 + 1520 + codec_lib.addCSourceFiles(.{ 1521 + .files = options.sources, 1522 + .flags = options.cflags, 1523 + }); 1524 + 1525 + for (options.macros) |macro| { 1526 + codec_lib.defineCMacro(macro, null); 1527 + } 1528 + 1529 + defineCMacros(codec_lib); 1530 + addIncludePaths(codec_lib); 1531 + 1532 + const codec = b.addSharedLibrary(.{ 1533 + .name = options.name, 1534 + .target = options.target, 1535 + .optimize = options.optimize, 1536 + }); 1537 + 1538 + b.installArtifact(codec); 1539 + 1540 + codec.addCSourceFiles(.{ 1541 + .files = &[_][]const u8{ 1542 + "lib/rbcodec/codecs/codec_crt0.c", 1543 + }, 1544 + .flags = options.cflags, 1545 + }); 1546 + 1547 + for (options.macros) |macro| { 1548 + codec.defineCMacro(macro, null); 1549 + } 1550 + defineCMacros(codec); 1551 + addIncludePaths(codec); 1552 + 1553 + for (options.link_libraries) |lib| { 1554 + codec.linkLibrary(lib); 1555 + } 1556 + codec.linkLibrary(codec_lib); 1557 + } 1558 + 1559 + fn build_plugin(b: *std.Build, options: BuildOptions) void { 1560 + const plugin = b.addSharedLibrary(.{ 1561 + .name = options.name, 1562 + .target = options.target, 1563 + .optimize = options.optimize, 1564 + .strip = true, 1565 + }); 1566 + 1567 + b.installArtifact(plugin); 1568 + 1569 + plugin.addCSourceFiles(.{ 1570 + .files = options.sources, 1571 + .flags = &cflags, 1572 + }); 1573 + 1574 + plugin.defineCMacro("PLUGIN", null); 1575 + defineCMacros(plugin); 1576 + addPluginIncludePaths(plugin); 1577 + 1578 + for (options.link_libraries) |lib| { 1579 + plugin.linkLibrary(lib); 1580 + } 1581 + } 1582 + 2312 1583 fn defineCMacros(c: *std.Build.Step.Compile) void { 2313 1584 c.defineCMacro("_USE_MISC", null); 2314 1585 c.defineCMacro("ROCKBOX", null); ··· 2325 1596 c.defineCMacro("_REENTRANT", null); 2326 1597 } 2327 1598 1599 + fn addOpusIncludePaths(c: *std.Build.Step.Compile) void { 1600 + c.addIncludePath(.{ .cwd_relative = "/usr/include" }); 1601 + c.addIncludePath(.{ .cwd_relative = "/usr/include/x86_64-linux-gnu" }); 1602 + c.addIncludePath(.{ .cwd_relative = "./firmware/export" }); 1603 + c.addIncludePath(.{ .cwd_relative = "./firmware/drivers" }); 1604 + c.addIncludePath(.{ .cwd_relative = "./build" }); 1605 + c.addIncludePath(.{ .cwd_relative = "./firmware/include" }); 1606 + c.addIncludePath(.{ .cwd_relative = "./firmware/target/hosted/sdl" }); 1607 + c.addIncludePath(.{ .cwd_relative = "./firmware/target/hosted" }); 1608 + c.addIncludePath(.{ .cwd_relative = "./firmware/target/hosted/sdl/app" }); 1609 + c.addIncludePath(.{ .cwd_relative = "./apps" }); 1610 + c.addIncludePath(.{ .cwd_relative = "./apps/gui" }); 1611 + c.addIncludePath(.{ .cwd_relative = "./apps/recorder" }); 1612 + c.addIncludePath(.{ .cwd_relative = "./lib/rbcodec" }); 1613 + c.addIncludePath(.{ .cwd_relative = "./lib/rbcodec/metadata" }); 1614 + c.addIncludePath(.{ .cwd_relative = "./firmware/kernel/include" }); 1615 + c.addIncludePath(.{ .cwd_relative = "./firmware" }); 1616 + c.addIncludePath(.{ .cwd_relative = "./firmware/asm" }); 1617 + c.addIncludePath(.{ .cwd_relative = "./lib/rbcodec/dsp" }); 1618 + c.addIncludePath(.{ .cwd_relative = "./lib/rbcodec/codecs" }); 1619 + c.addIncludePath(.{ .cwd_relative = "./lib/skin_parser" }); 1620 + c.addIncludePath(.{ .cwd_relative = "./build/lang" }); 1621 + c.addIncludePath(.{ .cwd_relative = "./lib/skin_parser" }); 1622 + c.addIncludePath(.{ .cwd_relative = "./apps/gui/skin_engine" }); 1623 + c.addIncludePath(.{ .cwd_relative = "./lib/fixedpoint" }); 1624 + c.addIncludePath(.{ .cwd_relative = "./lib/rbcodec/codecs/lib" }); 1625 + c.addIncludePath(.{ .cwd_relative = "./lib/rbcodec/codecs/libopus" }); 1626 + } 1627 + 2328 1628 fn addIncludePaths(c: *std.Build.Step.Compile) void { 2329 1629 c.addIncludePath(.{ .cwd_relative = "/usr/include" }); 2330 1630 c.addIncludePath(.{ .cwd_relative = "/usr/include/x86_64-linux-gnu" }); ··· 2341 1641 c.addIncludePath(.{ .cwd_relative = "./apps/recorder" }); 2342 1642 c.addIncludePath(.{ .cwd_relative = "./lib/rbcodec" }); 2343 1643 c.addIncludePath(.{ .cwd_relative = "./lib/rbcodec/metadata" }); 2344 - c.addIncludePath(.{ .cwd_relative = "./lib/rbcodec/codecs/libspeex" }); 2345 1644 c.addIncludePath(.{ .cwd_relative = "./firmware/kernel/include" }); 2346 1645 c.addIncludePath(.{ .cwd_relative = "./firmware" }); 2347 1646 c.addIncludePath(.{ .cwd_relative = "./firmware/asm" }); ··· 2355 1654 c.addIncludePath(.{ .cwd_relative = "./lib/rbcodec/codecs/lib" }); 2356 1655 c.addIncludePath(.{ .cwd_relative = "./lib/tlsf/src" }); 2357 1656 c.addIncludePath(.{ .cwd_relative = "./apps/plugins" }); 2358 - c.addIncludePath(.{ .cwd_relative = "./lib/rbcodec/codecs/libfaad" }); 2359 1657 c.addIncludePath(.{ .cwd_relative = "./uisimulator/common" }); 2360 1658 c.addIncludePath(.{ .cwd_relative = "./lib/rbcodec/codecs/libopus" }); 2361 - c.addIncludePath(.{ .cwd_relative = "./lib/rbcodec/codecs/libopus/celt" }); 2362 - c.addIncludePath(.{ .cwd_relative = "./lib/rbcodec/codecs/libopus/silk" }); 2363 1659 c.addIncludePath(.{ .cwd_relative = "./lib/rbcodec/codecs/libtremor" }); 2364 1660 c.addIncludePath(.{ .cwd_relative = "./lib/rbcodec/codecs/libm4a" }); 2365 1661 c.addIncludePath(.{ .cwd_relative = "./lib/rbcodec/codecs/libcook" }); 2366 - c.addIncludePath(.{ .cwd_relative = "./lib/rbcodec/codecs/libfaad" }); 2367 1662 c.addIncludePath(.{ .cwd_relative = "./lib/rbcodec/codecs/libatrac" }); 2368 1663 c.addIncludePath(.{ .cwd_relative = "./lib/rbcodec/codecs/libmusepack" }); 2369 1664 c.addIncludePath(.{ .cwd_relative = "./lib/rbcodec/codecs/libtta" });

lib/rbcodec/codecs/opus.c

··· 38 38 39 39 #define SEEK_REWIND 3840 /* 80 ms @ 48 kHz */ 40 40 41 + #ifndef MIN 42 + #define MIN(a,b) ((a)<(b) ? (a):(b)) 43 + #endif 44 + 41 45 /* the opus pseudo stack pointer */ 42 46 extern char *global_stack; 43 47