Skip to content

Distribute and run LLMs with a single file.

chore: integrate whisper.cpp as a submodule (#813)

Nathan Brake1a5d1c2e5bc9
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 575b413a..b57a86ba 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -14,12 +14,19 @@ jobs:
- name: Clone
id: checkout
uses: actions/checkout@v4
+ - name: Initialize submodules # <-- ADD THIS STEP
+ run: |
+ git submodule update --init --recursive
- name: Dependencies
id: depends
run: |
sudo apt-get update
- sudo apt-get install make
+ sudo apt-get install make patch
+
+ - name: Apply whisper.cpp patches
+ run: |
+ bash whisper.cpp.patches/apply-patches.sh
- name: Cache cosmocc toolchain
id: cache-cosmocc-toolchain
diff --git a/.gitmodules b/.gitmodules
new file mode 100644
index 00000000..0914618c
--- /dev/null
+++ b/.gitmodules
@@ -0,0 +1,3 @@
+[submodule "whisper.cpp"]
+ path = whisper.cpp
+ url = https://github.com/ggerganov/whisper.cpp.git
diff --git a/Makefile b/Makefile
index a11e1790..8071b41d 100644
--- a/Makefile
+++ b/Makefile
@@ -8,6 +8,8 @@ MAKEFLAGS += --no-builtin-rules
.DELETE_ON_ERROR:
.FEATURES: output-sync
+# setup target needs to run before build/config.mk checks make version
+ifneq ($(MAKECMDGOALS),setup)
include build/config.mk
include build/rules.mk
@@ -17,6 +19,7 @@ include llama.cpp/BUILD.mk
include stable-diffusion.cpp/BUILD.mk
include whisper.cpp/BUILD.mk
include localscore/BUILD.mk
+endif
# the root package is `o//` by default
# building a package also builds its sub-packages
@@ -85,5 +88,20 @@ cosmocc: $(COSMOCC) # cosmocc toolchain setup
.PHONY: cosmocc-ci
cosmocc-ci: $(COSMOCC) $(PREFIX)/bin/ape # cosmocc toolchain setup in ci context
+.PHONY: setup
+setup: # Initialize and configure all dependencies (submodules, patches, etc.)
+ @echo "Setting up dependencies..."
+ @mkdir -p o/tmp
+ @if [ ! -f whisper.cpp/.git ]; then \
+ echo "Initializing whisper.cpp submodule..."; \
+ git submodule update --init whisper.cpp; \
+ fi
+ @echo "Applying whisper.cpp patches..."
+ @export TMPDIR=$$(pwd)/o/tmp && ./whisper.cpp.patches/apply-patches.sh
+ @echo "Setup complete!"
+
+
+ifneq ($(MAKECMDGOALS),setup)
include build/deps.mk
include build/tags.mk
+endif
diff --git a/README.md b/README.md
index 864a081d..ccdceffa 100644
--- a/README.md
+++ b/README.md
@@ -485,6 +485,21 @@ will be used to build it), `wget` (or `curl`), and `unzip` available at
[https://cosmo.zip/pub/cosmos/bin/](https://cosmo.zip/pub/cosmos/bin/).
Windows users need [cosmos bash](https://justine.lol/cosmo3/) shell too.
+### Dependency Setup
+
+Some dependencies are managed as git submodules with
+llamafile-specific patches. Before building, you need to initialize and
+configure these dependencies:
+
+```sh
+make setup
+```
+
+The patches modify dependencies. These modifications remain as local
+changes in the submodule working directories.
+
+### Building
+
```sh
make -j8
sudo make install PREFIX=/usr/local
diff --git a/RELEASE.md b/RELEASE.md
index 76a1c5a1..f3a85f76 100644
--- a/RELEASE.md
+++ b/RELEASE.md
@@ -6,7 +6,19 @@ The two primary artifacts of the release are the `llamafile-<version>.zip` and t
## Release Process
-Note: Step 2 and 3 are only needed if you are making a new release of the ggml-cuda.so and ggml-rocm.so shared libraries. You only need to do this when you are making changes to the CUDA code or the API's surrounding it. Otherwise you can use the previous release of the shared libraries.
+Note: Steps 2 and 3 are only needed if you are making a new release of the ggml-cuda.so and ggml-rocm.so shared libraries. You only need to do this when you are making changes to the CUDA code or the API's surrounding it. Otherwise you can use the previous release of the shared libraries.
+
+### Preparing the Build Environment
+
+Before building, ensure all dependencies are initialized and configured:
+
+```sh
+make setup
+```
+
+This initializes git submodules (e.g., whisper.cpp) and applies llamafile patches. The patches integrate dependencies with llamafile's build system and add llamafile-specific functionality.
+
+### Release Steps
1. Update the version number in `version.h`
2. Build the ggml-cuda.so and ggml-rocm.so shared libraries on Linux. You need to do this for Llamafile and LocalScore. Llamafile uses TINYBLAS as a default and LocalScore uses CUBLAS as a default for CUDA.
@@ -126,4 +138,4 @@ You can use the script to create the appropriately named binaries:
`./llamafile/release.sh -v <version> -s <source_dir> -d <dest_dir>`
-Make sure to move the llamafile-<version>.zip file to the <dest_dir> as well, and you are good to release after you've tested.
\ No newline at end of file
+Make sure to move the llamafile-<version>.zip file to the <dest_dir> as well, and you are good to release after you've tested.
diff --git a/whisper.cpp b/whisper.cpp
new file mode 160000
index 00000000..6739eb83
--- /dev/null
+++ b/whisper.cpp
@@ -0,0 +1 @@
+Subproject commit 6739eb83c3ca5cf40d24c6fe8442a761a1eb6248
diff --git a/whisper.cpp.patches/apply-patches.sh b/whisper.cpp.patches/apply-patches.sh
new file mode 100755
index 00000000..e1802d62
--- /dev/null
+++ b/whisper.cpp.patches/apply-patches.sh
@@ -0,0 +1,106 @@
+#!/bin/bash
+# Apply llamafile patches to whisper.cpp submodule
+
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+WHISPER_DIR="$SCRIPT_DIR/../whisper.cpp"
+PATCHES_DIR="$SCRIPT_DIR/patches"
+LLAMAFILE_FILES_DIR="$SCRIPT_DIR/llamafile-files"
+
+cd "$WHISPER_DIR"
+
+# Check if patches are already applied
+if [ -f "BUILD.mk" ]; then
+ echo "Patches appear to be already applied. Skipping..."
+ exit 0
+fi
+
+echo "Applying patches to whisper.cpp submodule..."
+
+# Step 1: Apply patches to modify files in their original locations
+echo "Applying modifications to upstream files..."
+for patch_file in "$PATCHES_DIR"/*.patch; do
+ if [ -f "$patch_file" ]; then
+ echo "Applying $(basename "$patch_file")..."
+ patch -p0 < "$patch_file"
+ fi
+done
+
+# Step 2: Copy modified files from their original locations to root
+echo "Copying modified files to root directory..."
+cp examples/server/server.cpp .
+cp examples/common.cpp .
+cp examples/common.h .
+cp examples/main/main.cpp .
+cp examples/stream/stream.cpp .
+cp examples/grammar-parser.cpp .
+cp examples/grammar-parser.h .
+cp examples/dr_wav.h .
+cp examples/server/httplib.h .
+cp src/whisper.cpp .
+cp src/whisper-mel-cuda.cu .
+cp include/whisper.h .
+
+# Step 3: Copy new llamafile-specific files to root
+echo "Copying llamafile-specific files..."
+cp "$LLAMAFILE_FILES_DIR/BUILD.mk" .
+cp "$LLAMAFILE_FILES_DIR/README.llamafile" .
+cp "$LLAMAFILE_FILES_DIR/README.md" .
+# Copy header files, excluding those that were patched
+for file in "$LLAMAFILE_FILES_DIR"/*.h; do
+ [ -f "$file" ] || continue
+ filename=$(basename "$file")
+ if [ "$filename" != "common.h" ] && [ "$filename" != "whisper.h" ] && \
+ [ "$filename" != "grammar-parser.h" ] && [ "$filename" != "dr_wav.h" ] && \
+ [ "$filename" != "httplib.h" ]; then
+ cp "$file" .
+ fi
+done
+cp "$LLAMAFILE_FILES_DIR"/*.c . 2>/dev/null || true
+# Copy cpp files, excluding those that were patched
+for file in "$LLAMAFILE_FILES_DIR"/*.cpp; do
+ [ -f "$file" ] || continue
+ filename=$(basename "$file")
+ if [ "$filename" != "common.cpp" ] && [ "$filename" != "server.cpp" ] && \
+ [ "$filename" != "whisper.cpp" ] && [ "$filename" != "main.cpp" ] && \
+ [ "$filename" != "stream.cpp" ] && [ "$filename" != "grammar-parser.cpp" ]; then
+ cp "$file" .
+ fi
+done
+cp "$LLAMAFILE_FILES_DIR"/*.hpp . 2>/dev/null || true
+# Don't copy .cu files since whisper-mel-cuda.cu is now patched
+cp "$LLAMAFILE_FILES_DIR/main.1" .
+cp "$LLAMAFILE_FILES_DIR/main.1.asc" .
+cp "$LLAMAFILE_FILES_DIR/jfk.wav" .
+cp -r "$LLAMAFILE_FILES_DIR/doc" .
+
+# Step 4: Remove unnecessary files and directories
+echo "Removing unnecessary files and directories..."
+rm -rf bindings
+rm -rf .github
+rm -rf .devops
+rm -rf examples
+rm -rf ggml
+rm -rf src
+rm -rf include
+rm -rf tests
+rm -rf scripts
+rm -rf spm-headers
+rm -rf cmake
+rm -rf models
+rm -rf samples
+rm -rf grammars
+rm -f .gitignore
+rm -f .gitmodules
+rm -f Package.swift
+rm -f README_sycl.md
+rm -f AUTHORS
+rm -f CMakeLists.txt
+rm -f Makefile
+
+echo ""
+echo "Patches applied successfully!"
+echo "Note: These changes are not committed to the submodule."
+echo "To reset the submodule to its clean state, run:"
+echo " cd whisper.cpp && git reset --hard && git clean -fd"
diff --git a/whisper.cpp/BUILD.mk b/whisper.cpp.patches/llamafile-files/BUILD.mk
similarity index 100%
rename from whisper.cpp/BUILD.mk
rename to whisper.cpp.patches/llamafile-files/BUILD.mk
diff --git a/whisper.cpp/README.llamafile b/whisper.cpp.patches/llamafile-files/README.llamafile
similarity index 100%
rename from whisper.cpp/README.llamafile
rename to whisper.cpp.patches/llamafile-files/README.llamafile
diff --git a/whisper.cpp/README.md b/whisper.cpp.patches/llamafile-files/README.md
similarity index 100%
rename from whisper.cpp/README.md
rename to whisper.cpp.patches/llamafile-files/README.md
diff --git a/whisper.cpp/color.cpp b/whisper.cpp.patches/llamafile-files/color.cpp
similarity index 100%
rename from whisper.cpp/color.cpp
rename to whisper.cpp.patches/llamafile-files/color.cpp
diff --git a/whisper.cpp/color.h b/whisper.cpp.patches/llamafile-files/color.h
similarity index 100%
rename from whisper.cpp/color.h
rename to whisper.cpp.patches/llamafile-files/color.h
diff --git a/whisper.cpp/doc/getting-started.md b/whisper.cpp.patches/llamafile-files/doc/getting-started.md
similarity index 100%
rename from whisper.cpp/doc/getting-started.md
rename to whisper.cpp.patches/llamafile-files/doc/getting-started.md
diff --git a/whisper.cpp/doc/gpu.md b/whisper.cpp.patches/llamafile-files/doc/gpu.md
similarity index 100%
rename from whisper.cpp/doc/gpu.md
rename to whisper.cpp.patches/llamafile-files/doc/gpu.md
diff --git a/whisper.cpp/doc/index.md b/whisper.cpp.patches/llamafile-files/doc/index.md
similarity index 100%
rename from whisper.cpp/doc/index.md
rename to whisper.cpp.patches/llamafile-files/doc/index.md
diff --git a/whisper.cpp/doc/packaging.md b/whisper.cpp.patches/llamafile-files/doc/packaging.md
similarity index 100%
rename from whisper.cpp/doc/packaging.md
rename to whisper.cpp.patches/llamafile-files/doc/packaging.md
diff --git a/whisper.cpp/doc/server.md b/whisper.cpp.patches/llamafile-files/doc/server.md
similarity index 100%
rename from whisper.cpp/doc/server.md
rename to whisper.cpp.patches/llamafile-files/doc/server.md
diff --git a/whisper.cpp/doc/translate.md b/whisper.cpp.patches/llamafile-files/doc/translate.md
similarity index 100%
rename from whisper.cpp/doc/translate.md
rename to whisper.cpp.patches/llamafile-files/doc/translate.md
diff --git a/whisper.cpp/dr_wav.c b/whisper.cpp.patches/llamafile-files/dr_wav.c
similarity index 100%
rename from whisper.cpp/dr_wav.c
rename to whisper.cpp.patches/llamafile-files/dr_wav.c
diff --git a/whisper.cpp/ggml_extend.hpp b/whisper.cpp.patches/llamafile-files/ggml_extend.hpp
similarity index 100%
rename from whisper.cpp/ggml_extend.hpp
rename to whisper.cpp.patches/llamafile-files/ggml_extend.hpp
diff --git a/whisper.cpp/jfk.wav b/whisper.cpp.patches/llamafile-files/jfk.wav
similarity index 100%
rename from whisper.cpp/jfk.wav
rename to whisper.cpp.patches/llamafile-files/jfk.wav
diff --git a/whisper.cpp/main.1 b/whisper.cpp.patches/llamafile-files/main.1
similarity index 100%
rename from whisper.cpp/main.1
rename to whisper.cpp.patches/llamafile-files/main.1
diff --git a/whisper.cpp/main.1.asc b/whisper.cpp.patches/llamafile-files/main.1.asc
similarity index 100%
rename from whisper.cpp/main.1.asc
rename to whisper.cpp.patches/llamafile-files/main.1.asc
diff --git a/whisper.cpp/mic2raw.cpp b/whisper.cpp.patches/llamafile-files/mic2raw.cpp
similarity index 100%
rename from whisper.cpp/mic2raw.cpp
rename to whisper.cpp.patches/llamafile-files/mic2raw.cpp
diff --git a/whisper.cpp/mic2txt.cpp b/whisper.cpp.patches/llamafile-files/mic2txt.cpp
similarity index 100%
rename from whisper.cpp/mic2txt.cpp
rename to whisper.cpp.patches/llamafile-files/mic2txt.cpp
diff --git a/whisper.cpp/miniaudio.c b/whisper.cpp.patches/llamafile-files/miniaudio.c
similarity index 100%
rename from whisper.cpp/miniaudio.c
rename to whisper.cpp.patches/llamafile-files/miniaudio.c
diff --git a/whisper.cpp/miniaudio.h b/whisper.cpp.patches/llamafile-files/miniaudio.h
similarity index 100%
rename from whisper.cpp/miniaudio.h
rename to whisper.cpp.patches/llamafile-files/miniaudio.h
diff --git a/whisper.cpp/slurp.cpp b/whisper.cpp.patches/llamafile-files/slurp.cpp
similarity index 100%
rename from whisper.cpp/slurp.cpp
rename to whisper.cpp.patches/llamafile-files/slurp.cpp
diff --git a/whisper.cpp/slurp.h b/whisper.cpp.patches/llamafile-files/slurp.h
similarity index 100%
rename from whisper.cpp/slurp.h
rename to whisper.cpp.patches/llamafile-files/slurp.h
diff --git a/whisper.cpp/whisper-mel-cuda.hpp b/whisper.cpp.patches/llamafile-files/whisper-mel-cuda.hpp
similarity index 100%
rename from whisper.cpp/whisper-mel-cuda.hpp
rename to whisper.cpp.patches/llamafile-files/whisper-mel-cuda.hpp
diff --git a/whisper.cpp/whisper-mel.hpp b/whisper.cpp.patches/llamafile-files/whisper-mel.hpp
similarity index 100%
rename from whisper.cpp/whisper-mel.hpp
rename to whisper.cpp.patches/llamafile-files/whisper-mel.hpp
diff --git a/whisper.cpp.patches/patches/001-server-llamafile-integration.patch b/whisper.cpp.patches/patches/001-server-llamafile-integration.patch
new file mode 100644
index 00000000..ffaa1add
--- /dev/null
+++ b/whisper.cpp.patches/patches/001-server-llamafile-integration.patch
@@ -0,0 +1,307 @@
+--- examples/server/server.cpp 2025-10-31 16:34:53
++++ ../non_submodule_llamafile/whisper.cpp/server.cpp 2025-10-31 16:53:51
+@@ -1,9 +1,14 @@
++// -*- mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8 -*-
++// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
++#include "llamafile/debug.h"
+ #include "common.h"
++#include "slurp.h"
+
+ #include "whisper.h"
+ #include "httplib.h"
+-#include "json.hpp"
++#include "llama.cpp/json.h"
+
++#include <cosmo.h>
+ #include <cmath>
+ #include <fstream>
+ #include <cstdio>
+@@ -12,6 +17,7 @@
+ #include <vector>
+ #include <cstring>
+ #include <sstream>
++#include <chrono>
+
+ #if defined(_MSC_VER)
+ #pragma warning(disable: 4244 4267) // possible loss of data
+@@ -39,8 +45,6 @@
+ int32_t port = 8080;
+ int32_t read_timeout = 600;
+ int32_t write_timeout = 600;
+-
+- bool ffmpeg_converter = false;
+ };
+
+ struct whisper_params {
+@@ -74,7 +78,6 @@
+ bool print_realtime = false;
+ bool print_progress = false;
+ bool no_timestamps = false;
+- bool use_gpu = true;
+ bool flash_attn = false;
+
+ std::string language = "en";
+@@ -134,7 +137,8 @@
+ fprintf(stderr, " --public PATH, [%-7s] Path to the public folder\n", sparams.public_path.c_str());
+ fprintf(stderr, " --request-path PATH, [%-7s] Request path for all requests\n", sparams.request_path.c_str());
+ fprintf(stderr, " --inference-path PATH, [%-7s] Inference path for all requests\n", sparams.inference_path.c_str());
+- fprintf(stderr, " --convert, [%-7s] Convert audio to WAV, requires ffmpeg on the server", sparams.ffmpeg_converter ? "true" : "false");
++ fprintf(stderr, " --recompile [%-7s] Force GPU support to be recompiled at runtime if possible.\n", FLAG_recompile ? "true" : "false");
++ fprintf(stderr, " --nocompile [%-7s] Never compile GPU support at runtime.", FLAG_nocompile ? "true" : "false");
+ fprintf(stderr, "\n");
+ }
+
+@@ -142,6 +146,40 @@
+ for (int i = 1; i < argc; i++) {
+ std::string arg = argv[i];
+
++ if (arg == "--log-disable") {
++ FLAG_log_disable = true;
++ } else if (arg == "--cli") {
++ } else if (arg == "--server") {
++ } else if (arg == "--fast") {
++ FLAG_fast = true;
++ } else if (arg == "--precise") {
++ FLAG_precise = true;
++ } else if (arg == "--trace") {
++ FLAG_trace = true;
++ } else if (arg == "--trap") {
++ FLAG_trap = true;
++ FLAG_unsecure = true; // for better backtraces
++ llamafile_trapping_enabled(+1);
++ } else if (arg == "--unsecure") {
++ FLAG_unsecure = true;
++ } else if (arg == "--nocompile") {
++ FLAG_nocompile = true;
++ } else if (arg == "--recompile") {
++ FLAG_recompile = true;
++ } else if (arg == "--tinyblas") {
++ FLAG_tinyblas = true; // undocumented
++ } else if (arg == "--gpu") {
++ if (++i >= argc) {
++ fprintf(stderr, "error: missing --gpu flag value\n");
++ exit(1);
++ }
++ FLAG_gpu = llamafile_gpu_parse(argv[i]);
++ if (FLAG_gpu == LLAMAFILE_GPU_ERROR) {
++ fprintf(stderr, "error: invalid --gpu flag value: %s\n", argv[i]);
++ exit(1);
++ }
++ } else
++
+ if (arg == "-h" || arg == "--help") {
+ whisper_print_usage(argc, argv, params, sparams);
+ exit(0);
+@@ -177,22 +215,40 @@
+ else if (arg == "-m" || arg == "--model") { params.model = argv[++i]; }
+ else if (arg == "-oved" || arg == "--ov-e-device") { params.openvino_encode_device = argv[++i]; }
+ else if (arg == "-dtw" || arg == "--dtw") { params.dtw = argv[++i]; }
+- else if (arg == "-ng" || arg == "--no-gpu") { params.use_gpu = false; }
++ else if (arg == "-ng" || arg == "--no-gpu") { FLAG_gpu = LLAMAFILE_GPU_DISABLE; }
+ else if (arg == "-fa" || arg == "--flash-attn") { params.flash_attn = true; }
+ // server params
+ else if ( arg == "--port") { sparams.port = std::stoi(argv[++i]); }
+ else if ( arg == "--host") { sparams.hostname = argv[++i]; }
+ else if ( arg == "--public") { sparams.public_path = argv[++i]; }
+ else if ( arg == "--request-path") { sparams.request_path = argv[++i]; }
+- else if ( arg == "--inference-path") { sparams.inference_path = argv[++i]; }
+- else if ( arg == "--convert") { sparams.ffmpeg_converter = true; }
++ else if ( arg == "--recompile") { FLAG_recompile = true; }
++ else if ( arg == "--nocompile") { FLAG_nocompile = true; }
++ else if ( arg == "--tinyblas") { FLAG_tinyblas = true; }
++ else if ( arg == "--unsecure") { FLAG_unsecure = true; }
++
++ else if (arg == "--gpu") {
++ if (++i >= argc) {
++ fprintf(stderr, "error: missing --gpu flag value\n");
++ exit(1);
++ }
++ FLAG_gpu = llamafile_gpu_parse(argv[i]);
++ if (FLAG_gpu == LLAMAFILE_GPU_ERROR) {
++ fprintf(stderr, "error: invalid --gpu flag value: %s\n", argv[i]);
++ exit(1);
++ }
++ return true;
++ }
++
+ else {
+ fprintf(stderr, "error: unknown argument: %s\n", arg.c_str());
+- whisper_print_usage(argc, argv, params, sparams);
++ // whisper_print_usage(argc, argv, params, sparams); // [jart]
+ exit(0);
+ }
+ }
+
++ FLAGS_READY = true;
++
+ return true;
+ }
+
+@@ -203,45 +259,6 @@
+ int progress_prev;
+ };
+
+-void check_ffmpeg_availibility() {
+- int result = system("ffmpeg -version");
+-
+- if (result == 0) {
+- std::cout << "ffmpeg is available." << std::endl;
+- } else {
+- // ffmpeg is not available
+- std::cout << "ffmpeg is not found. Please ensure that ffmpeg is installed ";
+- std::cout << "and that its executable is included in your system's PATH. ";
+- exit(0);
+- }
+-}
+-
+-bool convert_to_wav(const std::string & temp_filename, std::string & error_resp) {
+- std::ostringstream cmd_stream;
+- std::string converted_filename_temp = temp_filename + "_temp.wav";
+- cmd_stream << "ffmpeg -i \"" << temp_filename << "\" -ar 16000 -ac 1 -c:a pcm_s16le \"" << converted_filename_temp << "\" 2>&1";
+- std::string cmd = cmd_stream.str();
+-
+- int status = std::system(cmd.c_str());
+- if (status != 0) {
+- error_resp = "{\"error\":\"FFmpeg conversion failed.\"}";
+- return false;
+- }
+-
+- // Remove the original file
+- if (remove(temp_filename.c_str()) != 0) {
+- error_resp = "{\"error\":\"Failed to remove the original file.\"}";
+- return false;
+- }
+-
+- // Rename the temporary file to match the original filename
+- if (rename(converted_filename_temp.c_str(), temp_filename.c_str()) != 0) {
+- error_resp = "{\"error\":\"Failed to rename the temporary file.\"}";
+- return false;
+- }
+- return true;
+-}
+-
+ std::string estimate_diarization_speaker(std::vector<std::vector<float>> pcmf32s, int64_t t0, int64_t t1, bool id_only = false) {
+ std::string speaker = "";
+ const int64_t n_samples = pcmf32s[0].size();
+@@ -476,7 +493,7 @@
+
+ } // namespace
+
+-int main(int argc, char ** argv) {
++int whisper_server_main(int argc, char ** argv) {
+ whisper_params params;
+ server_params sparams;
+
+@@ -499,13 +516,9 @@
+ exit(0);
+ }
+
+- if (sparams.ffmpeg_converter) {
+- check_ffmpeg_availibility();
+- }
+ // whisper init
+ struct whisper_context_params cparams = whisper_context_default_params();
+
+- cparams.use_gpu = params.use_gpu;
+ cparams.flash_attn = params.flash_attn;
+
+ if (!params.dtw.empty()) {
+@@ -674,43 +687,24 @@
+ std::vector<float> pcmf32; // mono-channel F32 PCM
+ std::vector<std::vector<float>> pcmf32s; // stereo-channel F32 PCM
+
+- if (sparams.ffmpeg_converter) {
+- // if file is not wav, convert to wav
+- // write to temporary file
+- const std::string temp_filename = "whisper_server_temp_file.wav";
+- std::ofstream temp_file{temp_filename, std::ios::binary};
+- temp_file << audio_file.content;
+- temp_file.close();
++ // write incoming buffer to temporary file
++ std::string temp_filename = __get_tmpdir();
++ temp_filename += "/whisperfile.";
++ temp_filename += std::to_string(_rand64());
+
+- std::string error_resp = "{\"error\":\"Failed to execute ffmpeg command.\"}";
+- const bool is_converted = convert_to_wav(temp_filename, error_resp);
+- if (!is_converted) {
+- res.set_content(error_resp, "application/json");
+- return;
+- }
++ std::ofstream temp_file{temp_filename, std::ios::binary};
++ temp_file << audio_file.content;
++ temp_file.close();
+
+- // read wav content into pcmf32
+- if (!::read_wav(temp_filename, pcmf32, pcmf32s, params.diarize))
+- {
+- fprintf(stderr, "error: failed to read WAV file '%s'\n", temp_filename.c_str());
+- const std::string error_resp = "{\"error\":\"failed to read WAV file\"}";
+- res.set_content(error_resp, "application/json");
+- std::remove(temp_filename.c_str());
+- return;
+- }
+- // remove temp file
+- std::remove(temp_filename.c_str());
+- } else {
+- if (!::read_wav(audio_file.content, pcmf32, pcmf32s, params.diarize))
+- {
+- fprintf(stderr, "error: failed to read WAV file\n");
+- const std::string error_resp = "{\"error\":\"failed to read WAV file\"}";
+- res.set_content(error_resp, "application/json");
+- return;
+- }
++ bool ok = slurp_audio_file(temp_filename.c_str(), pcmf32, pcmf32s, params.diarize);
++ unlink(temp_filename.c_str());
++ if (!ok) {
++ fprintf(stderr, "error: failed to read audio file\n");
++ const std::string error_resp = "{\"error\":\"failed to read audio file\"}";
++ res.set_content(error_resp, "application/json");
++ return;
+ }
+
+-
+ printf("Successfully loaded %s\n", filename.c_str());
+
+ // print system information
+@@ -745,6 +739,7 @@
+ }
+
+ // run the inference
++ float t_total;
+ {
+ printf("Running whisper.cpp inference on %s\n", filename.c_str());
+ whisper_full_params wparams = whisper_full_default_params(WHISPER_SAMPLING_GREEDY);
+@@ -823,12 +818,15 @@
+ wparams.abort_callback_user_data = &is_aborted;
+ }
+
++ // time the processing
++ auto t_start = std::chrono::high_resolution_clock::now();
+ if (whisper_full_parallel(ctx, wparams, pcmf32.data(), pcmf32.size(), params.n_processors) != 0) {
+ fprintf(stderr, "%s: failed to process audio\n", argv[0]);
+ const std::string error_resp = "{\"error\":\"failed to process audio\"}";
+ res.set_content(error_resp, "application/json");
+ return;
+ }
++ t_total = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now() - t_start).count();
+ }
+
+ // return results to user
+@@ -888,6 +886,7 @@
+ {"language", whisper_lang_str_full(whisper_full_lang_id(ctx))},
+ {"duration", float(pcmf32.size())/WHISPER_SAMPLE_RATE},
+ {"text", results},
++ {"transcribe_time", t_total},
+ {"segments", json::array()}
+ };
+ const int n_segments = whisper_full_n_segments(ctx);
+@@ -946,7 +945,7 @@
+ "application/json");
+ }
+
+- // reset params to their defaults
++ // reset params to thier defaults
+ params = default_params;
+ });
+ svr.Post(sparams.request_path + "/load", [&](const Request &req, Response &res){
diff --git a/whisper.cpp.patches/patches/002-common-cpp-llamafile-integration.patch b/whisper.cpp.patches/patches/002-common-cpp-llamafile-integration.patch
new file mode 100644
index 00000000..d1824081
--- /dev/null
+++ b/whisper.cpp.patches/patches/002-common-cpp-llamafile-integration.patch
@@ -0,0 +1,781 @@
+--- examples/common.cpp 2025-10-31 16:34:53
++++ ../non_submodule_llamafile/whisper.cpp/common.cpp 2025-10-31 16:53:51
+@@ -1,20 +1,16 @@
++// -*- mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8 -*-
++// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+ #define _USE_MATH_DEFINES // for M_PI
+
++#include "llamafile/log.h"
++#include "llamafile/llamafile.h"
+ #include "common.h"
+
+ // third-party utilities
+ // use your favorite implementations
+-#define DR_WAV_IMPLEMENTATION
++// #define DR_WAV_IMPLEMENTATION // [jart] comment out
+ #include "dr_wav.h"
+
+-#include <cmath>
+-#include <cstring>
+-#include <fstream>
+-#include <regex>
+-#include <locale>
+-#include <codecvt>
+-#include <sstream>
+-
+ #if defined(_MSC_VER)
+ #pragma warning(disable: 4244 4267) // possible loss of data
+ #endif
+@@ -24,729 +20,13 @@
+ #include <io.h>
+ #endif
+
+-#ifdef WHISPER_FFMPEG
+-// as implemented in ffmpeg_trancode.cpp only embedded in common lib if whisper built with ffmpeg support
+-extern bool ffmpeg_decode_audio(const std::string & ifname, std::vector<uint8_t> & wav_data);
+-#endif
+-
+-// Function to check if the next argument exists
+-static std::string get_next_arg(int& i, int argc, char** argv, const std::string& flag, gpt_params& params) {
+- if (i + 1 < argc && argv[i + 1][0] != '-') {
+- return argv[++i];
+- } else {
+- fprintf(stderr, "error: %s requires one argument.\n", flag.c_str());
+- gpt_print_usage(argc, argv, params);
+- exit(0);
+- }
+-}
+-
+-bool gpt_params_parse(int argc, char ** argv, gpt_params & params) {
+- for (int i = 1; i < argc; i++) {
+- std::string arg = argv[i];
+-
+- if (arg == "-s" || arg == "--seed") {
+- params.seed = std::stoi(get_next_arg(i, argc, argv, arg, params));
+- } else if (arg == "-t" || arg == "--threads") {
+- params.n_threads = std::stoi(get_next_arg(i, argc, argv, arg, params));
+- } else if (arg == "-p" || arg == "--prompt") {
+- params.prompt = get_next_arg(i, argc, argv, arg, params);
+- } else if (arg == "-n" || arg == "--n_predict") {
+- params.n_predict = std::stoi(get_next_arg(i, argc, argv, arg, params));
+- } else if (arg == "-np" || arg == "--n_parallel") {
+- params.n_parallel = std::stoi(get_next_arg(i, argc, argv, arg, params));
+- } else if (arg == "--top_k") {
+- params.top_k = std::stoi(get_next_arg(i, argc, argv, arg, params));
+- } else if (arg == "--top_p") {
+- params.top_p = std::stof(get_next_arg(i, argc, argv, arg, params));
+- } else if (arg == "--temp") {
+- params.temp = std::stof(get_next_arg(i, argc, argv, arg, params));
+- } else if (arg == "--repeat-last-n") {
+- params.repeat_last_n = std::stoi(get_next_arg(i, argc, argv, arg, params));
+- } else if (arg == "--repeat-penalty") {
+- params.repeat_penalty = std::stof(get_next_arg(i, argc, argv, arg, params));
+- } else if (arg == "-b" || arg == "--batch_size") {
+- params.n_batch= std::stoi(get_next_arg(i, argc, argv, arg, params));
+- } else if (arg == "-c" || arg == "--context") {
+- params.n_ctx= std::stoi(get_next_arg(i, argc, argv, arg, params));
+- } else if (arg == "-ngl" || arg == "--gpu-layers" || arg == "--n-gpu-layers") {
+- params.n_gpu_layers = std::stoi(get_next_arg(i, argc, argv, arg, params));
+- } else if (arg == "--ignore-eos") {
+- params.ignore_eos = true;
+- } else if (arg == "-m" || arg == "--model") {
+- params.model = get_next_arg(i, argc, argv, arg, params);
+- } else if (arg == "-i" || arg == "--interactive") {
+- params.interactive = true;
+- } else if (arg == "-ip" || arg == "--interactive-port") {
+- params.interactive = true;
+- params.interactive_port = std::stoi(get_next_arg(i, argc, argv, arg, params));
+- } else if (arg == "-h" || arg == "--help") {
+- gpt_print_usage(argc, argv, params);
+- exit(0);
+- } else if (arg == "-f" || arg == "--file") {
+- get_next_arg(i, argc, argv, arg, params);
+- std::ifstream file(argv[i]);
+- if (!file) {
+- fprintf(stderr, "error: failed to open file '%s'\n", argv[i]);
+- break;
+- }
+- std::copy(std::istreambuf_iterator<char>(file), std::istreambuf_iterator<char>(), back_inserter(params.prompt));
+- if (params.prompt.back() == '\n') {
+- params.prompt.pop_back();
+- }
+- } else if (arg == "-tt" || arg == "--token_test") {
+- params.token_test = get_next_arg(i, argc, argv, arg, params);
+- }
+- else {
+- fprintf(stderr, "error: unknown argument: %s\n", arg.c_str());
+- gpt_print_usage(argc, argv, params);
+- exit(0);
+- }
+- }
+-
+- return true;
+-}
+-
+-void gpt_print_usage(int /*argc*/, char ** argv, const gpt_params & params) {
+- fprintf(stderr, "usage: %s [options]\n", argv[0]);
+- fprintf(stderr, "\n");
+- fprintf(stderr, "options:\n");
+- fprintf(stderr, " -h, --help show this help message and exit\n");
+- fprintf(stderr, " -s SEED, --seed SEED RNG seed (default: -1)\n");
+- fprintf(stderr, " -t N, --threads N number of threads to use during computation (default: %d)\n", params.n_threads);
+- fprintf(stderr, " -p PROMPT, --prompt PROMPT\n");
+- fprintf(stderr, " prompt to start generation with (default: random)\n");
+- fprintf(stderr, " -f FNAME, --file FNAME\n");
+- fprintf(stderr, " load prompt from a file\n");
+- fprintf(stderr, " -tt TOKEN_TEST, --token_test TOKEN_TEST\n");
+- fprintf(stderr, " test tokenization\n");
+- fprintf(stderr, " -n N, --n_predict N number of tokens to predict (default: %d)\n", params.n_predict);
+- fprintf(stderr, " --top_k N top-k sampling (default: %d)\n", params.top_k);
+- fprintf(stderr, " --top_p N top-p sampling (default: %.1f)\n", params.top_p);
+- fprintf(stderr, " --temp N temperature (default: %.1f)\n", params.temp);
+- fprintf(stderr, " --repeat-last-n N last n tokens to consider for penalize (default: %d, 0 = disabled)\n", params.repeat_last_n);
+- fprintf(stderr, " --repeat-penalty N penalize repeat sequence of tokens (default: %.2f, 1.0 = disabled)\n", (double)params.repeat_penalty);
+- fprintf(stderr, " -b N, --batch_size N batch size for prompt processing (default: %d)\n", params.n_batch);
+- fprintf(stderr, " -c N, --context N context / KV cache size (default: %d)\n", params.n_ctx);
+- fprintf(stderr, " --ignore-eos ignore EOS token during generation\n");
+- fprintf(stderr, " -ngl N, --gpu-layers N number of layers to offload to GPU on supported models (default: %d)\n", params.n_gpu_layers);
+- fprintf(stderr, " -m FNAME, --model FNAME\n");
+- fprintf(stderr, " model path (default: %s)\n", params.model.c_str());
+- fprintf(stderr, "\n");
+-}
+-
+-std::string gpt_random_prompt(std::mt19937 & rng) {
+- const int r = rng() % 10;
+- switch (r) {
+- case 0: return "So";
+- case 1: return "Once upon a time";
+- case 2: return "When";
+- case 3: return "The";
+- case 4: return "After";
+- case 5: return "If";
+- case 6: return "import";
+- case 7: return "He";
+- case 8: return "She";
+- case 9: return "They";
+- }
+-
+- return "The";
+-}
+-
+-std::string trim(const std::string & s) {
+- std::regex e("^\\s+|\\s+$");
+- return std::regex_replace(s, e, "");
+-}
+-
+-std::string replace(const std::string & s, const std::string & from, const std::string & to) {
+- std::string result = s;
+- size_t pos = 0;
+- while ((pos = result.find(from, pos)) != std::string::npos) {
+- result.replace(pos, from.length(), to);
+- pos += to.length();
+- }
+- return result;
+-}
+-
+-void gpt_vocab::add_special_token(const std::string & token) {
+- special_tokens.push_back(token);
+-}
+-
+-std::map<std::string, int32_t> json_parse(const std::string & fname) {
+- std::map<std::string, int32_t> result;
+-
+- // read file into string
+- std::string json;
+- {
+- std::ifstream ifs(fname);
+- if (!ifs) {
+- fprintf(stderr, "Failed to open %s\n", fname.c_str());
+- exit(1);
+- }
+-
+- json = std::string((std::istreambuf_iterator<char>(ifs)),
+- (std::istreambuf_iterator<char>()));
+- }
+-
+- if (json[0] != '{') {
+- return result;
+- }
+-
+- // parse json
+- {
+- bool has_key = false;
+- bool in_token = false;
+-
+- std::string str_key = "";
+- std::string str_val = "";
+-
+- int n = json.size();
+- for (int i = 1; i < n; ++i) {
+- if (!in_token) {
+- if (json[i] == ' ') continue;
+- if (json[i] == '"') {
+- in_token = true;
+- continue;
+- }
+- } else {
+- if (json[i] == '\\' && i+1 < n) {
+- if (has_key == false) {
+- str_key += json[i];
+- } else {
+- str_val += json[i];
+- }
+- ++i;
+- } else if (json[i] == '"') {
+- if (has_key == false) {
+- has_key = true;
+- ++i;
+- while (json[i] == ' ') ++i;
+- ++i; // :
+- while (json[i] == ' ') ++i;
+- if (json[i] != '\"') {
+- while (json[i] != ',' && json[i] != '}') {
+- str_val += json[i++];
+- }
+- has_key = false;
+- } else {
+- in_token = true;
+- continue;
+- }
+- } else {
+- has_key = false;
+- }
+-
+- str_key = ::replace(str_key, "\\u0120", " " ); // \u0120 -> space
+- str_key = ::replace(str_key, "\\u010a", "\n"); // \u010a -> new line
+- str_key = ::replace(str_key, "\\\"", "\""); // \\\" -> "
+-
+- try {
+- result[str_key] = std::stoi(str_val);
+- } catch (...) {
+- //fprintf(stderr, "%s: ignoring key '%s' with value '%s'\n", fname.c_str(), str_key.c_str(), str_val.c_str());
+-
+- }
+- str_key = "";
+- str_val = "";
+- in_token = false;
+- continue;
+- }
+- if (has_key == false) {
+- str_key += json[i];
+- } else {
+- str_val += json[i];
+- }
+- }
+- }
+- }
+-
+- return result;
+-}
+-
+-std::string convert_to_utf8(const std::wstring & input) {
+- std::wstring_convert<std::codecvt_utf8<wchar_t>> converter;
+- return converter.to_bytes(input);
+-}
+-
+-
+-std::wstring convert_to_wstring(const std::string & input) {
+- std::wstring_convert<std::codecvt_utf8<wchar_t>> converter;
+- return converter.from_bytes(input);
+-}
+-
+-void gpt_split_words(std::string str, std::vector<std::string>& words) {
+- const std::string pattern = R"('s|'t|'re|'ve|'m|'ll|'d| ?[[:alpha:]]+| ?[[:digit:]]+| ?[^\s[:alpha:][:digit:]]+|\s+(?!\S)|\s+)";
+- const std::regex re(pattern);
+- std::smatch m;
+-
+- while (std::regex_search(str, m, re)) {
+- for (auto x : m) {
+- words.push_back(x);
+- }
+- str = m.suffix();
+- }
+-}
+-
+-std::vector<gpt_vocab::id> gpt_tokenize(const gpt_vocab & vocab, const std::string & text) {
+- std::vector<std::string> words;
+-
+- // first split the text into words
+- {
+- std::string str = text;
+-
+- // Generate the subpattern from the special_tokens vector if it's not empty
+- if (!vocab.special_tokens.empty()) {
+- const std::regex escape(R"([\[\\\^\$\.\|\?\*\+\(\)\{\}])");
+- std::string special_tokens_subpattern;
+- for (const auto & token : vocab.special_tokens) {
+- if (!special_tokens_subpattern.empty()) {
+- special_tokens_subpattern += "|";
+- }
+- special_tokens_subpattern += std::regex_replace(token, escape, R"(\$&)");
+- }
+-
+- std::regex re(special_tokens_subpattern);
+- std::smatch m;
+- // Split the text by special tokens.
+- while (std::regex_search(str, m, re)) {
+- // Split the substrings in-between special tokens into words.
+- gpt_split_words(m.prefix(), words);
+- // Add matched special tokens as words.
+- for (auto x : m) {
+- words.push_back(x);
+- }
+- str = m.suffix();
+- }
+- // Remaining text without special tokens will be handled below.
+- }
+-
+- gpt_split_words(str, words);
+- }
+-
+- // find the longest token that forms each word in words:
+- std::vector<gpt_vocab::id> tokens;
+- for (const auto & word : words) {
+- for (int i = 0; i < (int) word.size(); ){
+- for (int j = word.size() - 1; j >= i; j--){
+- auto cand = word.substr(i, j-i+1);
+- auto it = vocab.token_to_id.find(cand);
+- if (it != vocab.token_to_id.end()){ // word.substr(i, j-i+1) in vocab
+- tokens.push_back(it->second);
+- i = j + 1;
+- break;
+- }
+- else if (j == i){ // word.substr(i, 1) has no matching
+- fprintf(stderr, "%s: unknown token '%s'\n", __func__, word.substr(i, 1).data());
+- i++;
+- }
+- }
+- }
+- }
+-
+- return tokens;
+-}
+-
+-static std::vector<gpt_vocab::id> parse_tokens_from_string(const std::string& input, char delimiter) {
+- std::vector<gpt_vocab::id> output;
+- std::stringstream ss(input);
+- std::string token;
+-
+- while (std::getline(ss, token, delimiter)) {
+- output.push_back(std::stoi(token));
+- }
+-
+- return output;
+-}
+-
+-static std::map<std::string, std::vector<gpt_vocab::id>> extract_tests_from_file(const std::string & fpath_test){
+- if (fpath_test.empty()){
+- fprintf(stderr, "%s : No test file found.\n", __func__);
+- return std::map<std::string, std::vector<gpt_vocab::id>>();
+- }
+-
+- std::map<std::string, std::vector<gpt_vocab::id>> tests;
+-
+- auto fin = std::ifstream(fpath_test, std::ios_base::in);
+- const char * delimeter = " => ";
+- const char del_tok = ',';
+- std::string line;
+- while (std::getline(fin, line)) {
+- size_t delimiterPos = line.find(delimeter);
+- if (delimiterPos != std::string::npos) {
+- std::string text = line.substr(0, delimiterPos);
+- std::string s_tokens = line.substr(delimiterPos + std::strlen(delimeter));
+- tests[text] = parse_tokens_from_string(s_tokens, del_tok);
+- }
+- }
+- return tests;
+-}
+-
+-void test_gpt_tokenizer(gpt_vocab & vocab, const std::string & fpath_test){
+- std::map<std::string, std::vector<gpt_vocab::id>> tests = extract_tests_from_file(fpath_test);
++#include <cosmo.h>
++#include <stdlib.h>
++#include <unistd.h>
+
+- size_t n_fails = 0;
+-
+- for (const auto & test : tests) {
+- std::vector<gpt_vocab::id> tokens = gpt_tokenize(vocab, test.first);
+-
+- if (tokens != test.second){
+- n_fails++;
+-
+- // print out failure cases
+- fprintf(stderr, "%s : failed test: '%s'\n", __func__, test.first.c_str());
+- fprintf(stderr, "%s : tokens in hf: ", __func__);
+- for (const auto & t : test.second) {
+- fprintf(stderr, "%s(%d), ", vocab.id_to_token[t].c_str(), t);
+- }
+- fprintf(stderr, "\n");
+- fprintf(stderr, "%s : tokens in ggml: ", __func__);
+- for (const auto & t : tokens) {
+- fprintf(stderr, "%s(%d), ", vocab.id_to_token[t].c_str(), t);
+- }
+- fprintf(stderr, "\n");
+- }
+- }
+-
+- fprintf(stderr, "%s : %zu tests failed out of %zu tests.\n", __func__, n_fails, tests.size());
+-}
+-
+-bool gpt_vocab_init(const std::string & fname, gpt_vocab & vocab) {
+- printf("%s: loading vocab from '%s'\n", __func__, fname.c_str());
+-
+- vocab.token_to_id = ::json_parse(fname);
+-
+- for (const auto & kv : vocab.token_to_id) {
+- vocab.id_to_token[kv.second] = kv.first;
+- }
+-
+- printf("%s: vocab size = %d\n", __func__, (int) vocab.token_to_id.size());
+-
+- // print the vocabulary
+- //for (auto kv : vocab.token_to_id) {
+- // printf("'%s' -> %d\n", kv.first.data(), kv.second);
+- //}
+-
+- return true;
+-}
+-
+-gpt_vocab::id gpt_sample_top_k_top_p(
+- const gpt_vocab & vocab,
+- const float * logits,
+- int top_k,
+- double top_p,
+- double temp,
+- std::mt19937 & rng) {
+- int n_logits = vocab.id_to_token.size();
+-
+- std::vector<std::pair<double, gpt_vocab::id>> logits_id;
+- logits_id.reserve(n_logits);
+-
+- {
+- const double scale = 1.0/temp;
+- for (int i = 0; i < n_logits; ++i) {
+- logits_id.push_back(std::make_pair(logits[i]*scale, i));
+- }
+- }
+-
+- // find the top K tokens
+- std::partial_sort(
+- logits_id.begin(),
+- logits_id.begin() + top_k, logits_id.end(),
+- [](const std::pair<double, gpt_vocab::id> & a, const std::pair<double, gpt_vocab::id> & b) {
+- return a.first > b.first;
+- });
+-
+- logits_id.resize(top_k);
+-
+- double maxl = -INFINITY;
+- for (const auto & kv : logits_id) {
+- maxl = std::max(maxl, kv.first);
+- }
+-
+- // compute probs for the top K tokens
+- std::vector<double> probs;
+- probs.reserve(logits_id.size());
+-
+- double sum = 0.0;
+- for (const auto & kv : logits_id) {
+- double p = exp(kv.first - maxl);
+- probs.push_back(p);
+- sum += p;
+- }
+-
+- // normalize the probs
+- for (auto & p : probs) {
+- p /= sum;
+- }
+-
+- if (top_p < 1.0f) {
+- double cumsum = 0.0f;
+- for (int i = 0; i < top_k; i++) {
+- cumsum += probs[i];
+- if (cumsum >= top_p) {
+- top_k = i + 1;
+- probs.resize(top_k);
+- logits_id.resize(top_k);
+- break;
+- }
+- }
+-
+- cumsum = 1.0/cumsum;
+- for (int i = 0; i < (int) probs.size(); i++) {
+- probs[i] *= cumsum;
+- }
+- }
+-
+- //printf("\n");
+- //for (int i = 0; i < (int) probs.size(); i++) {
+- // printf("%d: '%s' %f\n", i, vocab.id_to_token.at(logits_id[i].second).c_str(), probs[i]);
+- //}
+- //exit(0);
+-
+- std::discrete_distribution<> dist(probs.begin(), probs.end());
+- int idx = dist(rng);
+-
+- return logits_id[idx].second;
+-}
+-
+-gpt_vocab::id gpt_sample_top_k_top_p_repeat(
+- const gpt_vocab & vocab,
+- const float * logits,
+- const int32_t * last_n_tokens_data,
+- size_t last_n_tokens_data_size,
+- int top_k,
+- double top_p,
+- double temp,
+- int repeat_last_n,
+- float repeat_penalty,
+- std::mt19937 & rng) {
+-
+- int n_logits = vocab.id_to_token.size();
+-
+- const auto * plogits = logits;
+-
+- const auto last_n_tokens = std::vector<int32_t>(last_n_tokens_data, last_n_tokens_data + last_n_tokens_data_size);
+-
+- if (temp <= 0) {
+- // select the token with the highest logit directly
+- float max_logit = plogits[0];
+- gpt_vocab::id max_id = 0;
+-
+- for (int i = 1; i < n_logits; ++i) {
+- if (plogits[i] > max_logit) {
+- max_logit = plogits[i];
+- max_id = i;
+- }
+- }
+- return max_id;
+- }
+-
+-
+- std::vector<std::pair<double, gpt_vocab::id>> logits_id;
+- logits_id.reserve(n_logits);
+-
+- {
+- const float scale = 1.0f/temp;
+- for (int i = 0; i < n_logits; ++i) {
+- // repetition penalty from ctrl paper (https://arxiv.org/abs/1909.05858)
+- // credit https://github.com/facebookresearch/llama/compare/main...shawwn:llama:main
+- if (repeat_last_n > 0 && std::find(last_n_tokens.end()-repeat_last_n, last_n_tokens.end(), i) != last_n_tokens.end()) {
+- // if score < 0 then repetition penalty has to multiplied to reduce the previous token probability
+- if (plogits[i] < 0.0f) {
+- logits_id.push_back(std::make_pair(plogits[i]*scale*repeat_penalty, i));
+- } else {
+- logits_id.push_back(std::make_pair(plogits[i]*scale/repeat_penalty, i));
+- }
+- } else {
+- logits_id.push_back(std::make_pair(plogits[i]*scale, i));
+- }
+- }
+- }
+-
+- // find the top K tokens
+- std::partial_sort(
+- logits_id.begin(),
+- logits_id.begin() + top_k, logits_id.end(),
+- [](const std::pair<double, gpt_vocab::id> & a, const std::pair<double, gpt_vocab::id> & b) {
+- return a.first > b.first;
+- });
++#include "third_party/stb/stb_vorbis.h"
++#include "miniaudio.h"
+
+- logits_id.resize(top_k);
+-
+- double maxl = -INFINITY;
+- for (const auto & kv : logits_id) {
+- maxl = std::max(maxl, kv.first);
+- }
+-
+- // compute probs for the top K tokens
+- std::vector<double> probs;
+- probs.reserve(logits_id.size());
+-
+- double sum = 0.0;
+- for (const auto & kv : logits_id) {
+- double p = exp(kv.first - maxl);
+- probs.push_back(p);
+- sum += p;
+- }
+-
+- // normalize the probs
+- for (auto & p : probs) {
+- p /= sum;
+- }
+-
+- if (top_p < 1.0f) {
+- double cumsum = 0.0f;
+- for (int i = 0; i < top_k; i++) {
+- cumsum += probs[i];
+- if (cumsum >= top_p) {
+- top_k = i + 1;
+- probs.resize(top_k);
+- logits_id.resize(top_k);
+- break;
+- }
+- }
+-
+- cumsum = 1.0/cumsum;
+- for (int i = 0; i < (int) probs.size(); i++) {
+- probs[i] *= cumsum;
+- }
+- }
+-
+-// printf("\n");
+-// for (int i = 0; i < (int) probs.size(); i++) {
+-// for (int i = 0; i < 10; i++) {
+-// printf("%d: '%s' %f\n", i, vocab.id_to_token.at(logits_id[i].second).c_str(), probs[i]);
+-// }
+-
+- std::discrete_distribution<> dist(probs.begin(), probs.end());
+- int idx = dist(rng);
+-
+- return logits_id[idx].second;
+-
+-}
+-
+-bool is_wav_buffer(const std::string buf) {
+- // RIFF ref: https://en.wikipedia.org/wiki/Resource_Interchange_File_Format
+- // WAV ref: https://www.mmsp.ece.mcgill.ca/Documents/AudioFormats/WAVE/WAVE.html
+- if (buf.size() < 12 || buf.substr(0, 4) != "RIFF" || buf.substr(8, 4) != "WAVE") {
+- return false;
+- }
+-
+- uint32_t chunk_size = *reinterpret_cast<const uint32_t*>(buf.data() + 4);
+- if (chunk_size + 8 != buf.size()) {
+- return false;
+- }
+-
+- return true;
+-}
+-
+-bool read_wav(const std::string & fname, std::vector<float>& pcmf32, std::vector<std::vector<float>>& pcmf32s, bool stereo) {
+- drwav wav;
+- std::vector<uint8_t> wav_data; // used for pipe input from stdin or ffmpeg decoding output
+-
+- if (fname == "-") {
+- {
+- #ifdef _WIN32
+- _setmode(_fileno(stdin), _O_BINARY);
+- #endif
+-
+- uint8_t buf[1024];
+- while (true)
+- {
+- const size_t n = fread(buf, 1, sizeof(buf), stdin);
+- if (n == 0) {
+- break;
+- }
+- wav_data.insert(wav_data.end(), buf, buf + n);
+- }
+- }
+-
+- if (drwav_init_memory(&wav, wav_data.data(), wav_data.size(), nullptr) == false) {
+- fprintf(stderr, "error: failed to open WAV file from stdin\n");
+- return false;
+- }
+-
+- fprintf(stderr, "%s: read %zu bytes from stdin\n", __func__, wav_data.size());
+- }
+- else if (is_wav_buffer(fname)) {
+- if (drwav_init_memory(&wav, fname.c_str(), fname.size(), nullptr) == false) {
+- fprintf(stderr, "error: failed to open WAV file from fname buffer\n");
+- return false;
+- }
+- }
+- else if (drwav_init_file(&wav, fname.c_str(), nullptr) == false) {
+-#if defined(WHISPER_FFMPEG)
+- if (ffmpeg_decode_audio(fname, wav_data) != 0) {
+- fprintf(stderr, "error: failed to ffmpeg decode '%s' \n", fname.c_str());
+- return false;
+- }
+- if (drwav_init_memory(&wav, wav_data.data(), wav_data.size(), nullptr) == false) {
+- fprintf(stderr, "error: failed to read wav data as wav \n");
+- return false;
+- }
+-#else
+- fprintf(stderr, "error: failed to open '%s' as WAV file\n", fname.c_str());
+- return false;
+-#endif
+- }
+-
+- if (wav.channels != 1 && wav.channels != 2) {
+- fprintf(stderr, "%s: WAV file '%s' must be mono or stereo\n", __func__, fname.c_str());
+- drwav_uninit(&wav);
+- return false;
+- }
+-
+- if (stereo && wav.channels != 2) {
+- fprintf(stderr, "%s: WAV file '%s' must be stereo for diarization\n", __func__, fname.c_str());
+- drwav_uninit(&wav);
+- return false;
+- }
+-
+- if (wav.sampleRate != COMMON_SAMPLE_RATE) {
+- fprintf(stderr, "%s: WAV file '%s' must be %i kHz\n", __func__, fname.c_str(), COMMON_SAMPLE_RATE/1000);
+- drwav_uninit(&wav);
+- return false;
+- }
+-
+- if (wav.bitsPerSample != 16) {
+- fprintf(stderr, "%s: WAV file '%s' must be 16-bit\n", __func__, fname.c_str());
+- drwav_uninit(&wav);
+- return false;
+- }
+-
+- const uint64_t n = wav_data.empty() ? wav.totalPCMFrameCount : wav_data.size()/(wav.channels*wav.bitsPerSample/8);
+-
+- std::vector<int16_t> pcm16;
+- pcm16.resize(n*wav.channels);
+- drwav_read_pcm_frames_s16(&wav, n, pcm16.data());
+- drwav_uninit(&wav);
+-
+- // convert to mono, float
+- pcmf32.resize(n);
+- if (wav.channels == 1) {
+- for (uint64_t i = 0; i < n; i++) {
+- pcmf32[i] = float(pcm16[i])/32768.0f;
+- }
+- } else {
+- for (uint64_t i = 0; i < n; i++) {
+- pcmf32[i] = float(pcm16[2*i] + pcm16[2*i + 1])/65536.0f;
+- }
+- }
+-
+- if (stereo) {
+- // convert to stereo, float
+- pcmf32s.resize(2);
+-
+- pcmf32s[0].resize(n);
+- pcmf32s[1].resize(n);
+- for (uint64_t i = 0; i < n; i++) {
+- pcmf32s[0][i] = float(pcm16[2*i])/32768.0f;
+- pcmf32s[1][i] = float(pcm16[2*i + 1])/32768.0f;
+- }
+- }
+-
+- return true;
+-}
+-
+ void high_pass_filter(std::vector<float> & data, float cutoff, float sample_rate) {
+ const float rc = 1.0f / (2.0f * M_PI * cutoff);
+ const float dt = 1.0f / sample_rate;
+@@ -788,7 +68,7 @@
+ energy_last /= n_samples_last;
+
+ if (verbose) {
+- fprintf(stderr, "%s: energy_all: %f, energy_last: %f, vad_thold: %f, freq_thold: %f\n", __func__, energy_all, energy_last, vad_thold, freq_thold);
++ tinylogf("%s: energy_all: %f, energy_last: %f, vad_thold: %f, freq_thold: %f\n", __func__, energy_all, energy_last, vad_thold, freq_thold);
+ }
+
+ if (energy_last > vad_thold*energy_all) {
+@@ -841,7 +121,7 @@
+ exit(0);
+ } else {
+ fprintf(stderr, "error: unknown argument: %s\n", arg.c_str());
+- sam_print_usage(argc, argv, params);
++ // sam_print_usage(argc, argv, params); // [jart]
+ exit(0);
+ }
+ }
diff --git a/whisper.cpp.patches/patches/003-common-h-llamafile-integration.patch b/whisper.cpp.patches/patches/003-common-h-llamafile-integration.patch
new file mode 100644
index 00000000..5e664c82
--- /dev/null
+++ b/whisper.cpp.patches/patches/003-common-h-llamafile-integration.patch
@@ -0,0 +1,202 @@
+--- examples/common.h 2025-10-31 16:34:53
++++ ../non_submodule_llamafile/whisper.cpp/common.h 2025-10-31 16:53:51
+@@ -1,153 +1,26 @@
++// -*- mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8 -*-
++// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
++
+ // Various helper functions and utilities
+
+ #pragma once
+
+ #include <string>
+-#include <map>
+ #include <vector>
+-#include <random>
+ #include <thread>
+-#include <ctime>
+ #include <fstream>
+
++#include "llamafile/xterm.h"
++
+ #define COMMON_SAMPLE_RATE 16000
+
+ //
+-// GPT CLI argument parsing
+-//
+-
+-struct gpt_params {
+- int32_t seed = -1; // RNG seed
+- int32_t n_threads = std::min(4, (int32_t) std::thread::hardware_concurrency());
+- int32_t n_predict = 200; // new tokens to predict
+- int32_t n_parallel = 1; // number of parallel streams
+- int32_t n_batch = 32; // batch size for prompt processing
+- int32_t n_ctx = 2048; // context size (this is the KV cache max size)
+- int32_t n_gpu_layers = 0; // number of layers to offlload to the GPU
+-
+- bool ignore_eos = false; // ignore EOS token when generating text
+-
+- // sampling parameters
+- int32_t top_k = 40;
+- float top_p = 0.9f;
+- float temp = 0.9f;
+- int32_t repeat_last_n = 64;
+- float repeat_penalty = 1.00f;
+-
+- std::string model = "models/gpt-2-117M/ggml-model.bin"; // model path
+- std::string prompt = "";
+- std::string token_test = "";
+-
+- bool interactive = false;
+- int32_t interactive_port = -1;
+-};
+-
+-bool gpt_params_parse(int argc, char ** argv, gpt_params & params);
+-
+-void gpt_print_usage(int argc, char ** argv, const gpt_params & params);
+-
+-std::string gpt_random_prompt(std::mt19937 & rng);
+-
+-//
+-// Vocab utils
+-//
+-
+-std::string trim(const std::string & s);
+-
+-std::string replace(
+- const std::string & s,
+- const std::string & from,
+- const std::string & to);
+-
+-struct gpt_vocab {
+- using id = int32_t;
+- using token = std::string;
+-
+- std::map<token, id> token_to_id;
+- std::map<id, token> id_to_token;
+- std::vector<std::string> special_tokens;
+-
+- void add_special_token(const std::string & token);
+-};
+-
+-// poor-man's JSON parsing
+-std::map<std::string, int32_t> json_parse(const std::string & fname);
+-
+-std::string convert_to_utf8(const std::wstring & input);
+-
+-std::wstring convert_to_wstring(const std::string & input);
+-
+-void gpt_split_words(std::string str, std::vector<std::string>& words);
+-
+-// split text into tokens
+-//
+-// ref: https://github.com/openai/gpt-2/blob/a74da5d99abaaba920de8131d64da2862a8f213b/src/encoder.py#L53
+-//
+-// Regex (Python):
+-// r"""'s|'t|'re|'ve|'m|'ll|'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+"""
+-//
+-// Regex (C++):
+-// R"('s|'t|'re|'ve|'m|'ll|'d| ?[[:alpha:]]+| ?[[:digit:]]+| ?[^\s[:alpha:][:digit:]]+|\s+(?!\S)|\s+)"
+-//
+-std::vector<gpt_vocab::id> gpt_tokenize(const gpt_vocab & vocab, const std::string & text);
+-
+-// test outputs of gpt_tokenize
+-//
+-// - compare with tokens generated by the huggingface tokenizer
+-// - test cases are chosen based on the model's main language (under 'prompt' directory)
+-// - if all sentences are tokenized identically, print 'All tests passed.'
+-// - otherwise, print sentence, huggingface tokens, ggml tokens
+-//
+-void test_gpt_tokenizer(gpt_vocab & vocab, const std::string & fpath_test);
+-
+-// load the tokens from encoder.json
+-bool gpt_vocab_init(const std::string & fname, gpt_vocab & vocab);
+-
+-// sample next token given probabilities for each embedding
+-//
+-// - consider only the top K tokens
+-// - from them, consider only the top tokens with cumulative probability > P
+-//
+-// TODO: not sure if this implementation is correct
+-// TODO: temperature is not implemented
+-//
+-gpt_vocab::id gpt_sample_top_k_top_p(
+- const gpt_vocab & vocab,
+- const float * logits,
+- int top_k,
+- double top_p,
+- double temp,
+- std::mt19937 & rng);
+-
+-gpt_vocab::id gpt_sample_top_k_top_p_repeat(
+- const gpt_vocab & vocab,
+- const float * logits,
+- const int32_t * last_n_tokens_data,
+- size_t last_n_tokens_data_size,
+- int top_k,
+- double top_p,
+- double temp,
+- int repeat_last_n,
+- float repeat_penalty,
+- std::mt19937 & rng);
+-
+-//
+ // Audio utils
+ //
+
+ // Check if a buffer is a WAV audio file
+ bool is_wav_buffer(const std::string buf);
+
+-// Read WAV audio file and store the PCM data into pcmf32
+-// fname can be a buffer of WAV data instead of a filename
+-// The sample rate of the audio must be equal to COMMON_SAMPLE_RATE
+-// If stereo flag is set and the audio has 2 channels, the pcmf32s will contain 2 channel PCM
+-bool read_wav(
+- const std::string & fname,
+- std::vector<float> & pcmf32,
+- std::vector<std::vector<float>> & pcmf32s,
+- bool stereo);
+-
+ // Write PCM data into WAV audio file
+ class wav_writer {
+ private:
+@@ -185,7 +58,7 @@
+ // It is assumed that PCM data is normalized to a range from -1 to 1
+ bool write_audio(const float * data, size_t length) {
+ for (size_t i = 0; i < length; ++i) {
+- const int16_t intSample = int16_t(data[i] * 32767);
++ const int16_t intSample = data[i] * 32767;
+ file.write(reinterpret_cast<const char *>(&intSample), sizeof(int16_t));
+ dataSize += sizeof(int16_t);
+ }
+@@ -286,12 +159,27 @@
+ // Terminal utils
+ //
+
++static std::string set_xterm256_foreground(int rgb) {
++ int x = rgb2xterm256(rgb);
++ std::ostringstream oss;
++ oss << "\033[38;5;" << x << "m";
++ return oss.str();
++}
+
+-// Terminal color map. 10 colors grouped in ranges [0.0, 0.1, ..., 0.9]
+-// Lowest is red, middle is yellow, highest is green.
++static inline int rgb(int red, int green, int blue) {
++ return (red & 255) << 16 | (green & 255) << 8 | (blue & 255);
++}
++
++// Lowest is red, middle is yellow, highest is green. Color scheme from
++// Paul Tol; it is colorblind friendly https://personal.sron.nl/~pault/
+ const std::vector<std::string> k_colors = {
+- "\033[38;5;196m", "\033[38;5;202m", "\033[38;5;208m", "\033[38;5;214m", "\033[38;5;220m",
+- "\033[38;5;226m", "\033[38;5;190m", "\033[38;5;154m", "\033[38;5;118m", "\033[38;5;82m",
++ set_xterm256_foreground(rgb(220, 5, 12)),
++ set_xterm256_foreground(rgb(232, 96, 28)),
++ set_xterm256_foreground(rgb(241, 147, 45)),
++ set_xterm256_foreground(rgb(246, 193, 65)),
++ set_xterm256_foreground(rgb(247, 240, 86)),
++ set_xterm256_foreground(rgb(144, 201, 135)),
++ set_xterm256_foreground(rgb( 78, 178, 101)),
+ };
+
+ //
diff --git a/whisper.cpp.patches/patches/004-whisper-cpp-llamafile-integration.patch b/whisper.cpp.patches/patches/004-whisper-cpp-llamafile-integration.patch
new file mode 100644
index 00000000..4008dcd3
--- /dev/null
+++ b/whisper.cpp.patches/patches/004-whisper-cpp-llamafile-integration.patch
@@ -0,0 +1,264 @@
+--- src/whisper.cpp 2025-10-31 16:34:53
++++ ../non_submodule_llamafile/whisper.cpp/whisper.cpp 2025-10-31 16:53:51
+@@ -1,37 +1,26 @@
++// -*- mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8 -*-
++// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
++#include "llama.cpp/ggml-vector.h"
++#include "llama.cpp/cores.h"
+ #include "whisper.h"
+
+-#ifdef WHISPER_USE_COREML
+-#include "coreml/whisper-encoder.h"
+-#endif
++#define GGML_USE_CUDA
++#define GGML_USE_METAL
+
+ #ifdef GGML_USE_METAL
+-#include "ggml-metal.h"
++#include "llama.cpp/ggml-metal.h"
+ #endif
+
+ #ifdef GGML_USE_CUDA
+-#include "ggml-cuda.h"
+-#include "whisper-mel-cuda.hpp"
++#include "llama.cpp/ggml-cuda.h"
++#include "whisper.cpp/whisper-mel-cuda.hpp"
+ #endif
+
+-#ifdef GGML_USE_SYCL
+-#include "ggml-sycl.h"
+-#endif
++#include "llama.cpp/ggml.h"
++#include "llama.cpp/ggml-alloc.h"
++#include "llama.cpp/ggml-backend.h"
+
+-#ifdef GGML_USE_VULKAN
+-#include "ggml-vulkan.h"
+-#endif
+-
+-#ifdef GGML_USE_BLAS
+-#include "ggml-blas.h"
+-#endif
+-
+-#ifdef WHISPER_USE_OPENVINO
+-#include "openvino/whisper-openvino-encoder.h"
+-#endif
+-
+-#include "ggml.h"
+-#include "ggml-alloc.h"
+-#include "ggml-backend.h"
++#include "llamafile/llamafile.h"
+
+ #include "whisper-mel.hpp"
+
+@@ -226,7 +215,8 @@
+ // and X_1 and Y_1 are the remaining views. X_1 and Y_1 end up being small matrices that can be processed with more
+ // general-purpose kernels
+ //
+-static struct ggml_tensor * ggml_mul_mat_pad(struct ggml_context * ctx, struct ggml_tensor * x, struct ggml_tensor * y, int pad = 32) {
++static struct ggml_tensor * ggml_mul_mat_pad(struct ggml_context * ctx, struct ggml_tensor * x, struct ggml_tensor * y) {
++ int pad = 32;
+ // use padding only if dimension 0 is at least 8 times larger than the padding
+ // else we won't get much benefit from the optimization
+ const int n_pad_req = 8;
+@@ -249,7 +239,7 @@
+ // TODO: check if other platforms can benefit from this optimization
+ // TODO: CUDA is currently broken - seems ggml_mul_mat does not handle views correctly
+ #if defined(GGML_USE_METAL)
+-#define ggml_mul_mat ggml_mul_mat_pad
++#define ggml_mul_mat (llamafile_has_metal() ? ggml_mul_mat_pad : ggml_mul_mat)
+ #endif
+
+ // available whisper models
+@@ -1085,18 +1075,18 @@
+ }
+
+ static uint32_t whisper_kv_cache_get_padding(const struct whisper_context & wctx) {
+- if (!wctx.params.flash_attn || !wctx.params.use_gpu) {
++ if (!wctx.params.flash_attn) {
+ return 1u;
+ }
+
+ #ifdef GGML_USE_METAL
+- if (wctx.params.use_gpu) {
++ if (llamafile_has_metal()) {
+ return 32u;
+ }
+ #endif
+
+ #ifdef GGML_USE_CUDA
+- if (wctx.params.use_gpu) {
++ if (llamafile_has_cuda()) {
+ return 256u;
+ }
+ #endif
+@@ -1239,7 +1229,7 @@
+ ggml_backend_t result = NULL;
+
+ #ifdef GGML_USE_CUDA
+- if (params.use_gpu) {
++ if (llamafile_has_cuda()) {
+ WHISPER_LOG_INFO("%s: using CUDA backend\n", __func__);
+ result = ggml_backend_cuda_init(params.gpu_device);
+ if (!result) {
+@@ -1249,7 +1239,7 @@
+ #endif
+
+ #ifdef GGML_USE_METAL
+- if (params.use_gpu) {
++ if (!result && llamafile_has_metal()) {
+ WHISPER_LOG_INFO("%s: using Metal backend\n", __func__);
+ ggml_backend_metal_log_set_callback(g_state.log_callback, g_state.log_callback_user_data);
+ result = ggml_backend_metal_init();
+@@ -1317,14 +1307,14 @@
+ static ggml_backend_buffer_type_t whisper_default_buffer_type(const whisper_context_params & params) {
+ ggml_backend_buffer_type_t result = nullptr;
+
+- params.use_gpu || (result = ggml_backend_cpu_buffer_type());
+-
+ #ifdef GGML_USE_CUDA
+- result || (result = ggml_backend_cuda_buffer_type(params.gpu_device));
++ if (!result && llamafile_has_cuda())
++ result = ggml_backend_cuda_buffer_type(params.gpu_device);
+ #endif
+
+ #ifdef GGML_USE_METAL
+- result || (result = ggml_backend_metal_buffer_type());
++ if (!result && llamafile_has_metal())
++ result = ggml_backend_metal_buffer_type();
+ #endif
+
+ #ifdef GGML_USE_SYCL
+@@ -1335,7 +1325,8 @@
+ result || (result = ggml_backend_vk_buffer_type(params.gpu_device));
+ #endif
+
+- result || (result = ggml_backend_cpu_buffer_type());
++ if (!result)
++ result = ggml_backend_cpu_buffer_type();
+
+ return result;
+ }
+@@ -2784,7 +2775,7 @@
+ whisper_context & wctx,
+ whisper_state & wstate,
+ const whisper_batch & batch,
+- const int n_threads,
++ int n_threads,
+ bool save_alignment_heads_QKs,
+ ggml_abort_callback abort_callback,
+ void * abort_callback_data) {
+@@ -2875,6 +2866,11 @@
+ }
+
+ logits = gf->nodes[gf->n_nodes - 1];
++
++ if (batch.n_tokens < 16) {
++ if (n_threads > 23)
++ n_threads = 23;
++ }
+
+ if (!ggml_graph_compute_helper(sched, gf, n_threads)) {
+ return false;
+@@ -3603,7 +3599,6 @@
+
+ struct whisper_context_params whisper_context_default_params() {
+ struct whisper_context_params result = {
+- /*.use_gpu =*/ true,
+ /*.flash_attn =*/ false,
+ /*.gpu_device =*/ 0,
+
+@@ -3708,7 +3703,8 @@
+ params.dtw_token_timestamps = false;
+ }
+
+- WHISPER_LOG_INFO("%s: use gpu = %d\n", __func__, params.use_gpu);
++ WHISPER_LOG_INFO("%s: cuda gpu = %d\n", __func__, llamafile_has_cuda());
++ WHISPER_LOG_INFO("%s: metal gpu = %d\n", __func__, llamafile_has_metal());
+ WHISPER_LOG_INFO("%s: flash attn = %d\n", __func__, params.flash_attn);
+ WHISPER_LOG_INFO("%s: gpu_device = %d\n", __func__, params.gpu_device);
+ WHISPER_LOG_INFO("%s: dtw = %d\n", __func__, params.dtw_token_timestamps);
+@@ -4782,7 +4778,7 @@
+ struct whisper_full_params result = {
+ /*.strategy =*/ strategy,
+
+- /*.n_threads =*/ std::min(4, (int32_t) std::thread::hardware_concurrency()),
++ /*.n_threads =*/ std::min(8, (int32_t) cpu_get_num_math()),
+ /*.n_max_text_ctx =*/ 16384,
+ /*.offset_ms =*/ 0,
+ /*.duration_ms =*/ 0,
+@@ -5130,12 +5126,7 @@
+ // populate the logprobs array (log_softmax)
+ {
+ const float logit_max = *std::max_element(logits.begin(), logits.end());
+- float logsumexp = 0.0f;
+- for (int i = 0; i < n_logits; ++i) {
+- if (logits[i] > -INFINITY) {
+- logsumexp += expf(logits[i] - logit_max);
+- }
+- }
++ float logsumexp = ggml_vec_soft_max_f32(n_logits, 0, logits.data(), logit_max); // [jart]
+ logsumexp = logf(logsumexp) + logit_max;
+
+ for (int i = 0; i < n_logits; ++i) {
+@@ -5155,14 +5146,14 @@
+ {
+ float logsumexp = 0.0f;
+ const float logprob_max = *std::max_element(logprobs.begin() + vocab.token_beg, logprobs.end());
+- for (int i = vocab.token_beg; i < n_logits; ++i) {
+- if (logprobs[i] > -INFINITY) {
+- logsumexp += expf(logprobs[i] - logprob_max);
++ if (logprob_max > -INFINITY) {
++ float logsumexp = ggml_vec_soft_max_f32(n_logits - vocab.token_beg, 0,
++ &logprobs[vocab.token_beg],
++ logprob_max); // [jart]
++ if (logsumexp > 0.0f) {
++ timestamp_logprob = logf(logsumexp) + logprob_max;
+ }
+ }
+- if (logsumexp > 0.0f) {
+- timestamp_logprob = logf(logsumexp) + logprob_max;
+- }
+ }
+
+ const float max_text_token_logprob = *std::max_element(logprobs.begin(), logprobs.begin() + vocab.token_beg);
+@@ -5181,12 +5172,7 @@
+ // populate the logprobs array (log_softmax)
+ {
+ const float logit_max = *std::max_element(logits.begin(), logits.end());
+- float logsumexp = 0.0f;
+- for (int i = 0; i < n_logits; ++i) {
+- if (logits[i] > -INFINITY) {
+- logsumexp += expf(logits[i] - logit_max);
+- }
+- }
++ float logsumexp = ggml_vec_soft_max_f32(n_logits, 0, logits.data(), logit_max); // [jart]
+ logsumexp = logf(logsumexp) + logit_max;
+
+ for (int i = 0; i < n_logits; ++i) {
+@@ -5203,15 +5189,7 @@
+ }
+
+ // compute probs
+- {
+- for (int i = 0; i < n_logits; ++i) {
+- if (logits[i] == -INFINITY) {
+- probs[i] = 0.0f;
+- } else {
+- probs[i] = expf(logprobs[i]);
+- }
+- }
+- }
++ ggml_vec_soft_max_f32(n_logits, &probs[0], logprobs.data(), 0); // [jart]
+
+ #if 0
+ // print first 100 logits - token string : logit
+@@ -7462,6 +7440,8 @@
+ static void whisper_log_callback_default(ggml_log_level level, const char * text, void * user_data) {
+ (void) level;
+ (void) user_data;
++ if (FLAG_log_disable)
++ return;
+ fputs(text, stderr);
+ fflush(stderr);
+ }
diff --git a/whisper.cpp.patches/patches/005-whisper-h-llamafile-integration.patch b/whisper.cpp.patches/patches/005-whisper-h-llamafile-integration.patch
new file mode 100644
index 00000000..664382a4
--- /dev/null
+++ b/whisper.cpp.patches/patches/005-whisper-h-llamafile-integration.patch
@@ -0,0 +1,19 @@
+--- include/whisper.h 2025-10-31 16:34:53
++++ ../non_submodule_llamafile/whisper.cpp/whisper.h 2025-10-31 16:53:51
+@@ -1,7 +1,7 @@
+ #ifndef WHISPER_H
+ #define WHISPER_H
+
+-#include "ggml.h"
++#include "ggml_extend.hpp"
+
+ #include <stddef.h>
+ #include <stdint.h>
+@@ -114,7 +114,6 @@
+ } whisper_aheads;
+
+ struct whisper_context_params {
+- bool use_gpu;
+ bool flash_attn;
+ int gpu_device; // CUDA device
+
diff --git a/whisper.cpp.patches/patches/006-main-cpp-llamafile-integration.patch b/whisper.cpp.patches/patches/006-main-cpp-llamafile-integration.patch
new file mode 100644
index 00000000..fd806e31
--- /dev/null
+++ b/whisper.cpp.patches/patches/006-main-cpp-llamafile-integration.patch
@@ -0,0 +1,248 @@
+--- examples/main/main.cpp 2025-10-31 22:21:46
++++ ../whisper.cpp.patches/main.cpp 2025-10-31 16:01:53
+@@ -1,4 +1,11 @@
++// -*- mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8 -*-
++// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
++
++#include "llamafile/version.h"
++#include "llamafile/llamafile.h"
++#include "llama.cpp/cores.h"
+ #include "common.h"
++#include "slurp.h"
+
+ #include "whisper.h"
+ #include "grammar-parser.h"
+@@ -11,24 +18,19 @@
+ #include <thread>
+ #include <vector>
+ #include <cstring>
++#include <cosmo.h>
+
++#include "llamafile/llamafile.h"
++#include "llamafile/debug.h"
++#include "llama.cpp/string.h"
++
+ #if defined(_MSC_VER)
+ #pragma warning(disable: 4244 4267) // possible loss of data
+ #endif
+
+-// helper function to replace substrings
+-static void replace_all(std::string & s, const std::string & search, const std::string & replace) {
+- for (size_t pos = 0; ; pos += replace.length()) {
+- pos = s.find(search, pos);
+- if (pos == std::string::npos) break;
+- s.erase(pos, search.length());
+- s.insert(pos, replace);
+- }
+-}
+-
+ // command-line parameters
+ struct whisper_params {
+- int32_t n_threads = std::min(4, (int32_t) std::thread::hardware_concurrency());
++ int32_t n_threads = std::min(16, cpu_get_num_math());
+ int32_t n_processors = 1;
+ int32_t offset_t_ms = 0;
+ int32_t offset_n = 0;
+@@ -68,7 +70,6 @@
+ bool print_progress = false;
+ bool no_timestamps = false;
+ bool log_score = false;
+- bool use_gpu = true;
+ bool flash_attn = false;
+
+ std::string language = "en";
+@@ -91,7 +92,7 @@
+ std::vector<std::string> fname_inp = {};
+ std::vector<std::string> fname_out = {};
+
+- grammar_parser::parse_state grammar_parsed;
++ whisper_grammar_parser::parse_state grammar_parsed;
+ };
+
+ static void whisper_print_usage(int argc, char ** argv, const whisper_params & params);
+@@ -118,6 +119,40 @@
+ continue;
+ }
+
++ if (arg == "--log-disable") {
++ FLAG_log_disable = true;
++ } else if (arg == "--cli") {
++ } else if (arg == "--server") {
++ } else if (arg == "--fast") {
++ FLAG_fast = true;
++ } else if (arg == "--precise") {
++ FLAG_precise = true;
++ } else if (arg == "--trace") {
++ FLAG_trace = true;
++ } else if (arg == "--trap") {
++ FLAG_trap = true;
++ FLAG_unsecure = true; // for better backtraces
++ llamafile_trapping_enabled(+1);
++ } else if (arg == "--unsecure") {
++ FLAG_unsecure = true;
++ } else if (arg == "--nocompile") {
++ FLAG_nocompile = true;
++ } else if (arg == "--recompile") {
++ FLAG_recompile = true;
++ } else if (arg == "--tinyblas") {
++ FLAG_tinyblas = true; // undocumented
++ } else if (arg == "--gpu") {
++ if (++i >= argc) {
++ fprintf(stderr, "error: missing --gpu flag value\n");
++ exit(1);
++ }
++ FLAG_gpu = llamafile_gpu_parse(argv[i]);
++ if (FLAG_gpu == LLAMAFILE_GPU_ERROR) {
++ fprintf(stderr, "error: invalid --gpu flag value: %s\n", argv[i]);
++ exit(1);
++ }
++ } else
++
+ if (arg == "-h" || arg == "--help") {
+ whisper_print_usage(argc, argv, params);
+ exit(0);
+@@ -153,7 +188,7 @@
+ else if (arg == "-oj" || arg == "--output-json") { params.output_jsn = true; }
+ else if (arg == "-ojf" || arg == "--output-json-full"){ params.output_jsn_full = params.output_jsn = true; }
+ else if (arg == "-of" || arg == "--output-file") { params.fname_out.emplace_back(argv[++i]); }
+- else if (arg == "-np" || arg == "--no-prints") { params.no_prints = true; }
++ else if (arg == "-np" || arg == "--no-prints") { params.no_prints = true; FLAG_log_disable = true; }
+ else if (arg == "-ps" || arg == "--print-special") { params.print_special = true; }
+ else if (arg == "-pc" || arg == "--print-colors") { params.print_colors = true; }
+ else if (arg == "-pp" || arg == "--print-progress") { params.print_progress = true; }
+@@ -166,18 +201,20 @@
+ else if (arg == "-oved" || arg == "--ov-e-device") { params.openvino_encode_device = argv[++i]; }
+ else if (arg == "-dtw" || arg == "--dtw") { params.dtw = argv[++i]; }
+ else if (arg == "-ls" || arg == "--log-score") { params.log_score = true; }
+- else if (arg == "-ng" || arg == "--no-gpu") { params.use_gpu = false; }
++ else if (arg == "-ng" || arg == "--no-gpu") { FLAG_gpu = LLAMAFILE_GPU_DISABLE; }
+ else if (arg == "-fa" || arg == "--flash-attn") { params.flash_attn = true; }
+ else if ( arg == "--suppress-regex") { params.suppress_regex = argv[++i]; }
+ else if ( arg == "--grammar") { params.grammar = argv[++i]; }
+ else if ( arg == "--grammar-rule") { params.grammar_rule = argv[++i]; }
+ else if ( arg == "--grammar-penalty") { params.grammar_penalty = std::stof(argv[++i]); }
+ else {
+- fprintf(stderr, "error: unknown argument: %s\n", arg.c_str());
+- whisper_print_usage(argc, argv, params);
++ fprintf(stderr, "error: unknown argument: %s\n", arg.c_str()); // [jart]
++ // whisper_print_usage(argc, argv, params); // [jart]
+ exit(0);
+ }
+ }
++
++ FLAGS_READY = true;
+
+ return true;
+ }
+@@ -232,7 +269,7 @@
+ fprintf(stderr, " -oved D, --ov-e-device DNAME [%-7s] the OpenVINO device used for encode inference\n", params.openvino_encode_device.c_str());
+ fprintf(stderr, " -dtw MODEL --dtw MODEL [%-7s] compute token-level timestamps\n", params.dtw.c_str());
+ fprintf(stderr, " -ls, --log-score [%-7s] log best decoder scores of tokens\n", params.log_score?"true":"false");
+- fprintf(stderr, " -ng, --no-gpu [%-7s] disable GPU\n", params.use_gpu ? "false" : "true");
++ fprintf(stderr, " -ng, --no-gpu [%-7s] disable GPU\n", FLAG_gpu == LLAMAFILE_GPU_DISABLE ? "false" : "true");
+ fprintf(stderr, " -fa, --flash-attn [%-7s] flash attention\n", params.flash_attn ? "true" : "false");
+ fprintf(stderr, " --suppress-regex REGEX [%-7s] regular expression matching tokens to suppress\n", params.suppress_regex.c_str());
+ fprintf(stderr, " --grammar GRAMMAR [%-7s] GBNF grammar to guide decoding\n", params.grammar.c_str());
+@@ -825,10 +862,10 @@
+ }
+ }
+
+- ::replace_all(txt_bg, "'", "\u2019");
+- ::replace_all(txt_bg, "\"", "\\\"");
+- ::replace_all(txt_fg, "'", "\u2019");
+- ::replace_all(txt_fg, "\"", "\\\"");
++ txt_bg = replace_all(txt_bg, "'", "\u2019");
++ txt_bg = replace_all(txt_bg, "\"", "\\\"");
++ txt_fg = replace_all(txt_fg, "'", "\u2019");
++ txt_fg = replace_all(txt_fg, "\"", "\\\"");
+ }
+
+ if (is_first) {
+@@ -903,9 +940,37 @@
+
+ static void cb_log_disable(enum ggml_log_level , const char * , void * ) { }
+
++int whisper_server_main(int argc, char ** argv);
++
+ int main(int argc, char ** argv) {
+- whisper_params params;
+
++ mallopt(M_GRANULARITY, 1 * 1024 * 1024);
++ mallopt(M_MMAP_THRESHOLD, 1 * 1024 * 1024);
++ mallopt(M_TRIM_THRESHOLD, 32 * 1024 * 1024);
++ FLAG_gpu = LLAMAFILE_GPU_DISABLE; // pass `--gpu auto` to enable it
++ llamafile_check_cpu();
++ ShowCrashReports();
++
++ if (llamafile_has(argv, "--version")) {
++ puts("whisperfile v" LLAMAFILE_VERSION_STRING);
++ return 0;
++ }
++
++ if (llamafile_has(argv, "-h") ||
++ llamafile_has(argv, "-help") ||
++ llamafile_has(argv, "--help")) {
++ llamafile_help("/zip/whisper.cpp/main.1.asc");
++ __builtin_unreachable();
++ }
++
++ argc = cosmo_args("/zip/.args", &argv);
++
++ if (!llamafile_has(argv, "--cli") &&
++ (llamafile_has(argv, "--server") ||
++ !llamafile_has(argv, "-f"))) {
++ return whisper_server_main(argc, argv);
++ }
++
+ // If the only argument starts with "@", read arguments line-by-line
+ // from the given file.
+ std::vector<std::string> vec_args;
+@@ -935,6 +1000,7 @@
+ }
+ }
+
++ whisper_params params;
+ if (whisper_params_parse(argc, argv, params) == false) {
+ whisper_print_usage(argc, argv, params);
+ return 1;
+@@ -979,7 +1045,6 @@
+
+ struct whisper_context_params cparams = whisper_context_default_params();
+
+- cparams.use_gpu = params.use_gpu;
+ cparams.flash_attn = params.flash_attn;
+
+ if (!params.dtw.empty()) {
+@@ -1020,10 +1085,10 @@
+ // read grammar from file
+ std::ifstream ifs(params.grammar.c_str());
+ const std::string txt = std::string((std::istreambuf_iterator<char>(ifs)), std::istreambuf_iterator<char>());
+- grammar = grammar_parser::parse(txt.c_str());
++ grammar = whisper_grammar_parser::parse(txt.c_str());
+ } else {
+ // read grammar from string
+- grammar = grammar_parser::parse(params.grammar.c_str());
++ grammar = whisper_grammar_parser::parse(params.grammar.c_str());
+ }
+
+ // will be empty (default) if there are parse errors
+@@ -1032,7 +1097,7 @@
+ return 4;
+ } else {
+ fprintf(stderr, "%s: grammar:\n", __func__);
+- grammar_parser::print_grammar(stderr, grammar);
++ whisper_grammar_parser::print_grammar(stderr, grammar);
+ fprintf(stderr, "\n");
+ }
+ }
+@@ -1044,8 +1109,8 @@
+ std::vector<float> pcmf32; // mono-channel F32 PCM
+ std::vector<std::vector<float>> pcmf32s; // stereo-channel F32 PCM
+
+- if (!::read_wav(fname_inp, pcmf32, pcmf32s, params.diarize)) {
+- fprintf(stderr, "error: failed to read WAV file '%s'\n", fname_inp.c_str());
++ if (!slurp_audio_file(fname_inp.c_str(), pcmf32, pcmf32s, params.diarize)) {
++ fprintf(stderr, "error: failed to read audio file '%s'\n", fname_inp.c_str());
+ continue;
+ }
+
diff --git a/whisper.cpp.patches/patches/007-stream-cpp-llamafile-integration.patch b/whisper.cpp.patches/patches/007-stream-cpp-llamafile-integration.patch
new file mode 100644
index 00000000..a2f626db
--- /dev/null
+++ b/whisper.cpp.patches/patches/007-stream-cpp-llamafile-integration.patch
@@ -0,0 +1,522 @@
+--- examples/stream/stream.cpp 2025-10-31 22:21:46
++++ ../whisper.cpp.patches/stream.cpp 2025-10-31 16:01:53
+@@ -1,8 +1,3 @@
+-// Real-time speech recognition of input from a microphone
+-//
+-// A very quick-n-dirty implementation serving mainly as a proof of concept.
+-//
+-#include "common-sdl.h"
+ #include "common.h"
+ #include "whisper.h"
+
+@@ -12,11 +7,11 @@
+ #include <thread>
+ #include <vector>
+ #include <fstream>
++#include <cosmoaudio.h>
+
+-
+ // command-line parameters
+ struct whisper_params {
+- int32_t n_threads = std::min(4, (int32_t) std::thread::hardware_concurrency());
++ int32_t n_threads = std::min(8, (int32_t) std::thread::hardware_concurrency());
+ int32_t step_ms = 3000;
+ int32_t length_ms = 10000;
+ int32_t keep_ms = 200;
+@@ -33,7 +28,7 @@
+ bool no_context = true;
+ bool no_timestamps = false;
+ bool tinydiarize = false;
+- bool save_audio = false; // save audio to wav file
++ bool save_audio = false;
+ bool use_gpu = true;
+ bool flash_attn = false;
+
+@@ -67,7 +62,7 @@
+ else if (arg == "-kc" || arg == "--keep-context") { params.no_context = false; }
+ else if (arg == "-l" || arg == "--language") { params.language = argv[++i]; }
+ else if (arg == "-m" || arg == "--model") { params.model = argv[++i]; }
+- else if (arg == "-f" || arg == "--file") { params.fname_out = argv[++i]; }
++ else if (arg == "-o" || arg == "--output-file") { params.fname_out = argv[++i]; }
+ else if (arg == "-tdrz" || arg == "--tinydiarize") { params.tinydiarize = true; }
+ else if (arg == "-sa" || arg == "--save-audio") { params.save_audio = true; }
+ else if (arg == "-ng" || arg == "--no-gpu") { params.use_gpu = false; }
+@@ -104,7 +99,7 @@
+ fprintf(stderr, " -kc, --keep-context [%-7s] keep context between audio chunks\n", params.no_context ? "false" : "true");
+ fprintf(stderr, " -l LANG, --language LANG [%-7s] spoken language\n", params.language.c_str());
+ fprintf(stderr, " -m FNAME, --model FNAME [%-7s] model path\n", params.model.c_str());
+- fprintf(stderr, " -f FNAME, --file FNAME [%-7s] text output file name\n", params.fname_out.c_str());
++ fprintf(stderr, " -o FNAME, --file FNAME [%-7s] text output file name\n", params.fname_out.c_str());
+ fprintf(stderr, " -tdrz, --tinydiarize [%-7s] enable tinydiarize (requires a tdrz model)\n", params.tinydiarize ? "true" : "false");
+ fprintf(stderr, " -sa, --save-audio [%-7s] save the recorded audio to a file\n", params.save_audio ? "true" : "false");
+ fprintf(stderr, " -ng, --no-gpu [%-7s] disable GPU inference\n", params.use_gpu ? "false" : "true");
+@@ -112,39 +107,60 @@
+ fprintf(stderr, "\n");
+ }
+
+-int main(int argc, char ** argv) {
++struct Transcriber {
+ whisper_params params;
++ bool use_vad;
++ int n_samples_step;
++ int n_samples_len;
++ int n_samples_keep;
++ int n_new_line;
++ struct CosmoAudio *audio;
++ struct whisper_context *ctx;
++ std::vector<float> pcmf32;
++ std::vector<float> pcmf32_old;
++ std::vector<float> pcmf32_new;
++ std::vector<whisper_token> prompt_tokens;
++ int n_iter;
++ std::ofstream fout;
++ wav_writer wavWriter;
+
+- if (whisper_params_parse(argc, argv, params) == false) {
++ int main(int argc, char *argv[]);
++
++ void inference();
++};
++
++int Transcriber::main(int argc, char *argv[]) {
++ if (whisper_params_parse(argc, argv, params) == false)
+ return 1;
+- }
+
+ params.keep_ms = std::min(params.keep_ms, params.step_ms);
+ params.length_ms = std::max(params.length_ms, params.step_ms);
+
+- const int n_samples_step = (1e-3*params.step_ms )*WHISPER_SAMPLE_RATE;
+- const int n_samples_len = (1e-3*params.length_ms)*WHISPER_SAMPLE_RATE;
+- const int n_samples_keep = (1e-3*params.keep_ms )*WHISPER_SAMPLE_RATE;
+- const int n_samples_30s = (1e-3*30000.0 )*WHISPER_SAMPLE_RATE;
++ n_samples_step = (1e-3*params.step_ms )*WHISPER_SAMPLE_RATE;
++ n_samples_len = (1e-3*params.length_ms)*WHISPER_SAMPLE_RATE;
++ n_samples_keep = (1e-3*params.keep_ms )*WHISPER_SAMPLE_RATE;
+
+- const bool use_vad = n_samples_step <= 0; // sliding window mode uses VAD
++ use_vad = n_samples_step <= 0; // sliding window mode uses VAD
+
+- const int n_new_line = !use_vad ? std::max(1, params.length_ms / params.step_ms - 1) : 1; // number of steps to print new line
++ n_new_line = !use_vad ? std::max(1, params.length_ms / params.step_ms - 1) : 1; // number of steps to print new line
+
+ params.no_timestamps = !use_vad;
+ params.no_context |= use_vad;
+ params.max_tokens = 0;
+
+ // init audio
+-
+- audio_async audio(params.length_ms);
+- if (!audio.init(params.capture_id, WHISPER_SAMPLE_RATE)) {
+- fprintf(stderr, "%s: audio.init() failed!\n", __func__);
+- return 1;
++ struct CosmoAudioOpenOptions cao = {};
++ cao.sizeofThis = sizeof(struct CosmoAudioOpenOptions);
++ cao.deviceType = kCosmoAudioDeviceTypeCapture;
++ cao.sampleRate = WHISPER_SAMPLE_RATE;
++ cao.bufferFrames = n_samples_len;
++ cao.channels = 1;
++ cao.debugLog = 1;
++ if (cosmoaudio_open(&audio, &cao) != COSMOAUDIO_SUCCESS) {
++ fprintf(stderr, "error: failed to open microphone\n");
++ exit(1);
+ }
+
+- audio.resume();
+-
+ // whisper init
+ if (params.language != "auto" && whisper_lang_id(params.language.c_str()) == -1){
+ fprintf(stderr, "error: unknown language '%s'\n", params.language.c_str());
+@@ -153,53 +169,13 @@
+ }
+
+ struct whisper_context_params cparams = whisper_context_default_params();
+-
+- cparams.use_gpu = params.use_gpu;
++ // cparams.use_gpu = params.use_gpu;
+ cparams.flash_attn = params.flash_attn;
+
+- struct whisper_context * ctx = whisper_init_from_file_with_params(params.model.c_str(), cparams);
++ ctx = whisper_init_from_file_with_params(params.model.c_str(), cparams);
+
+- std::vector<float> pcmf32 (n_samples_30s, 0.0f);
+- std::vector<float> pcmf32_old;
+- std::vector<float> pcmf32_new(n_samples_30s, 0.0f);
+-
+- std::vector<whisper_token> prompt_tokens;
+-
+- // print some info about the processing
+- {
+- fprintf(stderr, "\n");
+- if (!whisper_is_multilingual(ctx)) {
+- if (params.language != "en" || params.translate) {
+- params.language = "en";
+- params.translate = false;
+- fprintf(stderr, "%s: WARNING: model is not multilingual, ignoring language and translation options\n", __func__);
+- }
+- }
+- fprintf(stderr, "%s: processing %d samples (step = %.1f sec / len = %.1f sec / keep = %.1f sec), %d threads, lang = %s, task = %s, timestamps = %d ...\n",
+- __func__,
+- n_samples_step,
+- float(n_samples_step)/WHISPER_SAMPLE_RATE,
+- float(n_samples_len )/WHISPER_SAMPLE_RATE,
+- float(n_samples_keep)/WHISPER_SAMPLE_RATE,
+- params.n_threads,
+- params.language.c_str(),
+- params.translate ? "translate" : "transcribe",
+- params.no_timestamps ? 0 : 1);
+-
+- if (!use_vad) {
+- fprintf(stderr, "%s: n_new_line = %d, no_context = %d\n", __func__, n_new_line, params.no_context);
+- } else {
+- fprintf(stderr, "%s: using VAD, will transcribe on speech activity\n", __func__);
+- }
+-
+- fprintf(stderr, "\n");
+- }
+-
+- int n_iter = 0;
++ n_iter = 0;
+
+- bool is_running = true;
+-
+- std::ofstream fout;
+ if (params.fname_out.length() > 0) {
+ fout.open(params.fname_out);
+ if (!fout.is_open()) {
+@@ -208,7 +184,6 @@
+ }
+ }
+
+- wav_writer wavWriter;
+ // save wav file
+ if (params.save_audio) {
+ // Get current date/time for filename
+@@ -216,9 +191,9 @@
+ char buffer[80];
+ strftime(buffer, sizeof(buffer), "%Y%m%d%H%M%S", localtime(&now));
+ std::string filename = std::string(buffer) + ".wav";
+-
+ wavWriter.open(filename, WHISPER_SAMPLE_RATE, 16, 1);
+ }
++
+ printf("[Start speaking]\n");
+ fflush(stdout);
+
+@@ -226,195 +201,163 @@
+ const auto t_start = t_last;
+
+ // main audio loop
+- while (is_running) {
+- if (params.save_audio) {
++ for (;;) {
++ if (params.save_audio)
+ wavWriter.write(pcmf32_new.data(), pcmf32_new.size());
+- }
+- // handle Ctrl + C
+- is_running = sdl_poll_events();
++ inference();
++ }
+
+- if (!is_running) {
++ cosmoaudio_close(audio);
++ whisper_print_timings(ctx);
++ whisper_free(ctx);
++ return 0;
++}
++
++void Transcriber::inference() {
++
++ pcmf32_new.clear();
++ for (;;) {
++ int rc;
++ int avail = 2;
++ if ((rc = cosmoaudio_poll(audio, &avail, 0)) != COSMOAUDIO_SUCCESS) {
++ fprintf(stderr, "error: cosmoaudio_poll failed: %d\n", rc);
++ exit(1);
++ }
++ --avail;
++ int old_size = pcmf32_new.size();
++ pcmf32_new.resize(old_size + avail);
++ if ((rc = cosmoaudio_read(audio, &pcmf32_new[old_size], avail)) != avail) {
++ fprintf(stderr, "error: cosmoaudio_poll failed: %d (want %d)\n", rc, avail);
++ continue;
++ }
++ int new_size = pcmf32_new.size();
++ if (new_size > 2*n_samples_step) {
++ fprintf(stderr, "\n\n%s: WARNING: cannot process audio fast enough, dropping audio ...\n\n", __func__);
++ pcmf32_new.clear();
++ }
++ if (new_size >= n_samples_step) {
+ break;
+ }
++ }
+
+- // process new audio
++ // get audio
++ int n_samples_new = pcmf32_new.size();
++ // take up to params.length_ms audio from previous iteration
++ const int n_samples_take = std::min((int) pcmf32_old.size(), std::max(0, n_samples_keep + n_samples_len - n_samples_new));
++ // printf("processing: take = %d, new = %d, old = %d\n", n_samples_take, n_samples_new, (int) pcmf32_old.size());
++ pcmf32.resize(n_samples_new + n_samples_take);
++ for (int i = 0; i < n_samples_take; i++)
++ pcmf32[i] = pcmf32_old[pcmf32_old.size() - n_samples_take + i];
++ memcpy(pcmf32.data() + n_samples_take, pcmf32_new.data(), n_samples_new*sizeof(float));
+
+- if (!use_vad) {
+- while (true) {
+- audio.get(params.step_ms, pcmf32_new);
++ pcmf32_old = pcmf32;
+
+- if ((int) pcmf32_new.size() > 2*n_samples_step) {
+- fprintf(stderr, "\n\n%s: WARNING: cannot process audio fast enough, dropping audio ...\n\n", __func__);
+- audio.clear();
+- continue;
+- }
++ // run the inference
++ {
++ whisper_full_params wparams = whisper_full_default_params(WHISPER_SAMPLING_BEAM_SEARCH);
++ wparams.print_progress = false;
++ wparams.print_special = params.print_special;
++ wparams.print_realtime = false;
++ wparams.print_timestamps = !params.no_timestamps;
++ wparams.translate = params.translate;
++ wparams.single_segment = !use_vad;
++ wparams.max_tokens = params.max_tokens;
++ wparams.language = params.language.c_str();
++ wparams.n_threads = params.n_threads;
++ wparams.audio_ctx = params.audio_ctx;
++ wparams.tdrz_enable = params.tinydiarize; // [TDRZ]
++ wparams.temperature_inc = params.no_fallback ? 0.0f : wparams.temperature_inc;
++ wparams.prompt_tokens = params.no_context ? nullptr : prompt_tokens.data();
++ wparams.prompt_n_tokens = params.no_context ? 0 : prompt_tokens.size();
+
+- if ((int) pcmf32_new.size() >= n_samples_step) {
+- audio.clear();
+- break;
+- }
++ if (whisper_full(ctx, wparams, pcmf32.data(), pcmf32.size()) != 0) {
++ fprintf(stderr, "error: failed to process audio\n");
++ exit(6);
++ }
+
+- std::this_thread::sleep_for(std::chrono::milliseconds(1));
+- }
++ // print result;
++ {
++ if (!use_vad) {
++ printf("\33[2K\r");
+
+- const int n_samples_new = pcmf32_new.size();
++ // print long empty line to clear the previous line
++ printf("%s", std::string(100, ' ').c_str());
+
+- // take up to params.length_ms audio from previous iteration
+- const int n_samples_take = std::min((int) pcmf32_old.size(), std::max(0, n_samples_keep + n_samples_len - n_samples_new));
+-
+- //printf("processing: take = %d, new = %d, old = %d\n", n_samples_take, n_samples_new, (int) pcmf32_old.size());
+-
+- pcmf32.resize(n_samples_new + n_samples_take);
+-
+- for (int i = 0; i < n_samples_take; i++) {
+- pcmf32[i] = pcmf32_old[pcmf32_old.size() - n_samples_take + i];
++ printf("\33[2K\r");
+ }
+
+- memcpy(pcmf32.data() + n_samples_take, pcmf32_new.data(), n_samples_new*sizeof(float));
++ const int n_segments = whisper_full_n_segments(ctx);
++ for (int i = 0; i < n_segments; ++i) {
++ const char * text = whisper_full_get_segment_text(ctx, i);
+
+- pcmf32_old = pcmf32;
+- } else {
+- const auto t_now = std::chrono::high_resolution_clock::now();
+- const auto t_diff = std::chrono::duration_cast<std::chrono::milliseconds>(t_now - t_last).count();
++ if (params.no_timestamps) {
++ printf("%s", text);
++ fflush(stdout);
+
+- if (t_diff < 2000) {
+- std::this_thread::sleep_for(std::chrono::milliseconds(100));
+-
+- continue;
+- }
+-
+- audio.get(2000, pcmf32_new);
+-
+- if (::vad_simple(pcmf32_new, WHISPER_SAMPLE_RATE, 1000, params.vad_thold, params.freq_thold, false)) {
+- audio.get(params.length_ms, pcmf32);
+- } else {
+- std::this_thread::sleep_for(std::chrono::milliseconds(100));
+-
+- continue;
+- }
+-
+- t_last = t_now;
+- }
+-
+- // run the inference
+- {
+- whisper_full_params wparams = whisper_full_default_params(WHISPER_SAMPLING_GREEDY);
+-
+- wparams.print_progress = false;
+- wparams.print_special = params.print_special;
+- wparams.print_realtime = false;
+- wparams.print_timestamps = !params.no_timestamps;
+- wparams.translate = params.translate;
+- wparams.single_segment = !use_vad;
+- wparams.max_tokens = params.max_tokens;
+- wparams.language = params.language.c_str();
+- wparams.n_threads = params.n_threads;
+-
+- wparams.audio_ctx = params.audio_ctx;
+-
+- wparams.tdrz_enable = params.tinydiarize; // [TDRZ]
+-
+- // disable temperature fallback
+- //wparams.temperature_inc = -1.0f;
+- wparams.temperature_inc = params.no_fallback ? 0.0f : wparams.temperature_inc;
+-
+- wparams.prompt_tokens = params.no_context ? nullptr : prompt_tokens.data();
+- wparams.prompt_n_tokens = params.no_context ? 0 : prompt_tokens.size();
+-
+- if (whisper_full(ctx, wparams, pcmf32.data(), pcmf32.size()) != 0) {
+- fprintf(stderr, "%s: failed to process audio\n", argv[0]);
+- return 6;
+- }
+-
+- // print result;
+- {
+- if (!use_vad) {
+- printf("\33[2K\r");
+-
+- // print long empty line to clear the previous line
+- printf("%s", std::string(100, ' ').c_str());
+-
+- printf("\33[2K\r");
++ if (params.fname_out.length() > 0) {
++ fout << text;
++ }
+ } else {
+- const int64_t t1 = (t_last - t_start).count()/1000000;
+- const int64_t t0 = std::max(0.0, t1 - pcmf32.size()*1000.0/WHISPER_SAMPLE_RATE);
++ const int64_t t0 = whisper_full_get_segment_t0(ctx, i);
++ const int64_t t1 = whisper_full_get_segment_t1(ctx, i);
+
+- printf("\n");
+- printf("### Transcription %d START | t0 = %d ms | t1 = %d ms\n", n_iter, (int) t0, (int) t1);
+- printf("\n");
+- }
++ std::string output = "[" + to_timestamp(t0, false) + " --> " + to_timestamp(t1, false) + "] " + text;
+
+- const int n_segments = whisper_full_n_segments(ctx);
+- for (int i = 0; i < n_segments; ++i) {
+- const char * text = whisper_full_get_segment_text(ctx, i);
++ if (whisper_full_get_segment_speaker_turn_next(ctx, i)) {
++ output += " [SPEAKER_TURN]";
++ }
+
+- if (params.no_timestamps) {
+- printf("%s", text);
+- fflush(stdout);
++ output += "\n";
+
+- if (params.fname_out.length() > 0) {
+- fout << text;
+- }
+- } else {
+- const int64_t t0 = whisper_full_get_segment_t0(ctx, i);
+- const int64_t t1 = whisper_full_get_segment_t1(ctx, i);
++ printf("%s", output.c_str());
++ fflush(stdout);
+
+- std::string output = "[" + to_timestamp(t0, false) + " --> " + to_timestamp(t1, false) + "] " + text;
+-
+- if (whisper_full_get_segment_speaker_turn_next(ctx, i)) {
+- output += " [SPEAKER_TURN]";
+- }
+-
+- output += "\n";
+-
+- printf("%s", output.c_str());
+- fflush(stdout);
+-
+- if (params.fname_out.length() > 0) {
+- fout << output;
+- }
++ if (params.fname_out.length() > 0) {
++ fout << output;
+ }
+ }
++ }
+
+- if (params.fname_out.length() > 0) {
+- fout << std::endl;
+- }
++ if (params.fname_out.length() > 0) {
++ fout << std::endl;
++ }
+
+- if (use_vad) {
+- printf("\n");
+- printf("### Transcription %d END\n", n_iter);
+- }
++ if (use_vad) {
++ printf("\n");
++ printf("### Transcription %d END\n", n_iter);
+ }
++ }
+
+- ++n_iter;
++ ++n_iter;
+
+- if (!use_vad && (n_iter % n_new_line) == 0) {
+- printf("\n");
++ if (!use_vad && (n_iter % n_new_line) == 0) {
++ printf("\n");
+
+- // keep part of the audio for next iteration to try to mitigate word boundary issues
+- pcmf32_old = std::vector<float>(pcmf32.end() - n_samples_keep, pcmf32.end());
++ // keep part of the audio for next iteration to try to mitigate word boundary issues
++ pcmf32_old = std::vector<float>(pcmf32.end() - n_samples_keep, pcmf32.end());
+
+- // Add tokens of the last full length segment as the prompt
+- if (!params.no_context) {
+- prompt_tokens.clear();
++ // Add tokens of the last full length segment as the prompt
++ if (!params.no_context) {
++ prompt_tokens.clear();
+
+- const int n_segments = whisper_full_n_segments(ctx);
+- for (int i = 0; i < n_segments; ++i) {
+- const int token_count = whisper_full_n_tokens(ctx, i);
+- for (int j = 0; j < token_count; ++j) {
+- prompt_tokens.push_back(whisper_full_get_token_id(ctx, i, j));
+- }
++ const int n_segments = whisper_full_n_segments(ctx);
++ for (int i = 0; i < n_segments; ++i) {
++ const int token_count = whisper_full_n_tokens(ctx, i);
++ for (int j = 0; j < token_count; ++j) {
++ prompt_tokens.push_back(whisper_full_get_token_id(ctx, i, j));
+ }
+ }
+ }
+- fflush(stdout);
+ }
++ fflush(stdout);
+ }
++}
+
+- audio.pause();
++int main(int argc, char *argv[]) {
++ FLAG_gpu = LLAMAFILE_GPU_DISABLE;
++ llamafile_check_cpu();
++ ShowCrashReports();
+
+- whisper_print_timings(ctx);
+- whisper_free(ctx);
+-
+- return 0;
++ struct Transcriber ts;
++ return ts.main(argc, argv);
+ }
diff --git a/whisper.cpp.patches/patches/008-whisper-mel-cuda-cu-llamafile-integration.patch b/whisper.cpp.patches/patches/008-whisper-mel-cuda-cu-llamafile-integration.patch
new file mode 100644
index 00000000..26204f75
--- /dev/null
+++ b/whisper.cpp.patches/patches/008-whisper-mel-cuda-cu-llamafile-integration.patch
@@ -0,0 +1,9 @@
+--- src/whisper-mel-cuda.cu 2025-10-31 22:21:46
++++ ../whisper.cpp.patches/whisper-mel-cuda.cu 2025-10-31 16:01:53
+@@ -1,5 +1,5 @@
+ #define CUB_IGNORE_DEPRECATED_CPP_DIALECT
+-#include "whisper-mel-cuda.hpp"
++#include "whisper.cpp/whisper-mel-cuda.hpp"
+ #include "whisper.h"
+
+ #include <ggml-backend.h>
diff --git a/whisper.cpp.patches/patches/009-grammar-parser-cpp-llamafile-integration.patch b/whisper.cpp.patches/patches/009-grammar-parser-cpp-llamafile-integration.patch
new file mode 100644
index 00000000..4588d6d8
--- /dev/null
+++ b/whisper.cpp.patches/patches/009-grammar-parser-cpp-llamafile-integration.patch
@@ -0,0 +1,17 @@
+--- examples/grammar-parser.cpp 2025-10-31 22:21:46
++++ ../whisper.cpp.patches/grammar-parser.cpp 2025-10-31 16:01:53
+@@ -1,3 +1,5 @@
++// -*- mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8 -*-
++// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+ #include "grammar-parser.h"
+ #include <cstdint>
+ #include <cwchar>
+@@ -6,7 +8,7 @@
+ #include <stdexcept>
+ #include <exception>
+
+-namespace grammar_parser {
++namespace whisper_grammar_parser {
+ // NOTE: assumes valid utf8 (but checks for overrun)
+ // copied from whisper.cpp
+ static std::pair<uint32_t, const char *> decode_utf8(const char * src) {
diff --git a/whisper.cpp.patches/patches/010-grammar-parser-h-llamafile-integration.patch b/whisper.cpp.patches/patches/010-grammar-parser-h-llamafile-integration.patch
new file mode 100644
index 00000000..a8fca9b9
--- /dev/null
+++ b/whisper.cpp.patches/patches/010-grammar-parser-h-llamafile-integration.patch
@@ -0,0 +1,18 @@
+--- examples/grammar-parser.h 2025-10-31 22:21:46
++++ ../whisper.cpp.patches/grammar-parser.h 2025-10-31 16:01:53
+@@ -1,3 +1,6 @@
++// -*- mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8 -*-
++// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
++
+ // Implements a parser for an extended Backus-Naur form (BNF), producing the
+ // binary context-free grammar format specified by whisper.h. Supports character
+ // ranges, grouping, and repetition operators. As an example, a grammar for
+@@ -16,7 +19,7 @@
+ #include <cstdint>
+ #include <string>
+
+-namespace grammar_parser {
++namespace whisper_grammar_parser {
+ struct parse_state {
+ std::map<std::string, uint32_t> symbol_ids;
+ std::vector<std::vector<whisper_grammar_element>> rules;
diff --git a/whisper.cpp.patches/patches/011-dr-wav-h-llamafile-integration.patch b/whisper.cpp.patches/patches/011-dr-wav-h-llamafile-integration.patch
new file mode 100644
index 00000000..58feb5ee
--- /dev/null
+++ b/whisper.cpp.patches/patches/011-dr-wav-h-llamafile-integration.patch
@@ -0,0 +1,541 @@
+--- examples/dr_wav.h 2025-10-31 22:21:46
++++ ../whisper.cpp.patches/dr_wav.h 2025-10-31 16:01:53
+@@ -2553,404 +2553,402 @@
+ #include <errno.h>
+ static drwav_result drwav_result_from_errno(int e)
+ {
+- switch (e)
+- {
+- case 0: return DRWAV_SUCCESS;
++ // [jart] errno toil
++ if (e == 0) return DRWAV_SUCCESS;
+ #ifdef EPERM
+- case EPERM: return DRWAV_INVALID_OPERATION;
++ if (e == EPERM) return DRWAV_INVALID_OPERATION;
+ #endif
+ #ifdef ENOENT
+- case ENOENT: return DRWAV_DOES_NOT_EXIST;
++ if (e == ENOENT) return DRWAV_DOES_NOT_EXIST;
+ #endif
+ #ifdef ESRCH
+- case ESRCH: return DRWAV_DOES_NOT_EXIST;
++ if (e == ESRCH) return DRWAV_DOES_NOT_EXIST;
+ #endif
+ #ifdef EINTR
+- case EINTR: return DRWAV_INTERRUPT;
++ if (e == EINTR) return DRWAV_INTERRUPT;
+ #endif
+ #ifdef EIO
+- case EIO: return DRWAV_IO_ERROR;
++ if (e == EIO) return DRWAV_IO_ERROR;
+ #endif
+ #ifdef ENXIO
+- case ENXIO: return DRWAV_DOES_NOT_EXIST;
++ if (e == ENXIO) return DRWAV_DOES_NOT_EXIST;
+ #endif
+ #ifdef E2BIG
+- case E2BIG: return DRWAV_INVALID_ARGS;
++ if (e == E2BIG) return DRWAV_INVALID_ARGS;
+ #endif
+ #ifdef ENOEXEC
+- case ENOEXEC: return DRWAV_INVALID_FILE;
++ if (e == ENOEXEC) return DRWAV_INVALID_FILE;
+ #endif
+ #ifdef EBADF
+- case EBADF: return DRWAV_INVALID_FILE;
++ if (e == EBADF) return DRWAV_INVALID_FILE;
+ #endif
+ #ifdef ECHILD
+- case ECHILD: return DRWAV_ERROR;
++ if (e == ECHILD) return DRWAV_ERROR;
+ #endif
+ #ifdef EAGAIN
+- case EAGAIN: return DRWAV_UNAVAILABLE;
++ if (e == EAGAIN) return DRWAV_UNAVAILABLE;
+ #endif
+ #ifdef ENOMEM
+- case ENOMEM: return DRWAV_OUT_OF_MEMORY;
++ if (e == ENOMEM) return DRWAV_OUT_OF_MEMORY;
+ #endif
+ #ifdef EACCES
+- case EACCES: return DRWAV_ACCESS_DENIED;
++ if (e == EACCES) return DRWAV_ACCESS_DENIED;
+ #endif
+ #ifdef EFAULT
+- case EFAULT: return DRWAV_BAD_ADDRESS;
++ if (e == EFAULT) return DRWAV_BAD_ADDRESS;
+ #endif
+ #ifdef ENOTBLK
+- case ENOTBLK: return DRWAV_ERROR;
++ if (e == ENOTBLK) return DRWAV_ERROR;
+ #endif
+ #ifdef EBUSY
+- case EBUSY: return DRWAV_BUSY;
++ if (e == EBUSY) return DRWAV_BUSY;
+ #endif
+ #ifdef EEXIST
+- case EEXIST: return DRWAV_ALREADY_EXISTS;
++ if (e == EEXIST) return DRWAV_ALREADY_EXISTS;
+ #endif
+ #ifdef EXDEV
+- case EXDEV: return DRWAV_ERROR;
++ if (e == EXDEV) return DRWAV_ERROR;
+ #endif
+ #ifdef ENODEV
+- case ENODEV: return DRWAV_DOES_NOT_EXIST;
++ if (e == ENODEV) return DRWAV_DOES_NOT_EXIST;
+ #endif
+ #ifdef ENOTDIR
+- case ENOTDIR: return DRWAV_NOT_DIRECTORY;
++ if (e == ENOTDIR) return DRWAV_NOT_DIRECTORY;
+ #endif
+ #ifdef EISDIR
+- case EISDIR: return DRWAV_IS_DIRECTORY;
++ if (e == EISDIR) return DRWAV_IS_DIRECTORY;
+ #endif
+ #ifdef EINVAL
+- case EINVAL: return DRWAV_INVALID_ARGS;
++ if (e == EINVAL) return DRWAV_INVALID_ARGS;
+ #endif
+ #ifdef ENFILE
+- case ENFILE: return DRWAV_TOO_MANY_OPEN_FILES;
++ if (e == ENFILE) return DRWAV_TOO_MANY_OPEN_FILES;
+ #endif
+ #ifdef EMFILE
+- case EMFILE: return DRWAV_TOO_MANY_OPEN_FILES;
++ if (e == EMFILE) return DRWAV_TOO_MANY_OPEN_FILES;
+ #endif
+ #ifdef ENOTTY
+- case ENOTTY: return DRWAV_INVALID_OPERATION;
++ if (e == ENOTTY) return DRWAV_INVALID_OPERATION;
+ #endif
+ #ifdef ETXTBSY
+- case ETXTBSY: return DRWAV_BUSY;
++ if (e == ETXTBSY) return DRWAV_BUSY;
+ #endif
+ #ifdef EFBIG
+- case EFBIG: return DRWAV_TOO_BIG;
++ if (e == EFBIG) return DRWAV_TOO_BIG;
+ #endif
+ #ifdef ENOSPC
+- case ENOSPC: return DRWAV_NO_SPACE;
++ if (e == ENOSPC) return DRWAV_NO_SPACE;
+ #endif
+ #ifdef ESPIPE
+- case ESPIPE: return DRWAV_BAD_SEEK;
++ if (e == ESPIPE) return DRWAV_BAD_SEEK;
+ #endif
+ #ifdef EROFS
+- case EROFS: return DRWAV_ACCESS_DENIED;
++ if (e == EROFS) return DRWAV_ACCESS_DENIED;
+ #endif
+ #ifdef EMLINK
+- case EMLINK: return DRWAV_TOO_MANY_LINKS;
++ if (e == EMLINK) return DRWAV_TOO_MANY_LINKS;
+ #endif
+ #ifdef EPIPE
+- case EPIPE: return DRWAV_BAD_PIPE;
++ if (e == EPIPE) return DRWAV_BAD_PIPE;
+ #endif
+ #ifdef EDOM
+- case EDOM: return DRWAV_OUT_OF_RANGE;
++ if (e == EDOM) return DRWAV_OUT_OF_RANGE;
+ #endif
+ #ifdef ERANGE
+- case ERANGE: return DRWAV_OUT_OF_RANGE;
++ if (e == ERANGE) return DRWAV_OUT_OF_RANGE;
+ #endif
+ #ifdef EDEADLK
+- case EDEADLK: return DRWAV_DEADLOCK;
++ if (e == EDEADLK) return DRWAV_DEADLOCK;
+ #endif
+ #ifdef ENAMETOOLONG
+- case ENAMETOOLONG: return DRWAV_PATH_TOO_LONG;
++ if (e == ENAMETOOLONG) return DRWAV_PATH_TOO_LONG;
+ #endif
+ #ifdef ENOLCK
+- case ENOLCK: return DRWAV_ERROR;
++ if (e == ENOLCK) return DRWAV_ERROR;
+ #endif
+ #ifdef ENOSYS
+- case ENOSYS: return DRWAV_NOT_IMPLEMENTED;
++ if (e == ENOSYS) return DRWAV_NOT_IMPLEMENTED;
+ #endif
+ #ifdef ENOTEMPTY
+- case ENOTEMPTY: return DRWAV_DIRECTORY_NOT_EMPTY;
++ if (e == ENOTEMPTY) return DRWAV_DIRECTORY_NOT_EMPTY;
+ #endif
+ #ifdef ELOOP
+- case ELOOP: return DRWAV_TOO_MANY_LINKS;
++ if (e == ELOOP) return DRWAV_TOO_MANY_LINKS;
+ #endif
+ #ifdef ENOMSG
+- case ENOMSG: return DRWAV_NO_MESSAGE;
++ if (e == ENOMSG) return DRWAV_NO_MESSAGE;
+ #endif
+ #ifdef EIDRM
+- case EIDRM: return DRWAV_ERROR;
++ if (e == EIDRM) return DRWAV_ERROR;
+ #endif
+ #ifdef ECHRNG
+- case ECHRNG: return DRWAV_ERROR;
++ if (e == ECHRNG) return DRWAV_ERROR;
+ #endif
+ #ifdef EL2NSYNC
+- case EL2NSYNC: return DRWAV_ERROR;
++ if (e == EL2NSYNC) return DRWAV_ERROR;
+ #endif
+ #ifdef EL3HLT
+- case EL3HLT: return DRWAV_ERROR;
++ if (e == EL3HLT) return DRWAV_ERROR;
+ #endif
+ #ifdef EL3RST
+- case EL3RST: return DRWAV_ERROR;
++ if (e == EL3RST) return DRWAV_ERROR;
+ #endif
+ #ifdef ELNRNG
+- case ELNRNG: return DRWAV_OUT_OF_RANGE;
++ if (e == ELNRNG) return DRWAV_OUT_OF_RANGE;
+ #endif
+ #ifdef EUNATCH
+- case EUNATCH: return DRWAV_ERROR;
++ if (e == EUNATCH) return DRWAV_ERROR;
+ #endif
+ #ifdef ENOCSI
+- case ENOCSI: return DRWAV_ERROR;
++ if (e == ENOCSI) return DRWAV_ERROR;
+ #endif
+ #ifdef EL2HLT
+- case EL2HLT: return DRWAV_ERROR;
++ if (e == EL2HLT) return DRWAV_ERROR;
+ #endif
+ #ifdef EBADE
+- case EBADE: return DRWAV_ERROR;
++ if (e == EBADE) return DRWAV_ERROR;
+ #endif
+ #ifdef EBADR
+- case EBADR: return DRWAV_ERROR;
++ if (e == EBADR) return DRWAV_ERROR;
+ #endif
+ #ifdef EXFULL
+- case EXFULL: return DRWAV_ERROR;
++ if (e == EXFULL) return DRWAV_ERROR;
+ #endif
+ #ifdef ENOANO
+- case ENOANO: return DRWAV_ERROR;
++ if (e == ENOANO) return DRWAV_ERROR;
+ #endif
+ #ifdef EBADRQC
+- case EBADRQC: return DRWAV_ERROR;
++ if (e == EBADRQC) return DRWAV_ERROR;
+ #endif
+ #ifdef EBADSLT
+- case EBADSLT: return DRWAV_ERROR;
++ if (e == EBADSLT) return DRWAV_ERROR;
+ #endif
+ #ifdef EBFONT
+- case EBFONT: return DRWAV_INVALID_FILE;
++ if (e == EBFONT) return DRWAV_INVALID_FILE;
+ #endif
+ #ifdef ENOSTR
+- case ENOSTR: return DRWAV_ERROR;
++ if (e == ENOSTR) return DRWAV_ERROR;
+ #endif
+ #ifdef ENODATA
+- case ENODATA: return DRWAV_NO_DATA_AVAILABLE;
++ if (e == ENODATA) return DRWAV_NO_DATA_AVAILABLE;
+ #endif
+ #ifdef ETIME
+- case ETIME: return DRWAV_TIMEOUT;
++ if (e == ETIME) return DRWAV_TIMEOUT;
+ #endif
+ #ifdef ENOSR
+- case ENOSR: return DRWAV_NO_DATA_AVAILABLE;
++ if (e == ENOSR) return DRWAV_NO_DATA_AVAILABLE;
+ #endif
+ #ifdef ENONET
+- case ENONET: return DRWAV_NO_NETWORK;
++ if (e == ENONET) return DRWAV_NO_NETWORK;
+ #endif
+ #ifdef ENOPKG
+- case ENOPKG: return DRWAV_ERROR;
++ if (e == ENOPKG) return DRWAV_ERROR;
+ #endif
+ #ifdef EREMOTE
+- case EREMOTE: return DRWAV_ERROR;
++ if (e == EREMOTE) return DRWAV_ERROR;
+ #endif
+ #ifdef ENOLINK
+- case ENOLINK: return DRWAV_ERROR;
++ if (e == ENOLINK) return DRWAV_ERROR;
+ #endif
+ #ifdef EADV
+- case EADV: return DRWAV_ERROR;
++ if (e == EADV) return DRWAV_ERROR;
+ #endif
+ #ifdef ESRMNT
+- case ESRMNT: return DRWAV_ERROR;
++ if (e == ESRMNT) return DRWAV_ERROR;
+ #endif
+ #ifdef ECOMM
+- case ECOMM: return DRWAV_ERROR;
++ if (e == ECOMM) return DRWAV_ERROR;
+ #endif
+ #ifdef EPROTO
+- case EPROTO: return DRWAV_ERROR;
++ if (e == EPROTO) return DRWAV_ERROR;
+ #endif
+ #ifdef EMULTIHOP
+- case EMULTIHOP: return DRWAV_ERROR;
++ if (e == EMULTIHOP) return DRWAV_ERROR;
+ #endif
+ #ifdef EDOTDOT
+- case EDOTDOT: return DRWAV_ERROR;
++ if (e == EDOTDOT) return DRWAV_ERROR;
+ #endif
+ #ifdef EBADMSG
+- case EBADMSG: return DRWAV_BAD_MESSAGE;
++ if (e == EBADMSG) return DRWAV_BAD_MESSAGE;
+ #endif
+ #ifdef EOVERFLOW
+- case EOVERFLOW: return DRWAV_TOO_BIG;
++ if (e == EOVERFLOW) return DRWAV_TOO_BIG;
+ #endif
+ #ifdef ENOTUNIQ
+- case ENOTUNIQ: return DRWAV_NOT_UNIQUE;
++ if (e == ENOTUNIQ) return DRWAV_NOT_UNIQUE;
+ #endif
+ #ifdef EBADFD
+- case EBADFD: return DRWAV_ERROR;
++ if (e == EBADFD) return DRWAV_ERROR;
+ #endif
+ #ifdef EREMCHG
+- case EREMCHG: return DRWAV_ERROR;
++ if (e == EREMCHG) return DRWAV_ERROR;
+ #endif
+ #ifdef ELIBACC
+- case ELIBACC: return DRWAV_ACCESS_DENIED;
++ if (e == ELIBACC) return DRWAV_ACCESS_DENIED;
+ #endif
+ #ifdef ELIBBAD
+- case ELIBBAD: return DRWAV_INVALID_FILE;
++ if (e == ELIBBAD) return DRWAV_INVALID_FILE;
+ #endif
+ #ifdef ELIBSCN
+- case ELIBSCN: return DRWAV_INVALID_FILE;
++ if (e == ELIBSCN) return DRWAV_INVALID_FILE;
+ #endif
+ #ifdef ELIBMAX
+- case ELIBMAX: return DRWAV_ERROR;
++ if (e == ELIBMAX) return DRWAV_ERROR;
+ #endif
+ #ifdef ELIBEXEC
+- case ELIBEXEC: return DRWAV_ERROR;
++ if (e == ELIBEXEC) return DRWAV_ERROR;
+ #endif
+ #ifdef EILSEQ
+- case EILSEQ: return DRWAV_INVALID_DATA;
++ if (e == EILSEQ) return DRWAV_INVALID_DATA;
+ #endif
+ #ifdef ERESTART
+- case ERESTART: return DRWAV_ERROR;
++ if (e == ERESTART) return DRWAV_ERROR;
+ #endif
+ #ifdef ESTRPIPE
+- case ESTRPIPE: return DRWAV_ERROR;
++ if (e == ESTRPIPE) return DRWAV_ERROR;
+ #endif
+ #ifdef EUSERS
+- case EUSERS: return DRWAV_ERROR;
++ if (e == EUSERS) return DRWAV_ERROR;
+ #endif
+ #ifdef ENOTSOCK
+- case ENOTSOCK: return DRWAV_NOT_SOCKET;
++ if (e == ENOTSOCK) return DRWAV_NOT_SOCKET;
+ #endif
+ #ifdef EDESTADDRREQ
+- case EDESTADDRREQ: return DRWAV_NO_ADDRESS;
++ if (e == EDESTADDRREQ) return DRWAV_NO_ADDRESS;
+ #endif
+ #ifdef EMSGSIZE
+- case EMSGSIZE: return DRWAV_TOO_BIG;
++ if (e == EMSGSIZE) return DRWAV_TOO_BIG;
+ #endif
+ #ifdef EPROTOTYPE
+- case EPROTOTYPE: return DRWAV_BAD_PROTOCOL;
++ if (e == EPROTOTYPE) return DRWAV_BAD_PROTOCOL;
+ #endif
+ #ifdef ENOPROTOOPT
+- case ENOPROTOOPT: return DRWAV_PROTOCOL_UNAVAILABLE;
++ if (e == ENOPROTOOPT) return DRWAV_PROTOCOL_UNAVAILABLE;
+ #endif
+ #ifdef EPROTONOSUPPORT
+- case EPROTONOSUPPORT: return DRWAV_PROTOCOL_NOT_SUPPORTED;
++ if (e == EPROTONOSUPPORT) return DRWAV_PROTOCOL_NOT_SUPPORTED;
+ #endif
+ #ifdef ESOCKTNOSUPPORT
+- case ESOCKTNOSUPPORT: return DRWAV_SOCKET_NOT_SUPPORTED;
++ if (e == ESOCKTNOSUPPORT) return DRWAV_SOCKET_NOT_SUPPORTED;
+ #endif
+ #ifdef EOPNOTSUPP
+- case EOPNOTSUPP: return DRWAV_INVALID_OPERATION;
++ if (e == EOPNOTSUPP) return DRWAV_INVALID_OPERATION;
+ #endif
+ #ifdef EPFNOSUPPORT
+- case EPFNOSUPPORT: return DRWAV_PROTOCOL_FAMILY_NOT_SUPPORTED;
++ if (e == EPFNOSUPPORT) return DRWAV_PROTOCOL_FAMILY_NOT_SUPPORTED;
+ #endif
+ #ifdef EAFNOSUPPORT
+- case EAFNOSUPPORT: return DRWAV_ADDRESS_FAMILY_NOT_SUPPORTED;
++ if (e == EAFNOSUPPORT) return DRWAV_ADDRESS_FAMILY_NOT_SUPPORTED;
+ #endif
+ #ifdef EADDRINUSE
+- case EADDRINUSE: return DRWAV_ALREADY_IN_USE;
++ if (e == EADDRINUSE) return DRWAV_ALREADY_IN_USE;
+ #endif
+ #ifdef EADDRNOTAVAIL
+- case EADDRNOTAVAIL: return DRWAV_ERROR;
++ if (e == EADDRNOTAVAIL) return DRWAV_ERROR;
+ #endif
+ #ifdef ENETDOWN
+- case ENETDOWN: return DRWAV_NO_NETWORK;
++ if (e == ENETDOWN) return DRWAV_NO_NETWORK;
+ #endif
+ #ifdef ENETUNREACH
+- case ENETUNREACH: return DRWAV_NO_NETWORK;
++ if (e == ENETUNREACH) return DRWAV_NO_NETWORK;
+ #endif
+ #ifdef ENETRESET
+- case ENETRESET: return DRWAV_NO_NETWORK;
++ if (e == ENETRESET) return DRWAV_NO_NETWORK;
+ #endif
+ #ifdef ECONNABORTED
+- case ECONNABORTED: return DRWAV_NO_NETWORK;
++ if (e == ECONNABORTED) return DRWAV_NO_NETWORK;
+ #endif
+ #ifdef ECONNRESET
+- case ECONNRESET: return DRWAV_CONNECTION_RESET;
++ if (e == ECONNRESET) return DRWAV_CONNECTION_RESET;
+ #endif
+ #ifdef ENOBUFS
+- case ENOBUFS: return DRWAV_NO_SPACE;
++ if (e == ENOBUFS) return DRWAV_NO_SPACE;
+ #endif
+ #ifdef EISCONN
+- case EISCONN: return DRWAV_ALREADY_CONNECTED;
++ if (e == EISCONN) return DRWAV_ALREADY_CONNECTED;
+ #endif
+ #ifdef ENOTCONN
+- case ENOTCONN: return DRWAV_NOT_CONNECTED;
++ if (e == ENOTCONN) return DRWAV_NOT_CONNECTED;
+ #endif
+ #ifdef ESHUTDOWN
+- case ESHUTDOWN: return DRWAV_ERROR;
++ if (e == ESHUTDOWN) return DRWAV_ERROR;
+ #endif
+ #ifdef ETOOMANYREFS
+- case ETOOMANYREFS: return DRWAV_ERROR;
++ if (e == ETOOMANYREFS) return DRWAV_ERROR;
+ #endif
+ #ifdef ETIMEDOUT
+- case ETIMEDOUT: return DRWAV_TIMEOUT;
++ if (e == ETIMEDOUT) return DRWAV_TIMEOUT;
+ #endif
+ #ifdef ECONNREFUSED
+- case ECONNREFUSED: return DRWAV_CONNECTION_REFUSED;
++ if (e == ECONNREFUSED) return DRWAV_CONNECTION_REFUSED;
+ #endif
+ #ifdef EHOSTDOWN
+- case EHOSTDOWN: return DRWAV_NO_HOST;
++ if (e == EHOSTDOWN) return DRWAV_NO_HOST;
+ #endif
+ #ifdef EHOSTUNREACH
+- case EHOSTUNREACH: return DRWAV_NO_HOST;
++ if (e == EHOSTUNREACH) return DRWAV_NO_HOST;
+ #endif
+ #ifdef EALREADY
+- case EALREADY: return DRWAV_IN_PROGRESS;
++ if (e == EALREADY) return DRWAV_IN_PROGRESS;
+ #endif
+ #ifdef EINPROGRESS
+- case EINPROGRESS: return DRWAV_IN_PROGRESS;
++ if (e == EINPROGRESS) return DRWAV_IN_PROGRESS;
+ #endif
+ #ifdef ESTALE
+- case ESTALE: return DRWAV_INVALID_FILE;
++ if (e == ESTALE) return DRWAV_INVALID_FILE;
+ #endif
+ #ifdef EUCLEAN
+- case EUCLEAN: return DRWAV_ERROR;
++ if (e == EUCLEAN) return DRWAV_ERROR;
+ #endif
+ #ifdef ENOTNAM
+- case ENOTNAM: return DRWAV_ERROR;
++ if (e == ENOTNAM) return DRWAV_ERROR;
+ #endif
+ #ifdef ENAVAIL
+- case ENAVAIL: return DRWAV_ERROR;
++ if (e == ENAVAIL) return DRWAV_ERROR;
+ #endif
+ #ifdef EISNAM
+- case EISNAM: return DRWAV_ERROR;
++ if (e == EISNAM) return DRWAV_ERROR;
+ #endif
+ #ifdef EREMOTEIO
+- case EREMOTEIO: return DRWAV_IO_ERROR;
++ if (e == EREMOTEIO) return DRWAV_IO_ERROR;
+ #endif
+ #ifdef EDQUOT
+- case EDQUOT: return DRWAV_NO_SPACE;
++ if (e == EDQUOT) return DRWAV_NO_SPACE;
+ #endif
+ #ifdef ENOMEDIUM
+- case ENOMEDIUM: return DRWAV_DOES_NOT_EXIST;
++ if (e == ENOMEDIUM) return DRWAV_DOES_NOT_EXIST;
+ #endif
+ #ifdef EMEDIUMTYPE
+- case EMEDIUMTYPE: return DRWAV_ERROR;
++ if (e == EMEDIUMTYPE) return DRWAV_ERROR;
+ #endif
+ #ifdef ECANCELED
+- case ECANCELED: return DRWAV_CANCELLED;
++ if (e == ECANCELED) return DRWAV_CANCELLED;
+ #endif
+ #ifdef ENOKEY
+- case ENOKEY: return DRWAV_ERROR;
++ if (e == ENOKEY) return DRWAV_ERROR;
+ #endif
+ #ifdef EKEYEXPIRED
+- case EKEYEXPIRED: return DRWAV_ERROR;
++ if (e == EKEYEXPIRED) return DRWAV_ERROR;
+ #endif
+ #ifdef EKEYREVOKED
+- case EKEYREVOKED: return DRWAV_ERROR;
++ if (e == EKEYREVOKED) return DRWAV_ERROR;
+ #endif
+ #ifdef EKEYREJECTED
+- case EKEYREJECTED: return DRWAV_ERROR;
++ if (e == EKEYREJECTED) return DRWAV_ERROR;
+ #endif
+ #ifdef EOWNERDEAD
+- case EOWNERDEAD: return DRWAV_ERROR;
++ if (e == EOWNERDEAD) return DRWAV_ERROR;
+ #endif
+ #ifdef ENOTRECOVERABLE
+- case ENOTRECOVERABLE: return DRWAV_ERROR;
++ if (e == ENOTRECOVERABLE) return DRWAV_ERROR;
+ #endif
+ #ifdef ERFKILL
+- case ERFKILL: return DRWAV_ERROR;
++ if (e == ERFKILL) return DRWAV_ERROR;
+ #endif
+ #ifdef EHWPOISON
+- case EHWPOISON: return DRWAV_ERROR;
++ if (e == EHWPOISON) return DRWAV_ERROR;
+ #endif
+- default: return DRWAV_ERROR;
+- }
++ return DRWAV_ERROR;
+ }
+
+ static drwav_result drwav_fopen(FILE** ppFile, const char* pFilePath, const char* pOpenMode)
diff --git a/whisper.cpp.patches/patches/012-httplib-h-llamafile-integration.patch b/whisper.cpp.patches/patches/012-httplib-h-llamafile-integration.patch
new file mode 100644
index 00000000..91ccfb24
--- /dev/null
+++ b/whisper.cpp.patches/patches/012-httplib-h-llamafile-integration.patch
@@ -0,0 +1,10 @@
+--- examples/server/httplib.h 2025-10-31 22:21:46
++++ ../whisper.cpp.patches/httplib.h 2025-10-31 16:05:04
+@@ -233,6 +233,7 @@
+ #include <unordered_map>
+ #include <unordered_set>
+ #include <utility>
++#include <exception>
+
+ #ifdef CPPHTTPLIB_OPENSSL_SUPPORT
+ #ifdef _WIN32
diff --git a/whisper.cpp/LICENSE b/whisper.cpp/LICENSE
deleted file mode 100644
index acb96ce7..00000000
--- a/whisper.cpp/LICENSE
+++ /dev/null
@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2023-2024 The ggml authors
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
diff --git a/whisper.cpp/common.cpp b/whisper.cpp/common.cpp
deleted file mode 100644
index 06e9ed70..00000000
--- a/whisper.cpp/common.cpp
+++ /dev/null
@@ -1,191 +0,0 @@
-// -*- mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8 -*-
-// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
-#define _USE_MATH_DEFINES // for M_PI
-
-#include "llamafile/log.h"
-#include "llamafile/llamafile.h"
-#include "common.h"
-
-// third-party utilities
-// use your favorite implementations
-// #define DR_WAV_IMPLEMENTATION // [jart] comment out
-#include "dr_wav.h"
-
-#if defined(_MSC_VER)
-#pragma warning(disable: 4244 4267) // possible loss of data
-#endif
-
-#ifdef _WIN32
-#include <fcntl.h>
-#include <io.h>
-#endif
-
-#include <cosmo.h>
-#include <stdlib.h>
-#include <unistd.h>
-
-#include "third_party/stb/stb_vorbis.h"
-#include "miniaudio.h"
-
-void high_pass_filter(std::vector<float> & data, float cutoff, float sample_rate) {
- const float rc = 1.0f / (2.0f * M_PI * cutoff);
- const float dt = 1.0f / sample_rate;
- const float alpha = dt / (rc + dt);
-
- float y = data[0];
-
- for (size_t i = 1; i < data.size(); i++) {
- y = alpha * (y + data[i] - data[i - 1]);
- data[i] = y;
- }
-}
-
-bool vad_simple(std::vector<float> & pcmf32, int sample_rate, int last_ms, float vad_thold, float freq_thold, bool verbose) {
- const int n_samples = pcmf32.size();
- const int n_samples_last = (sample_rate * last_ms) / 1000;
-
- if (n_samples_last >= n_samples) {
- // not enough samples - assume no speech
- return false;
- }
-
- if (freq_thold > 0.0f) {
- high_pass_filter(pcmf32, freq_thold, sample_rate);
- }
-
- float energy_all = 0.0f;
- float energy_last = 0.0f;
-
- for (int i = 0; i < n_samples; i++) {
- energy_all += fabsf(pcmf32[i]);
-
- if (i >= n_samples - n_samples_last) {
- energy_last += fabsf(pcmf32[i]);
- }
- }
-
- energy_all /= n_samples;
- energy_last /= n_samples_last;
-
- if (verbose) {
- tinylogf("%s: energy_all: %f, energy_last: %f, vad_thold: %f, freq_thold: %f\n", __func__, energy_all, energy_last, vad_thold, freq_thold);
- }
-
- if (energy_last > vad_thold*energy_all) {
- return false;
- }
-
- return true;
-}
-
-float similarity(const std::string & s0, const std::string & s1) {
- const size_t len0 = s0.size() + 1;
- const size_t len1 = s1.size() + 1;
-
- std::vector<int> col(len1, 0);
- std::vector<int> prevCol(len1, 0);
-
- for (size_t i = 0; i < len1; i++) {
- prevCol[i] = i;
- }
-
- for (size_t i = 0; i < len0; i++) {
- col[0] = i;
- for (size_t j = 1; j < len1; j++) {
- col[j] = std::min(std::min(1 + col[j - 1], 1 + prevCol[j]), prevCol[j - 1] + (i > 0 && s0[i - 1] == s1[j - 1] ? 0 : 1));
- }
- col.swap(prevCol);
- }
-
- const float dist = prevCol[len1 - 1];
-
- return 1.0f - (dist / std::max(s0.size(), s1.size()));
-}
-
-bool sam_params_parse(int argc, char ** argv, sam_params & params) {
- for (int i = 1; i < argc; i++) {
- std::string arg = argv[i];
-
- if (arg == "-s" || arg == "--seed") {
- params.seed = std::stoi(argv[++i]);
- } else if (arg == "-t" || arg == "--threads") {
- params.n_threads = std::stoi(argv[++i]);
- } else if (arg == "-m" || arg == "--model") {
- params.model = argv[++i];
- } else if (arg == "-i" || arg == "--inp") {
- params.fname_inp = argv[++i];
- } else if (arg == "-o" || arg == "--out") {
- params.fname_out = argv[++i];
- } else if (arg == "-h" || arg == "--help") {
- sam_print_usage(argc, argv, params);
- exit(0);
- } else {
- fprintf(stderr, "error: unknown argument: %s\n", arg.c_str());
- // sam_print_usage(argc, argv, params); // [jart]
- exit(0);
- }
- }
-
- return true;
-}
-
-void sam_print_usage(int /*argc*/, char ** argv, const sam_params & params) {
- fprintf(stderr, "usage: %s [options]\n", argv[0]);
- fprintf(stderr, "\n");
- fprintf(stderr, "options:\n");
- fprintf(stderr, " -h, --help show this help message and exit\n");
- fprintf(stderr, " -s SEED, --seed SEED RNG seed (default: -1)\n");
- fprintf(stderr, " -t N, --threads N number of threads to use during computation (default: %d)\n", params.n_threads);
- fprintf(stderr, " -m FNAME, --model FNAME\n");
- fprintf(stderr, " model path (default: %s)\n", params.model.c_str());
- fprintf(stderr, " -i FNAME, --inp FNAME\n");
- fprintf(stderr, " input file (default: %s)\n", params.fname_inp.c_str());
- fprintf(stderr, " -o FNAME, --out FNAME\n");
- fprintf(stderr, " output file (default: %s)\n", params.fname_out.c_str());
- fprintf(stderr, "\n");
-}
-
-// 500 -> 00:05.000
-// 6000 -> 01:00.000
-std::string to_timestamp(int64_t t, bool comma) {
- int64_t msec = t * 10;
- int64_t hr = msec / (1000 * 60 * 60);
- msec = msec - hr * (1000 * 60 * 60);
- int64_t min = msec / (1000 * 60);
- msec = msec - min * (1000 * 60);
- int64_t sec = msec / 1000;
- msec = msec - sec * 1000;
-
- char buf[32];
- snprintf(buf, sizeof(buf), "%02d:%02d:%02d%s%03d", (int) hr, (int) min, (int) sec, comma ? "," : ".", (int) msec);
-
- return std::string(buf);
-}
-
-int timestamp_to_sample(int64_t t, int n_samples, int whisper_sample_rate) {
- return std::max(0, std::min((int) n_samples - 1, (int) ((t*whisper_sample_rate)/100)));
-}
-
-bool is_file_exist(const char *fileName)
-{
- std::ifstream infile(fileName);
- return infile.good();
-}
-
-bool speak_with_file(const std::string & command, const std::string & text, const std::string & path, int voice_id)
-{
- std::ofstream speak_file(path.c_str());
- if (speak_file.fail()) {
- fprintf(stderr, "%s: failed to open speak_file\n", __func__);
- return false;
- } else {
- speak_file.write(text.c_str(), text.size());
- speak_file.close();
- int ret = system((command + " " + std::to_string(voice_id) + " " + path).c_str());
- if (ret != 0) {
- fprintf(stderr, "%s: failed to speak\n", __func__);
- return false;
- }
- }
- return true;
-}
diff --git a/whisper.cpp/common.h b/whisper.cpp/common.h
deleted file mode 100644
index 5c2321ba..00000000
--- a/whisper.cpp/common.h
+++ /dev/null
@@ -1,199 +0,0 @@
-// -*- mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8 -*-
-// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
-
-// Various helper functions and utilities
-
-#pragma once
-
-#include <string>
-#include <vector>
-#include <thread>
-#include <fstream>
-
-#include "llamafile/xterm.h"
-
-#define COMMON_SAMPLE_RATE 16000
-
-//
-// Audio utils
-//
-
-// Check if a buffer is a WAV audio file
-bool is_wav_buffer(const std::string buf);
-
-// Write PCM data into WAV audio file
-class wav_writer {
-private:
- std::ofstream file;
- uint32_t dataSize = 0;
- std::string wav_filename;
-
- bool write_header(const uint32_t sample_rate,
- const uint16_t bits_per_sample,
- const uint16_t channels) {
-
- file.write("RIFF", 4);
- file.write("\0\0\0\0", 4); // Placeholder for file size
- file.write("WAVE", 4);
- file.write("fmt ", 4);
-
- const uint32_t sub_chunk_size = 16;
- const uint16_t audio_format = 1; // PCM format
- const uint32_t byte_rate = sample_rate * channels * bits_per_sample / 8;
- const uint16_t block_align = channels * bits_per_sample / 8;
-
- file.write(reinterpret_cast<const char *>(&sub_chunk_size), 4);
- file.write(reinterpret_cast<const char *>(&audio_format), 2);
- file.write(reinterpret_cast<const char *>(&channels), 2);
- file.write(reinterpret_cast<const char *>(&sample_rate), 4);
- file.write(reinterpret_cast<const char *>(&byte_rate), 4);
- file.write(reinterpret_cast<const char *>(&block_align), 2);
- file.write(reinterpret_cast<const char *>(&bits_per_sample), 2);
- file.write("data", 4);
- file.write("\0\0\0\0", 4); // Placeholder for data size
-
- return true;
- }
-
- // It is assumed that PCM data is normalized to a range from -1 to 1
- bool write_audio(const float * data, size_t length) {
- for (size_t i = 0; i < length; ++i) {
- const int16_t intSample = data[i] * 32767;
- file.write(reinterpret_cast<const char *>(&intSample), sizeof(int16_t));
- dataSize += sizeof(int16_t);
- }
- if (file.is_open()) {
- file.seekp(4, std::ios::beg);
- uint32_t fileSize = 36 + dataSize;
- file.write(reinterpret_cast<char *>(&fileSize), 4);
- file.seekp(40, std::ios::beg);
- file.write(reinterpret_cast<char *>(&dataSize), 4);
- file.seekp(0, std::ios::end);
- }
- return true;
- }
-
- bool open_wav(const std::string & filename) {
- if (filename != wav_filename) {
- if (file.is_open()) {
- file.close();
- }
- }
- if (!file.is_open()) {
- file.open(filename, std::ios::binary);
- wav_filename = filename;
- dataSize = 0;
- }
- return file.is_open();
- }
-
-public:
- bool open(const std::string & filename,
- const uint32_t sample_rate,
- const uint16_t bits_per_sample,
- const uint16_t channels) {
-
- if (open_wav(filename)) {
- write_header(sample_rate, bits_per_sample, channels);
- } else {
- return false;
- }
-
- return true;
- }
-
- bool close() {
- file.close();
- return true;
- }
-
- bool write(const float * data, size_t length) {
- return write_audio(data, length);
- }
-
- ~wav_writer() {
- if (file.is_open()) {
- file.close();
- }
- }
-};
-
-
-// Apply a high-pass frequency filter to PCM audio
-// Suppresses frequencies below cutoff Hz
-void high_pass_filter(
- std::vector<float> & data,
- float cutoff,
- float sample_rate);
-
-// Basic voice activity detection (VAD) using audio energy adaptive threshold
-bool vad_simple(
- std::vector<float> & pcmf32,
- int sample_rate,
- int last_ms,
- float vad_thold,
- float freq_thold,
- bool verbose);
-
-// compute similarity between two strings using Levenshtein distance
-float similarity(const std::string & s0, const std::string & s1);
-
-//
-// SAM argument parsing
-//
-
-struct sam_params {
- int32_t seed = -1; // RNG seed
- int32_t n_threads = std::min(4, (int32_t) std::thread::hardware_concurrency());
-
- std::string model = "models/sam-vit-b/ggml-model-f16.bin"; // model path
- std::string fname_inp = "img.jpg";
- std::string fname_out = "img.out";
-};
-
-bool sam_params_parse(int argc, char ** argv, sam_params & params);
-
-void sam_print_usage(int argc, char ** argv, const sam_params & params);
-
-//
-// Terminal utils
-//
-
-static std::string set_xterm256_foreground(int rgb) {
- int x = rgb2xterm256(rgb);
- std::ostringstream oss;
- oss << "\033[38;5;" << x << "m";
- return oss.str();
-}
-
-static inline int rgb(int red, int green, int blue) {
- return (red & 255) << 16 | (green & 255) << 8 | (blue & 255);
-}
-
-// Lowest is red, middle is yellow, highest is green. Color scheme from
-// Paul Tol; it is colorblind friendly https://personal.sron.nl/~pault/
-const std::vector<std::string> k_colors = {
- set_xterm256_foreground(rgb(220, 5, 12)),
- set_xterm256_foreground(rgb(232, 96, 28)),
- set_xterm256_foreground(rgb(241, 147, 45)),
- set_xterm256_foreground(rgb(246, 193, 65)),
- set_xterm256_foreground(rgb(247, 240, 86)),
- set_xterm256_foreground(rgb(144, 201, 135)),
- set_xterm256_foreground(rgb( 78, 178, 101)),
-};
-
-//
-// Other utils
-//
-
-// convert timestamp to string, 6000 -> 01:00.000
-std::string to_timestamp(int64_t t, bool comma = false);
-
-// given a timestamp get the sample
-int timestamp_to_sample(int64_t t, int n_samples, int whisper_sample_rate);
-
-// check if file exists using ifstream
-bool is_file_exist(const char *fileName);
-
-// write text to file, and call system("command voice_id file")
-bool speak_with_file(const std::string & command, const std::string & text, const std::string & path, int voice_id);
diff --git a/whisper.cpp/dr_wav.h b/whisper.cpp/dr_wav.h
deleted file mode 100644
index 61f813b1..00000000
--- a/whisper.cpp/dr_wav.h
+++ /dev/null
@@ -1,6432 +0,0 @@
-/*
-WAV audio loader and writer. Choice of public domain or MIT-0. See license statements at the end of this file.
-dr_wav - v0.12.16 - 2020-12-02
-
-David Reid - [email protected]
-
-GitHub: https://github.com/mackron/dr_libs
-*/
-
-/*
-RELEASE NOTES - VERSION 0.12
-============================
-Version 0.12 includes breaking changes to custom chunk handling.
-
-
-Changes to Chunk Callback
--------------------------
-dr_wav supports the ability to fire a callback when a chunk is encounted (except for WAVE and FMT chunks). The callback has been updated to include both the
-container (RIFF or Wave64) and the FMT chunk which contains information about the format of the data in the wave file.
-
-Previously, there was no direct way to determine the container, and therefore no way to discriminate against the different IDs in the chunk header (RIFF and
-Wave64 containers encode chunk ID's differently). The `container` parameter can be used to know which ID to use.
-
-Sometimes it can be useful to know the data format at the time the chunk callback is fired. A pointer to a `drwav_fmt` object is now passed into the chunk
-callback which will give you information about the data format. To determine the sample format, use `drwav_fmt_get_format()`. This will return one of the
-`DR_WAVE_FORMAT_*` tokens.
-*/
-
-/*
-Introduction
-============
-This is a single file library. To use it, do something like the following in one .c file.
-
- ```c
- #define DR_WAV_IMPLEMENTATION
- #include "dr_wav.h"
- ```
-
-You can then #include this file in other parts of the program as you would with any other header file. Do something like the following to read audio data:
-
- ```c
- drwav wav;
- if (!drwav_init_file(&wav, "my_song.wav", NULL)) {
- // Error opening WAV file.
- }
-
- drwav_int32* pDecodedInterleavedPCMFrames = malloc(wav.totalPCMFrameCount * wav.channels * sizeof(drwav_int32));
- size_t numberOfSamplesActuallyDecoded = drwav_read_pcm_frames_s32(&wav, wav.totalPCMFrameCount, pDecodedInterleavedPCMFrames);
-
- ...
-
- drwav_uninit(&wav);
- ```
-
-If you just want to quickly open and read the audio data in a single operation you can do something like this:
-
- ```c
- unsigned int channels;
- unsigned int sampleRate;
- drwav_uint64 totalPCMFrameCount;
- float* pSampleData = drwav_open_file_and_read_pcm_frames_f32("my_song.wav", &channels, &sampleRate, &totalPCMFrameCount, NULL);
- if (pSampleData == NULL) {
- // Error opening and reading WAV file.
- }
-
- ...
-
- drwav_free(pSampleData);
- ```
-
-The examples above use versions of the API that convert the audio data to a consistent format (32-bit signed PCM, in this case), but you can still output the
-audio data in its internal format (see notes below for supported formats):
-
- ```c
- size_t framesRead = drwav_read_pcm_frames(&wav, wav.totalPCMFrameCount, pDecodedInterleavedPCMFrames);
- ```
-
-You can also read the raw bytes of audio data, which could be useful if dr_wav does not have native support for a particular data format:
-
- ```c
- size_t bytesRead = drwav_read_raw(&wav, bytesToRead, pRawDataBuffer);
- ```
-
-dr_wav can also be used to output WAV files. This does not currently support compressed formats. To use this, look at `drwav_init_write()`,
-`drwav_init_file_write()`, etc. Use `drwav_write_pcm_frames()` to write samples, or `drwav_write_raw()` to write raw data in the "data" chunk.
-
- ```c
- drwav_data_format format;
- format.container = drwav_container_riff; // <-- drwav_container_riff = normal WAV files, drwav_container_w64 = Sony Wave64.
- format.format = DR_WAVE_FORMAT_PCM; // <-- Any of the DR_WAVE_FORMAT_* codes.
- format.channels = 2;
- format.sampleRate = 44100;
- format.bitsPerSample = 16;
- drwav_init_file_write(&wav, "data/recording.wav", &format, NULL);
-
- ...
-
- drwav_uint64 framesWritten = drwav_write_pcm_frames(pWav, frameCount, pSamples);
- ```
-
-dr_wav has seamless support the Sony Wave64 format. The decoder will automatically detect it and it should Just Work without any manual intervention.
-
-
-Build Options
-=============
-#define these options before including this file.
-
-#define DR_WAV_NO_CONVERSION_API
- Disables conversion APIs such as `drwav_read_pcm_frames_f32()` and `drwav_s16_to_f32()`.
-
-#define DR_WAV_NO_STDIO
- Disables APIs that initialize a decoder from a file such as `drwav_init_file()`, `drwav_init_file_write()`, etc.
-
-
-
-Notes
-=====
-- Samples are always interleaved.
-- The default read function does not do any data conversion. Use `drwav_read_pcm_frames_f32()`, `drwav_read_pcm_frames_s32()` and `drwav_read_pcm_frames_s16()`
- to read and convert audio data to 32-bit floating point, signed 32-bit integer and signed 16-bit integer samples respectively. Tested and supported internal
- formats include the following:
- - Unsigned 8-bit PCM
- - Signed 12-bit PCM
- - Signed 16-bit PCM
- - Signed 24-bit PCM
- - Signed 32-bit PCM
- - IEEE 32-bit floating point
- - IEEE 64-bit floating point
- - A-law and u-law
- - Microsoft ADPCM
- - IMA ADPCM (DVI, format code 0x11)
-- dr_wav will try to read the WAV file as best it can, even if it's not strictly conformant to the WAV format.
-*/
-
-#ifndef dr_wav_h
-#define dr_wav_h
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define DRWAV_STRINGIFY(x) #x
-#define DRWAV_XSTRINGIFY(x) DRWAV_STRINGIFY(x)
-
-#define DRWAV_VERSION_MAJOR 0
-#define DRWAV_VERSION_MINOR 12
-#define DRWAV_VERSION_REVISION 16
-#define DRWAV_VERSION_STRING DRWAV_XSTRINGIFY(DRWAV_VERSION_MAJOR) "." DRWAV_XSTRINGIFY(DRWAV_VERSION_MINOR) "." DRWAV_XSTRINGIFY(DRWAV_VERSION_REVISION)
-
-#include <stddef.h> /* For size_t. */
-
-/* Sized types. */
-typedef signed char drwav_int8;
-typedef unsigned char drwav_uint8;
-typedef signed short drwav_int16;
-typedef unsigned short drwav_uint16;
-typedef signed int drwav_int32;
-typedef unsigned int drwav_uint32;
-#if defined(_MSC_VER)
- typedef signed __int64 drwav_int64;
- typedef unsigned __int64 drwav_uint64;
-#else
- #if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)))
- #pragma GCC diagnostic push
- #pragma GCC diagnostic ignored "-Wlong-long"
- #if defined(__clang__)
- #pragma GCC diagnostic ignored "-Wc++11-long-long"
- #endif
- #endif
- typedef signed long long drwav_int64;
- typedef unsigned long long drwav_uint64;
- #if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)))
- #pragma GCC diagnostic pop
- #endif
-#endif
-#if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__)) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
- typedef drwav_uint64 drwav_uintptr;
-#else
- typedef drwav_uint32 drwav_uintptr;
-#endif
-typedef drwav_uint8 drwav_bool8;
-typedef drwav_uint32 drwav_bool32;
-#define DRWAV_TRUE 1
-#define DRWAV_FALSE 0
-
-#if !defined(DRWAV_API)
- #if defined(DRWAV_DLL)
- #if defined(_WIN32)
- #define DRWAV_DLL_IMPORT __declspec(dllimport)
- #define DRWAV_DLL_EXPORT __declspec(dllexport)
- #define DRWAV_DLL_PRIVATE static
- #else
- #if defined(__GNUC__) && __GNUC__ >= 4
- #define DRWAV_DLL_IMPORT __attribute__((visibility("default")))
- #define DRWAV_DLL_EXPORT __attribute__((visibility("default")))
- #define DRWAV_DLL_PRIVATE __attribute__((visibility("hidden")))
- #else
- #define DRWAV_DLL_IMPORT
- #define DRWAV_DLL_EXPORT
- #define DRWAV_DLL_PRIVATE static
- #endif
- #endif
-
- #if defined(DR_WAV_IMPLEMENTATION) || defined(DRWAV_IMPLEMENTATION)
- #define DRWAV_API DRWAV_DLL_EXPORT
- #else
- #define DRWAV_API DRWAV_DLL_IMPORT
- #endif
- #define DRWAV_PRIVATE DRWAV_DLL_PRIVATE
- #else
- #define DRWAV_API extern
- #define DRWAV_PRIVATE static
- #endif
-#endif
-
-typedef drwav_int32 drwav_result;
-#define DRWAV_SUCCESS 0
-#define DRWAV_ERROR -1 /* A generic error. */
-#define DRWAV_INVALID_ARGS -2
-#define DRWAV_INVALID_OPERATION -3
-#define DRWAV_OUT_OF_MEMORY -4
-#define DRWAV_OUT_OF_RANGE -5
-#define DRWAV_ACCESS_DENIED -6
-#define DRWAV_DOES_NOT_EXIST -7
-#define DRWAV_ALREADY_EXISTS -8
-#define DRWAV_TOO_MANY_OPEN_FILES -9
-#define DRWAV_INVALID_FILE -10
-#define DRWAV_TOO_BIG -11
-#define DRWAV_PATH_TOO_LONG -12
-#define DRWAV_NAME_TOO_LONG -13
-#define DRWAV_NOT_DIRECTORY -14
-#define DRWAV_IS_DIRECTORY -15
-#define DRWAV_DIRECTORY_NOT_EMPTY -16
-#define DRWAV_END_OF_FILE -17
-#define DRWAV_NO_SPACE -18
-#define DRWAV_BUSY -19
-#define DRWAV_IO_ERROR -20
-#define DRWAV_INTERRUPT -21
-#define DRWAV_UNAVAILABLE -22
-#define DRWAV_ALREADY_IN_USE -23
-#define DRWAV_BAD_ADDRESS -24
-#define DRWAV_BAD_SEEK -25
-#define DRWAV_BAD_PIPE -26
-#define DRWAV_DEADLOCK -27
-#define DRWAV_TOO_MANY_LINKS -28
-#define DRWAV_NOT_IMPLEMENTED -29
-#define DRWAV_NO_MESSAGE -30
-#define DRWAV_BAD_MESSAGE -31
-#define DRWAV_NO_DATA_AVAILABLE -32
-#define DRWAV_INVALID_DATA -33
-#define DRWAV_TIMEOUT -34
-#define DRWAV_NO_NETWORK -35
-#define DRWAV_NOT_UNIQUE -36
-#define DRWAV_NOT_SOCKET -37
-#define DRWAV_NO_ADDRESS -38
-#define DRWAV_BAD_PROTOCOL -39
-#define DRWAV_PROTOCOL_UNAVAILABLE -40
-#define DRWAV_PROTOCOL_NOT_SUPPORTED -41
-#define DRWAV_PROTOCOL_FAMILY_NOT_SUPPORTED -42
-#define DRWAV_ADDRESS_FAMILY_NOT_SUPPORTED -43
-#define DRWAV_SOCKET_NOT_SUPPORTED -44
-#define DRWAV_CONNECTION_RESET -45
-#define DRWAV_ALREADY_CONNECTED -46
-#define DRWAV_NOT_CONNECTED -47
-#define DRWAV_CONNECTION_REFUSED -48
-#define DRWAV_NO_HOST -49
-#define DRWAV_IN_PROGRESS -50
-#define DRWAV_CANCELLED -51
-#define DRWAV_MEMORY_ALREADY_MAPPED -52
-#define DRWAV_AT_END -53
-
-/* Common data formats. */
-#define DR_WAVE_FORMAT_PCM 0x1
-#define DR_WAVE_FORMAT_ADPCM 0x2
-#define DR_WAVE_FORMAT_IEEE_FLOAT 0x3
-#define DR_WAVE_FORMAT_ALAW 0x6
-#define DR_WAVE_FORMAT_MULAW 0x7
-#define DR_WAVE_FORMAT_DVI_ADPCM 0x11
-#define DR_WAVE_FORMAT_EXTENSIBLE 0xFFFE
-
-/* Constants. */
-#ifndef DRWAV_MAX_SMPL_LOOPS
-#define DRWAV_MAX_SMPL_LOOPS 1
-#endif
-
-/* Flags to pass into drwav_init_ex(), etc. */
-#define DRWAV_SEQUENTIAL 0x00000001
-
-DRWAV_API void drwav_version(drwav_uint32* pMajor, drwav_uint32* pMinor, drwav_uint32* pRevision);
-DRWAV_API const char* drwav_version_string(void);
-
-typedef enum
-{
- drwav_seek_origin_start,
- drwav_seek_origin_current
-} drwav_seek_origin;
-
-typedef enum
-{
- drwav_container_riff,
- drwav_container_w64,
- drwav_container_rf64
-} drwav_container;
-
-typedef struct
-{
- union
- {
- drwav_uint8 fourcc[4];
- drwav_uint8 guid[16];
- } id;
-
- /* The size in bytes of the chunk. */
- drwav_uint64 sizeInBytes;
-
- /*
- RIFF = 2 byte alignment.
- W64 = 8 byte alignment.
- */
- unsigned int paddingSize;
-} drwav_chunk_header;
-
-typedef struct
-{
- /*
- The format tag exactly as specified in the wave file's "fmt" chunk. This can be used by applications
- that require support for data formats not natively supported by dr_wav.
- */
- drwav_uint16 formatTag;
-
- /* The number of channels making up the audio data. When this is set to 1 it is mono, 2 is stereo, etc. */
- drwav_uint16 channels;
-
- /* The sample rate. Usually set to something like 44100. */
- drwav_uint32 sampleRate;
-
- /* Average bytes per second. You probably don't need this, but it's left here for informational purposes. */
- drwav_uint32 avgBytesPerSec;
-
- /* Block align. This is equal to the number of channels * bytes per sample. */
- drwav_uint16 blockAlign;
-
- /* Bits per sample. */
- drwav_uint16 bitsPerSample;
-
- /* The size of the extended data. Only used internally for validation, but left here for informational purposes. */
- drwav_uint16 extendedSize;
-
- /*
- The number of valid bits per sample. When <formatTag> is equal to WAVE_FORMAT_EXTENSIBLE, <bitsPerSample>
- is always rounded up to the nearest multiple of 8. This variable contains information about exactly how
- many bits are valid per sample. Mainly used for informational purposes.
- */
- drwav_uint16 validBitsPerSample;
-
- /* The channel mask. Not used at the moment. */
- drwav_uint32 channelMask;
-
- /* The sub-format, exactly as specified by the wave file. */
- drwav_uint8 subFormat[16];
-} drwav_fmt;
-
-DRWAV_API drwav_uint16 drwav_fmt_get_format(const drwav_fmt* pFMT);
-
-
-/*
-Callback for when data is read. Return value is the number of bytes actually read.
-
-pUserData [in] The user data that was passed to drwav_init() and family.
-pBufferOut [out] The output buffer.
-bytesToRead [in] The number of bytes to read.
-
-Returns the number of bytes actually read.
-
-A return value of less than bytesToRead indicates the end of the stream. Do _not_ return from this callback until
-either the entire bytesToRead is filled or you have reached the end of the stream.
-*/
-typedef size_t (* drwav_read_proc)(void* pUserData, void* pBufferOut, size_t bytesToRead);
-
-/*
-Callback for when data is written. Returns value is the number of bytes actually written.
-
-pUserData [in] The user data that was passed to drwav_init_write() and family.
-pData [out] A pointer to the data to write.
-bytesToWrite [in] The number of bytes to write.
-
-Returns the number of bytes actually written.
-
-If the return value differs from bytesToWrite, it indicates an error.
-*/
-typedef size_t (* drwav_write_proc)(void* pUserData, const void* pData, size_t bytesToWrite);
-
-/*
-Callback for when data needs to be seeked.
-
-pUserData [in] The user data that was passed to drwav_init() and family.
-offset [in] The number of bytes to move, relative to the origin. Will never be negative.
-origin [in] The origin of the seek - the current position or the start of the stream.
-
-Returns whether or not the seek was successful.
-
-Whether or not it is relative to the beginning or current position is determined by the "origin" parameter which will be either drwav_seek_origin_start or
-drwav_seek_origin_current.
-*/
-typedef drwav_bool32 (* drwav_seek_proc)(void* pUserData, int offset, drwav_seek_origin origin);
-
-/*
-Callback for when drwav_init_ex() finds a chunk.
-
-pChunkUserData [in] The user data that was passed to the pChunkUserData parameter of drwav_init_ex() and family.
-onRead [in] A pointer to the function to call when reading.
-onSeek [in] A pointer to the function to call when seeking.
-pReadSeekUserData [in] The user data that was passed to the pReadSeekUserData parameter of drwav_init_ex() and family.
-pChunkHeader [in] A pointer to an object containing basic header information about the chunk. Use this to identify the chunk.
-container [in] Whether or not the WAV file is a RIFF or Wave64 container. If you're unsure of the difference, assume RIFF.
-pFMT [in] A pointer to the object containing the contents of the "fmt" chunk.
-
-Returns the number of bytes read + seeked.
-
-To read data from the chunk, call onRead(), passing in pReadSeekUserData as the first parameter. Do the same for seeking with onSeek(). The return value must
-be the total number of bytes you have read _plus_ seeked.
-
-Use the `container` argument to discriminate the fields in `pChunkHeader->id`. If the container is `drwav_container_riff` or `drwav_container_rf64` you should
-use `id.fourcc`, otherwise you should use `id.guid`.
-
-The `pFMT` parameter can be used to determine the data format of the wave file. Use `drwav_fmt_get_format()` to get the sample format, which will be one of the
-`DR_WAVE_FORMAT_*` identifiers.
-
-The read pointer will be sitting on the first byte after the chunk's header. You must not attempt to read beyond the boundary of the chunk.
-*/
-typedef drwav_uint64 (* drwav_chunk_proc)(void* pChunkUserData, drwav_read_proc onRead, drwav_seek_proc onSeek, void* pReadSeekUserData, const drwav_chunk_header* pChunkHeader, drwav_container container, const drwav_fmt* pFMT);
-
-typedef struct
-{
- void* pUserData;
- void* (* onMalloc)(size_t sz, void* pUserData);
- void* (* onRealloc)(void* p, size_t sz, void* pUserData);
- void (* onFree)(void* p, void* pUserData);
-} drwav_allocation_callbacks;
-
-/* Structure for internal use. Only used for loaders opened with drwav_init_memory(). */
-typedef struct
-{
- const drwav_uint8* data;
- size_t dataSize;
- size_t currentReadPos;
-} drwav__memory_stream;
-
-/* Structure for internal use. Only used for writers opened with drwav_init_memory_write(). */
-typedef struct
-{
- void** ppData;
- size_t* pDataSize;
- size_t dataSize;
- size_t dataCapacity;
- size_t currentWritePos;
-} drwav__memory_stream_write;
-
-typedef struct
-{
- drwav_container container; /* RIFF, W64. */
- drwav_uint32 format; /* DR_WAVE_FORMAT_* */
- drwav_uint32 channels;
- drwav_uint32 sampleRate;
- drwav_uint32 bitsPerSample;
-} drwav_data_format;
-
-
-/* See the following for details on the 'smpl' chunk: https://sites.google.com/site/musicgapi/technical-documents/wav-file-format#smpl */
-typedef struct
-{
- drwav_uint32 cuePointId;
- drwav_uint32 type;
- drwav_uint32 start;
- drwav_uint32 end;
- drwav_uint32 fraction;
- drwav_uint32 playCount;
-} drwav_smpl_loop;
-
- typedef struct
-{
- drwav_uint32 manufacturer;
- drwav_uint32 product;
- drwav_uint32 samplePeriod;
- drwav_uint32 midiUnityNotes;
- drwav_uint32 midiPitchFraction;
- drwav_uint32 smpteFormat;
- drwav_uint32 smpteOffset;
- drwav_uint32 numSampleLoops;
- drwav_uint32 samplerData;
- drwav_smpl_loop loops[DRWAV_MAX_SMPL_LOOPS];
-} drwav_smpl;
-
-typedef struct
-{
- /* A pointer to the function to call when more data is needed. */
- drwav_read_proc onRead;
-
- /* A pointer to the function to call when data needs to be written. Only used when the drwav object is opened in write mode. */
- drwav_write_proc onWrite;
-
- /* A pointer to the function to call when the wav file needs to be seeked. */
- drwav_seek_proc onSeek;
-
- /* The user data to pass to callbacks. */
- void* pUserData;
-
- /* Allocation callbacks. */
- drwav_allocation_callbacks allocationCallbacks;
-
-
- /* Whether or not the WAV file is formatted as a standard RIFF file or W64. */
- drwav_container container;
-
-
- /* Structure containing format information exactly as specified by the wav file. */
- drwav_fmt fmt;
-
- /* The sample rate. Will be set to something like 44100. */
- drwav_uint32 sampleRate;
-
- /* The number of channels. This will be set to 1 for monaural streams, 2 for stereo, etc. */
- drwav_uint16 channels;
-
- /* The bits per sample. Will be set to something like 16, 24, etc. */
- drwav_uint16 bitsPerSample;
-
- /* Equal to fmt.formatTag, or the value specified by fmt.subFormat if fmt.formatTag is equal to 65534 (WAVE_FORMAT_EXTENSIBLE). */
- drwav_uint16 translatedFormatTag;
-
- /* The total number of PCM frames making up the audio data. */
- drwav_uint64 totalPCMFrameCount;
-
-
- /* The size in bytes of the data chunk. */
- drwav_uint64 dataChunkDataSize;
-
- /* The position in the stream of the first byte of the data chunk. This is used for seeking. */
- drwav_uint64 dataChunkDataPos;
-
- /* The number of bytes remaining in the data chunk. */
- drwav_uint64 bytesRemaining;
-
-
- /*
- Only used in sequential write mode. Keeps track of the desired size of the "data" chunk at the point of initialization time. Always
- set to 0 for non-sequential writes and when the drwav object is opened in read mode. Used for validation.
- */
- drwav_uint64 dataChunkDataSizeTargetWrite;
-
- /* Keeps track of whether or not the wav writer was initialized in sequential mode. */
- drwav_bool32 isSequentialWrite;
-
-
- /* smpl chunk. */
- drwav_smpl smpl;
-
-
- /* A hack to avoid a DRWAV_MALLOC() when opening a decoder with drwav_init_memory(). */
- drwav__memory_stream memoryStream;
- drwav__memory_stream_write memoryStreamWrite;
-
- /* Generic data for compressed formats. This data is shared across all block-compressed formats. */
- struct
- {
- drwav_uint64 iCurrentPCMFrame; /* The index of the next PCM frame that will be read by drwav_read_*(). This is used with "totalPCMFrameCount" to ensure we don't read excess samples at the end of the last block. */
- } compressed;
-
- /* Microsoft ADPCM specific data. */
- struct
- {
- drwav_uint32 bytesRemainingInBlock;
- drwav_uint16 predictor[2];
- drwav_int32 delta[2];
- drwav_int32 cachedFrames[4]; /* Samples are stored in this cache during decoding. */
- drwav_uint32 cachedFrameCount;
- drwav_int32 prevFrames[2][2]; /* The previous 2 samples for each channel (2 channels at most). */
- } msadpcm;
-
- /* IMA ADPCM specific data. */
- struct
- {
- drwav_uint32 bytesRemainingInBlock;
- drwav_int32 predictor[2];
- drwav_int32 stepIndex[2];
- drwav_int32 cachedFrames[16]; /* Samples are stored in this cache during decoding. */
- drwav_uint32 cachedFrameCount;
- } ima;
-} drwav;
-
-
-/*
-Initializes a pre-allocated drwav object for reading.
-
-pWav [out] A pointer to the drwav object being initialized.
-onRead [in] The function to call when data needs to be read from the client.
-onSeek [in] The function to call when the read position of the client data needs to move.
-onChunk [in, optional] The function to call when a chunk is enumerated at initialized time.
-pUserData, pReadSeekUserData [in, optional] A pointer to application defined data that will be passed to onRead and onSeek.
-pChunkUserData [in, optional] A pointer to application defined data that will be passed to onChunk.
-flags [in, optional] A set of flags for controlling how things are loaded.
-
-Returns true if successful; false otherwise.
-
-Close the loader with drwav_uninit().
-
-This is the lowest level function for initializing a WAV file. You can also use drwav_init_file() and drwav_init_memory()
-to open the stream from a file or from a block of memory respectively.
-
-Possible values for flags:
- DRWAV_SEQUENTIAL: Never perform a backwards seek while loading. This disables the chunk callback and will cause this function
- to return as soon as the data chunk is found. Any chunks after the data chunk will be ignored.
-
-drwav_init() is equivalent to "drwav_init_ex(pWav, onRead, onSeek, NULL, pUserData, NULL, 0);".
-
-The onChunk callback is not called for the WAVE or FMT chunks. The contents of the FMT chunk can be read from pWav->fmt
-after the function returns.
-
-See also: drwav_init_file(), drwav_init_memory(), drwav_uninit()
-*/
-DRWAV_API drwav_bool32 drwav_init(drwav* pWav, drwav_read_proc onRead, drwav_seek_proc onSeek, void* pUserData, const drwav_allocation_callbacks* pAllocationCallbacks);
-DRWAV_API drwav_bool32 drwav_init_ex(drwav* pWav, drwav_read_proc onRead, drwav_seek_proc onSeek, drwav_chunk_proc onChunk, void* pReadSeekUserData, void* pChunkUserData, drwav_uint32 flags, const drwav_allocation_callbacks* pAllocationCallbacks);
-
-/*
-Initializes a pre-allocated drwav object for writing.
-
-onWrite [in] The function to call when data needs to be written.
-onSeek [in] The function to call when the write position needs to move.
-pUserData [in, optional] A pointer to application defined data that will be passed to onWrite and onSeek.
-
-Returns true if successful; false otherwise.
-
-Close the writer with drwav_uninit().
-
-This is the lowest level function for initializing a WAV file. You can also use drwav_init_file_write() and drwav_init_memory_write()
-to open the stream from a file or from a block of memory respectively.
-
-If the total sample count is known, you can use drwav_init_write_sequential(). This avoids the need for dr_wav to perform
-a post-processing step for storing the total sample count and the size of the data chunk which requires a backwards seek.
-
-See also: drwav_init_file_write(), drwav_init_memory_write(), drwav_uninit()
-*/
-DRWAV_API drwav_bool32 drwav_init_write(drwav* pWav, const drwav_data_format* pFormat, drwav_write_proc onWrite, drwav_seek_proc onSeek, void* pUserData, const drwav_allocation_callbacks* pAllocationCallbacks);
-DRWAV_API drwav_bool32 drwav_init_write_sequential(drwav* pWav, const drwav_data_format* pFormat, drwav_uint64 totalSampleCount, drwav_write_proc onWrite, void* pUserData, const drwav_allocation_callbacks* pAllocationCallbacks);
-DRWAV_API drwav_bool32 drwav_init_write_sequential_pcm_frames(drwav* pWav, const drwav_data_format* pFormat, drwav_uint64 totalPCMFrameCount, drwav_write_proc onWrite, void* pUserData, const drwav_allocation_callbacks* pAllocationCallbacks);
-
-/*
-Utility function to determine the target size of the entire data to be written (including all headers and chunks).
-
-Returns the target size in bytes.
-
-Useful if the application needs to know the size to allocate.
-
-Only writing to the RIFF chunk and one data chunk is currently supported.
-
-See also: drwav_init_write(), drwav_init_file_write(), drwav_init_memory_write()
-*/
-DRWAV_API drwav_uint64 drwav_target_write_size_bytes(const drwav_data_format* pFormat, drwav_uint64 totalSampleCount);
-
-/*
-Uninitializes the given drwav object.
-
-Use this only for objects initialized with drwav_init*() functions (drwav_init(), drwav_init_ex(), drwav_init_write(), drwav_init_write_sequential()).
-*/
-DRWAV_API drwav_result drwav_uninit(drwav* pWav);
-
-
-/*
-Reads raw audio data.
-
-This is the lowest level function for reading audio data. It simply reads the given number of
-bytes of the raw internal sample data.
-
-Consider using drwav_read_pcm_frames_s16(), drwav_read_pcm_frames_s32() or drwav_read_pcm_frames_f32() for
-reading sample data in a consistent format.
-
-pBufferOut can be NULL in which case a seek will be performed.
-
-Returns the number of bytes actually read.
-*/
-DRWAV_API size_t drwav_read_raw(drwav* pWav, size_t bytesToRead, void* pBufferOut);
-
-/*
-Reads up to the specified number of PCM frames from the WAV file.
-
-The output data will be in the file's internal format, converted to native-endian byte order. Use
-drwav_read_pcm_frames_s16/f32/s32() to read data in a specific format.
-
-If the return value is less than <framesToRead> it means the end of the file has been reached or
-you have requested more PCM frames than can possibly fit in the output buffer.
-
-This function will only work when sample data is of a fixed size and uncompressed. If you are
-using a compressed format consider using drwav_read_raw() or drwav_read_pcm_frames_s16/s32/f32().
-
-pBufferOut can be NULL in which case a seek will be performed.
-*/
-DRWAV_API drwav_uint64 drwav_read_pcm_frames(drwav* pWav, drwav_uint64 framesToRead, void* pBufferOut);
-DRWAV_API drwav_uint64 drwav_read_pcm_frames_le(drwav* pWav, drwav_uint64 framesToRead, void* pBufferOut);
-DRWAV_API drwav_uint64 drwav_read_pcm_frames_be(drwav* pWav, drwav_uint64 framesToRead, void* pBufferOut);
-
-/*
-Seeks to the given PCM frame.
-
-Returns true if successful; false otherwise.
-*/
-DRWAV_API drwav_bool32 drwav_seek_to_pcm_frame(drwav* pWav, drwav_uint64 targetFrameIndex);
-
-
-/*
-Writes raw audio data.
-
-Returns the number of bytes actually written. If this differs from bytesToWrite, it indicates an error.
-*/
-DRWAV_API size_t drwav_write_raw(drwav* pWav, size_t bytesToWrite, const void* pData);
-
-/*
-Writes PCM frames.
-
-Returns the number of PCM frames written.
-
-Input samples need to be in native-endian byte order. On big-endian architectures the input data will be converted to
-little-endian. Use drwav_write_raw() to write raw audio data without performing any conversion.
-*/
-DRWAV_API drwav_uint64 drwav_write_pcm_frames(drwav* pWav, drwav_uint64 framesToWrite, const void* pData);
-DRWAV_API drwav_uint64 drwav_write_pcm_frames_le(drwav* pWav, drwav_uint64 framesToWrite, const void* pData);
-DRWAV_API drwav_uint64 drwav_write_pcm_frames_be(drwav* pWav, drwav_uint64 framesToWrite, const void* pData);
-
-
-/* Conversion Utilities */
-#ifndef DR_WAV_NO_CONVERSION_API
-
-/*
-Reads a chunk of audio data and converts it to signed 16-bit PCM samples.
-
-pBufferOut can be NULL in which case a seek will be performed.
-
-Returns the number of PCM frames actually read.
-
-If the return value is less than <framesToRead> it means the end of the file has been reached.
-*/
-DRWAV_API drwav_uint64 drwav_read_pcm_frames_s16(drwav* pWav, drwav_uint64 framesToRead, drwav_int16* pBufferOut);
-DRWAV_API drwav_uint64 drwav_read_pcm_frames_s16le(drwav* pWav, drwav_uint64 framesToRead, drwav_int16* pBufferOut);
-DRWAV_API drwav_uint64 drwav_read_pcm_frames_s16be(drwav* pWav, drwav_uint64 framesToRead, drwav_int16* pBufferOut);
-
-/* Low-level function for converting unsigned 8-bit PCM samples to signed 16-bit PCM samples. */
-DRWAV_API void drwav_u8_to_s16(drwav_int16* pOut, const drwav_uint8* pIn, size_t sampleCount);
-
-/* Low-level function for converting signed 24-bit PCM samples to signed 16-bit PCM samples. */
-DRWAV_API void drwav_s24_to_s16(drwav_int16* pOut, const drwav_uint8* pIn, size_t sampleCount);
-
-/* Low-level function for converting signed 32-bit PCM samples to signed 16-bit PCM samples. */
-DRWAV_API void drwav_s32_to_s16(drwav_int16* pOut, const drwav_int32* pIn, size_t sampleCount);
-
-/* Low-level function for converting IEEE 32-bit floating point samples to signed 16-bit PCM samples. */
-DRWAV_API void drwav_f32_to_s16(drwav_int16* pOut, const float* pIn, size_t sampleCount);
-
-/* Low-level function for converting IEEE 64-bit floating point samples to signed 16-bit PCM samples. */
-DRWAV_API void drwav_f64_to_s16(drwav_int16* pOut, const double* pIn, size_t sampleCount);
-
-/* Low-level function for converting A-law samples to signed 16-bit PCM samples. */
-DRWAV_API void drwav_alaw_to_s16(drwav_int16* pOut, const drwav_uint8* pIn, size_t sampleCount);
-
-/* Low-level function for converting u-law samples to signed 16-bit PCM samples. */
-DRWAV_API void drwav_mulaw_to_s16(drwav_int16* pOut, const drwav_uint8* pIn, size_t sampleCount);
-
-
-/*
-Reads a chunk of audio data and converts it to IEEE 32-bit floating point samples.
-
-pBufferOut can be NULL in which case a seek will be performed.
-
-Returns the number of PCM frames actually read.
-
-If the return value is less than <framesToRead> it means the end of the file has been reached.
-*/
-DRWAV_API drwav_uint64 drwav_read_pcm_frames_f32(drwav* pWav, drwav_uint64 framesToRead, float* pBufferOut);
-DRWAV_API drwav_uint64 drwav_read_pcm_frames_f32le(drwav* pWav, drwav_uint64 framesToRead, float* pBufferOut);
-DRWAV_API drwav_uint64 drwav_read_pcm_frames_f32be(drwav* pWav, drwav_uint64 framesToRead, float* pBufferOut);
-
-/* Low-level function for converting unsigned 8-bit PCM samples to IEEE 32-bit floating point samples. */
-DRWAV_API void drwav_u8_to_f32(float* pOut, const drwav_uint8* pIn, size_t sampleCount);
-
-/* Low-level function for converting signed 16-bit PCM samples to IEEE 32-bit floating point samples. */
-DRWAV_API void drwav_s16_to_f32(float* pOut, const drwav_int16* pIn, size_t sampleCount);
-
-/* Low-level function for converting signed 24-bit PCM samples to IEEE 32-bit floating point samples. */
-DRWAV_API void drwav_s24_to_f32(float* pOut, const drwav_uint8* pIn, size_t sampleCount);
-
-/* Low-level function for converting signed 32-bit PCM samples to IEEE 32-bit floating point samples. */
-DRWAV_API void drwav_s32_to_f32(float* pOut, const drwav_int32* pIn, size_t sampleCount);
-
-/* Low-level function for converting IEEE 64-bit floating point samples to IEEE 32-bit floating point samples. */
-DRWAV_API void drwav_f64_to_f32(float* pOut, const double* pIn, size_t sampleCount);
-
-/* Low-level function for converting A-law samples to IEEE 32-bit floating point samples. */
-DRWAV_API void drwav_alaw_to_f32(float* pOut, const drwav_uint8* pIn, size_t sampleCount);
-
-/* Low-level function for converting u-law samples to IEEE 32-bit floating point samples. */
-DRWAV_API void drwav_mulaw_to_f32(float* pOut, const drwav_uint8* pIn, size_t sampleCount);
-
-
-/*
-Reads a chunk of audio data and converts it to signed 32-bit PCM samples.
-
-pBufferOut can be NULL in which case a seek will be performed.
-
-Returns the number of PCM frames actually read.
-
-If the return value is less than <framesToRead> it means the end of the file has been reached.
-*/
-DRWAV_API drwav_uint64 drwav_read_pcm_frames_s32(drwav* pWav, drwav_uint64 framesToRead, drwav_int32* pBufferOut);
-DRWAV_API drwav_uint64 drwav_read_pcm_frames_s32le(drwav* pWav, drwav_uint64 framesToRead, drwav_int32* pBufferOut);
-DRWAV_API drwav_uint64 drwav_read_pcm_frames_s32be(drwav* pWav, drwav_uint64 framesToRead, drwav_int32* pBufferOut);
-
-/* Low-level function for converting unsigned 8-bit PCM samples to signed 32-bit PCM samples. */
-DRWAV_API void drwav_u8_to_s32(drwav_int32* pOut, const drwav_uint8* pIn, size_t sampleCount);
-
-/* Low-level function for converting signed 16-bit PCM samples to signed 32-bit PCM samples. */
-DRWAV_API void drwav_s16_to_s32(drwav_int32* pOut, const drwav_int16* pIn, size_t sampleCount);
-
-/* Low-level function for converting signed 24-bit PCM samples to signed 32-bit PCM samples. */
-DRWAV_API void drwav_s24_to_s32(drwav_int32* pOut, const drwav_uint8* pIn, size_t sampleCount);
-
-/* Low-level function for converting IEEE 32-bit floating point samples to signed 32-bit PCM samples. */
-DRWAV_API void drwav_f32_to_s32(drwav_int32* pOut, const float* pIn, size_t sampleCount);
-
-/* Low-level function for converting IEEE 64-bit floating point samples to signed 32-bit PCM samples. */
-DRWAV_API void drwav_f64_to_s32(drwav_int32* pOut, const double* pIn, size_t sampleCount);
-
-/* Low-level function for converting A-law samples to signed 32-bit PCM samples. */
-DRWAV_API void drwav_alaw_to_s32(drwav_int32* pOut, const drwav_uint8* pIn, size_t sampleCount);
-
-/* Low-level function for converting u-law samples to signed 32-bit PCM samples. */
-DRWAV_API void drwav_mulaw_to_s32(drwav_int32* pOut, const drwav_uint8* pIn, size_t sampleCount);
-
-#endif /* DR_WAV_NO_CONVERSION_API */
-
-
-/* High-Level Convenience Helpers */
-
-#ifndef DR_WAV_NO_STDIO
-/*
-Helper for initializing a wave file for reading using stdio.
-
-This holds the internal FILE object until drwav_uninit() is called. Keep this in mind if you're caching drwav
-objects because the operating system may restrict the number of file handles an application can have open at
-any given time.
-*/
-DRWAV_API drwav_bool32 drwav_init_file(drwav* pWav, const char* filename, const drwav_allocation_callbacks* pAllocationCallbacks);
-DRWAV_API drwav_bool32 drwav_init_file_ex(drwav* pWav, const char* filename, drwav_chunk_proc onChunk, void* pChunkUserData, drwav_uint32 flags, const drwav_allocation_callbacks* pAllocationCallbacks);
-DRWAV_API drwav_bool32 drwav_init_file_w(drwav* pWav, const wchar_t* filename, const drwav_allocation_callbacks* pAllocationCallbacks);
-DRWAV_API drwav_bool32 drwav_init_file_ex_w(drwav* pWav, const wchar_t* filename, drwav_chunk_proc onChunk, void* pChunkUserData, drwav_uint32 flags, const drwav_allocation_callbacks* pAllocationCallbacks);
-
-/*
-Helper for initializing a wave file for writing using stdio.
-
-This holds the internal FILE object until drwav_uninit() is called. Keep this in mind if you're caching drwav
-objects because the operating system may restrict the number of file handles an application can have open at
-any given time.
-*/
-DRWAV_API drwav_bool32 drwav_init_file_write(drwav* pWav, const char* filename, const drwav_data_format* pFormat, const drwav_allocation_callbacks* pAllocationCallbacks);
-DRWAV_API drwav_bool32 drwav_init_file_write_sequential(drwav* pWav, const char* filename, const drwav_data_format* pFormat, drwav_uint64 totalSampleCount, const drwav_allocation_callbacks* pAllocationCallbacks);
-DRWAV_API drwav_bool32 drwav_init_file_write_sequential_pcm_frames(drwav* pWav, const char* filename, const drwav_data_format* pFormat, drwav_uint64 totalPCMFrameCount, const drwav_allocation_callbacks* pAllocationCallbacks);
-DRWAV_API drwav_bool32 drwav_init_file_write_w(drwav* pWav, const wchar_t* filename, const drwav_data_format* pFormat, const drwav_allocation_callbacks* pAllocationCallbacks);
-DRWAV_API drwav_bool32 drwav_init_file_write_sequential_w(drwav* pWav, const wchar_t* filename, const drwav_data_format* pFormat, drwav_uint64 totalSampleCount, const drwav_allocation_callbacks* pAllocationCallbacks);
-DRWAV_API drwav_bool32 drwav_init_file_write_sequential_pcm_frames_w(drwav* pWav, const wchar_t* filename, const drwav_data_format* pFormat, drwav_uint64 totalPCMFrameCount, const drwav_allocation_callbacks* pAllocationCallbacks);
-#endif /* DR_WAV_NO_STDIO */
-
-/*
-Helper for initializing a loader from a pre-allocated memory buffer.
-
-This does not create a copy of the data. It is up to the application to ensure the buffer remains valid for
-the lifetime of the drwav object.
-
-The buffer should contain the contents of the entire wave file, not just the sample data.
-*/
-DRWAV_API drwav_bool32 drwav_init_memory(drwav* pWav, const void* data, size_t dataSize, const drwav_allocation_callbacks* pAllocationCallbacks);
-DRWAV_API drwav_bool32 drwav_init_memory_ex(drwav* pWav, const void* data, size_t dataSize, drwav_chunk_proc onChunk, void* pChunkUserData, drwav_uint32 flags, const drwav_allocation_callbacks* pAllocationCallbacks);
-
-/*
-Helper for initializing a writer which outputs data to a memory buffer.
-
-dr_wav will manage the memory allocations, however it is up to the caller to free the data with drwav_free().
-
-The buffer will remain allocated even after drwav_uninit() is called. The buffer should not be considered valid
-until after drwav_uninit() has been called.
-*/
-DRWAV_API drwav_bool32 drwav_init_memory_write(drwav* pWav, void** ppData, size_t* pDataSize, const drwav_data_format* pFormat, const drwav_allocation_callbacks* pAllocationCallbacks);
-DRWAV_API drwav_bool32 drwav_init_memory_write_sequential(drwav* pWav, void** ppData, size_t* pDataSize, const drwav_data_format* pFormat, drwav_uint64 totalSampleCount, const drwav_allocation_callbacks* pAllocationCallbacks);
-DRWAV_API drwav_bool32 drwav_init_memory_write_sequential_pcm_frames(drwav* pWav, void** ppData, size_t* pDataSize, const drwav_data_format* pFormat, drwav_uint64 totalPCMFrameCount, const drwav_allocation_callbacks* pAllocationCallbacks);
-
-
-#ifndef DR_WAV_NO_CONVERSION_API
-/*
-Opens and reads an entire wav file in a single operation.
-
-The return value is a heap-allocated buffer containing the audio data. Use drwav_free() to free the buffer.
-*/
-DRWAV_API drwav_int16* drwav_open_and_read_pcm_frames_s16(drwav_read_proc onRead, drwav_seek_proc onSeek, void* pUserData, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks);
-DRWAV_API float* drwav_open_and_read_pcm_frames_f32(drwav_read_proc onRead, drwav_seek_proc onSeek, void* pUserData, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks);
-DRWAV_API drwav_int32* drwav_open_and_read_pcm_frames_s32(drwav_read_proc onRead, drwav_seek_proc onSeek, void* pUserData, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks);
-#ifndef DR_WAV_NO_STDIO
-/*
-Opens and decodes an entire wav file in a single operation.
-
-The return value is a heap-allocated buffer containing the audio data. Use drwav_free() to free the buffer.
-*/
-DRWAV_API drwav_int16* drwav_open_file_and_read_pcm_frames_s16(const char* filename, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks);
-DRWAV_API float* drwav_open_file_and_read_pcm_frames_f32(const char* filename, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks);
-DRWAV_API drwav_int32* drwav_open_file_and_read_pcm_frames_s32(const char* filename, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks);
-DRWAV_API drwav_int16* drwav_open_file_and_read_pcm_frames_s16_w(const wchar_t* filename, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks);
-DRWAV_API float* drwav_open_file_and_read_pcm_frames_f32_w(const wchar_t* filename, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks);
-DRWAV_API drwav_int32* drwav_open_file_and_read_pcm_frames_s32_w(const wchar_t* filename, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks);
-#endif
-/*
-Opens and decodes an entire wav file from a block of memory in a single operation.
-
-The return value is a heap-allocated buffer containing the audio data. Use drwav_free() to free the buffer.
-*/
-DRWAV_API drwav_int16* drwav_open_memory_and_read_pcm_frames_s16(const void* data, size_t dataSize, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks);
-DRWAV_API float* drwav_open_memory_and_read_pcm_frames_f32(const void* data, size_t dataSize, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks);
-DRWAV_API drwav_int32* drwav_open_memory_and_read_pcm_frames_s32(const void* data, size_t dataSize, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks);
-#endif
-
-/* Frees data that was allocated internally by dr_wav. */
-DRWAV_API void drwav_free(void* p, const drwav_allocation_callbacks* pAllocationCallbacks);
-
-/* Converts bytes from a wav stream to a sized type of native endian. */
-DRWAV_API drwav_uint16 drwav_bytes_to_u16(const drwav_uint8* data);
-DRWAV_API drwav_int16 drwav_bytes_to_s16(const drwav_uint8* data);
-DRWAV_API drwav_uint32 drwav_bytes_to_u32(const drwav_uint8* data);
-DRWAV_API drwav_int32 drwav_bytes_to_s32(const drwav_uint8* data);
-DRWAV_API drwav_uint64 drwav_bytes_to_u64(const drwav_uint8* data);
-DRWAV_API drwav_int64 drwav_bytes_to_s64(const drwav_uint8* data);
-
-/* Compares a GUID for the purpose of checking the type of a Wave64 chunk. */
-DRWAV_API drwav_bool32 drwav_guid_equal(const drwav_uint8 a[16], const drwav_uint8 b[16]);
-
-/* Compares a four-character-code for the purpose of checking the type of a RIFF chunk. */
-DRWAV_API drwav_bool32 drwav_fourcc_equal(const drwav_uint8* a, const char* b);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* dr_wav_h */
-
-
-/************************************************************************************************************************************************************
- ************************************************************************************************************************************************************
-
- IMPLEMENTATION
-
- ************************************************************************************************************************************************************
- ************************************************************************************************************************************************************/
-#if defined(DR_WAV_IMPLEMENTATION) || defined(DRWAV_IMPLEMENTATION)
-#ifndef dr_wav_c
-#define dr_wav_c
-
-#include <stdlib.h>
-#include <string.h> /* For memcpy(), memset() */
-#include <limits.h> /* For INT_MAX */
-
-#ifndef DR_WAV_NO_STDIO
-#include <stdio.h>
-#include <wchar.h>
-#endif
-
-/* Standard library stuff. */
-#ifndef DRWAV_ASSERT
-#include <assert.h>
-#define DRWAV_ASSERT(expression) assert(expression)
-#endif
-#ifndef DRWAV_MALLOC
-#define DRWAV_MALLOC(sz) malloc((sz))
-#endif
-#ifndef DRWAV_REALLOC
-#define DRWAV_REALLOC(p, sz) realloc((p), (sz))
-#endif
-#ifndef DRWAV_FREE
-#define DRWAV_FREE(p) free((p))
-#endif
-#ifndef DRWAV_COPY_MEMORY
-#define DRWAV_COPY_MEMORY(dst, src, sz) memcpy((dst), (src), (sz))
-#endif
-#ifndef DRWAV_ZERO_MEMORY
-#define DRWAV_ZERO_MEMORY(p, sz) memset((p), 0, (sz))
-#endif
-#ifndef DRWAV_ZERO_OBJECT
-#define DRWAV_ZERO_OBJECT(p) DRWAV_ZERO_MEMORY((p), sizeof(*p))
-#endif
-
-#define drwav_countof(x) (sizeof(x) / sizeof(x[0]))
-#define drwav_align(x, a) ((((x) + (a) - 1) / (a)) * (a))
-#define drwav_min(a, b) (((a) < (b)) ? (a) : (b))
-#define drwav_max(a, b) (((a) > (b)) ? (a) : (b))
-#define drwav_clamp(x, lo, hi) (drwav_max((lo), drwav_min((hi), (x))))
-
-#define DRWAV_MAX_SIMD_VECTOR_SIZE 64 /* 64 for AVX-512 in the future. */
-
-/* CPU architecture. */
-#if defined(__x86_64__) || defined(_M_X64)
- #define DRWAV_X64
-#elif defined(__i386) || defined(_M_IX86)
- #define DRWAV_X86
-#elif defined(__arm__) || defined(_M_ARM)
- #define DRWAV_ARM
-#endif
-
-#ifdef _MSC_VER
- #define DRWAV_INLINE __forceinline
-#elif defined(__GNUC__)
- /*
- I've had a bug report where GCC is emitting warnings about functions possibly not being inlineable. This warning happens when
- the __attribute__((always_inline)) attribute is defined without an "inline" statement. I think therefore there must be some
- case where "__inline__" is not always defined, thus the compiler emitting these warnings. When using -std=c89 or -ansi on the
- command line, we cannot use the "inline" keyword and instead need to use "__inline__". In an attempt to work around this issue
- I am using "__inline__" only when we're compiling in strict ANSI mode.
- */
- #if defined(__STRICT_ANSI__)
- #define DRWAV_INLINE __inline__ __attribute__((always_inline))
- #else
- #define DRWAV_INLINE inline __attribute__((always_inline))
- #endif
-#elif defined(__WATCOMC__)
- #define DRWAV_INLINE __inline
-#else
- #define DRWAV_INLINE
-#endif
-
-#if defined(SIZE_MAX)
- #define DRWAV_SIZE_MAX SIZE_MAX
-#else
- #if defined(_WIN64) || defined(_LP64) || defined(__LP64__)
- #define DRWAV_SIZE_MAX ((drwav_uint64)0xFFFFFFFFFFFFFFFF)
- #else
- #define DRWAV_SIZE_MAX 0xFFFFFFFF
- #endif
-#endif
-
-#if defined(_MSC_VER) && _MSC_VER >= 1400
- #define DRWAV_HAS_BYTESWAP16_INTRINSIC
- #define DRWAV_HAS_BYTESWAP32_INTRINSIC
- #define DRWAV_HAS_BYTESWAP64_INTRINSIC
-#elif defined(__clang__)
- #if defined(__has_builtin)
- #if __has_builtin(__builtin_bswap16)
- #define DRWAV_HAS_BYTESWAP16_INTRINSIC
- #endif
- #if __has_builtin(__builtin_bswap32)
- #define DRWAV_HAS_BYTESWAP32_INTRINSIC
- #endif
- #if __has_builtin(__builtin_bswap64)
- #define DRWAV_HAS_BYTESWAP64_INTRINSIC
- #endif
- #endif
-#elif defined(__GNUC__)
- #if ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))
- #define DRWAV_HAS_BYTESWAP32_INTRINSIC
- #define DRWAV_HAS_BYTESWAP64_INTRINSIC
- #endif
- #if ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8))
- #define DRWAV_HAS_BYTESWAP16_INTRINSIC
- #endif
-#endif
-
-DRWAV_API void drwav_version(drwav_uint32* pMajor, drwav_uint32* pMinor, drwav_uint32* pRevision)
-{
- if (pMajor) {
- *pMajor = DRWAV_VERSION_MAJOR;
- }
-
- if (pMinor) {
- *pMinor = DRWAV_VERSION_MINOR;
- }
-
- if (pRevision) {
- *pRevision = DRWAV_VERSION_REVISION;
- }
-}
-
-DRWAV_API const char* drwav_version_string(void)
-{
- return DRWAV_VERSION_STRING;
-}
-
-/*
-These limits are used for basic validation when initializing the decoder. If you exceed these limits, first of all: what on Earth are
-you doing?! (Let me know, I'd be curious!) Second, you can adjust these by #define-ing them before the dr_wav implementation.
-*/
-#ifndef DRWAV_MAX_SAMPLE_RATE
-#define DRWAV_MAX_SAMPLE_RATE 384000
-#endif
-#ifndef DRWAV_MAX_CHANNELS
-#define DRWAV_MAX_CHANNELS 256
-#endif
-#ifndef DRWAV_MAX_BITS_PER_SAMPLE
-#define DRWAV_MAX_BITS_PER_SAMPLE 64
-#endif
-
-static const drwav_uint8 drwavGUID_W64_RIFF[16] = {0x72,0x69,0x66,0x66, 0x2E,0x91, 0xCF,0x11, 0xA5,0xD6, 0x28,0xDB,0x04,0xC1,0x00,0x00}; /* 66666972-912E-11CF-A5D6-28DB04C10000 */
-static const drwav_uint8 drwavGUID_W64_WAVE[16] = {0x77,0x61,0x76,0x65, 0xF3,0xAC, 0xD3,0x11, 0x8C,0xD1, 0x00,0xC0,0x4F,0x8E,0xDB,0x8A}; /* 65766177-ACF3-11D3-8CD1-00C04F8EDB8A */
-/*static const drwav_uint8 drwavGUID_W64_JUNK[16] = {0x6A,0x75,0x6E,0x6B, 0xF3,0xAC, 0xD3,0x11, 0x8C,0xD1, 0x00,0xC0,0x4F,0x8E,0xDB,0x8A};*/ /* 6B6E756A-ACF3-11D3-8CD1-00C04F8EDB8A */
-static const drwav_uint8 drwavGUID_W64_FMT [16] = {0x66,0x6D,0x74,0x20, 0xF3,0xAC, 0xD3,0x11, 0x8C,0xD1, 0x00,0xC0,0x4F,0x8E,0xDB,0x8A}; /* 20746D66-ACF3-11D3-8CD1-00C04F8EDB8A */
-static const drwav_uint8 drwavGUID_W64_FACT[16] = {0x66,0x61,0x63,0x74, 0xF3,0xAC, 0xD3,0x11, 0x8C,0xD1, 0x00,0xC0,0x4F,0x8E,0xDB,0x8A}; /* 74636166-ACF3-11D3-8CD1-00C04F8EDB8A */
-static const drwav_uint8 drwavGUID_W64_DATA[16] = {0x64,0x61,0x74,0x61, 0xF3,0xAC, 0xD3,0x11, 0x8C,0xD1, 0x00,0xC0,0x4F,0x8E,0xDB,0x8A}; /* 61746164-ACF3-11D3-8CD1-00C04F8EDB8A */
-static const drwav_uint8 drwavGUID_W64_SMPL[16] = {0x73,0x6D,0x70,0x6C, 0xF3,0xAC, 0xD3,0x11, 0x8C,0xD1, 0x00,0xC0,0x4F,0x8E,0xDB,0x8A}; /* 6C706D73-ACF3-11D3-8CD1-00C04F8EDB8A */
-
-static DRWAV_INLINE drwav_bool32 drwav__guid_equal(const drwav_uint8 a[16], const drwav_uint8 b[16])
-{
- int i;
- for (i = 0; i < 16; i += 1) {
- if (a[i] != b[i]) {
- return DRWAV_FALSE;
- }
- }
-
- return DRWAV_TRUE;
-}
-
-static DRWAV_INLINE drwav_bool32 drwav__fourcc_equal(const drwav_uint8* a, const char* b)
-{
- return
- a[0] == b[0] &&
- a[1] == b[1] &&
- a[2] == b[2] &&
- a[3] == b[3];
-}
-
-
-
-static DRWAV_INLINE int drwav__is_little_endian(void)
-{
-#if defined(DRWAV_X86) || defined(DRWAV_X64)
- return DRWAV_TRUE;
-#elif defined(__BYTE_ORDER) && defined(__LITTLE_ENDIAN) && __BYTE_ORDER == __LITTLE_ENDIAN
- return DRWAV_TRUE;
-#else
- int n = 1;
- return (*(char*)&n) == 1;
-#endif
-}
-
-static DRWAV_INLINE drwav_uint16 drwav__bytes_to_u16(const drwav_uint8* data)
-{
- return (data[0] << 0) | (data[1] << 8);
-}
-
-static DRWAV_INLINE drwav_int16 drwav__bytes_to_s16(const drwav_uint8* data)
-{
- return (short)drwav__bytes_to_u16(data);
-}
-
-static DRWAV_INLINE drwav_uint32 drwav__bytes_to_u32(const drwav_uint8* data)
-{
- return (data[0] << 0) | (data[1] << 8) | (data[2] << 16) | (data[3] << 24);
-}
-
-static DRWAV_INLINE drwav_int32 drwav__bytes_to_s32(const drwav_uint8* data)
-{
- return (drwav_int32)drwav__bytes_to_u32(data);
-}
-
-static DRWAV_INLINE drwav_uint64 drwav__bytes_to_u64(const drwav_uint8* data)
-{
- return
- ((drwav_uint64)data[0] << 0) | ((drwav_uint64)data[1] << 8) | ((drwav_uint64)data[2] << 16) | ((drwav_uint64)data[3] << 24) |
- ((drwav_uint64)data[4] << 32) | ((drwav_uint64)data[5] << 40) | ((drwav_uint64)data[6] << 48) | ((drwav_uint64)data[7] << 56);
-}
-
-static DRWAV_INLINE drwav_int64 drwav__bytes_to_s64(const drwav_uint8* data)
-{
- return (drwav_int64)drwav__bytes_to_u64(data);
-}
-
-static DRWAV_INLINE void drwav__bytes_to_guid(const drwav_uint8* data, drwav_uint8* guid)
-{
- int i;
- for (i = 0; i < 16; ++i) {
- guid[i] = data[i];
- }
-}
-
-
-static DRWAV_INLINE drwav_uint16 drwav__bswap16(drwav_uint16 n)
-{
-#ifdef DRWAV_HAS_BYTESWAP16_INTRINSIC
- #if defined(_MSC_VER)
- return _byteswap_ushort(n);
- #elif defined(__GNUC__) || defined(__clang__)
- return __builtin_bswap16(n);
- #else
- #error "This compiler does not support the byte swap intrinsic."
- #endif
-#else
- return ((n & 0xFF00) >> 8) |
- ((n & 0x00FF) << 8);
-#endif
-}
-
-static DRWAV_INLINE drwav_uint32 drwav__bswap32(drwav_uint32 n)
-{
-#ifdef DRWAV_HAS_BYTESWAP32_INTRINSIC
- #if defined(_MSC_VER)
- return _byteswap_ulong(n);
- #elif defined(__GNUC__) || defined(__clang__)
- #if defined(DRWAV_ARM) && (defined(__ARM_ARCH) && __ARM_ARCH >= 6) && !defined(DRWAV_64BIT) /* <-- 64-bit inline assembly has not been tested, so disabling for now. */
- /* Inline assembly optimized implementation for ARM. In my testing, GCC does not generate optimized code with __builtin_bswap32(). */
- drwav_uint32 r;
- __asm__ __volatile__ (
- #if defined(DRWAV_64BIT)
- "rev %w[out], %w[in]" : [out]"=r"(r) : [in]"r"(n) /* <-- This is untested. If someone in the community could test this, that would be appreciated! */
- #else
- "rev %[out], %[in]" : [out]"=r"(r) : [in]"r"(n)
- #endif
- );
- return r;
- #else
- return __builtin_bswap32(n);
- #endif
- #else
- #error "This compiler does not support the byte swap intrinsic."
- #endif
-#else
- return ((n & 0xFF000000) >> 24) |
- ((n & 0x00FF0000) >> 8) |
- ((n & 0x0000FF00) << 8) |
- ((n & 0x000000FF) << 24);
-#endif
-}
-
-static DRWAV_INLINE drwav_uint64 drwav__bswap64(drwav_uint64 n)
-{
-#ifdef DRWAV_HAS_BYTESWAP64_INTRINSIC
- #if defined(_MSC_VER)
- return _byteswap_uint64(n);
- #elif defined(__GNUC__) || defined(__clang__)
- return __builtin_bswap64(n);
- #else
- #error "This compiler does not support the byte swap intrinsic."
- #endif
-#else
- /* Weird "<< 32" bitshift is required for C89 because it doesn't support 64-bit constants. Should be optimized out by a good compiler. */
- return ((n & ((drwav_uint64)0xFF000000 << 32)) >> 56) |
- ((n & ((drwav_uint64)0x00FF0000 << 32)) >> 40) |
- ((n & ((drwav_uint64)0x0000FF00 << 32)) >> 24) |
- ((n & ((drwav_uint64)0x000000FF << 32)) >> 8) |
- ((n & ((drwav_uint64)0xFF000000 )) << 8) |
- ((n & ((drwav_uint64)0x00FF0000 )) << 24) |
- ((n & ((drwav_uint64)0x0000FF00 )) << 40) |
- ((n & ((drwav_uint64)0x000000FF )) << 56);
-#endif
-}
-
-
-static DRWAV_INLINE drwav_int16 drwav__bswap_s16(drwav_int16 n)
-{
- return (drwav_int16)drwav__bswap16((drwav_uint16)n);
-}
-
-static DRWAV_INLINE void drwav__bswap_samples_s16(drwav_int16* pSamples, drwav_uint64 sampleCount)
-{
- drwav_uint64 iSample;
- for (iSample = 0; iSample < sampleCount; iSample += 1) {
- pSamples[iSample] = drwav__bswap_s16(pSamples[iSample]);
- }
-}
-
-
-static DRWAV_INLINE void drwav__bswap_s24(drwav_uint8* p)
-{
- drwav_uint8 t;
- t = p[0];
- p[0] = p[2];
- p[2] = t;
-}
-
-static DRWAV_INLINE void drwav__bswap_samples_s24(drwav_uint8* pSamples, drwav_uint64 sampleCount)
-{
- drwav_uint64 iSample;
- for (iSample = 0; iSample < sampleCount; iSample += 1) {
- drwav_uint8* pSample = pSamples + (iSample*3);
- drwav__bswap_s24(pSample);
- }
-}
-
-
-static DRWAV_INLINE drwav_int32 drwav__bswap_s32(drwav_int32 n)
-{
- return (drwav_int32)drwav__bswap32((drwav_uint32)n);
-}
-
-static DRWAV_INLINE void drwav__bswap_samples_s32(drwav_int32* pSamples, drwav_uint64 sampleCount)
-{
- drwav_uint64 iSample;
- for (iSample = 0; iSample < sampleCount; iSample += 1) {
- pSamples[iSample] = drwav__bswap_s32(pSamples[iSample]);
- }
-}
-
-
-static DRWAV_INLINE float drwav__bswap_f32(float n)
-{
- union {
- drwav_uint32 i;
- float f;
- } x;
- x.f = n;
- x.i = drwav__bswap32(x.i);
-
- return x.f;
-}
-
-static DRWAV_INLINE void drwav__bswap_samples_f32(float* pSamples, drwav_uint64 sampleCount)
-{
- drwav_uint64 iSample;
- for (iSample = 0; iSample < sampleCount; iSample += 1) {
- pSamples[iSample] = drwav__bswap_f32(pSamples[iSample]);
- }
-}
-
-
-static DRWAV_INLINE double drwav__bswap_f64(double n)
-{
- union {
- drwav_uint64 i;
- double f;
- } x;
- x.f = n;
- x.i = drwav__bswap64(x.i);
-
- return x.f;
-}
-
-static DRWAV_INLINE void drwav__bswap_samples_f64(double* pSamples, drwav_uint64 sampleCount)
-{
- drwav_uint64 iSample;
- for (iSample = 0; iSample < sampleCount; iSample += 1) {
- pSamples[iSample] = drwav__bswap_f64(pSamples[iSample]);
- }
-}
-
-
-static DRWAV_INLINE void drwav__bswap_samples_pcm(void* pSamples, drwav_uint64 sampleCount, drwav_uint32 bytesPerSample)
-{
- /* Assumes integer PCM. Floating point PCM is done in drwav__bswap_samples_ieee(). */
- switch (bytesPerSample)
- {
- case 2: /* s16, s12 (loosely packed) */
- {
- drwav__bswap_samples_s16((drwav_int16*)pSamples, sampleCount);
- } break;
- case 3: /* s24 */
- {
- drwav__bswap_samples_s24((drwav_uint8*)pSamples, sampleCount);
- } break;
- case 4: /* s32 */
- {
- drwav__bswap_samples_s32((drwav_int32*)pSamples, sampleCount);
- } break;
- default:
- {
- /* Unsupported format. */
- DRWAV_ASSERT(DRWAV_FALSE);
- } break;
- }
-}
-
-static DRWAV_INLINE void drwav__bswap_samples_ieee(void* pSamples, drwav_uint64 sampleCount, drwav_uint32 bytesPerSample)
-{
- switch (bytesPerSample)
- {
- #if 0 /* Contributions welcome for f16 support. */
- case 2: /* f16 */
- {
- drwav__bswap_samples_f16((drwav_float16*)pSamples, sampleCount);
- } break;
- #endif
- case 4: /* f32 */
- {
- drwav__bswap_samples_f32((float*)pSamples, sampleCount);
- } break;
- case 8: /* f64 */
- {
- drwav__bswap_samples_f64((double*)pSamples, sampleCount);
- } break;
- default:
- {
- /* Unsupported format. */
- DRWAV_ASSERT(DRWAV_FALSE);
- } break;
- }
-}
-
-static DRWAV_INLINE void drwav__bswap_samples(void* pSamples, drwav_uint64 sampleCount, drwav_uint32 bytesPerSample, drwav_uint16 format)
-{
- switch (format)
- {
- case DR_WAVE_FORMAT_PCM:
- {
- drwav__bswap_samples_pcm(pSamples, sampleCount, bytesPerSample);
- } break;
-
- case DR_WAVE_FORMAT_IEEE_FLOAT:
- {
- drwav__bswap_samples_ieee(pSamples, sampleCount, bytesPerSample);
- } break;
-
- case DR_WAVE_FORMAT_ALAW:
- case DR_WAVE_FORMAT_MULAW:
- {
- drwav__bswap_samples_s16((drwav_int16*)pSamples, sampleCount);
- } break;
-
- case DR_WAVE_FORMAT_ADPCM:
- case DR_WAVE_FORMAT_DVI_ADPCM:
- default:
- {
- /* Unsupported format. */
- DRWAV_ASSERT(DRWAV_FALSE);
- } break;
- }
-}
-
-
-static void* drwav__malloc_default(size_t sz, void* pUserData)
-{
- (void)pUserData;
- return DRWAV_MALLOC(sz);
-}
-
-static void* drwav__realloc_default(void* p, size_t sz, void* pUserData)
-{
- (void)pUserData;
- return DRWAV_REALLOC(p, sz);
-}
-
-static void drwav__free_default(void* p, void* pUserData)
-{
- (void)pUserData;
- DRWAV_FREE(p);
-}
-
-
-static void* drwav__malloc_from_callbacks(size_t sz, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
- if (pAllocationCallbacks == NULL) {
- return NULL;
- }
-
- if (pAllocationCallbacks->onMalloc != NULL) {
- return pAllocationCallbacks->onMalloc(sz, pAllocationCallbacks->pUserData);
- }
-
- /* Try using realloc(). */
- if (pAllocationCallbacks->onRealloc != NULL) {
- return pAllocationCallbacks->onRealloc(NULL, sz, pAllocationCallbacks->pUserData);
- }
-
- return NULL;
-}
-
-static void* drwav__realloc_from_callbacks(void* p, size_t szNew, size_t szOld, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
- if (pAllocationCallbacks == NULL) {
- return NULL;
- }
-
- if (pAllocationCallbacks->onRealloc != NULL) {
- return pAllocationCallbacks->onRealloc(p, szNew, pAllocationCallbacks->pUserData);
- }
-
- /* Try emulating realloc() in terms of malloc()/free(). */
- if (pAllocationCallbacks->onMalloc != NULL && pAllocationCallbacks->onFree != NULL) {
- void* p2;
-
- p2 = pAllocationCallbacks->onMalloc(szNew, pAllocationCallbacks->pUserData);
- if (p2 == NULL) {
- return NULL;
- }
-
- if (p != NULL) {
- DRWAV_COPY_MEMORY(p2, p, szOld);
- pAllocationCallbacks->onFree(p, pAllocationCallbacks->pUserData);
- }
-
- return p2;
- }
-
- return NULL;
-}
-
-static void drwav__free_from_callbacks(void* p, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
- if (p == NULL || pAllocationCallbacks == NULL) {
- return;
- }
-
- if (pAllocationCallbacks->onFree != NULL) {
- pAllocationCallbacks->onFree(p, pAllocationCallbacks->pUserData);
- }
-}
-
-
-static drwav_allocation_callbacks drwav_copy_allocation_callbacks_or_defaults(const drwav_allocation_callbacks* pAllocationCallbacks)
-{
- if (pAllocationCallbacks != NULL) {
- /* Copy. */
- return *pAllocationCallbacks;
- } else {
- /* Defaults. */
- drwav_allocation_callbacks allocationCallbacks;
- allocationCallbacks.pUserData = NULL;
- allocationCallbacks.onMalloc = drwav__malloc_default;
- allocationCallbacks.onRealloc = drwav__realloc_default;
- allocationCallbacks.onFree = drwav__free_default;
- return allocationCallbacks;
- }
-}
-
-
-static DRWAV_INLINE drwav_bool32 drwav__is_compressed_format_tag(drwav_uint16 formatTag)
-{
- return
- formatTag == DR_WAVE_FORMAT_ADPCM ||
- formatTag == DR_WAVE_FORMAT_DVI_ADPCM;
-}
-
-static unsigned int drwav__chunk_padding_size_riff(drwav_uint64 chunkSize)
-{
- return (unsigned int)(chunkSize % 2);
-}
-
-static unsigned int drwav__chunk_padding_size_w64(drwav_uint64 chunkSize)
-{
- return (unsigned int)(chunkSize % 8);
-}
-
-static drwav_uint64 drwav_read_pcm_frames_s16__msadpcm(drwav* pWav, drwav_uint64 samplesToRead, drwav_int16* pBufferOut);
-static drwav_uint64 drwav_read_pcm_frames_s16__ima(drwav* pWav, drwav_uint64 samplesToRead, drwav_int16* pBufferOut);
-static drwav_bool32 drwav_init_write__internal(drwav* pWav, const drwav_data_format* pFormat, drwav_uint64 totalSampleCount);
-
-static drwav_result drwav__read_chunk_header(drwav_read_proc onRead, void* pUserData, drwav_container container, drwav_uint64* pRunningBytesReadOut, drwav_chunk_header* pHeaderOut)
-{
- if (container == drwav_container_riff || container == drwav_container_rf64) {
- drwav_uint8 sizeInBytes[4];
-
- if (onRead(pUserData, pHeaderOut->id.fourcc, 4) != 4) {
- return DRWAV_AT_END;
- }
-
- if (onRead(pUserData, sizeInBytes, 4) != 4) {
- return DRWAV_INVALID_FILE;
- }
-
- pHeaderOut->sizeInBytes = drwav__bytes_to_u32(sizeInBytes);
- pHeaderOut->paddingSize = drwav__chunk_padding_size_riff(pHeaderOut->sizeInBytes);
- *pRunningBytesReadOut += 8;
- } else {
- drwav_uint8 sizeInBytes[8];
-
- if (onRead(pUserData, pHeaderOut->id.guid, 16) != 16) {
- return DRWAV_AT_END;
- }
-
- if (onRead(pUserData, sizeInBytes, 8) != 8) {
- return DRWAV_INVALID_FILE;
- }
-
- pHeaderOut->sizeInBytes = drwav__bytes_to_u64(sizeInBytes) - 24; /* <-- Subtract 24 because w64 includes the size of the header. */
- pHeaderOut->paddingSize = drwav__chunk_padding_size_w64(pHeaderOut->sizeInBytes);
- *pRunningBytesReadOut += 24;
- }
-
- return DRWAV_SUCCESS;
-}
-
-static drwav_bool32 drwav__seek_forward(drwav_seek_proc onSeek, drwav_uint64 offset, void* pUserData)
-{
- drwav_uint64 bytesRemainingToSeek = offset;
- while (bytesRemainingToSeek > 0) {
- if (bytesRemainingToSeek > 0x7FFFFFFF) {
- if (!onSeek(pUserData, 0x7FFFFFFF, drwav_seek_origin_current)) {
- return DRWAV_FALSE;
- }
- bytesRemainingToSeek -= 0x7FFFFFFF;
- } else {
- if (!onSeek(pUserData, (int)bytesRemainingToSeek, drwav_seek_origin_current)) {
- return DRWAV_FALSE;
- }
- bytesRemainingToSeek = 0;
- }
- }
-
- return DRWAV_TRUE;
-}
-
-static drwav_bool32 drwav__seek_from_start(drwav_seek_proc onSeek, drwav_uint64 offset, void* pUserData)
-{
- if (offset <= 0x7FFFFFFF) {
- return onSeek(pUserData, (int)offset, drwav_seek_origin_start);
- }
-
- /* Larger than 32-bit seek. */
- if (!onSeek(pUserData, 0x7FFFFFFF, drwav_seek_origin_start)) {
- return DRWAV_FALSE;
- }
- offset -= 0x7FFFFFFF;
-
- for (;;) {
- if (offset <= 0x7FFFFFFF) {
- return onSeek(pUserData, (int)offset, drwav_seek_origin_current);
- }
-
- if (!onSeek(pUserData, 0x7FFFFFFF, drwav_seek_origin_current)) {
- return DRWAV_FALSE;
- }
- offset -= 0x7FFFFFFF;
- }
-
- /* Should never get here. */
- /*return DRWAV_TRUE; */
-}
-
-
-static drwav_bool32 drwav__read_fmt(drwav_read_proc onRead, drwav_seek_proc onSeek, void* pUserData, drwav_container container, drwav_uint64* pRunningBytesReadOut, drwav_fmt* fmtOut)
-{
- drwav_chunk_header header;
- drwav_uint8 fmt[16];
-
- if (drwav__read_chunk_header(onRead, pUserData, container, pRunningBytesReadOut, &header) != DRWAV_SUCCESS) {
- return DRWAV_FALSE;
- }
-
-
- /* Skip non-fmt chunks. */
- while (((container == drwav_container_riff || container == drwav_container_rf64) && !drwav__fourcc_equal(header.id.fourcc, "fmt ")) || (container == drwav_container_w64 && !drwav__guid_equal(header.id.guid, drwavGUID_W64_FMT))) {
- if (!drwav__seek_forward(onSeek, header.sizeInBytes + header.paddingSize, pUserData)) {
- return DRWAV_FALSE;
- }
- *pRunningBytesReadOut += header.sizeInBytes + header.paddingSize;
-
- /* Try the next header. */
- if (drwav__read_chunk_header(onRead, pUserData, container, pRunningBytesReadOut, &header) != DRWAV_SUCCESS) {
- return DRWAV_FALSE;
- }
- }
-
-
- /* Validation. */
- if (container == drwav_container_riff || container == drwav_container_rf64) {
- if (!drwav__fourcc_equal(header.id.fourcc, "fmt ")) {
- return DRWAV_FALSE;
- }
- } else {
- if (!drwav__guid_equal(header.id.guid, drwavGUID_W64_FMT)) {
- return DRWAV_FALSE;
- }
- }
-
-
- if (onRead(pUserData, fmt, sizeof(fmt)) != sizeof(fmt)) {
- return DRWAV_FALSE;
- }
- *pRunningBytesReadOut += sizeof(fmt);
-
- fmtOut->formatTag = drwav__bytes_to_u16(fmt + 0);
- fmtOut->channels = drwav__bytes_to_u16(fmt + 2);
- fmtOut->sampleRate = drwav__bytes_to_u32(fmt + 4);
- fmtOut->avgBytesPerSec = drwav__bytes_to_u32(fmt + 8);
- fmtOut->blockAlign = drwav__bytes_to_u16(fmt + 12);
- fmtOut->bitsPerSample = drwav__bytes_to_u16(fmt + 14);
-
- fmtOut->extendedSize = 0;
- fmtOut->validBitsPerSample = 0;
- fmtOut->channelMask = 0;
- memset(fmtOut->subFormat, 0, sizeof(fmtOut->subFormat));
-
- if (header.sizeInBytes > 16) {
- drwav_uint8 fmt_cbSize[2];
- int bytesReadSoFar = 0;
-
- if (onRead(pUserData, fmt_cbSize, sizeof(fmt_cbSize)) != sizeof(fmt_cbSize)) {
- return DRWAV_FALSE; /* Expecting more data. */
- }
- *pRunningBytesReadOut += sizeof(fmt_cbSize);
-
- bytesReadSoFar = 18;
-
- fmtOut->extendedSize = drwav__bytes_to_u16(fmt_cbSize);
- if (fmtOut->extendedSize > 0) {
- /* Simple validation. */
- if (fmtOut->formatTag == DR_WAVE_FORMAT_EXTENSIBLE) {
- if (fmtOut->extendedSize != 22) {
- return DRWAV_FALSE;
- }
- }
-
- if (fmtOut->formatTag == DR_WAVE_FORMAT_EXTENSIBLE) {
- drwav_uint8 fmtext[22];
- if (onRead(pUserData, fmtext, fmtOut->extendedSize) != fmtOut->extendedSize) {
- return DRWAV_FALSE; /* Expecting more data. */
- }
-
- fmtOut->validBitsPerSample = drwav__bytes_to_u16(fmtext + 0);
- fmtOut->channelMask = drwav__bytes_to_u32(fmtext + 2);
- drwav__bytes_to_guid(fmtext + 6, fmtOut->subFormat);
- } else {
- if (!onSeek(pUserData, fmtOut->extendedSize, drwav_seek_origin_current)) {
- return DRWAV_FALSE;
- }
- }
- *pRunningBytesReadOut += fmtOut->extendedSize;
-
- bytesReadSoFar += fmtOut->extendedSize;
- }
-
- /* Seek past any leftover bytes. For w64 the leftover will be defined based on the chunk size. */
- if (!onSeek(pUserData, (int)(header.sizeInBytes - bytesReadSoFar), drwav_seek_origin_current)) {
- return DRWAV_FALSE;
- }
- *pRunningBytesReadOut += (header.sizeInBytes - bytesReadSoFar);
- }
-
- if (header.paddingSize > 0) {
- if (!onSeek(pUserData, header.paddingSize, drwav_seek_origin_current)) {
- return DRWAV_FALSE;
- }
- *pRunningBytesReadOut += header.paddingSize;
- }
-
- return DRWAV_TRUE;
-}
-
-
-static size_t drwav__on_read(drwav_read_proc onRead, void* pUserData, void* pBufferOut, size_t bytesToRead, drwav_uint64* pCursor)
-{
- size_t bytesRead;
-
- DRWAV_ASSERT(onRead != NULL);
- DRWAV_ASSERT(pCursor != NULL);
-
- bytesRead = onRead(pUserData, pBufferOut, bytesToRead);
- *pCursor += bytesRead;
- return bytesRead;
-}
-
-#if 0
-static drwav_bool32 drwav__on_seek(drwav_seek_proc onSeek, void* pUserData, int offset, drwav_seek_origin origin, drwav_uint64* pCursor)
-{
- DRWAV_ASSERT(onSeek != NULL);
- DRWAV_ASSERT(pCursor != NULL);
-
- if (!onSeek(pUserData, offset, origin)) {
- return DRWAV_FALSE;
- }
-
- if (origin == drwav_seek_origin_start) {
- *pCursor = offset;
- } else {
- *pCursor += offset;
- }
-
- return DRWAV_TRUE;
-}
-#endif
-
-
-
-static drwav_uint32 drwav_get_bytes_per_pcm_frame(drwav* pWav)
-{
- /*
- The bytes per frame is a bit ambiguous. It can be either be based on the bits per sample, or the block align. The way I'm doing it here
- is that if the bits per sample is a multiple of 8, use floor(bitsPerSample*channels/8), otherwise fall back to the block align.
- */
- if ((pWav->bitsPerSample & 0x7) == 0) {
- /* Bits per sample is a multiple of 8. */
- return (pWav->bitsPerSample * pWav->fmt.channels) >> 3;
- } else {
- return pWav->fmt.blockAlign;
- }
-}
-
-DRWAV_API drwav_uint16 drwav_fmt_get_format(const drwav_fmt* pFMT)
-{
- if (pFMT == NULL) {
- return 0;
- }
-
- if (pFMT->formatTag != DR_WAVE_FORMAT_EXTENSIBLE) {
- return pFMT->formatTag;
- } else {
- return drwav__bytes_to_u16(pFMT->subFormat); /* Only the first two bytes are required. */
- }
-}
-
-static drwav_bool32 drwav_preinit(drwav* pWav, drwav_read_proc onRead, drwav_seek_proc onSeek, void* pReadSeekUserData, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
- if (pWav == NULL || onRead == NULL || onSeek == NULL) {
- return DRWAV_FALSE;
- }
-
- DRWAV_ZERO_MEMORY(pWav, sizeof(*pWav));
- pWav->onRead = onRead;
- pWav->onSeek = onSeek;
- pWav->pUserData = pReadSeekUserData;
- pWav->allocationCallbacks = drwav_copy_allocation_callbacks_or_defaults(pAllocationCallbacks);
-
- if (pWav->allocationCallbacks.onFree == NULL || (pWav->allocationCallbacks.onMalloc == NULL && pWav->allocationCallbacks.onRealloc == NULL)) {
- return DRWAV_FALSE; /* Invalid allocation callbacks. */
- }
-
- return DRWAV_TRUE;
-}
-
-static drwav_bool32 drwav_init__internal(drwav* pWav, drwav_chunk_proc onChunk, void* pChunkUserData, drwav_uint32 flags)
-{
- /* This function assumes drwav_preinit() has been called beforehand. */
-
- drwav_uint64 cursor; /* <-- Keeps track of the byte position so we can seek to specific locations. */
- drwav_bool32 sequential;
- drwav_uint8 riff[4];
- drwav_fmt fmt;
- unsigned short translatedFormatTag;
- drwav_bool32 foundDataChunk;
- drwav_uint64 dataChunkSize = 0; /* <-- Important! Don't explicitly set this to 0 anywhere else. Calculation of the size of the data chunk is performed in different paths depending on the container. */
- drwav_uint64 sampleCountFromFactChunk = 0; /* Same as dataChunkSize - make sure this is the only place this is initialized to 0. */
- drwav_uint64 chunkSize;
-
- cursor = 0;
- sequential = (flags & DRWAV_SEQUENTIAL) != 0;
-
- /* The first 4 bytes should be the RIFF identifier. */
- if (drwav__on_read(pWav->onRead, pWav->pUserData, riff, sizeof(riff), &cursor) != sizeof(riff)) {
- return DRWAV_FALSE;
- }
-
- /*
- The first 4 bytes can be used to identify the container. For RIFF files it will start with "RIFF" and for
- w64 it will start with "riff".
- */
- if (drwav__fourcc_equal(riff, "RIFF")) {
- pWav->container = drwav_container_riff;
- } else if (drwav__fourcc_equal(riff, "riff")) {
- int i;
- drwav_uint8 riff2[12];
-
- pWav->container = drwav_container_w64;
-
- /* Check the rest of the GUID for validity. */
- if (drwav__on_read(pWav->onRead, pWav->pUserData, riff2, sizeof(riff2), &cursor) != sizeof(riff2)) {
- return DRWAV_FALSE;
- }
-
- for (i = 0; i < 12; ++i) {
- if (riff2[i] != drwavGUID_W64_RIFF[i+4]) {
- return DRWAV_FALSE;
- }
- }
- } else if (drwav__fourcc_equal(riff, "RF64")) {
- pWav->container = drwav_container_rf64;
- } else {
- return DRWAV_FALSE; /* Unknown or unsupported container. */
- }
-
-
- if (pWav->container == drwav_container_riff || pWav->container == drwav_container_rf64) {
- drwav_uint8 chunkSizeBytes[4];
- drwav_uint8 wave[4];
-
- /* RIFF/WAVE */
- if (drwav__on_read(pWav->onRead, pWav->pUserData, chunkSizeBytes, sizeof(chunkSizeBytes), &cursor) != sizeof(chunkSizeBytes)) {
- return DRWAV_FALSE;
- }
-
- if (pWav->container == drwav_container_riff) {
- if (drwav__bytes_to_u32(chunkSizeBytes) < 36) {
- return DRWAV_FALSE; /* Chunk size should always be at least 36 bytes. */
- }
- } else {
- if (drwav__bytes_to_u32(chunkSizeBytes) != 0xFFFFFFFF) {
- return DRWAV_FALSE; /* Chunk size should always be set to -1/0xFFFFFFFF for RF64. The actual size is retrieved later. */
- }
- }
-
- if (drwav__on_read(pWav->onRead, pWav->pUserData, wave, sizeof(wave), &cursor) != sizeof(wave)) {
- return DRWAV_FALSE;
- }
-
- if (!drwav__fourcc_equal(wave, "WAVE")) {
- return DRWAV_FALSE; /* Expecting "WAVE". */
- }
- } else {
- drwav_uint8 chunkSizeBytes[8];
- drwav_uint8 wave[16];
-
- /* W64 */
- if (drwav__on_read(pWav->onRead, pWav->pUserData, chunkSizeBytes, sizeof(chunkSizeBytes), &cursor) != sizeof(chunkSizeBytes)) {
- return DRWAV_FALSE;
- }
-
- if (drwav__bytes_to_u64(chunkSizeBytes) < 80) {
- return DRWAV_FALSE;
- }
-
- if (drwav__on_read(pWav->onRead, pWav->pUserData, wave, sizeof(wave), &cursor) != sizeof(wave)) {
- return DRWAV_FALSE;
- }
-
- if (!drwav__guid_equal(wave, drwavGUID_W64_WAVE)) {
- return DRWAV_FALSE;
- }
- }
-
-
- /* For RF64, the "ds64" chunk must come next, before the "fmt " chunk. */
- if (pWav->container == drwav_container_rf64) {
- drwav_uint8 sizeBytes[8];
- drwav_uint64 bytesRemainingInChunk;
- drwav_chunk_header header;
- drwav_result result = drwav__read_chunk_header(pWav->onRead, pWav->pUserData, pWav->container, &cursor, &header);
- if (result != DRWAV_SUCCESS) {
- return DRWAV_FALSE;
- }
-
- if (!drwav__fourcc_equal(header.id.fourcc, "ds64")) {
- return DRWAV_FALSE; /* Expecting "ds64". */
- }
-
- bytesRemainingInChunk = header.sizeInBytes + header.paddingSize;
-
- /* We don't care about the size of the RIFF chunk - skip it. */
- if (!drwav__seek_forward(pWav->onSeek, 8, pWav->pUserData)) {
- return DRWAV_FALSE;
- }
- bytesRemainingInChunk -= 8;
- cursor += 8;
-
-
- /* Next 8 bytes is the size of the "data" chunk. */
- if (drwav__on_read(pWav->onRead, pWav->pUserData, sizeBytes, sizeof(sizeBytes), &cursor) != sizeof(sizeBytes)) {
- return DRWAV_FALSE;
- }
- bytesRemainingInChunk -= 8;
- dataChunkSize = drwav__bytes_to_u64(sizeBytes);
-
-
- /* Next 8 bytes is the same count which we would usually derived from the FACT chunk if it was available. */
- if (drwav__on_read(pWav->onRead, pWav->pUserData, sizeBytes, sizeof(sizeBytes), &cursor) != sizeof(sizeBytes)) {
- return DRWAV_FALSE;
- }
- bytesRemainingInChunk -= 8;
- sampleCountFromFactChunk = drwav__bytes_to_u64(sizeBytes);
-
-
- /* Skip over everything else. */
- if (!drwav__seek_forward(pWav->onSeek, bytesRemainingInChunk, pWav->pUserData)) {
- return DRWAV_FALSE;
- }
- cursor += bytesRemainingInChunk;
- }
-
-
- /* The next bytes should be the "fmt " chunk. */
- if (!drwav__read_fmt(pWav->onRead, pWav->onSeek, pWav->pUserData, pWav->container, &cursor, &fmt)) {
- return DRWAV_FALSE; /* Failed to read the "fmt " chunk. */
- }
-
- /* Basic validation. */
- if ((fmt.sampleRate == 0 || fmt.sampleRate > DRWAV_MAX_SAMPLE_RATE) ||
- (fmt.channels == 0 || fmt.channels > DRWAV_MAX_CHANNELS) ||
- (fmt.bitsPerSample == 0 || fmt.bitsPerSample > DRWAV_MAX_BITS_PER_SAMPLE) ||
- fmt.blockAlign == 0) {
- return DRWAV_FALSE; /* Probably an invalid WAV file. */
- }
-
-
- /* Translate the internal format. */
- translatedFormatTag = fmt.formatTag;
- if (translatedFormatTag == DR_WAVE_FORMAT_EXTENSIBLE) {
- translatedFormatTag = drwav__bytes_to_u16(fmt.subFormat + 0);
- }
-
-
- /*
- We need to enumerate over each chunk for two reasons:
- 1) The "data" chunk may not be the next one
- 2) We may want to report each chunk back to the client
-
- In order to correctly report each chunk back to the client we will need to keep looping until the end of the file.
- */
- foundDataChunk = DRWAV_FALSE;
-
- /* The next chunk we care about is the "data" chunk. This is not necessarily the next chunk so we'll need to loop. */
- for (;;)
- {
- drwav_chunk_header header;
- drwav_result result = drwav__read_chunk_header(pWav->onRead, pWav->pUserData, pWav->container, &cursor, &header);
- if (result != DRWAV_SUCCESS) {
- if (!foundDataChunk) {
- return DRWAV_FALSE;
- } else {
- break; /* Probably at the end of the file. Get out of the loop. */
- }
- }
-
- /* Tell the client about this chunk. */
- if (!sequential && onChunk != NULL) {
- drwav_uint64 callbackBytesRead = onChunk(pChunkUserData, pWav->onRead, pWav->onSeek, pWav->pUserData, &header, pWav->container, &fmt);
-
- /*
- dr_wav may need to read the contents of the chunk, so we now need to seek back to the position before
- we called the callback.
- */
- if (callbackBytesRead > 0) {
- if (!drwav__seek_from_start(pWav->onSeek, cursor, pWav->pUserData)) {
- return DRWAV_FALSE;
- }
- }
- }
-
-
- if (!foundDataChunk) {
- pWav->dataChunkDataPos = cursor;
- }
-
- chunkSize = header.sizeInBytes;
- if (pWav->container == drwav_container_riff || pWav->container == drwav_container_rf64) {
- if (drwav__fourcc_equal(header.id.fourcc, "data")) {
- foundDataChunk = DRWAV_TRUE;
- if (pWav->container != drwav_container_rf64) { /* The data chunk size for RF64 will always be set to 0xFFFFFFFF here. It was set to it's true value earlier. */
- dataChunkSize = chunkSize;
- }
- }
- } else {
- if (drwav__guid_equal(header.id.guid, drwavGUID_W64_DATA)) {
- foundDataChunk = DRWAV_TRUE;
- dataChunkSize = chunkSize;
- }
- }
-
- /*
- If at this point we have found the data chunk and we're running in sequential mode, we need to break out of this loop. The reason for
- this is that we would otherwise require a backwards seek which sequential mode forbids.
- */
- if (foundDataChunk && sequential) {
- break;
- }
-
- /* Optional. Get the total sample count from the FACT chunk. This is useful for compressed formats. */
- if (pWav->container == drwav_container_riff) {
- if (drwav__fourcc_equal(header.id.fourcc, "fact")) {
- drwav_uint32 sampleCount;
- if (drwav__on_read(pWav->onRead, pWav->pUserData, &sampleCount, 4, &cursor) != 4) {
- return DRWAV_FALSE;
- }
- chunkSize -= 4;
-
- if (!foundDataChunk) {
- pWav->dataChunkDataPos = cursor;
- }
-
- /*
- The sample count in the "fact" chunk is either unreliable, or I'm not understanding it properly. For now I am only enabling this
- for Microsoft ADPCM formats.
- */
- if (pWav->translatedFormatTag == DR_WAVE_FORMAT_ADPCM) {
- sampleCountFromFactChunk = sampleCount;
- } else {
- sampleCountFromFactChunk = 0;
- }
- }
- } else if (pWav->container == drwav_container_w64) {
- if (drwav__guid_equal(header.id.guid, drwavGUID_W64_FACT)) {
- if (drwav__on_read(pWav->onRead, pWav->pUserData, &sampleCountFromFactChunk, 8, &cursor) != 8) {
- return DRWAV_FALSE;
- }
- chunkSize -= 8;
-
- if (!foundDataChunk) {
- pWav->dataChunkDataPos = cursor;
- }
- }
- } else if (pWav->container == drwav_container_rf64) {
- /* We retrieved the sample count from the ds64 chunk earlier so no need to do that here. */
- }
-
- /* "smpl" chunk. */
- if (pWav->container == drwav_container_riff || pWav->container == drwav_container_rf64) {
- if (drwav__fourcc_equal(header.id.fourcc, "smpl")) {
- drwav_uint8 smplHeaderData[36]; /* 36 = size of the smpl header section, not including the loop data. */
- if (chunkSize >= sizeof(smplHeaderData)) {
- drwav_uint64 bytesJustRead = drwav__on_read(pWav->onRead, pWav->pUserData, smplHeaderData, sizeof(smplHeaderData), &cursor);
- chunkSize -= bytesJustRead;
-
- if (bytesJustRead == sizeof(smplHeaderData)) {
- drwav_uint32 iLoop;
-
- pWav->smpl.manufacturer = drwav__bytes_to_u32(smplHeaderData+0);
- pWav->smpl.product = drwav__bytes_to_u32(smplHeaderData+4);
- pWav->smpl.samplePeriod = drwav__bytes_to_u32(smplHeaderData+8);
- pWav->smpl.midiUnityNotes = drwav__bytes_to_u32(smplHeaderData+12);
- pWav->smpl.midiPitchFraction = drwav__bytes_to_u32(smplHeaderData+16);
- pWav->smpl.smpteFormat = drwav__bytes_to_u32(smplHeaderData+20);
- pWav->smpl.smpteOffset = drwav__bytes_to_u32(smplHeaderData+24);
- pWav->smpl.numSampleLoops = drwav__bytes_to_u32(smplHeaderData+28);
- pWav->smpl.samplerData = drwav__bytes_to_u32(smplHeaderData+32);
-
- for (iLoop = 0; iLoop < pWav->smpl.numSampleLoops && iLoop < drwav_countof(pWav->smpl.loops); ++iLoop) {
- drwav_uint8 smplLoopData[24]; /* 24 = size of a loop section in the smpl chunk. */
- bytesJustRead = drwav__on_read(pWav->onRead, pWav->pUserData, smplLoopData, sizeof(smplLoopData), &cursor);
- chunkSize -= bytesJustRead;
-
- if (bytesJustRead == sizeof(smplLoopData)) {
- pWav->smpl.loops[iLoop].cuePointId = drwav__bytes_to_u32(smplLoopData+0);
- pWav->smpl.loops[iLoop].type = drwav__bytes_to_u32(smplLoopData+4);
- pWav->smpl.loops[iLoop].start = drwav__bytes_to_u32(smplLoopData+8);
- pWav->smpl.loops[iLoop].end = drwav__bytes_to_u32(smplLoopData+12);
- pWav->smpl.loops[iLoop].fraction = drwav__bytes_to_u32(smplLoopData+16);
- pWav->smpl.loops[iLoop].playCount = drwav__bytes_to_u32(smplLoopData+20);
- } else {
- break; /* Break from the smpl loop for loop. */
- }
- }
- }
- } else {
- /* Looks like invalid data. Ignore the chunk. */
- }
- }
- } else {
- if (drwav__guid_equal(header.id.guid, drwavGUID_W64_SMPL)) {
- /*
- This path will be hit when a W64 WAV file contains a smpl chunk. I don't have a sample file to test this path, so a contribution
- is welcome to add support for this.
- */
- }
- }
-
- /* Make sure we seek past the padding. */
- chunkSize += header.paddingSize;
- if (!drwav__seek_forward(pWav->onSeek, chunkSize, pWav->pUserData)) {
- break;
- }
- cursor += chunkSize;
-
- if (!foundDataChunk) {
- pWav->dataChunkDataPos = cursor;
- }
- }
-
- /* If we haven't found a data chunk, return an error. */
- if (!foundDataChunk) {
- return DRWAV_FALSE;
- }
-
- /* We may have moved passed the data chunk. If so we need to move back. If running in sequential mode we can assume we are already sitting on the data chunk. */
- if (!sequential) {
- if (!drwav__seek_from_start(pWav->onSeek, pWav->dataChunkDataPos, pWav->pUserData)) {
- return DRWAV_FALSE;
- }
- cursor = pWav->dataChunkDataPos;
- }
-
-
- /* At this point we should be sitting on the first byte of the raw audio data. */
-
- pWav->fmt = fmt;
- pWav->sampleRate = fmt.sampleRate;
- pWav->channels = fmt.channels;
- pWav->bitsPerSample = fmt.bitsPerSample;
- pWav->bytesRemaining = dataChunkSize;
- pWav->translatedFormatTag = translatedFormatTag;
- pWav->dataChunkDataSize = dataChunkSize;
-
- if (sampleCountFromFactChunk != 0) {
- pWav->totalPCMFrameCount = sampleCountFromFactChunk;
- } else {
- pWav->totalPCMFrameCount = dataChunkSize / drwav_get_bytes_per_pcm_frame(pWav);
-
- if (pWav->translatedFormatTag == DR_WAVE_FORMAT_ADPCM) {
- drwav_uint64 totalBlockHeaderSizeInBytes;
- drwav_uint64 blockCount = dataChunkSize / fmt.blockAlign;
-
- /* Make sure any trailing partial block is accounted for. */
- if ((blockCount * fmt.blockAlign) < dataChunkSize) {
- blockCount += 1;
- }
-
- /* We decode two samples per byte. There will be blockCount headers in the data chunk. This is enough to know how to calculate the total PCM frame count. */
- totalBlockHeaderSizeInBytes = blockCount * (6*fmt.channels);
- pWav->totalPCMFrameCount = ((dataChunkSize - totalBlockHeaderSizeInBytes) * 2) / fmt.channels;
- }
- if (pWav->translatedFormatTag == DR_WAVE_FORMAT_DVI_ADPCM) {
- drwav_uint64 totalBlockHeaderSizeInBytes;
- drwav_uint64 blockCount = dataChunkSize / fmt.blockAlign;
-
- /* Make sure any trailing partial block is accounted for. */
- if ((blockCount * fmt.blockAlign) < dataChunkSize) {
- blockCount += 1;
- }
-
- /* We decode two samples per byte. There will be blockCount headers in the data chunk. This is enough to know how to calculate the total PCM frame count. */
- totalBlockHeaderSizeInBytes = blockCount * (4*fmt.channels);
- pWav->totalPCMFrameCount = ((dataChunkSize - totalBlockHeaderSizeInBytes) * 2) / fmt.channels;
-
- /* The header includes a decoded sample for each channel which acts as the initial predictor sample. */
- pWav->totalPCMFrameCount += blockCount;
- }
- }
-
- /* Some formats only support a certain number of channels. */
- if (pWav->translatedFormatTag == DR_WAVE_FORMAT_ADPCM || pWav->translatedFormatTag == DR_WAVE_FORMAT_DVI_ADPCM) {
- if (pWav->channels > 2) {
- return DRWAV_FALSE;
- }
- }
-
-#ifdef DR_WAV_LIBSNDFILE_COMPAT
- /*
- I use libsndfile as a benchmark for testing, however in the version I'm using (from the Windows installer on the libsndfile website),
- it appears the total sample count libsndfile uses for MS-ADPCM is incorrect. It would seem they are computing the total sample count
- from the number of blocks, however this results in the inclusion of extra silent samples at the end of the last block. The correct
- way to know the total sample count is to inspect the "fact" chunk, which should always be present for compressed formats, and should
- always include the sample count. This little block of code below is only used to emulate the libsndfile logic so I can properly run my
- correctness tests against libsndfile, and is disabled by default.
- */
- if (pWav->translatedFormatTag == DR_WAVE_FORMAT_ADPCM) {
- drwav_uint64 blockCount = dataChunkSize / fmt.blockAlign;
- pWav->totalPCMFrameCount = (((blockCount * (fmt.blockAlign - (6*pWav->channels))) * 2)) / fmt.channels; /* x2 because two samples per byte. */
- }
- if (pWav->translatedFormatTag == DR_WAVE_FORMAT_DVI_ADPCM) {
- drwav_uint64 blockCount = dataChunkSize / fmt.blockAlign;
- pWav->totalPCMFrameCount = (((blockCount * (fmt.blockAlign - (4*pWav->channels))) * 2) + (blockCount * pWav->channels)) / fmt.channels;
- }
-#endif
-
- return DRWAV_TRUE;
-}
-
-DRWAV_API drwav_bool32 drwav_init(drwav* pWav, drwav_read_proc onRead, drwav_seek_proc onSeek, void* pUserData, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
- return drwav_init_ex(pWav, onRead, onSeek, NULL, pUserData, NULL, 0, pAllocationCallbacks);
-}
-
-DRWAV_API drwav_bool32 drwav_init_ex(drwav* pWav, drwav_read_proc onRead, drwav_seek_proc onSeek, drwav_chunk_proc onChunk, void* pReadSeekUserData, void* pChunkUserData, drwav_uint32 flags, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
- if (!drwav_preinit(pWav, onRead, onSeek, pReadSeekUserData, pAllocationCallbacks)) {
- return DRWAV_FALSE;
- }
-
- return drwav_init__internal(pWav, onChunk, pChunkUserData, flags);
-}
-
-
-static drwav_uint32 drwav__riff_chunk_size_riff(drwav_uint64 dataChunkSize)
-{
- drwav_uint64 chunkSize = 4 + 24 + dataChunkSize + drwav__chunk_padding_size_riff(dataChunkSize); /* 4 = "WAVE". 24 = "fmt " chunk. */
- if (chunkSize > 0xFFFFFFFFUL) {
- chunkSize = 0xFFFFFFFFUL;
- }
-
- return (drwav_uint32)chunkSize; /* Safe cast due to the clamp above. */
-}
-
-static drwav_uint32 drwav__data_chunk_size_riff(drwav_uint64 dataChunkSize)
-{
- if (dataChunkSize <= 0xFFFFFFFFUL) {
- return (drwav_uint32)dataChunkSize;
- } else {
- return 0xFFFFFFFFUL;
- }
-}
-
-static drwav_uint64 drwav__riff_chunk_size_w64(drwav_uint64 dataChunkSize)
-{
- drwav_uint64 dataSubchunkPaddingSize = drwav__chunk_padding_size_w64(dataChunkSize);
-
- return 80 + 24 + dataChunkSize + dataSubchunkPaddingSize; /* +24 because W64 includes the size of the GUID and size fields. */
-}
-
-static drwav_uint64 drwav__data_chunk_size_w64(drwav_uint64 dataChunkSize)
-{
- return 24 + dataChunkSize; /* +24 because W64 includes the size of the GUID and size fields. */
-}
-
-static drwav_uint64 drwav__riff_chunk_size_rf64(drwav_uint64 dataChunkSize)
-{
- drwav_uint64 chunkSize = 4 + 36 + 24 + dataChunkSize + drwav__chunk_padding_size_riff(dataChunkSize); /* 4 = "WAVE". 36 = "ds64" chunk. 24 = "fmt " chunk. */
- if (chunkSize > 0xFFFFFFFFUL) {
- chunkSize = 0xFFFFFFFFUL;
- }
-
- return chunkSize;
-}
-
-static drwav_uint64 drwav__data_chunk_size_rf64(drwav_uint64 dataChunkSize)
-{
- return dataChunkSize;
-}
-
-
-static size_t drwav__write(drwav* pWav, const void* pData, size_t dataSize)
-{
- DRWAV_ASSERT(pWav != NULL);
- DRWAV_ASSERT(pWav->onWrite != NULL);
-
- /* Generic write. Assumes no byte reordering required. */
- return pWav->onWrite(pWav->pUserData, pData, dataSize);
-}
-
-static size_t drwav__write_u16ne_to_le(drwav* pWav, drwav_uint16 value)
-{
- DRWAV_ASSERT(pWav != NULL);
- DRWAV_ASSERT(pWav->onWrite != NULL);
-
- if (!drwav__is_little_endian()) {
- value = drwav__bswap16(value);
- }
-
- return drwav__write(pWav, &value, 2);
-}
-
-static size_t drwav__write_u32ne_to_le(drwav* pWav, drwav_uint32 value)
-{
- DRWAV_ASSERT(pWav != NULL);
- DRWAV_ASSERT(pWav->onWrite != NULL);
-
- if (!drwav__is_little_endian()) {
- value = drwav__bswap32(value);
- }
-
- return drwav__write(pWav, &value, 4);
-}
-
-static size_t drwav__write_u64ne_to_le(drwav* pWav, drwav_uint64 value)
-{
- DRWAV_ASSERT(pWav != NULL);
- DRWAV_ASSERT(pWav->onWrite != NULL);
-
- if (!drwav__is_little_endian()) {
- value = drwav__bswap64(value);
- }
-
- return drwav__write(pWav, &value, 8);
-}
-
-
-static drwav_bool32 drwav_preinit_write(drwav* pWav, const drwav_data_format* pFormat, drwav_bool32 isSequential, drwav_write_proc onWrite, drwav_seek_proc onSeek, void* pUserData, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
- if (pWav == NULL || onWrite == NULL) {
- return DRWAV_FALSE;
- }
-
- if (!isSequential && onSeek == NULL) {
- return DRWAV_FALSE; /* <-- onSeek is required when in non-sequential mode. */
- }
-
- /* Not currently supporting compressed formats. Will need to add support for the "fact" chunk before we enable this. */
- if (pFormat->format == DR_WAVE_FORMAT_EXTENSIBLE) {
- return DRWAV_FALSE;
- }
- if (pFormat->format == DR_WAVE_FORMAT_ADPCM || pFormat->format == DR_WAVE_FORMAT_DVI_ADPCM) {
- return DRWAV_FALSE;
- }
-
- DRWAV_ZERO_MEMORY(pWav, sizeof(*pWav));
- pWav->onWrite = onWrite;
- pWav->onSeek = onSeek;
- pWav->pUserData = pUserData;
- pWav->allocationCallbacks = drwav_copy_allocation_callbacks_or_defaults(pAllocationCallbacks);
-
- if (pWav->allocationCallbacks.onFree == NULL || (pWav->allocationCallbacks.onMalloc == NULL && pWav->allocationCallbacks.onRealloc == NULL)) {
- return DRWAV_FALSE; /* Invalid allocation callbacks. */
- }
-
- pWav->fmt.formatTag = (drwav_uint16)pFormat->format;
- pWav->fmt.channels = (drwav_uint16)pFormat->channels;
- pWav->fmt.sampleRate = pFormat->sampleRate;
- pWav->fmt.avgBytesPerSec = (drwav_uint32)((pFormat->bitsPerSample * pFormat->sampleRate * pFormat->channels) / 8);
- pWav->fmt.blockAlign = (drwav_uint16)((pFormat->channels * pFormat->bitsPerSample) / 8);
- pWav->fmt.bitsPerSample = (drwav_uint16)pFormat->bitsPerSample;
- pWav->fmt.extendedSize = 0;
- pWav->isSequentialWrite = isSequential;
-
- return DRWAV_TRUE;
-}
-
-static drwav_bool32 drwav_init_write__internal(drwav* pWav, const drwav_data_format* pFormat, drwav_uint64 totalSampleCount)
-{
- /* The function assumes drwav_preinit_write() was called beforehand. */
-
- size_t runningPos = 0;
- drwav_uint64 initialDataChunkSize = 0;
- drwav_uint64 chunkSizeFMT;
-
- /*
- The initial values for the "RIFF" and "data" chunks depends on whether or not we are initializing in sequential mode or not. In
- sequential mode we set this to its final values straight away since they can be calculated from the total sample count. In non-
- sequential mode we initialize it all to zero and fill it out in drwav_uninit() using a backwards seek.
- */
- if (pWav->isSequentialWrite) {
- initialDataChunkSize = (totalSampleCount * pWav->fmt.bitsPerSample) / 8;
-
- /*
- The RIFF container has a limit on the number of samples. drwav is not allowing this. There's no practical limits for Wave64
- so for the sake of simplicity I'm not doing any validation for that.
- */
- if (pFormat->container == drwav_container_riff) {
- if (initialDataChunkSize > (0xFFFFFFFFUL - 36)) {
- return DRWAV_FALSE; /* Not enough room to store every sample. */
- }
- }
- }
-
- pWav->dataChunkDataSizeTargetWrite = initialDataChunkSize;
-
-
- /* "RIFF" chunk. */
- if (pFormat->container == drwav_container_riff) {
- drwav_uint32 chunkSizeRIFF = 28 + (drwav_uint32)initialDataChunkSize; /* +28 = "WAVE" + [sizeof "fmt " chunk] */
- runningPos += drwav__write(pWav, "RIFF", 4);
- runningPos += drwav__write_u32ne_to_le(pWav, chunkSizeRIFF);
- runningPos += drwav__write(pWav, "WAVE", 4);
- } else if (pFormat->container == drwav_container_w64) {
- drwav_uint64 chunkSizeRIFF = 80 + 24 + initialDataChunkSize; /* +24 because W64 includes the size of the GUID and size fields. */
- runningPos += drwav__write(pWav, drwavGUID_W64_RIFF, 16);
- runningPos += drwav__write_u64ne_to_le(pWav, chunkSizeRIFF);
- runningPos += drwav__write(pWav, drwavGUID_W64_WAVE, 16);
- } else if (pFormat->container == drwav_container_rf64) {
- runningPos += drwav__write(pWav, "RF64", 4);
- runningPos += drwav__write_u32ne_to_le(pWav, 0xFFFFFFFF); /* Always 0xFFFFFFFF for RF64. Set to a proper value in the "ds64" chunk. */
- runningPos += drwav__write(pWav, "WAVE", 4);
- }
-
-
- /* "ds64" chunk (RF64 only). */
- if (pFormat->container == drwav_container_rf64) {
- drwav_uint32 initialds64ChunkSize = 28; /* 28 = [Size of RIFF (8 bytes)] + [Size of DATA (8 bytes)] + [Sample Count (8 bytes)] + [Table Length (4 bytes)]. Table length always set to 0. */
- drwav_uint64 initialRiffChunkSize = 8 + initialds64ChunkSize + initialDataChunkSize; /* +8 for the ds64 header. */
-
- runningPos += drwav__write(pWav, "ds64", 4);
- runningPos += drwav__write_u32ne_to_le(pWav, initialds64ChunkSize); /* Size of ds64. */
- runningPos += drwav__write_u64ne_to_le(pWav, initialRiffChunkSize); /* Size of RIFF. Set to true value at the end. */
- runningPos += drwav__write_u64ne_to_le(pWav, initialDataChunkSize); /* Size of DATA. Set to true value at the end. */
- runningPos += drwav__write_u64ne_to_le(pWav, totalSampleCount); /* Sample count. */
- runningPos += drwav__write_u32ne_to_le(pWav, 0); /* Table length. Always set to zero in our case since we're not doing any other chunks than "DATA". */
- }
-
-
- /* "fmt " chunk. */
- if (pFormat->container == drwav_container_riff || pFormat->container == drwav_container_rf64) {
- chunkSizeFMT = 16;
- runningPos += drwav__write(pWav, "fmt ", 4);
- runningPos += drwav__write_u32ne_to_le(pWav, (drwav_uint32)chunkSizeFMT);
- } else if (pFormat->container == drwav_container_w64) {
- chunkSizeFMT = 40;
- runningPos += drwav__write(pWav, drwavGUID_W64_FMT, 16);
- runningPos += drwav__write_u64ne_to_le(pWav, chunkSizeFMT);
- }
-
- runningPos += drwav__write_u16ne_to_le(pWav, pWav->fmt.formatTag);
- runningPos += drwav__write_u16ne_to_le(pWav, pWav->fmt.channels);
- runningPos += drwav__write_u32ne_to_le(pWav, pWav->fmt.sampleRate);
- runningPos += drwav__write_u32ne_to_le(pWav, pWav->fmt.avgBytesPerSec);
- runningPos += drwav__write_u16ne_to_le(pWav, pWav->fmt.blockAlign);
- runningPos += drwav__write_u16ne_to_le(pWav, pWav->fmt.bitsPerSample);
-
- pWav->dataChunkDataPos = runningPos;
-
- /* "data" chunk. */
- if (pFormat->container == drwav_container_riff) {
- drwav_uint32 chunkSizeDATA = (drwav_uint32)initialDataChunkSize;
- runningPos += drwav__write(pWav, "data", 4);
- runningPos += drwav__write_u32ne_to_le(pWav, chunkSizeDATA);
- } else if (pFormat->container == drwav_container_w64) {
- drwav_uint64 chunkSizeDATA = 24 + initialDataChunkSize; /* +24 because W64 includes the size of the GUID and size fields. */
- runningPos += drwav__write(pWav, drwavGUID_W64_DATA, 16);
- runningPos += drwav__write_u64ne_to_le(pWav, chunkSizeDATA);
- } else if (pFormat->container == drwav_container_rf64) {
- runningPos += drwav__write(pWav, "data", 4);
- runningPos += drwav__write_u32ne_to_le(pWav, 0xFFFFFFFF); /* Always set to 0xFFFFFFFF for RF64. The true size of the data chunk is specified in the ds64 chunk. */
- }
-
- /*
- The runningPos variable is incremented in the section above but is left unused which is causing some static analysis tools to detect it
- as a dead store. I'm leaving this as-is for safety just in case I want to expand this function later to include other tags and want to
- keep track of the running position for whatever reason. The line below should silence the static analysis tools.
- */
- (void)runningPos;
-
- /* Set some properties for the client's convenience. */
- pWav->container = pFormat->container;
- pWav->channels = (drwav_uint16)pFormat->channels;
- pWav->sampleRate = pFormat->sampleRate;
- pWav->bitsPerSample = (drwav_uint16)pFormat->bitsPerSample;
- pWav->translatedFormatTag = (drwav_uint16)pFormat->format;
-
- return DRWAV_TRUE;
-}
-
-
-DRWAV_API drwav_bool32 drwav_init_write(drwav* pWav, const drwav_data_format* pFormat, drwav_write_proc onWrite, drwav_seek_proc onSeek, void* pUserData, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
- if (!drwav_preinit_write(pWav, pFormat, DRWAV_FALSE, onWrite, onSeek, pUserData, pAllocationCallbacks)) {
- return DRWAV_FALSE;
- }
-
- return drwav_init_write__internal(pWav, pFormat, 0); /* DRWAV_FALSE = Not Sequential */
-}
-
-DRWAV_API drwav_bool32 drwav_init_write_sequential(drwav* pWav, const drwav_data_format* pFormat, drwav_uint64 totalSampleCount, drwav_write_proc onWrite, void* pUserData, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
- if (!drwav_preinit_write(pWav, pFormat, DRWAV_TRUE, onWrite, NULL, pUserData, pAllocationCallbacks)) {
- return DRWAV_FALSE;
- }
-
- return drwav_init_write__internal(pWav, pFormat, totalSampleCount); /* DRWAV_TRUE = Sequential */
-}
-
-DRWAV_API drwav_bool32 drwav_init_write_sequential_pcm_frames(drwav* pWav, const drwav_data_format* pFormat, drwav_uint64 totalPCMFrameCount, drwav_write_proc onWrite, void* pUserData, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
- if (pFormat == NULL) {
- return DRWAV_FALSE;
- }
-
- return drwav_init_write_sequential(pWav, pFormat, totalPCMFrameCount*pFormat->channels, onWrite, pUserData, pAllocationCallbacks);
-}
-
-DRWAV_API drwav_uint64 drwav_target_write_size_bytes(const drwav_data_format* pFormat, drwav_uint64 totalSampleCount)
-{
- /* Casting totalSampleCount to drwav_int64 for VC6 compatibility. No issues in practice because nobody is going to exhaust the whole 63 bits. */
- drwav_uint64 targetDataSizeBytes = (drwav_uint64)((drwav_int64)totalSampleCount * pFormat->channels * pFormat->bitsPerSample/8.0);
- drwav_uint64 riffChunkSizeBytes;
- drwav_uint64 fileSizeBytes = 0;
-
- if (pFormat->container == drwav_container_riff) {
- riffChunkSizeBytes = drwav__riff_chunk_size_riff(targetDataSizeBytes);
- fileSizeBytes = (8 + riffChunkSizeBytes); /* +8 because WAV doesn't include the size of the ChunkID and ChunkSize fields. */
- } else if (pFormat->container == drwav_container_w64) {
- riffChunkSizeBytes = drwav__riff_chunk_size_w64(targetDataSizeBytes);
- fileSizeBytes = riffChunkSizeBytes;
- } else if (pFormat->container == drwav_container_rf64) {
- riffChunkSizeBytes = drwav__riff_chunk_size_rf64(targetDataSizeBytes);
- fileSizeBytes = (8 + riffChunkSizeBytes); /* +8 because WAV doesn't include the size of the ChunkID and ChunkSize fields. */
- }
-
- return fileSizeBytes;
-}
-
-
-#ifndef DR_WAV_NO_STDIO
-
-/* drwav_result_from_errno() is only used for fopen() and wfopen() so putting it inside DR_WAV_NO_STDIO for now. If something else needs this later we can move it out. */
-#include <errno.h>
-static drwav_result drwav_result_from_errno(int e)
-{
- // [jart] errno toil
- if (e == 0) return DRWAV_SUCCESS;
- #ifdef EPERM
- if (e == EPERM) return DRWAV_INVALID_OPERATION;
- #endif
- #ifdef ENOENT
- if (e == ENOENT) return DRWAV_DOES_NOT_EXIST;
- #endif
- #ifdef ESRCH
- if (e == ESRCH) return DRWAV_DOES_NOT_EXIST;
- #endif
- #ifdef EINTR
- if (e == EINTR) return DRWAV_INTERRUPT;
- #endif
- #ifdef EIO
- if (e == EIO) return DRWAV_IO_ERROR;
- #endif
- #ifdef ENXIO
- if (e == ENXIO) return DRWAV_DOES_NOT_EXIST;
- #endif
- #ifdef E2BIG
- if (e == E2BIG) return DRWAV_INVALID_ARGS;
- #endif
- #ifdef ENOEXEC
- if (e == ENOEXEC) return DRWAV_INVALID_FILE;
- #endif
- #ifdef EBADF
- if (e == EBADF) return DRWAV_INVALID_FILE;
- #endif
- #ifdef ECHILD
- if (e == ECHILD) return DRWAV_ERROR;
- #endif
- #ifdef EAGAIN
- if (e == EAGAIN) return DRWAV_UNAVAILABLE;
- #endif
- #ifdef ENOMEM
- if (e == ENOMEM) return DRWAV_OUT_OF_MEMORY;
- #endif
- #ifdef EACCES
- if (e == EACCES) return DRWAV_ACCESS_DENIED;
- #endif
- #ifdef EFAULT
- if (e == EFAULT) return DRWAV_BAD_ADDRESS;
- #endif
- #ifdef ENOTBLK
- if (e == ENOTBLK) return DRWAV_ERROR;
- #endif
- #ifdef EBUSY
- if (e == EBUSY) return DRWAV_BUSY;
- #endif
- #ifdef EEXIST
- if (e == EEXIST) return DRWAV_ALREADY_EXISTS;
- #endif
- #ifdef EXDEV
- if (e == EXDEV) return DRWAV_ERROR;
- #endif
- #ifdef ENODEV
- if (e == ENODEV) return DRWAV_DOES_NOT_EXIST;
- #endif
- #ifdef ENOTDIR
- if (e == ENOTDIR) return DRWAV_NOT_DIRECTORY;
- #endif
- #ifdef EISDIR
- if (e == EISDIR) return DRWAV_IS_DIRECTORY;
- #endif
- #ifdef EINVAL
- if (e == EINVAL) return DRWAV_INVALID_ARGS;
- #endif
- #ifdef ENFILE
- if (e == ENFILE) return DRWAV_TOO_MANY_OPEN_FILES;
- #endif
- #ifdef EMFILE
- if (e == EMFILE) return DRWAV_TOO_MANY_OPEN_FILES;
- #endif
- #ifdef ENOTTY
- if (e == ENOTTY) return DRWAV_INVALID_OPERATION;
- #endif
- #ifdef ETXTBSY
- if (e == ETXTBSY) return DRWAV_BUSY;
- #endif
- #ifdef EFBIG
- if (e == EFBIG) return DRWAV_TOO_BIG;
- #endif
- #ifdef ENOSPC
- if (e == ENOSPC) return DRWAV_NO_SPACE;
- #endif
- #ifdef ESPIPE
- if (e == ESPIPE) return DRWAV_BAD_SEEK;
- #endif
- #ifdef EROFS
- if (e == EROFS) return DRWAV_ACCESS_DENIED;
- #endif
- #ifdef EMLINK
- if (e == EMLINK) return DRWAV_TOO_MANY_LINKS;
- #endif
- #ifdef EPIPE
- if (e == EPIPE) return DRWAV_BAD_PIPE;
- #endif
- #ifdef EDOM
- if (e == EDOM) return DRWAV_OUT_OF_RANGE;
- #endif
- #ifdef ERANGE
- if (e == ERANGE) return DRWAV_OUT_OF_RANGE;
- #endif
- #ifdef EDEADLK
- if (e == EDEADLK) return DRWAV_DEADLOCK;
- #endif
- #ifdef ENAMETOOLONG
- if (e == ENAMETOOLONG) return DRWAV_PATH_TOO_LONG;
- #endif
- #ifdef ENOLCK
- if (e == ENOLCK) return DRWAV_ERROR;
- #endif
- #ifdef ENOSYS
- if (e == ENOSYS) return DRWAV_NOT_IMPLEMENTED;
- #endif
- #ifdef ENOTEMPTY
- if (e == ENOTEMPTY) return DRWAV_DIRECTORY_NOT_EMPTY;
- #endif
- #ifdef ELOOP
- if (e == ELOOP) return DRWAV_TOO_MANY_LINKS;
- #endif
- #ifdef ENOMSG
- if (e == ENOMSG) return DRWAV_NO_MESSAGE;
- #endif
- #ifdef EIDRM
- if (e == EIDRM) return DRWAV_ERROR;
- #endif
- #ifdef ECHRNG
- if (e == ECHRNG) return DRWAV_ERROR;
- #endif
- #ifdef EL2NSYNC
- if (e == EL2NSYNC) return DRWAV_ERROR;
- #endif
- #ifdef EL3HLT
- if (e == EL3HLT) return DRWAV_ERROR;
- #endif
- #ifdef EL3RST
- if (e == EL3RST) return DRWAV_ERROR;
- #endif
- #ifdef ELNRNG
- if (e == ELNRNG) return DRWAV_OUT_OF_RANGE;
- #endif
- #ifdef EUNATCH
- if (e == EUNATCH) return DRWAV_ERROR;
- #endif
- #ifdef ENOCSI
- if (e == ENOCSI) return DRWAV_ERROR;
- #endif
- #ifdef EL2HLT
- if (e == EL2HLT) return DRWAV_ERROR;
- #endif
- #ifdef EBADE
- if (e == EBADE) return DRWAV_ERROR;
- #endif
- #ifdef EBADR
- if (e == EBADR) return DRWAV_ERROR;
- #endif
- #ifdef EXFULL
- if (e == EXFULL) return DRWAV_ERROR;
- #endif
- #ifdef ENOANO
- if (e == ENOANO) return DRWAV_ERROR;
- #endif
- #ifdef EBADRQC
- if (e == EBADRQC) return DRWAV_ERROR;
- #endif
- #ifdef EBADSLT
- if (e == EBADSLT) return DRWAV_ERROR;
- #endif
- #ifdef EBFONT
- if (e == EBFONT) return DRWAV_INVALID_FILE;
- #endif
- #ifdef ENOSTR
- if (e == ENOSTR) return DRWAV_ERROR;
- #endif
- #ifdef ENODATA
- if (e == ENODATA) return DRWAV_NO_DATA_AVAILABLE;
- #endif
- #ifdef ETIME
- if (e == ETIME) return DRWAV_TIMEOUT;
- #endif
- #ifdef ENOSR
- if (e == ENOSR) return DRWAV_NO_DATA_AVAILABLE;
- #endif
- #ifdef ENONET
- if (e == ENONET) return DRWAV_NO_NETWORK;
- #endif
- #ifdef ENOPKG
- if (e == ENOPKG) return DRWAV_ERROR;
- #endif
- #ifdef EREMOTE
- if (e == EREMOTE) return DRWAV_ERROR;
- #endif
- #ifdef ENOLINK
- if (e == ENOLINK) return DRWAV_ERROR;
- #endif
- #ifdef EADV
- if (e == EADV) return DRWAV_ERROR;
- #endif
- #ifdef ESRMNT
- if (e == ESRMNT) return DRWAV_ERROR;
- #endif
- #ifdef ECOMM
- if (e == ECOMM) return DRWAV_ERROR;
- #endif
- #ifdef EPROTO
- if (e == EPROTO) return DRWAV_ERROR;
- #endif
- #ifdef EMULTIHOP
- if (e == EMULTIHOP) return DRWAV_ERROR;
- #endif
- #ifdef EDOTDOT
- if (e == EDOTDOT) return DRWAV_ERROR;
- #endif
- #ifdef EBADMSG
- if (e == EBADMSG) return DRWAV_BAD_MESSAGE;
- #endif
- #ifdef EOVERFLOW
- if (e == EOVERFLOW) return DRWAV_TOO_BIG;
- #endif
- #ifdef ENOTUNIQ
- if (e == ENOTUNIQ) return DRWAV_NOT_UNIQUE;
- #endif
- #ifdef EBADFD
- if (e == EBADFD) return DRWAV_ERROR;
- #endif
- #ifdef EREMCHG
- if (e == EREMCHG) return DRWAV_ERROR;
- #endif
- #ifdef ELIBACC
- if (e == ELIBACC) return DRWAV_ACCESS_DENIED;
- #endif
- #ifdef ELIBBAD
- if (e == ELIBBAD) return DRWAV_INVALID_FILE;
- #endif
- #ifdef ELIBSCN
- if (e == ELIBSCN) return DRWAV_INVALID_FILE;
- #endif
- #ifdef ELIBMAX
- if (e == ELIBMAX) return DRWAV_ERROR;
- #endif
- #ifdef ELIBEXEC
- if (e == ELIBEXEC) return DRWAV_ERROR;
- #endif
- #ifdef EILSEQ
- if (e == EILSEQ) return DRWAV_INVALID_DATA;
- #endif
- #ifdef ERESTART
- if (e == ERESTART) return DRWAV_ERROR;
- #endif
- #ifdef ESTRPIPE
- if (e == ESTRPIPE) return DRWAV_ERROR;
- #endif
- #ifdef EUSERS
- if (e == EUSERS) return DRWAV_ERROR;
- #endif
- #ifdef ENOTSOCK
- if (e == ENOTSOCK) return DRWAV_NOT_SOCKET;
- #endif
- #ifdef EDESTADDRREQ
- if (e == EDESTADDRREQ) return DRWAV_NO_ADDRESS;
- #endif
- #ifdef EMSGSIZE
- if (e == EMSGSIZE) return DRWAV_TOO_BIG;
- #endif
- #ifdef EPROTOTYPE
- if (e == EPROTOTYPE) return DRWAV_BAD_PROTOCOL;
- #endif
- #ifdef ENOPROTOOPT
- if (e == ENOPROTOOPT) return DRWAV_PROTOCOL_UNAVAILABLE;
- #endif
- #ifdef EPROTONOSUPPORT
- if (e == EPROTONOSUPPORT) return DRWAV_PROTOCOL_NOT_SUPPORTED;
- #endif
- #ifdef ESOCKTNOSUPPORT
- if (e == ESOCKTNOSUPPORT) return DRWAV_SOCKET_NOT_SUPPORTED;
- #endif
- #ifdef EOPNOTSUPP
- if (e == EOPNOTSUPP) return DRWAV_INVALID_OPERATION;
- #endif
- #ifdef EPFNOSUPPORT
- if (e == EPFNOSUPPORT) return DRWAV_PROTOCOL_FAMILY_NOT_SUPPORTED;
- #endif
- #ifdef EAFNOSUPPORT
- if (e == EAFNOSUPPORT) return DRWAV_ADDRESS_FAMILY_NOT_SUPPORTED;
- #endif
- #ifdef EADDRINUSE
- if (e == EADDRINUSE) return DRWAV_ALREADY_IN_USE;
- #endif
- #ifdef EADDRNOTAVAIL
- if (e == EADDRNOTAVAIL) return DRWAV_ERROR;
- #endif
- #ifdef ENETDOWN
- if (e == ENETDOWN) return DRWAV_NO_NETWORK;
- #endif
- #ifdef ENETUNREACH
- if (e == ENETUNREACH) return DRWAV_NO_NETWORK;
- #endif
- #ifdef ENETRESET
- if (e == ENETRESET) return DRWAV_NO_NETWORK;
- #endif
- #ifdef ECONNABORTED
- if (e == ECONNABORTED) return DRWAV_NO_NETWORK;
- #endif
- #ifdef ECONNRESET
- if (e == ECONNRESET) return DRWAV_CONNECTION_RESET;
- #endif
- #ifdef ENOBUFS
- if (e == ENOBUFS) return DRWAV_NO_SPACE;
- #endif
- #ifdef EISCONN
- if (e == EISCONN) return DRWAV_ALREADY_CONNECTED;
- #endif
- #ifdef ENOTCONN
- if (e == ENOTCONN) return DRWAV_NOT_CONNECTED;
- #endif
- #ifdef ESHUTDOWN
- if (e == ESHUTDOWN) return DRWAV_ERROR;
- #endif
- #ifdef ETOOMANYREFS
- if (e == ETOOMANYREFS) return DRWAV_ERROR;
- #endif
- #ifdef ETIMEDOUT
- if (e == ETIMEDOUT) return DRWAV_TIMEOUT;
- #endif
- #ifdef ECONNREFUSED
- if (e == ECONNREFUSED) return DRWAV_CONNECTION_REFUSED;
- #endif
- #ifdef EHOSTDOWN
- if (e == EHOSTDOWN) return DRWAV_NO_HOST;
- #endif
- #ifdef EHOSTUNREACH
- if (e == EHOSTUNREACH) return DRWAV_NO_HOST;
- #endif
- #ifdef EALREADY
- if (e == EALREADY) return DRWAV_IN_PROGRESS;
- #endif
- #ifdef EINPROGRESS
- if (e == EINPROGRESS) return DRWAV_IN_PROGRESS;
- #endif
- #ifdef ESTALE
- if (e == ESTALE) return DRWAV_INVALID_FILE;
- #endif
- #ifdef EUCLEAN
- if (e == EUCLEAN) return DRWAV_ERROR;
- #endif
- #ifdef ENOTNAM
- if (e == ENOTNAM) return DRWAV_ERROR;
- #endif
- #ifdef ENAVAIL
- if (e == ENAVAIL) return DRWAV_ERROR;
- #endif
- #ifdef EISNAM
- if (e == EISNAM) return DRWAV_ERROR;
- #endif
- #ifdef EREMOTEIO
- if (e == EREMOTEIO) return DRWAV_IO_ERROR;
- #endif
- #ifdef EDQUOT
- if (e == EDQUOT) return DRWAV_NO_SPACE;
- #endif
- #ifdef ENOMEDIUM
- if (e == ENOMEDIUM) return DRWAV_DOES_NOT_EXIST;
- #endif
- #ifdef EMEDIUMTYPE
- if (e == EMEDIUMTYPE) return DRWAV_ERROR;
- #endif
- #ifdef ECANCELED
- if (e == ECANCELED) return DRWAV_CANCELLED;
- #endif
- #ifdef ENOKEY
- if (e == ENOKEY) return DRWAV_ERROR;
- #endif
- #ifdef EKEYEXPIRED
- if (e == EKEYEXPIRED) return DRWAV_ERROR;
- #endif
- #ifdef EKEYREVOKED
- if (e == EKEYREVOKED) return DRWAV_ERROR;
- #endif
- #ifdef EKEYREJECTED
- if (e == EKEYREJECTED) return DRWAV_ERROR;
- #endif
- #ifdef EOWNERDEAD
- if (e == EOWNERDEAD) return DRWAV_ERROR;
- #endif
- #ifdef ENOTRECOVERABLE
- if (e == ENOTRECOVERABLE) return DRWAV_ERROR;
- #endif
- #ifdef ERFKILL
- if (e == ERFKILL) return DRWAV_ERROR;
- #endif
- #ifdef EHWPOISON
- if (e == EHWPOISON) return DRWAV_ERROR;
- #endif
- return DRWAV_ERROR;
-}
-
-static drwav_result drwav_fopen(FILE** ppFile, const char* pFilePath, const char* pOpenMode)
-{
-#if _MSC_VER && _MSC_VER >= 1400
- errno_t err;
-#endif
-
- if (ppFile != NULL) {
- *ppFile = NULL; /* Safety. */
- }
-
- if (pFilePath == NULL || pOpenMode == NULL || ppFile == NULL) {
- return DRWAV_INVALID_ARGS;
- }
-
-#if _MSC_VER && _MSC_VER >= 1400
- err = fopen_s(ppFile, pFilePath, pOpenMode);
- if (err != 0) {
- return drwav_result_from_errno(err);
- }
-#else
-#if defined(_WIN32) || defined(__APPLE__)
- *ppFile = fopen(pFilePath, pOpenMode);
-#else
- #if defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS == 64 && defined(_LARGEFILE64_SOURCE)
- *ppFile = fopen64(pFilePath, pOpenMode);
- #else
- *ppFile = fopen(pFilePath, pOpenMode);
- #endif
-#endif
- if (*ppFile == NULL) {
- drwav_result result = drwav_result_from_errno(errno);
- if (result == DRWAV_SUCCESS) {
- result = DRWAV_ERROR; /* Just a safety check to make sure we never ever return success when pFile == NULL. */
- }
-
- return result;
- }
-#endif
-
- return DRWAV_SUCCESS;
-}
-
-/*
-_wfopen() isn't always available in all compilation environments.
-
- * Windows only.
- * MSVC seems to support it universally as far back as VC6 from what I can tell (haven't checked further back).
- * MinGW-64 (both 32- and 64-bit) seems to support it.
- * MinGW wraps it in !defined(__STRICT_ANSI__).
- * OpenWatcom wraps it in !defined(_NO_EXT_KEYS).
-
-This can be reviewed as compatibility issues arise. The preference is to use _wfopen_s() and _wfopen() as opposed to the wcsrtombs()
-fallback, so if you notice your compiler not detecting this properly I'm happy to look at adding support.
-*/
-#if defined(_WIN32)
- #if defined(_MSC_VER) || defined(__MINGW64__) || (!defined(__STRICT_ANSI__) && !defined(_NO_EXT_KEYS))
- #define DRWAV_HAS_WFOPEN
- #endif
-#endif
-
-static drwav_result drwav_wfopen(FILE** ppFile, const wchar_t* pFilePath, const wchar_t* pOpenMode, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
- if (ppFile != NULL) {
- *ppFile = NULL; /* Safety. */
- }
-
- if (pFilePath == NULL || pOpenMode == NULL || ppFile == NULL) {
- return DRWAV_INVALID_ARGS;
- }
-
-#if defined(DRWAV_HAS_WFOPEN)
- {
- /* Use _wfopen() on Windows. */
- #if defined(_MSC_VER) && _MSC_VER >= 1400
- errno_t err = _wfopen_s(ppFile, pFilePath, pOpenMode);
- if (err != 0) {
- return drwav_result_from_errno(err);
- }
- #else
- *ppFile = _wfopen(pFilePath, pOpenMode);
- if (*ppFile == NULL) {
- return drwav_result_from_errno(errno);
- }
- #endif
- (void)pAllocationCallbacks;
- }
-#else
- /*
- Use fopen() on anything other than Windows. Requires a conversion. This is annoying because fopen() is locale specific. The only real way I can
- think of to do this is with wcsrtombs(). Note that wcstombs() is apparently not thread-safe because it uses a static global mbstate_t object for
- maintaining state. I've checked this with -std=c89 and it works, but if somebody get's a compiler error I'll look into improving compatibility.
- */
- {
- mbstate_t mbs;
- size_t lenMB;
- const wchar_t* pFilePathTemp = pFilePath;
- char* pFilePathMB = NULL;
- char pOpenModeMB[32] = {0};
-
- /* Get the length first. */
- DRWAV_ZERO_OBJECT(&mbs);
- lenMB = wcsrtombs(NULL, &pFilePathTemp, 0, &mbs);
- if (lenMB == (size_t)-1) {
- return drwav_result_from_errno(errno);
- }
-
- pFilePathMB = (char*)drwav__malloc_from_callbacks(lenMB + 1, pAllocationCallbacks);
- if (pFilePathMB == NULL) {
- return DRWAV_OUT_OF_MEMORY;
- }
-
- pFilePathTemp = pFilePath;
- DRWAV_ZERO_OBJECT(&mbs);
- wcsrtombs(pFilePathMB, &pFilePathTemp, lenMB + 1, &mbs);
-
- /* The open mode should always consist of ASCII characters so we should be able to do a trivial conversion. */
- {
- size_t i = 0;
- for (;;) {
- if (pOpenMode[i] == 0) {
- pOpenModeMB[i] = '\0';
- break;
- }
-
- pOpenModeMB[i] = (char)pOpenMode[i];
- i += 1;
- }
- }
-
- *ppFile = fopen(pFilePathMB, pOpenModeMB);
-
- drwav__free_from_callbacks(pFilePathMB, pAllocationCallbacks);
- }
-
- if (*ppFile == NULL) {
- return DRWAV_ERROR;
- }
-#endif
-
- return DRWAV_SUCCESS;
-}
-
-
-static size_t drwav__on_read_stdio(void* pUserData, void* pBufferOut, size_t bytesToRead)
-{
- return fread(pBufferOut, 1, bytesToRead, (FILE*)pUserData);
-}
-
-static size_t drwav__on_write_stdio(void* pUserData, const void* pData, size_t bytesToWrite)
-{
- return fwrite(pData, 1, bytesToWrite, (FILE*)pUserData);
-}
-
-static drwav_bool32 drwav__on_seek_stdio(void* pUserData, int offset, drwav_seek_origin origin)
-{
- return fseek((FILE*)pUserData, offset, (origin == drwav_seek_origin_current) ? SEEK_CUR : SEEK_SET) == 0;
-}
-
-DRWAV_API drwav_bool32 drwav_init_file(drwav* pWav, const char* filename, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
- return drwav_init_file_ex(pWav, filename, NULL, NULL, 0, pAllocationCallbacks);
-}
-
-
-static drwav_bool32 drwav_init_file__internal_FILE(drwav* pWav, FILE* pFile, drwav_chunk_proc onChunk, void* pChunkUserData, drwav_uint32 flags, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
- drwav_bool32 result;
-
- result = drwav_preinit(pWav, drwav__on_read_stdio, drwav__on_seek_stdio, (void*)pFile, pAllocationCallbacks);
- if (result != DRWAV_TRUE) {
- fclose(pFile);
- return result;
- }
-
- result = drwav_init__internal(pWav, onChunk, pChunkUserData, flags);
- if (result != DRWAV_TRUE) {
- fclose(pFile);
- return result;
- }
-
- return DRWAV_TRUE;
-}
-
-DRWAV_API drwav_bool32 drwav_init_file_ex(drwav* pWav, const char* filename, drwav_chunk_proc onChunk, void* pChunkUserData, drwav_uint32 flags, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
- FILE* pFile;
- if (drwav_fopen(&pFile, filename, "rb") != DRWAV_SUCCESS) {
- return DRWAV_FALSE;
- }
-
- /* This takes ownership of the FILE* object. */
- return drwav_init_file__internal_FILE(pWav, pFile, onChunk, pChunkUserData, flags, pAllocationCallbacks);
-}
-
-DRWAV_API drwav_bool32 drwav_init_file_w(drwav* pWav, const wchar_t* filename, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
- return drwav_init_file_ex_w(pWav, filename, NULL, NULL, 0, pAllocationCallbacks);
-}
-
-DRWAV_API drwav_bool32 drwav_init_file_ex_w(drwav* pWav, const wchar_t* filename, drwav_chunk_proc onChunk, void* pChunkUserData, drwav_uint32 flags, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
- FILE* pFile;
- if (drwav_wfopen(&pFile, filename, L"rb", pAllocationCallbacks) != DRWAV_SUCCESS) {
- return DRWAV_FALSE;
- }
-
- /* This takes ownership of the FILE* object. */
- return drwav_init_file__internal_FILE(pWav, pFile, onChunk, pChunkUserData, flags, pAllocationCallbacks);
-}
-
-
-static drwav_bool32 drwav_init_file_write__internal_FILE(drwav* pWav, FILE* pFile, const drwav_data_format* pFormat, drwav_uint64 totalSampleCount, drwav_bool32 isSequential, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
- drwav_bool32 result;
-
- result = drwav_preinit_write(pWav, pFormat, isSequential, drwav__on_write_stdio, drwav__on_seek_stdio, (void*)pFile, pAllocationCallbacks);
- if (result != DRWAV_TRUE) {
- fclose(pFile);
- return result;
- }
-
- result = drwav_init_write__internal(pWav, pFormat, totalSampleCount);
- if (result != DRWAV_TRUE) {
- fclose(pFile);
- return result;
- }
-
- return DRWAV_TRUE;
-}
-
-static drwav_bool32 drwav_init_file_write__internal(drwav* pWav, const char* filename, const drwav_data_format* pFormat, drwav_uint64 totalSampleCount, drwav_bool32 isSequential, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
- FILE* pFile;
- if (drwav_fopen(&pFile, filename, "wb") != DRWAV_SUCCESS) {
- return DRWAV_FALSE;
- }
-
- /* This takes ownership of the FILE* object. */
- return drwav_init_file_write__internal_FILE(pWav, pFile, pFormat, totalSampleCount, isSequential, pAllocationCallbacks);
-}
-
-static drwav_bool32 drwav_init_file_write_w__internal(drwav* pWav, const wchar_t* filename, const drwav_data_format* pFormat, drwav_uint64 totalSampleCount, drwav_bool32 isSequential, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
- FILE* pFile;
- if (drwav_wfopen(&pFile, filename, L"wb", pAllocationCallbacks) != DRWAV_SUCCESS) {
- return DRWAV_FALSE;
- }
-
- /* This takes ownership of the FILE* object. */
- return drwav_init_file_write__internal_FILE(pWav, pFile, pFormat, totalSampleCount, isSequential, pAllocationCallbacks);
-}
-
-DRWAV_API drwav_bool32 drwav_init_file_write(drwav* pWav, const char* filename, const drwav_data_format* pFormat, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
- return drwav_init_file_write__internal(pWav, filename, pFormat, 0, DRWAV_FALSE, pAllocationCallbacks);
-}
-
-DRWAV_API drwav_bool32 drwav_init_file_write_sequential(drwav* pWav, const char* filename, const drwav_data_format* pFormat, drwav_uint64 totalSampleCount, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
- return drwav_init_file_write__internal(pWav, filename, pFormat, totalSampleCount, DRWAV_TRUE, pAllocationCallbacks);
-}
-
-DRWAV_API drwav_bool32 drwav_init_file_write_sequential_pcm_frames(drwav* pWav, const char* filename, const drwav_data_format* pFormat, drwav_uint64 totalPCMFrameCount, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
- if (pFormat == NULL) {
- return DRWAV_FALSE;
- }
-
- return drwav_init_file_write_sequential(pWav, filename, pFormat, totalPCMFrameCount*pFormat->channels, pAllocationCallbacks);
-}
-
-DRWAV_API drwav_bool32 drwav_init_file_write_w(drwav* pWav, const wchar_t* filename, const drwav_data_format* pFormat, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
- return drwav_init_file_write_w__internal(pWav, filename, pFormat, 0, DRWAV_FALSE, pAllocationCallbacks);
-}
-
-DRWAV_API drwav_bool32 drwav_init_file_write_sequential_w(drwav* pWav, const wchar_t* filename, const drwav_data_format* pFormat, drwav_uint64 totalSampleCount, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
- return drwav_init_file_write_w__internal(pWav, filename, pFormat, totalSampleCount, DRWAV_TRUE, pAllocationCallbacks);
-}
-
-DRWAV_API drwav_bool32 drwav_init_file_write_sequential_pcm_frames_w(drwav* pWav, const wchar_t* filename, const drwav_data_format* pFormat, drwav_uint64 totalPCMFrameCount, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
- if (pFormat == NULL) {
- return DRWAV_FALSE;
- }
-
- return drwav_init_file_write_sequential_w(pWav, filename, pFormat, totalPCMFrameCount*pFormat->channels, pAllocationCallbacks);
-}
-#endif /* DR_WAV_NO_STDIO */
-
-
-static size_t drwav__on_read_memory(void* pUserData, void* pBufferOut, size_t bytesToRead)
-{
- drwav* pWav = (drwav*)pUserData;
- size_t bytesRemaining;
-
- DRWAV_ASSERT(pWav != NULL);
- DRWAV_ASSERT(pWav->memoryStream.dataSize >= pWav->memoryStream.currentReadPos);
-
- bytesRemaining = pWav->memoryStream.dataSize - pWav->memoryStream.currentReadPos;
- if (bytesToRead > bytesRemaining) {
- bytesToRead = bytesRemaining;
- }
-
- if (bytesToRead > 0) {
- DRWAV_COPY_MEMORY(pBufferOut, pWav->memoryStream.data + pWav->memoryStream.currentReadPos, bytesToRead);
- pWav->memoryStream.currentReadPos += bytesToRead;
- }
-
- return bytesToRead;
-}
-
-static drwav_bool32 drwav__on_seek_memory(void* pUserData, int offset, drwav_seek_origin origin)
-{
- drwav* pWav = (drwav*)pUserData;
- DRWAV_ASSERT(pWav != NULL);
-
- if (origin == drwav_seek_origin_current) {
- if (offset > 0) {
- if (pWav->memoryStream.currentReadPos + offset > pWav->memoryStream.dataSize) {
- return DRWAV_FALSE; /* Trying to seek too far forward. */
- }
- } else {
- if (pWav->memoryStream.currentReadPos < (size_t)-offset) {
- return DRWAV_FALSE; /* Trying to seek too far backwards. */
- }
- }
-
- /* This will never underflow thanks to the clamps above. */
- pWav->memoryStream.currentReadPos += offset;
- } else {
- if ((drwav_uint32)offset <= pWav->memoryStream.dataSize) {
- pWav->memoryStream.currentReadPos = offset;
- } else {
- return DRWAV_FALSE; /* Trying to seek too far forward. */
- }
- }
-
- return DRWAV_TRUE;
-}
-
-static size_t drwav__on_write_memory(void* pUserData, const void* pDataIn, size_t bytesToWrite)
-{
- drwav* pWav = (drwav*)pUserData;
- size_t bytesRemaining;
-
- DRWAV_ASSERT(pWav != NULL);
- DRWAV_ASSERT(pWav->memoryStreamWrite.dataCapacity >= pWav->memoryStreamWrite.currentWritePos);
-
- bytesRemaining = pWav->memoryStreamWrite.dataCapacity - pWav->memoryStreamWrite.currentWritePos;
- if (bytesRemaining < bytesToWrite) {
- /* Need to reallocate. */
- void* pNewData;
- size_t newDataCapacity = (pWav->memoryStreamWrite.dataCapacity == 0) ? 256 : pWav->memoryStreamWrite.dataCapacity * 2;
-
- /* If doubling wasn't enough, just make it the minimum required size to write the data. */
- if ((newDataCapacity - pWav->memoryStreamWrite.currentWritePos) < bytesToWrite) {
- newDataCapacity = pWav->memoryStreamWrite.currentWritePos + bytesToWrite;
- }
-
- pNewData = drwav__realloc_from_callbacks(*pWav->memoryStreamWrite.ppData, newDataCapacity, pWav->memoryStreamWrite.dataCapacity, &pWav->allocationCallbacks);
- if (pNewData == NULL) {
- return 0;
- }
-
- *pWav->memoryStreamWrite.ppData = pNewData;
- pWav->memoryStreamWrite.dataCapacity = newDataCapacity;
- }
-
- DRWAV_COPY_MEMORY(((drwav_uint8*)(*pWav->memoryStreamWrite.ppData)) + pWav->memoryStreamWrite.currentWritePos, pDataIn, bytesToWrite);
-
- pWav->memoryStreamWrite.currentWritePos += bytesToWrite;
- if (pWav->memoryStreamWrite.dataSize < pWav->memoryStreamWrite.currentWritePos) {
- pWav->memoryStreamWrite.dataSize = pWav->memoryStreamWrite.currentWritePos;
- }
-
- *pWav->memoryStreamWrite.pDataSize = pWav->memoryStreamWrite.dataSize;
-
- return bytesToWrite;
-}
-
-static drwav_bool32 drwav__on_seek_memory_write(void* pUserData, int offset, drwav_seek_origin origin)
-{
- drwav* pWav = (drwav*)pUserData;
- DRWAV_ASSERT(pWav != NULL);
-
- if (origin == drwav_seek_origin_current) {
- if (offset > 0) {
- if (pWav->memoryStreamWrite.currentWritePos + offset > pWav->memoryStreamWrite.dataSize) {
- offset = (int)(pWav->memoryStreamWrite.dataSize - pWav->memoryStreamWrite.currentWritePos); /* Trying to seek too far forward. */
- }
- } else {
- if (pWav->memoryStreamWrite.currentWritePos < (size_t)-offset) {
- offset = -(int)pWav->memoryStreamWrite.currentWritePos; /* Trying to seek too far backwards. */
- }
- }
-
- /* This will never underflow thanks to the clamps above. */
- pWav->memoryStreamWrite.currentWritePos += offset;
- } else {
- if ((drwav_uint32)offset <= pWav->memoryStreamWrite.dataSize) {
- pWav->memoryStreamWrite.currentWritePos = offset;
- } else {
- pWav->memoryStreamWrite.currentWritePos = pWav->memoryStreamWrite.dataSize; /* Trying to seek too far forward. */
- }
- }
-
- return DRWAV_TRUE;
-}
-
-DRWAV_API drwav_bool32 drwav_init_memory(drwav* pWav, const void* data, size_t dataSize, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
- return drwav_init_memory_ex(pWav, data, dataSize, NULL, NULL, 0, pAllocationCallbacks);
-}
-
-DRWAV_API drwav_bool32 drwav_init_memory_ex(drwav* pWav, const void* data, size_t dataSize, drwav_chunk_proc onChunk, void* pChunkUserData, drwav_uint32 flags, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
- if (data == NULL || dataSize == 0) {
- return DRWAV_FALSE;
- }
-
- if (!drwav_preinit(pWav, drwav__on_read_memory, drwav__on_seek_memory, pWav, pAllocationCallbacks)) {
- return DRWAV_FALSE;
- }
-
- pWav->memoryStream.data = (const drwav_uint8*)data;
- pWav->memoryStream.dataSize = dataSize;
- pWav->memoryStream.currentReadPos = 0;
-
- return drwav_init__internal(pWav, onChunk, pChunkUserData, flags);
-}
-
-
-static drwav_bool32 drwav_init_memory_write__internal(drwav* pWav, void** ppData, size_t* pDataSize, const drwav_data_format* pFormat, drwav_uint64 totalSampleCount, drwav_bool32 isSequential, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
- if (ppData == NULL || pDataSize == NULL) {
- return DRWAV_FALSE;
- }
-
- *ppData = NULL; /* Important because we're using realloc()! */
- *pDataSize = 0;
-
- if (!drwav_preinit_write(pWav, pFormat, isSequential, drwav__on_write_memory, drwav__on_seek_memory_write, pWav, pAllocationCallbacks)) {
- return DRWAV_FALSE;
- }
-
- pWav->memoryStreamWrite.ppData = ppData;
- pWav->memoryStreamWrite.pDataSize = pDataSize;
- pWav->memoryStreamWrite.dataSize = 0;
- pWav->memoryStreamWrite.dataCapacity = 0;
- pWav->memoryStreamWrite.currentWritePos = 0;
-
- return drwav_init_write__internal(pWav, pFormat, totalSampleCount);
-}
-
-DRWAV_API drwav_bool32 drwav_init_memory_write(drwav* pWav, void** ppData, size_t* pDataSize, const drwav_data_format* pFormat, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
- return drwav_init_memory_write__internal(pWav, ppData, pDataSize, pFormat, 0, DRWAV_FALSE, pAllocationCallbacks);
-}
-
-DRWAV_API drwav_bool32 drwav_init_memory_write_sequential(drwav* pWav, void** ppData, size_t* pDataSize, const drwav_data_format* pFormat, drwav_uint64 totalSampleCount, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
- return drwav_init_memory_write__internal(pWav, ppData, pDataSize, pFormat, totalSampleCount, DRWAV_TRUE, pAllocationCallbacks);
-}
-
-DRWAV_API drwav_bool32 drwav_init_memory_write_sequential_pcm_frames(drwav* pWav, void** ppData, size_t* pDataSize, const drwav_data_format* pFormat, drwav_uint64 totalPCMFrameCount, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
- if (pFormat == NULL) {
- return DRWAV_FALSE;
- }
-
- return drwav_init_memory_write_sequential(pWav, ppData, pDataSize, pFormat, totalPCMFrameCount*pFormat->channels, pAllocationCallbacks);
-}
-
-
-
-DRWAV_API drwav_result drwav_uninit(drwav* pWav)
-{
- drwav_result result = DRWAV_SUCCESS;
-
- if (pWav == NULL) {
- return DRWAV_INVALID_ARGS;
- }
-
- /*
- If the drwav object was opened in write mode we'll need to finalize a few things:
- - Make sure the "data" chunk is aligned to 16-bits for RIFF containers, or 64 bits for W64 containers.
- - Set the size of the "data" chunk.
- */
- if (pWav->onWrite != NULL) {
- drwav_uint32 paddingSize = 0;
-
- /* Padding. Do not adjust pWav->dataChunkDataSize - this should not include the padding. */
- if (pWav->container == drwav_container_riff || pWav->container == drwav_container_rf64) {
- paddingSize = drwav__chunk_padding_size_riff(pWav->dataChunkDataSize);
- } else {
- paddingSize = drwav__chunk_padding_size_w64(pWav->dataChunkDataSize);
- }
-
- if (paddingSize > 0) {
- drwav_uint64 paddingData = 0;
- drwav__write(pWav, &paddingData, paddingSize); /* Byte order does not matter for this. */
- }
-
- /*
- Chunk sizes. When using sequential mode, these will have been filled in at initialization time. We only need
- to do this when using non-sequential mode.
- */
- if (pWav->onSeek && !pWav->isSequentialWrite) {
- if (pWav->container == drwav_container_riff) {
- /* The "RIFF" chunk size. */
- if (pWav->onSeek(pWav->pUserData, 4, drwav_seek_origin_start)) {
- drwav_uint32 riffChunkSize = drwav__riff_chunk_size_riff(pWav->dataChunkDataSize);
- drwav__write_u32ne_to_le(pWav, riffChunkSize);
- }
-
- /* the "data" chunk size. */
- if (pWav->onSeek(pWav->pUserData, (int)pWav->dataChunkDataPos + 4, drwav_seek_origin_start)) {
- drwav_uint32 dataChunkSize = drwav__data_chunk_size_riff(pWav->dataChunkDataSize);
- drwav__write_u32ne_to_le(pWav, dataChunkSize);
- }
- } else if (pWav->container == drwav_container_w64) {
- /* The "RIFF" chunk size. */
- if (pWav->onSeek(pWav->pUserData, 16, drwav_seek_origin_start)) {
- drwav_uint64 riffChunkSize = drwav__riff_chunk_size_w64(pWav->dataChunkDataSize);
- drwav__write_u64ne_to_le(pWav, riffChunkSize);
- }
-
- /* The "data" chunk size. */
- if (pWav->onSeek(pWav->pUserData, (int)pWav->dataChunkDataPos + 16, drwav_seek_origin_start)) {
- drwav_uint64 dataChunkSize = drwav__data_chunk_size_w64(pWav->dataChunkDataSize);
- drwav__write_u64ne_to_le(pWav, dataChunkSize);
- }
- } else if (pWav->container == drwav_container_rf64) {
- /* We only need to update the ds64 chunk. The "RIFF" and "data" chunks always have their sizes set to 0xFFFFFFFF for RF64. */
- int ds64BodyPos = 12 + 8;
-
- /* The "RIFF" chunk size. */
- if (pWav->onSeek(pWav->pUserData, ds64BodyPos + 0, drwav_seek_origin_start)) {
- drwav_uint64 riffChunkSize = drwav__riff_chunk_size_rf64(pWav->dataChunkDataSize);
- drwav__write_u64ne_to_le(pWav, riffChunkSize);
- }
-
- /* The "data" chunk size. */
- if (pWav->onSeek(pWav->pUserData, ds64BodyPos + 8, drwav_seek_origin_start)) {
- drwav_uint64 dataChunkSize = drwav__data_chunk_size_rf64(pWav->dataChunkDataSize);
- drwav__write_u64ne_to_le(pWav, dataChunkSize);
- }
- }
- }
-
- /* Validation for sequential mode. */
- if (pWav->isSequentialWrite) {
- if (pWav->dataChunkDataSize != pWav->dataChunkDataSizeTargetWrite) {
- result = DRWAV_INVALID_FILE;
- }
- }
- }
-
-#ifndef DR_WAV_NO_STDIO
- /*
- If we opened the file with drwav_open_file() we will want to close the file handle. We can know whether or not drwav_open_file()
- was used by looking at the onRead and onSeek callbacks.
- */
- if (pWav->onRead == drwav__on_read_stdio || pWav->onWrite == drwav__on_write_stdio) {
- fclose((FILE*)pWav->pUserData);
- }
-#endif
-
- return result;
-}
-
-
-
-DRWAV_API size_t drwav_read_raw(drwav* pWav, size_t bytesToRead, void* pBufferOut)
-{
- size_t bytesRead;
-
- if (pWav == NULL || bytesToRead == 0) {
- return 0;
- }
-
- if (bytesToRead > pWav->bytesRemaining) {
- bytesToRead = (size_t)pWav->bytesRemaining;
- }
-
- if (pBufferOut != NULL) {
- bytesRead = pWav->onRead(pWav->pUserData, pBufferOut, bytesToRead);
- } else {
- /* We need to seek. If we fail, we need to read-and-discard to make sure we get a good byte count. */
- bytesRead = 0;
- while (bytesRead < bytesToRead) {
- size_t bytesToSeek = (bytesToRead - bytesRead);
- if (bytesToSeek > 0x7FFFFFFF) {
- bytesToSeek = 0x7FFFFFFF;
- }
-
- if (pWav->onSeek(pWav->pUserData, (int)bytesToSeek, drwav_seek_origin_current) == DRWAV_FALSE) {
- break;
- }
-
- bytesRead += bytesToSeek;
- }
-
- /* When we get here we may need to read-and-discard some data. */
- while (bytesRead < bytesToRead) {
- drwav_uint8 buffer[4096];
- size_t bytesSeeked;
- size_t bytesToSeek = (bytesToRead - bytesRead);
- if (bytesToSeek > sizeof(buffer)) {
- bytesToSeek = sizeof(buffer);
- }
-
- bytesSeeked = pWav->onRead(pWav->pUserData, buffer, bytesToSeek);
- bytesRead += bytesSeeked;
-
- if (bytesSeeked < bytesToSeek) {
- break; /* Reached the end. */
- }
- }
- }
-
- pWav->bytesRemaining -= bytesRead;
- return bytesRead;
-}
-
-
-
-DRWAV_API drwav_uint64 drwav_read_pcm_frames_le(drwav* pWav, drwav_uint64 framesToRead, void* pBufferOut)
-{
- drwav_uint32 bytesPerFrame;
- drwav_uint64 bytesToRead; /* Intentionally uint64 instead of size_t so we can do a check that we're not reading too much on 32-bit builds. */
-
- if (pWav == NULL || framesToRead == 0) {
- return 0;
- }
-
- /* Cannot use this function for compressed formats. */
- if (drwav__is_compressed_format_tag(pWav->translatedFormatTag)) {
- return 0;
- }
-
- bytesPerFrame = drwav_get_bytes_per_pcm_frame(pWav);
- if (bytesPerFrame == 0) {
- return 0;
- }
-
- /* Don't try to read more samples than can potentially fit in the output buffer. */
- bytesToRead = framesToRead * bytesPerFrame;
- if (bytesToRead > DRWAV_SIZE_MAX) {
- bytesToRead = (DRWAV_SIZE_MAX / bytesPerFrame) * bytesPerFrame; /* Round the number of bytes to read to a clean frame boundary. */
- }
-
- /*
- Doing an explicit check here just to make it clear that we don't want to be attempt to read anything if there's no bytes to read. There
- *could* be a time where it evaluates to 0 due to overflowing.
- */
- if (bytesToRead == 0) {
- return 0;
- }
-
- return drwav_read_raw(pWav, (size_t)bytesToRead, pBufferOut) / bytesPerFrame;
-}
-
-DRWAV_API drwav_uint64 drwav_read_pcm_frames_be(drwav* pWav, drwav_uint64 framesToRead, void* pBufferOut)
-{
- drwav_uint64 framesRead = drwav_read_pcm_frames_le(pWav, framesToRead, pBufferOut);
-
- if (pBufferOut != NULL) {
- drwav__bswap_samples(pBufferOut, framesRead*pWav->channels, drwav_get_bytes_per_pcm_frame(pWav)/pWav->channels, pWav->translatedFormatTag);
- }
-
- return framesRead;
-}
-
-DRWAV_API drwav_uint64 drwav_read_pcm_frames(drwav* pWav, drwav_uint64 framesToRead, void* pBufferOut)
-{
- if (drwav__is_little_endian()) {
- return drwav_read_pcm_frames_le(pWav, framesToRead, pBufferOut);
- } else {
- return drwav_read_pcm_frames_be(pWav, framesToRead, pBufferOut);
- }
-}
-
-
-
-DRWAV_API drwav_bool32 drwav_seek_to_first_pcm_frame(drwav* pWav)
-{
- if (pWav->onWrite != NULL) {
- return DRWAV_FALSE; /* No seeking in write mode. */
- }
-
- if (!pWav->onSeek(pWav->pUserData, (int)pWav->dataChunkDataPos, drwav_seek_origin_start)) {
- return DRWAV_FALSE;
- }
-
- if (drwav__is_compressed_format_tag(pWav->translatedFormatTag)) {
- pWav->compressed.iCurrentPCMFrame = 0;
-
- /* Cached data needs to be cleared for compressed formats. */
- if (pWav->translatedFormatTag == DR_WAVE_FORMAT_ADPCM) {
- DRWAV_ZERO_OBJECT(&pWav->msadpcm);
- } else if (pWav->translatedFormatTag == DR_WAVE_FORMAT_DVI_ADPCM) {
- DRWAV_ZERO_OBJECT(&pWav->ima);
- } else {
- DRWAV_ASSERT(DRWAV_FALSE); /* If this assertion is triggered it means I've implemented a new compressed format but forgot to add a branch for it here. */
- }
- }
-
- pWav->bytesRemaining = pWav->dataChunkDataSize;
- return DRWAV_TRUE;
-}
-
-DRWAV_API drwav_bool32 drwav_seek_to_pcm_frame(drwav* pWav, drwav_uint64 targetFrameIndex)
-{
- /* Seeking should be compatible with wave files > 2GB. */
-
- if (pWav == NULL || pWav->onSeek == NULL) {
- return DRWAV_FALSE;
- }
-
- /* No seeking in write mode. */
- if (pWav->onWrite != NULL) {
- return DRWAV_FALSE;
- }
-
- /* If there are no samples, just return DRWAV_TRUE without doing anything. */
- if (pWav->totalPCMFrameCount == 0) {
- return DRWAV_TRUE;
- }
-
- /* Make sure the sample is clamped. */
- if (targetFrameIndex >= pWav->totalPCMFrameCount) {
- targetFrameIndex = pWav->totalPCMFrameCount - 1;
- }
-
- /*
- For compressed formats we just use a slow generic seek. If we are seeking forward we just seek forward. If we are going backwards we need
- to seek back to the start.
- */
- if (drwav__is_compressed_format_tag(pWav->translatedFormatTag)) {
- /* TODO: This can be optimized. */
-
- /*
- If we're seeking forward it's simple - just keep reading samples until we hit the sample we're requesting. If we're seeking backwards,
- we first need to seek back to the start and then just do the same thing as a forward seek.
- */
- if (targetFrameIndex < pWav->compressed.iCurrentPCMFrame) {
- if (!drwav_seek_to_first_pcm_frame(pWav)) {
- return DRWAV_FALSE;
- }
- }
-
- if (targetFrameIndex > pWav->compressed.iCurrentPCMFrame) {
- drwav_uint64 offsetInFrames = targetFrameIndex - pWav->compressed.iCurrentPCMFrame;
-
- drwav_int16 devnull[2048];
- while (offsetInFrames > 0) {
- drwav_uint64 framesRead = 0;
- drwav_uint64 framesToRead = offsetInFrames;
- if (framesToRead > drwav_countof(devnull)/pWav->channels) {
- framesToRead = drwav_countof(devnull)/pWav->channels;
- }
-
- if (pWav->translatedFormatTag == DR_WAVE_FORMAT_ADPCM) {
- framesRead = drwav_read_pcm_frames_s16__msadpcm(pWav, framesToRead, devnull);
- } else if (pWav->translatedFormatTag == DR_WAVE_FORMAT_DVI_ADPCM) {
- framesRead = drwav_read_pcm_frames_s16__ima(pWav, framesToRead, devnull);
- } else {
- DRWAV_ASSERT(DRWAV_FALSE); /* If this assertion is triggered it means I've implemented a new compressed format but forgot to add a branch for it here. */
- }
-
- if (framesRead != framesToRead) {
- return DRWAV_FALSE;
- }
-
- offsetInFrames -= framesRead;
- }
- }
- } else {
- drwav_uint64 totalSizeInBytes;
- drwav_uint64 currentBytePos;
- drwav_uint64 targetBytePos;
- drwav_uint64 offset;
-
- totalSizeInBytes = pWav->totalPCMFrameCount * drwav_get_bytes_per_pcm_frame(pWav);
- DRWAV_ASSERT(totalSizeInBytes >= pWav->bytesRemaining);
-
- currentBytePos = totalSizeInBytes - pWav->bytesRemaining;
- targetBytePos = targetFrameIndex * drwav_get_bytes_per_pcm_frame(pWav);
-
- if (currentBytePos < targetBytePos) {
- /* Offset forwards. */
- offset = (targetBytePos - currentBytePos);
- } else {
- /* Offset backwards. */
- if (!drwav_seek_to_first_pcm_frame(pWav)) {
- return DRWAV_FALSE;
- }
- offset = targetBytePos;
- }
-
- while (offset > 0) {
- int offset32 = ((offset > INT_MAX) ? INT_MAX : (int)offset);
- if (!pWav->onSeek(pWav->pUserData, offset32, drwav_seek_origin_current)) {
- return DRWAV_FALSE;
- }
-
- pWav->bytesRemaining -= offset32;
- offset -= offset32;
- }
- }
-
- return DRWAV_TRUE;
-}
-
-
-DRWAV_API size_t drwav_write_raw(drwav* pWav, size_t bytesToWrite, const void* pData)
-{
- size_t bytesWritten;
-
- if (pWav == NULL || bytesToWrite == 0 || pData == NULL) {
- return 0;
- }
-
- bytesWritten = pWav->onWrite(pWav->pUserData, pData, bytesToWrite);
- pWav->dataChunkDataSize += bytesWritten;
-
- return bytesWritten;
-}
-
-
-DRWAV_API drwav_uint64 drwav_write_pcm_frames_le(drwav* pWav, drwav_uint64 framesToWrite, const void* pData)
-{
- drwav_uint64 bytesToWrite;
- drwav_uint64 bytesWritten;
- const drwav_uint8* pRunningData;
-
- if (pWav == NULL || framesToWrite == 0 || pData == NULL) {
- return 0;
- }
-
- bytesToWrite = ((framesToWrite * pWav->channels * pWav->bitsPerSample) / 8);
- if (bytesToWrite > DRWAV_SIZE_MAX) {
- return 0;
- }
-
- bytesWritten = 0;
- pRunningData = (const drwav_uint8*)pData;
-
- while (bytesToWrite > 0) {
- size_t bytesJustWritten;
- drwav_uint64 bytesToWriteThisIteration;
-
- bytesToWriteThisIteration = bytesToWrite;
- DRWAV_ASSERT(bytesToWriteThisIteration <= DRWAV_SIZE_MAX); /* <-- This is checked above. */
-
- bytesJustWritten = drwav_write_raw(pWav, (size_t)bytesToWriteThisIteration, pRunningData);
- if (bytesJustWritten == 0) {
- break;
- }
-
- bytesToWrite -= bytesJustWritten;
- bytesWritten += bytesJustWritten;
- pRunningData += bytesJustWritten;
- }
-
- return (bytesWritten * 8) / pWav->bitsPerSample / pWav->channels;
-}
-
-DRWAV_API drwav_uint64 drwav_write_pcm_frames_be(drwav* pWav, drwav_uint64 framesToWrite, const void* pData)
-{
- drwav_uint64 bytesToWrite;
- drwav_uint64 bytesWritten;
- drwav_uint32 bytesPerSample;
- const drwav_uint8* pRunningData;
-
- if (pWav == NULL || framesToWrite == 0 || pData == NULL) {
- return 0;
- }
-
- bytesToWrite = ((framesToWrite * pWav->channels * pWav->bitsPerSample) / 8);
- if (bytesToWrite > DRWAV_SIZE_MAX) {
- return 0;
- }
-
- bytesWritten = 0;
- pRunningData = (const drwav_uint8*)pData;
-
- bytesPerSample = drwav_get_bytes_per_pcm_frame(pWav) / pWav->channels;
-
- while (bytesToWrite > 0) {
- drwav_uint8 temp[4096];
- drwav_uint32 sampleCount;
- size_t bytesJustWritten;
- drwav_uint64 bytesToWriteThisIteration;
-
- bytesToWriteThisIteration = bytesToWrite;
- DRWAV_ASSERT(bytesToWriteThisIteration <= DRWAV_SIZE_MAX); /* <-- This is checked above. */
-
- /*
- WAV files are always little-endian. We need to byte swap on big-endian architectures. Since our input buffer is read-only we need
- to use an intermediary buffer for the conversion.
- */
- sampleCount = sizeof(temp)/bytesPerSample;
-
- if (bytesToWriteThisIteration > ((drwav_uint64)sampleCount)*bytesPerSample) {
- bytesToWriteThisIteration = ((drwav_uint64)sampleCount)*bytesPerSample;
- }
-
- DRWAV_COPY_MEMORY(temp, pRunningData, (size_t)bytesToWriteThisIteration);
- drwav__bswap_samples(temp, sampleCount, bytesPerSample, pWav->translatedFormatTag);
-
- bytesJustWritten = drwav_write_raw(pWav, (size_t)bytesToWriteThisIteration, temp);
- if (bytesJustWritten == 0) {
- break;
- }
-
- bytesToWrite -= bytesJustWritten;
- bytesWritten += bytesJustWritten;
- pRunningData += bytesJustWritten;
- }
-
- return (bytesWritten * 8) / pWav->bitsPerSample / pWav->channels;
-}
-
-DRWAV_API drwav_uint64 drwav_write_pcm_frames(drwav* pWav, drwav_uint64 framesToWrite, const void* pData)
-{
- if (drwav__is_little_endian()) {
- return drwav_write_pcm_frames_le(pWav, framesToWrite, pData);
- } else {
- return drwav_write_pcm_frames_be(pWav, framesToWrite, pData);
- }
-}
-
-
-static drwav_uint64 drwav_read_pcm_frames_s16__msadpcm(drwav* pWav, drwav_uint64 framesToRead, drwav_int16* pBufferOut)
-{
- drwav_uint64 totalFramesRead = 0;
-
- DRWAV_ASSERT(pWav != NULL);
- DRWAV_ASSERT(framesToRead > 0);
-
- /* TODO: Lots of room for optimization here. */
-
- while (framesToRead > 0 && pWav->compressed.iCurrentPCMFrame < pWav->totalPCMFrameCount) {
- /* If there are no cached frames we need to load a new block. */
- if (pWav->msadpcm.cachedFrameCount == 0 && pWav->msadpcm.bytesRemainingInBlock == 0) {
- if (pWav->channels == 1) {
- /* Mono. */
- drwav_uint8 header[7];
- if (pWav->onRead(pWav->pUserData, header, sizeof(header)) != sizeof(header)) {
- return totalFramesRead;
- }
- pWav->msadpcm.bytesRemainingInBlock = pWav->fmt.blockAlign - sizeof(header);
-
- pWav->msadpcm.predictor[0] = header[0];
- pWav->msadpcm.delta[0] = drwav__bytes_to_s16(header + 1);
- pWav->msadpcm.prevFrames[0][1] = (drwav_int32)drwav__bytes_to_s16(header + 3);
- pWav->msadpcm.prevFrames[0][0] = (drwav_int32)drwav__bytes_to_s16(header + 5);
- pWav->msadpcm.cachedFrames[2] = pWav->msadpcm.prevFrames[0][0];
- pWav->msadpcm.cachedFrames[3] = pWav->msadpcm.prevFrames[0][1];
- pWav->msadpcm.cachedFrameCount = 2;
- } else {
- /* Stereo. */
- drwav_uint8 header[14];
- if (pWav->onRead(pWav->pUserData, header, sizeof(header)) != sizeof(header)) {
- return totalFramesRead;
- }
- pWav->msadpcm.bytesRemainingInBlock = pWav->fmt.blockAlign - sizeof(header);
-
- pWav->msadpcm.predictor[0] = header[0];
- pWav->msadpcm.predictor[1] = header[1];
- pWav->msadpcm.delta[0] = drwav__bytes_to_s16(header + 2);
- pWav->msadpcm.delta[1] = drwav__bytes_to_s16(header + 4);
- pWav->msadpcm.prevFrames[0][1] = (drwav_int32)drwav__bytes_to_s16(header + 6);
- pWav->msadpcm.prevFrames[1][1] = (drwav_int32)drwav__bytes_to_s16(header + 8);
- pWav->msadpcm.prevFrames[0][0] = (drwav_int32)drwav__bytes_to_s16(header + 10);
- pWav->msadpcm.prevFrames[1][0] = (drwav_int32)drwav__bytes_to_s16(header + 12);
-
- pWav->msadpcm.cachedFrames[0] = pWav->msadpcm.prevFrames[0][0];
- pWav->msadpcm.cachedFrames[1] = pWav->msadpcm.prevFrames[1][0];
- pWav->msadpcm.cachedFrames[2] = pWav->msadpcm.prevFrames[0][1];
- pWav->msadpcm.cachedFrames[3] = pWav->msadpcm.prevFrames[1][1];
- pWav->msadpcm.cachedFrameCount = 2;
- }
- }
-
- /* Output anything that's cached. */
- while (framesToRead > 0 && pWav->msadpcm.cachedFrameCount > 0 && pWav->compressed.iCurrentPCMFrame < pWav->totalPCMFrameCount) {
- if (pBufferOut != NULL) {
- drwav_uint32 iSample = 0;
- for (iSample = 0; iSample < pWav->channels; iSample += 1) {
- pBufferOut[iSample] = (drwav_int16)pWav->msadpcm.cachedFrames[(drwav_countof(pWav->msadpcm.cachedFrames) - (pWav->msadpcm.cachedFrameCount*pWav->channels)) + iSample];
- }
-
- pBufferOut += pWav->channels;
- }
-
- framesToRead -= 1;
- totalFramesRead += 1;
- pWav->compressed.iCurrentPCMFrame += 1;
- pWav->msadpcm.cachedFrameCount -= 1;
- }
-
- if (framesToRead == 0) {
- return totalFramesRead;
- }
-
-
- /*
- If there's nothing left in the cache, just go ahead and load more. If there's nothing left to load in the current block we just continue to the next
- loop iteration which will trigger the loading of a new block.
- */
- if (pWav->msadpcm.cachedFrameCount == 0) {
- if (pWav->msadpcm.bytesRemainingInBlock == 0) {
- continue;
- } else {
- static drwav_int32 adaptationTable[] = {
- 230, 230, 230, 230, 307, 409, 512, 614,
- 768, 614, 512, 409, 307, 230, 230, 230
- };
- static drwav_int32 coeff1Table[] = { 256, 512, 0, 192, 240, 460, 392 };
- static drwav_int32 coeff2Table[] = { 0, -256, 0, 64, 0, -208, -232 };
-
- drwav_uint8 nibbles;
- drwav_int32 nibble0;
- drwav_int32 nibble1;
-
- if (pWav->onRead(pWav->pUserData, &nibbles, 1) != 1) {
- return totalFramesRead;
- }
- pWav->msadpcm.bytesRemainingInBlock -= 1;
-
- /* TODO: Optimize away these if statements. */
- nibble0 = ((nibbles & 0xF0) >> 4); if ((nibbles & 0x80)) { nibble0 |= 0xFFFFFFF0UL; }
- nibble1 = ((nibbles & 0x0F) >> 0); if ((nibbles & 0x08)) { nibble1 |= 0xFFFFFFF0UL; }
-
- if (pWav->channels == 1) {
- /* Mono. */
- drwav_int32 newSample0;
- drwav_int32 newSample1;
-
- newSample0 = ((pWav->msadpcm.prevFrames[0][1] * coeff1Table[pWav->msadpcm.predictor[0]]) + (pWav->msadpcm.prevFrames[0][0] * coeff2Table[pWav->msadpcm.predictor[0]])) >> 8;
- newSample0 += nibble0 * pWav->msadpcm.delta[0];
- newSample0 = drwav_clamp(newSample0, -32768, 32767);
-
- pWav->msadpcm.delta[0] = (adaptationTable[((nibbles & 0xF0) >> 4)] * pWav->msadpcm.delta[0]) >> 8;
- if (pWav->msadpcm.delta[0] < 16) {
- pWav->msadpcm.delta[0] = 16;
- }
-
- pWav->msadpcm.prevFrames[0][0] = pWav->msadpcm.prevFrames[0][1];
- pWav->msadpcm.prevFrames[0][1] = newSample0;
-
-
- newSample1 = ((pWav->msadpcm.prevFrames[0][1] * coeff1Table[pWav->msadpcm.predictor[0]]) + (pWav->msadpcm.prevFrames[0][0] * coeff2Table[pWav->msadpcm.predictor[0]])) >> 8;
- newSample1 += nibble1 * pWav->msadpcm.delta[0];
- newSample1 = drwav_clamp(newSample1, -32768, 32767);
-
- pWav->msadpcm.delta[0] = (adaptationTable[((nibbles & 0x0F) >> 0)] * pWav->msadpcm.delta[0]) >> 8;
- if (pWav->msadpcm.delta[0] < 16) {
- pWav->msadpcm.delta[0] = 16;
- }
-
- pWav->msadpcm.prevFrames[0][0] = pWav->msadpcm.prevFrames[0][1];
- pWav->msadpcm.prevFrames[0][1] = newSample1;
-
-
- pWav->msadpcm.cachedFrames[2] = newSample0;
- pWav->msadpcm.cachedFrames[3] = newSample1;
- pWav->msadpcm.cachedFrameCount = 2;
- } else {
- /* Stereo. */
- drwav_int32 newSample0;
- drwav_int32 newSample1;
-
- /* Left. */
- newSample0 = ((pWav->msadpcm.prevFrames[0][1] * coeff1Table[pWav->msadpcm.predictor[0]]) + (pWav->msadpcm.prevFrames[0][0] * coeff2Table[pWav->msadpcm.predictor[0]])) >> 8;
- newSample0 += nibble0 * pWav->msadpcm.delta[0];
- newSample0 = drwav_clamp(newSample0, -32768, 32767);
-
- pWav->msadpcm.delta[0] = (adaptationTable[((nibbles & 0xF0) >> 4)] * pWav->msadpcm.delta[0]) >> 8;
- if (pWav->msadpcm.delta[0] < 16) {
- pWav->msadpcm.delta[0] = 16;
- }
-
- pWav->msadpcm.prevFrames[0][0] = pWav->msadpcm.prevFrames[0][1];
- pWav->msadpcm.prevFrames[0][1] = newSample0;
-
-
- /* Right. */
- newSample1 = ((pWav->msadpcm.prevFrames[1][1] * coeff1Table[pWav->msadpcm.predictor[1]]) + (pWav->msadpcm.prevFrames[1][0] * coeff2Table[pWav->msadpcm.predictor[1]])) >> 8;
- newSample1 += nibble1 * pWav->msadpcm.delta[1];
- newSample1 = drwav_clamp(newSample1, -32768, 32767);
-
- pWav->msadpcm.delta[1] = (adaptationTable[((nibbles & 0x0F) >> 0)] * pWav->msadpcm.delta[1]) >> 8;
- if (pWav->msadpcm.delta[1] < 16) {
- pWav->msadpcm.delta[1] = 16;
- }
-
- pWav->msadpcm.prevFrames[1][0] = pWav->msadpcm.prevFrames[1][1];
- pWav->msadpcm.prevFrames[1][1] = newSample1;
-
- pWav->msadpcm.cachedFrames[2] = newSample0;
- pWav->msadpcm.cachedFrames[3] = newSample1;
- pWav->msadpcm.cachedFrameCount = 1;
- }
- }
- }
- }
-
- return totalFramesRead;
-}
-
-
-static drwav_uint64 drwav_read_pcm_frames_s16__ima(drwav* pWav, drwav_uint64 framesToRead, drwav_int16* pBufferOut)
-{
- drwav_uint64 totalFramesRead = 0;
- drwav_uint32 iChannel;
-
- static drwav_int32 indexTable[16] = {
- -1, -1, -1, -1, 2, 4, 6, 8,
- -1, -1, -1, -1, 2, 4, 6, 8
- };
-
- static drwav_int32 stepTable[89] = {
- 7, 8, 9, 10, 11, 12, 13, 14, 16, 17,
- 19, 21, 23, 25, 28, 31, 34, 37, 41, 45,
- 50, 55, 60, 66, 73, 80, 88, 97, 107, 118,
- 130, 143, 157, 173, 190, 209, 230, 253, 279, 307,
- 337, 371, 408, 449, 494, 544, 598, 658, 724, 796,
- 876, 963, 1060, 1166, 1282, 1411, 1552, 1707, 1878, 2066,
- 2272, 2499, 2749, 3024, 3327, 3660, 4026, 4428, 4871, 5358,
- 5894, 6484, 7132, 7845, 8630, 9493, 10442, 11487, 12635, 13899,
- 15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767
- };
-
- DRWAV_ASSERT(pWav != NULL);
- DRWAV_ASSERT(framesToRead > 0);
-
- /* TODO: Lots of room for optimization here. */
-
- while (framesToRead > 0 && pWav->compressed.iCurrentPCMFrame < pWav->totalPCMFrameCount) {
- /* If there are no cached samples we need to load a new block. */
- if (pWav->ima.cachedFrameCount == 0 && pWav->ima.bytesRemainingInBlock == 0) {
- if (pWav->channels == 1) {
- /* Mono. */
- drwav_uint8 header[4];
- if (pWav->onRead(pWav->pUserData, header, sizeof(header)) != sizeof(header)) {
- return totalFramesRead;
- }
- pWav->ima.bytesRemainingInBlock = pWav->fmt.blockAlign - sizeof(header);
-
- if (header[2] >= drwav_countof(stepTable)) {
- pWav->onSeek(pWav->pUserData, pWav->ima.bytesRemainingInBlock, drwav_seek_origin_current);
- pWav->ima.bytesRemainingInBlock = 0;
- return totalFramesRead; /* Invalid data. */
- }
-
- pWav->ima.predictor[0] = drwav__bytes_to_s16(header + 0);
- pWav->ima.stepIndex[0] = header[2];
- pWav->ima.cachedFrames[drwav_countof(pWav->ima.cachedFrames) - 1] = pWav->ima.predictor[0];
- pWav->ima.cachedFrameCount = 1;
- } else {
- /* Stereo. */
- drwav_uint8 header[8];
- if (pWav->onRead(pWav->pUserData, header, sizeof(header)) != sizeof(header)) {
- return totalFramesRead;
- }
- pWav->ima.bytesRemainingInBlock = pWav->fmt.blockAlign - sizeof(header);
-
- if (header[2] >= drwav_countof(stepTable) || header[6] >= drwav_countof(stepTable)) {
- pWav->onSeek(pWav->pUserData, pWav->ima.bytesRemainingInBlock, drwav_seek_origin_current);
- pWav->ima.bytesRemainingInBlock = 0;
- return totalFramesRead; /* Invalid data. */
- }
-
- pWav->ima.predictor[0] = drwav__bytes_to_s16(header + 0);
- pWav->ima.stepIndex[0] = header[2];
- pWav->ima.predictor[1] = drwav__bytes_to_s16(header + 4);
- pWav->ima.stepIndex[1] = header[6];
-
- pWav->ima.cachedFrames[drwav_countof(pWav->ima.cachedFrames) - 2] = pWav->ima.predictor[0];
- pWav->ima.cachedFrames[drwav_countof(pWav->ima.cachedFrames) - 1] = pWav->ima.predictor[1];
- pWav->ima.cachedFrameCount = 1;
- }
- }
-
- /* Output anything that's cached. */
- while (framesToRead > 0 && pWav->ima.cachedFrameCount > 0 && pWav->compressed.iCurrentPCMFrame < pWav->totalPCMFrameCount) {
- if (pBufferOut != NULL) {
- drwav_uint32 iSample;
- for (iSample = 0; iSample < pWav->channels; iSample += 1) {
- pBufferOut[iSample] = (drwav_int16)pWav->ima.cachedFrames[(drwav_countof(pWav->ima.cachedFrames) - (pWav->ima.cachedFrameCount*pWav->channels)) + iSample];
- }
- pBufferOut += pWav->channels;
- }
-
- framesToRead -= 1;
- totalFramesRead += 1;
- pWav->compressed.iCurrentPCMFrame += 1;
- pWav->ima.cachedFrameCount -= 1;
- }
-
- if (framesToRead == 0) {
- return totalFramesRead;
- }
-
- /*
- If there's nothing left in the cache, just go ahead and load more. If there's nothing left to load in the current block we just continue to the next
- loop iteration which will trigger the loading of a new block.
- */
- if (pWav->ima.cachedFrameCount == 0) {
- if (pWav->ima.bytesRemainingInBlock == 0) {
- continue;
- } else {
- /*
- From what I can tell with stereo streams, it looks like every 4 bytes (8 samples) is for one channel. So it goes 4 bytes for the
- left channel, 4 bytes for the right channel.
- */
- pWav->ima.cachedFrameCount = 8;
- for (iChannel = 0; iChannel < pWav->channels; ++iChannel) {
- drwav_uint32 iByte;
- drwav_uint8 nibbles[4];
- if (pWav->onRead(pWav->pUserData, &nibbles, 4) != 4) {
- pWav->ima.cachedFrameCount = 0;
- return totalFramesRead;
- }
- pWav->ima.bytesRemainingInBlock -= 4;
-
- for (iByte = 0; iByte < 4; ++iByte) {
- drwav_uint8 nibble0 = ((nibbles[iByte] & 0x0F) >> 0);
- drwav_uint8 nibble1 = ((nibbles[iByte] & 0xF0) >> 4);
-
- drwav_int32 step = stepTable[pWav->ima.stepIndex[iChannel]];
- drwav_int32 predictor = pWav->ima.predictor[iChannel];
-
- drwav_int32 diff = step >> 3;
- if (nibble0 & 1) diff += step >> 2;
- if (nibble0 & 2) diff += step >> 1;
- if (nibble0 & 4) diff += step;
- if (nibble0 & 8) diff = -diff;
-
- predictor = drwav_clamp(predictor + diff, -32768, 32767);
- pWav->ima.predictor[iChannel] = predictor;
- pWav->ima.stepIndex[iChannel] = drwav_clamp(pWav->ima.stepIndex[iChannel] + indexTable[nibble0], 0, (drwav_int32)drwav_countof(stepTable)-1);
- pWav->ima.cachedFrames[(drwav_countof(pWav->ima.cachedFrames) - (pWav->ima.cachedFrameCount*pWav->channels)) + (iByte*2+0)*pWav->channels + iChannel] = predictor;
-
-
- step = stepTable[pWav->ima.stepIndex[iChannel]];
- predictor = pWav->ima.predictor[iChannel];
-
- diff = step >> 3;
- if (nibble1 & 1) diff += step >> 2;
- if (nibble1 & 2) diff += step >> 1;
- if (nibble1 & 4) diff += step;
- if (nibble1 & 8) diff = -diff;
-
- predictor = drwav_clamp(predictor + diff, -32768, 32767);
- pWav->ima.predictor[iChannel] = predictor;
- pWav->ima.stepIndex[iChannel] = drwav_clamp(pWav->ima.stepIndex[iChannel] + indexTable[nibble1], 0, (drwav_int32)drwav_countof(stepTable)-1);
- pWav->ima.cachedFrames[(drwav_countof(pWav->ima.cachedFrames) - (pWav->ima.cachedFrameCount*pWav->channels)) + (iByte*2+1)*pWav->channels + iChannel] = predictor;
- }
- }
- }
- }
- }
-
- return totalFramesRead;
-}
-
-
-#ifndef DR_WAV_NO_CONVERSION_API
-static unsigned short g_drwavAlawTable[256] = {
- 0xEA80, 0xEB80, 0xE880, 0xE980, 0xEE80, 0xEF80, 0xEC80, 0xED80, 0xE280, 0xE380, 0xE080, 0xE180, 0xE680, 0xE780, 0xE480, 0xE580,
- 0xF540, 0xF5C0, 0xF440, 0xF4C0, 0xF740, 0xF7C0, 0xF640, 0xF6C0, 0xF140, 0xF1C0, 0xF040, 0xF0C0, 0xF340, 0xF3C0, 0xF240, 0xF2C0,
- 0xAA00, 0xAE00, 0xA200, 0xA600, 0xBA00, 0xBE00, 0xB200, 0xB600, 0x8A00, 0x8E00, 0x8200, 0x8600, 0x9A00, 0x9E00, 0x9200, 0x9600,
- 0xD500, 0xD700, 0xD100, 0xD300, 0xDD00, 0xDF00, 0xD900, 0xDB00, 0xC500, 0xC700, 0xC100, 0xC300, 0xCD00, 0xCF00, 0xC900, 0xCB00,
- 0xFEA8, 0xFEB8, 0xFE88, 0xFE98, 0xFEE8, 0xFEF8, 0xFEC8, 0xFED8, 0xFE28, 0xFE38, 0xFE08, 0xFE18, 0xFE68, 0xFE78, 0xFE48, 0xFE58,
- 0xFFA8, 0xFFB8, 0xFF88, 0xFF98, 0xFFE8, 0xFFF8, 0xFFC8, 0xFFD8, 0xFF28, 0xFF38, 0xFF08, 0xFF18, 0xFF68, 0xFF78, 0xFF48, 0xFF58,
- 0xFAA0, 0xFAE0, 0xFA20, 0xFA60, 0xFBA0, 0xFBE0, 0xFB20, 0xFB60, 0xF8A0, 0xF8E0, 0xF820, 0xF860, 0xF9A0, 0xF9E0, 0xF920, 0xF960,
- 0xFD50, 0xFD70, 0xFD10, 0xFD30, 0xFDD0, 0xFDF0, 0xFD90, 0xFDB0, 0xFC50, 0xFC70, 0xFC10, 0xFC30, 0xFCD0, 0xFCF0, 0xFC90, 0xFCB0,
- 0x1580, 0x1480, 0x1780, 0x1680, 0x1180, 0x1080, 0x1380, 0x1280, 0x1D80, 0x1C80, 0x1F80, 0x1E80, 0x1980, 0x1880, 0x1B80, 0x1A80,
- 0x0AC0, 0x0A40, 0x0BC0, 0x0B40, 0x08C0, 0x0840, 0x09C0, 0x0940, 0x0EC0, 0x0E40, 0x0FC0, 0x0F40, 0x0CC0, 0x0C40, 0x0DC0, 0x0D40,
- 0x5600, 0x5200, 0x5E00, 0x5A00, 0x4600, 0x4200, 0x4E00, 0x4A00, 0x7600, 0x7200, 0x7E00, 0x7A00, 0x6600, 0x6200, 0x6E00, 0x6A00,
- 0x2B00, 0x2900, 0x2F00, 0x2D00, 0x2300, 0x2100, 0x2700, 0x2500, 0x3B00, 0x3900, 0x3F00, 0x3D00, 0x3300, 0x3100, 0x3700, 0x3500,
- 0x0158, 0x0148, 0x0178, 0x0168, 0x0118, 0x0108, 0x0138, 0x0128, 0x01D8, 0x01C8, 0x01F8, 0x01E8, 0x0198, 0x0188, 0x01B8, 0x01A8,
- 0x0058, 0x0048, 0x0078, 0x0068, 0x0018, 0x0008, 0x0038, 0x0028, 0x00D8, 0x00C8, 0x00F8, 0x00E8, 0x0098, 0x0088, 0x00B8, 0x00A8,
- 0x0560, 0x0520, 0x05E0, 0x05A0, 0x0460, 0x0420, 0x04E0, 0x04A0, 0x0760, 0x0720, 0x07E0, 0x07A0, 0x0660, 0x0620, 0x06E0, 0x06A0,
- 0x02B0, 0x0290, 0x02F0, 0x02D0, 0x0230, 0x0210, 0x0270, 0x0250, 0x03B0, 0x0390, 0x03F0, 0x03D0, 0x0330, 0x0310, 0x0370, 0x0350
-};
-
-static unsigned short g_drwavMulawTable[256] = {
- 0x8284, 0x8684, 0x8A84, 0x8E84, 0x9284, 0x9684, 0x9A84, 0x9E84, 0xA284, 0xA684, 0xAA84, 0xAE84, 0xB284, 0xB684, 0xBA84, 0xBE84,
- 0xC184, 0xC384, 0xC584, 0xC784, 0xC984, 0xCB84, 0xCD84, 0xCF84, 0xD184, 0xD384, 0xD584, 0xD784, 0xD984, 0xDB84, 0xDD84, 0xDF84,
- 0xE104, 0xE204, 0xE304, 0xE404, 0xE504, 0xE604, 0xE704, 0xE804, 0xE904, 0xEA04, 0xEB04, 0xEC04, 0xED04, 0xEE04, 0xEF04, 0xF004,
- 0xF0C4, 0xF144, 0xF1C4, 0xF244, 0xF2C4, 0xF344, 0xF3C4, 0xF444, 0xF4C4, 0xF544, 0xF5C4, 0xF644, 0xF6C4, 0xF744, 0xF7C4, 0xF844,
- 0xF8A4, 0xF8E4, 0xF924, 0xF964, 0xF9A4, 0xF9E4, 0xFA24, 0xFA64, 0xFAA4, 0xFAE4, 0xFB24, 0xFB64, 0xFBA4, 0xFBE4, 0xFC24, 0xFC64,
- 0xFC94, 0xFCB4, 0xFCD4, 0xFCF4, 0xFD14, 0xFD34, 0xFD54, 0xFD74, 0xFD94, 0xFDB4, 0xFDD4, 0xFDF4, 0xFE14, 0xFE34, 0xFE54, 0xFE74,
- 0xFE8C, 0xFE9C, 0xFEAC, 0xFEBC, 0xFECC, 0xFEDC, 0xFEEC, 0xFEFC, 0xFF0C, 0xFF1C, 0xFF2C, 0xFF3C, 0xFF4C, 0xFF5C, 0xFF6C, 0xFF7C,
- 0xFF88, 0xFF90, 0xFF98, 0xFFA0, 0xFFA8, 0xFFB0, 0xFFB8, 0xFFC0, 0xFFC8, 0xFFD0, 0xFFD8, 0xFFE0, 0xFFE8, 0xFFF0, 0xFFF8, 0x0000,
- 0x7D7C, 0x797C, 0x757C, 0x717C, 0x6D7C, 0x697C, 0x657C, 0x617C, 0x5D7C, 0x597C, 0x557C, 0x517C, 0x4D7C, 0x497C, 0x457C, 0x417C,
- 0x3E7C, 0x3C7C, 0x3A7C, 0x387C, 0x367C, 0x347C, 0x327C, 0x307C, 0x2E7C, 0x2C7C, 0x2A7C, 0x287C, 0x267C, 0x247C, 0x227C, 0x207C,
- 0x1EFC, 0x1DFC, 0x1CFC, 0x1BFC, 0x1AFC, 0x19FC, 0x18FC, 0x17FC, 0x16FC, 0x15FC, 0x14FC, 0x13FC, 0x12FC, 0x11FC, 0x10FC, 0x0FFC,
- 0x0F3C, 0x0EBC, 0x0E3C, 0x0DBC, 0x0D3C, 0x0CBC, 0x0C3C, 0x0BBC, 0x0B3C, 0x0ABC, 0x0A3C, 0x09BC, 0x093C, 0x08BC, 0x083C, 0x07BC,
- 0x075C, 0x071C, 0x06DC, 0x069C, 0x065C, 0x061C, 0x05DC, 0x059C, 0x055C, 0x051C, 0x04DC, 0x049C, 0x045C, 0x041C, 0x03DC, 0x039C,
- 0x036C, 0x034C, 0x032C, 0x030C, 0x02EC, 0x02CC, 0x02AC, 0x028C, 0x026C, 0x024C, 0x022C, 0x020C, 0x01EC, 0x01CC, 0x01AC, 0x018C,
- 0x0174, 0x0164, 0x0154, 0x0144, 0x0134, 0x0124, 0x0114, 0x0104, 0x00F4, 0x00E4, 0x00D4, 0x00C4, 0x00B4, 0x00A4, 0x0094, 0x0084,
- 0x0078, 0x0070, 0x0068, 0x0060, 0x0058, 0x0050, 0x0048, 0x0040, 0x0038, 0x0030, 0x0028, 0x0020, 0x0018, 0x0010, 0x0008, 0x0000
-};
-
-static DRWAV_INLINE drwav_int16 drwav__alaw_to_s16(drwav_uint8 sampleIn)
-{
- return (short)g_drwavAlawTable[sampleIn];
-}
-
-static DRWAV_INLINE drwav_int16 drwav__mulaw_to_s16(drwav_uint8 sampleIn)
-{
- return (short)g_drwavMulawTable[sampleIn];
-}
-
-
-
-static void drwav__pcm_to_s16(drwav_int16* pOut, const drwav_uint8* pIn, size_t totalSampleCount, unsigned int bytesPerSample)
-{
- unsigned int i;
-
- /* Special case for 8-bit sample data because it's treated as unsigned. */
- if (bytesPerSample == 1) {
- drwav_u8_to_s16(pOut, pIn, totalSampleCount);
- return;
- }
-
-
- /* Slightly more optimal implementation for common formats. */
- if (bytesPerSample == 2) {
- for (i = 0; i < totalSampleCount; ++i) {
- *pOut++ = ((const drwav_int16*)pIn)[i];
- }
- return;
- }
- if (bytesPerSample == 3) {
- drwav_s24_to_s16(pOut, pIn, totalSampleCount);
- return;
- }
- if (bytesPerSample == 4) {
- drwav_s32_to_s16(pOut, (const drwav_int32*)pIn, totalSampleCount);
- return;
- }
-
-
- /* Anything more than 64 bits per sample is not supported. */
- if (bytesPerSample > 8) {
- DRWAV_ZERO_MEMORY(pOut, totalSampleCount * sizeof(*pOut));
- return;
- }
-
-
- /* Generic, slow converter. */
- for (i = 0; i < totalSampleCount; ++i) {
- drwav_uint64 sample = 0;
- unsigned int shift = (8 - bytesPerSample) * 8;
-
- unsigned int j;
- for (j = 0; j < bytesPerSample; j += 1) {
- DRWAV_ASSERT(j < 8);
- sample |= (drwav_uint64)(pIn[j]) << shift;
- shift += 8;
- }
-
- pIn += j;
- *pOut++ = (drwav_int16)((drwav_int64)sample >> 48);
- }
-}
-
-static void drwav__ieee_to_s16(drwav_int16* pOut, const drwav_uint8* pIn, size_t totalSampleCount, unsigned int bytesPerSample)
-{
- if (bytesPerSample == 4) {
- drwav_f32_to_s16(pOut, (const float*)pIn, totalSampleCount);
- return;
- } else if (bytesPerSample == 8) {
- drwav_f64_to_s16(pOut, (const double*)pIn, totalSampleCount);
- return;
- } else {
- /* Only supporting 32- and 64-bit float. Output silence in all other cases. Contributions welcome for 16-bit float. */
- DRWAV_ZERO_MEMORY(pOut, totalSampleCount * sizeof(*pOut));
- return;
- }
-}
-
-static drwav_uint64 drwav_read_pcm_frames_s16__pcm(drwav* pWav, drwav_uint64 framesToRead, drwav_int16* pBufferOut)
-{
- drwav_uint32 bytesPerFrame;
- drwav_uint64 totalFramesRead;
- drwav_uint8 sampleData[4096];
-
- /* Fast path. */
- if ((pWav->translatedFormatTag == DR_WAVE_FORMAT_PCM && pWav->bitsPerSample == 16) || pBufferOut == NULL) {
- return drwav_read_pcm_frames(pWav, framesToRead, pBufferOut);
- }
-
- bytesPerFrame = drwav_get_bytes_per_pcm_frame(pWav);
- if (bytesPerFrame == 0) {
- return 0;
- }
-
- totalFramesRead = 0;
-
- while (framesToRead > 0) {
- drwav_uint64 framesRead = drwav_read_pcm_frames(pWav, drwav_min(framesToRead, sizeof(sampleData)/bytesPerFrame), sampleData);
- if (framesRead == 0) {
- break;
- }
-
- drwav__pcm_to_s16(pBufferOut, sampleData, (size_t)(framesRead*pWav->channels), bytesPerFrame/pWav->channels);
-
- pBufferOut += framesRead*pWav->channels;
- framesToRead -= framesRead;
- totalFramesRead += framesRead;
- }
-
- return totalFramesRead;
-}
-
-static drwav_uint64 drwav_read_pcm_frames_s16__ieee(drwav* pWav, drwav_uint64 framesToRead, drwav_int16* pBufferOut)
-{
- drwav_uint64 totalFramesRead;
- drwav_uint8 sampleData[4096];
- drwav_uint32 bytesPerFrame;
-
- if (pBufferOut == NULL) {
- return drwav_read_pcm_frames(pWav, framesToRead, NULL);
- }
-
- bytesPerFrame = drwav_get_bytes_per_pcm_frame(pWav);
- if (bytesPerFrame == 0) {
- return 0;
- }
-
- totalFramesRead = 0;
-
- while (framesToRead > 0) {
- drwav_uint64 framesRead = drwav_read_pcm_frames(pWav, drwav_min(framesToRead, sizeof(sampleData)/bytesPerFrame), sampleData);
- if (framesRead == 0) {
- break;
- }
-
- drwav__ieee_to_s16(pBufferOut, sampleData, (size_t)(framesRead*pWav->channels), bytesPerFrame/pWav->channels);
-
- pBufferOut += framesRead*pWav->channels;
- framesToRead -= framesRead;
- totalFramesRead += framesRead;
- }
-
- return totalFramesRead;
-}
-
-static drwav_uint64 drwav_read_pcm_frames_s16__alaw(drwav* pWav, drwav_uint64 framesToRead, drwav_int16* pBufferOut)
-{
- drwav_uint64 totalFramesRead;
- drwav_uint8 sampleData[4096];
- drwav_uint32 bytesPerFrame;
-
- if (pBufferOut == NULL) {
- return drwav_read_pcm_frames(pWav, framesToRead, NULL);
- }
-
- bytesPerFrame = drwav_get_bytes_per_pcm_frame(pWav);
- if (bytesPerFrame == 0) {
- return 0;
- }
-
- totalFramesRead = 0;
-
- while (framesToRead > 0) {
- drwav_uint64 framesRead = drwav_read_pcm_frames(pWav, drwav_min(framesToRead, sizeof(sampleData)/bytesPerFrame), sampleData);
- if (framesRead == 0) {
- break;
- }
-
- drwav_alaw_to_s16(pBufferOut, sampleData, (size_t)(framesRead*pWav->channels));
-
- pBufferOut += framesRead*pWav->channels;
- framesToRead -= framesRead;
- totalFramesRead += framesRead;
- }
-
- return totalFramesRead;
-}
-
-static drwav_uint64 drwav_read_pcm_frames_s16__mulaw(drwav* pWav, drwav_uint64 framesToRead, drwav_int16* pBufferOut)
-{
- drwav_uint64 totalFramesRead;
- drwav_uint8 sampleData[4096];
- drwav_uint32 bytesPerFrame;
-
- if (pBufferOut == NULL) {
- return drwav_read_pcm_frames(pWav, framesToRead, NULL);
- }
-
- bytesPerFrame = drwav_get_bytes_per_pcm_frame(pWav);
- if (bytesPerFrame == 0) {
- return 0;
- }
-
- totalFramesRead = 0;
-
- while (framesToRead > 0) {
- drwav_uint64 framesRead = drwav_read_pcm_frames(pWav, drwav_min(framesToRead, sizeof(sampleData)/bytesPerFrame), sampleData);
- if (framesRead == 0) {
- break;
- }
-
- drwav_mulaw_to_s16(pBufferOut, sampleData, (size_t)(framesRead*pWav->channels));
-
- pBufferOut += framesRead*pWav->channels;
- framesToRead -= framesRead;
- totalFramesRead += framesRead;
- }
-
- return totalFramesRead;
-}
-
-DRWAV_API drwav_uint64 drwav_read_pcm_frames_s16(drwav* pWav, drwav_uint64 framesToRead, drwav_int16* pBufferOut)
-{
- if (pWav == NULL || framesToRead == 0) {
- return 0;
- }
-
- if (pBufferOut == NULL) {
- return drwav_read_pcm_frames(pWav, framesToRead, NULL);
- }
-
- /* Don't try to read more samples than can potentially fit in the output buffer. */
- if (framesToRead * pWav->channels * sizeof(drwav_int16) > DRWAV_SIZE_MAX) {
- framesToRead = DRWAV_SIZE_MAX / sizeof(drwav_int16) / pWav->channels;
- }
-
- if (pWav->translatedFormatTag == DR_WAVE_FORMAT_PCM) {
- return drwav_read_pcm_frames_s16__pcm(pWav, framesToRead, pBufferOut);
- }
-
- if (pWav->translatedFormatTag == DR_WAVE_FORMAT_IEEE_FLOAT) {
- return drwav_read_pcm_frames_s16__ieee(pWav, framesToRead, pBufferOut);
- }
-
- if (pWav->translatedFormatTag == DR_WAVE_FORMAT_ALAW) {
- return drwav_read_pcm_frames_s16__alaw(pWav, framesToRead, pBufferOut);
- }
-
- if (pWav->translatedFormatTag == DR_WAVE_FORMAT_MULAW) {
- return drwav_read_pcm_frames_s16__mulaw(pWav, framesToRead, pBufferOut);
- }
-
- if (pWav->translatedFormatTag == DR_WAVE_FORMAT_ADPCM) {
- return drwav_read_pcm_frames_s16__msadpcm(pWav, framesToRead, pBufferOut);
- }
-
- if (pWav->translatedFormatTag == DR_WAVE_FORMAT_DVI_ADPCM) {
- return drwav_read_pcm_frames_s16__ima(pWav, framesToRead, pBufferOut);
- }
-
- return 0;
-}
-
-DRWAV_API drwav_uint64 drwav_read_pcm_frames_s16le(drwav* pWav, drwav_uint64 framesToRead, drwav_int16* pBufferOut)
-{
- drwav_uint64 framesRead = drwav_read_pcm_frames_s16(pWav, framesToRead, pBufferOut);
- if (pBufferOut != NULL && drwav__is_little_endian() == DRWAV_FALSE) {
- drwav__bswap_samples_s16(pBufferOut, framesRead*pWav->channels);
- }
-
- return framesRead;
-}
-
-DRWAV_API drwav_uint64 drwav_read_pcm_frames_s16be(drwav* pWav, drwav_uint64 framesToRead, drwav_int16* pBufferOut)
-{
- drwav_uint64 framesRead = drwav_read_pcm_frames_s16(pWav, framesToRead, pBufferOut);
- if (pBufferOut != NULL && drwav__is_little_endian() == DRWAV_TRUE) {
- drwav__bswap_samples_s16(pBufferOut, framesRead*pWav->channels);
- }
-
- return framesRead;
-}
-
-
-DRWAV_API void drwav_u8_to_s16(drwav_int16* pOut, const drwav_uint8* pIn, size_t sampleCount)
-{
- int r;
- size_t i;
- for (i = 0; i < sampleCount; ++i) {
- int x = pIn[i];
- r = x << 8;
- r = r - 32768;
- pOut[i] = (short)r;
- }
-}
-
-DRWAV_API void drwav_s24_to_s16(drwav_int16* pOut, const drwav_uint8* pIn, size_t sampleCount)
-{
- int r;
- size_t i;
- for (i = 0; i < sampleCount; ++i) {
- int x = ((int)(((unsigned int)(((const drwav_uint8*)pIn)[i*3+0]) << 8) | ((unsigned int)(((const drwav_uint8*)pIn)[i*3+1]) << 16) | ((unsigned int)(((const drwav_uint8*)pIn)[i*3+2])) << 24)) >> 8;
- r = x >> 8;
- pOut[i] = (short)r;
- }
-}
-
-DRWAV_API void drwav_s32_to_s16(drwav_int16* pOut, const drwav_int32* pIn, size_t sampleCount)
-{
- int r;
- size_t i;
- for (i = 0; i < sampleCount; ++i) {
- int x = pIn[i];
- r = x >> 16;
- pOut[i] = (short)r;
- }
-}
-
-DRWAV_API void drwav_f32_to_s16(drwav_int16* pOut, const float* pIn, size_t sampleCount)
-{
- int r;
- size_t i;
- for (i = 0; i < sampleCount; ++i) {
- float x = pIn[i];
- float c;
- c = ((x < -1) ? -1 : ((x > 1) ? 1 : x));
- c = c + 1;
- r = (int)(c * 32767.5f);
- r = r - 32768;
- pOut[i] = (short)r;
- }
-}
-
-DRWAV_API void drwav_f64_to_s16(drwav_int16* pOut, const double* pIn, size_t sampleCount)
-{
- int r;
- size_t i;
- for (i = 0; i < sampleCount; ++i) {
- double x = pIn[i];
- double c;
- c = ((x < -1) ? -1 : ((x > 1) ? 1 : x));
- c = c + 1;
- r = (int)(c * 32767.5);
- r = r - 32768;
- pOut[i] = (short)r;
- }
-}
-
-DRWAV_API void drwav_alaw_to_s16(drwav_int16* pOut, const drwav_uint8* pIn, size_t sampleCount)
-{
- size_t i;
- for (i = 0; i < sampleCount; ++i) {
- pOut[i] = drwav__alaw_to_s16(pIn[i]);
- }
-}
-
-DRWAV_API void drwav_mulaw_to_s16(drwav_int16* pOut, const drwav_uint8* pIn, size_t sampleCount)
-{
- size_t i;
- for (i = 0; i < sampleCount; ++i) {
- pOut[i] = drwav__mulaw_to_s16(pIn[i]);
- }
-}
-
-
-
-static void drwav__pcm_to_f32(float* pOut, const drwav_uint8* pIn, size_t sampleCount, unsigned int bytesPerSample)
-{
- unsigned int i;
-
- /* Special case for 8-bit sample data because it's treated as unsigned. */
- if (bytesPerSample == 1) {
- drwav_u8_to_f32(pOut, pIn, sampleCount);
- return;
- }
-
- /* Slightly more optimal implementation for common formats. */
- if (bytesPerSample == 2) {
- drwav_s16_to_f32(pOut, (const drwav_int16*)pIn, sampleCount);
- return;
- }
- if (bytesPerSample == 3) {
- drwav_s24_to_f32(pOut, pIn, sampleCount);
- return;
- }
- if (bytesPerSample == 4) {
- drwav_s32_to_f32(pOut, (const drwav_int32*)pIn, sampleCount);
- return;
- }
-
-
- /* Anything more than 64 bits per sample is not supported. */
- if (bytesPerSample > 8) {
- DRWAV_ZERO_MEMORY(pOut, sampleCount * sizeof(*pOut));
- return;
- }
-
-
- /* Generic, slow converter. */
- for (i = 0; i < sampleCount; ++i) {
- drwav_uint64 sample = 0;
- unsigned int shift = (8 - bytesPerSample) * 8;
-
- unsigned int j;
- for (j = 0; j < bytesPerSample; j += 1) {
- DRWAV_ASSERT(j < 8);
- sample |= (drwav_uint64)(pIn[j]) << shift;
- shift += 8;
- }
-
- pIn += j;
- *pOut++ = (float)((drwav_int64)sample / 9223372036854775807.0);
- }
-}
-
-static void drwav__ieee_to_f32(float* pOut, const drwav_uint8* pIn, size_t sampleCount, unsigned int bytesPerSample)
-{
- if (bytesPerSample == 4) {
- unsigned int i;
- for (i = 0; i < sampleCount; ++i) {
- *pOut++ = ((const float*)pIn)[i];
- }
- return;
- } else if (bytesPerSample == 8) {
- drwav_f64_to_f32(pOut, (const double*)pIn, sampleCount);
- return;
- } else {
- /* Only supporting 32- and 64-bit float. Output silence in all other cases. Contributions welcome for 16-bit float. */
- DRWAV_ZERO_MEMORY(pOut, sampleCount * sizeof(*pOut));
- return;
- }
-}
-
-
-static drwav_uint64 drwav_read_pcm_frames_f32__pcm(drwav* pWav, drwav_uint64 framesToRead, float* pBufferOut)
-{
- drwav_uint64 totalFramesRead;
- drwav_uint8 sampleData[4096];
-
- drwav_uint32 bytesPerFrame = drwav_get_bytes_per_pcm_frame(pWav);
- if (bytesPerFrame == 0) {
- return 0;
- }
-
- totalFramesRead = 0;
-
- while (framesToRead > 0) {
- drwav_uint64 framesRead = drwav_read_pcm_frames(pWav, drwav_min(framesToRead, sizeof(sampleData)/bytesPerFrame), sampleData);
- if (framesRead == 0) {
- break;
- }
-
- drwav__pcm_to_f32(pBufferOut, sampleData, (size_t)framesRead*pWav->channels, bytesPerFrame/pWav->channels);
-
- pBufferOut += framesRead*pWav->channels;
- framesToRead -= framesRead;
- totalFramesRead += framesRead;
- }
-
- return totalFramesRead;
-}
-
-static drwav_uint64 drwav_read_pcm_frames_f32__msadpcm(drwav* pWav, drwav_uint64 framesToRead, float* pBufferOut)
-{
- /*
- We're just going to borrow the implementation from the drwav_read_s16() since ADPCM is a little bit more complicated than other formats and I don't
- want to duplicate that code.
- */
- drwav_uint64 totalFramesRead = 0;
- drwav_int16 samples16[2048];
- while (framesToRead > 0) {
- drwav_uint64 framesRead = drwav_read_pcm_frames_s16(pWav, drwav_min(framesToRead, drwav_countof(samples16)/pWav->channels), samples16);
- if (framesRead == 0) {
- break;
- }
-
- drwav_s16_to_f32(pBufferOut, samples16, (size_t)(framesRead*pWav->channels)); /* <-- Safe cast because we're clamping to 2048. */
-
- pBufferOut += framesRead*pWav->channels;
- framesToRead -= framesRead;
- totalFramesRead += framesRead;
- }
-
- return totalFramesRead;
-}
-
-static drwav_uint64 drwav_read_pcm_frames_f32__ima(drwav* pWav, drwav_uint64 framesToRead, float* pBufferOut)
-{
- /*
- We're just going to borrow the implementation from the drwav_read_s16() since IMA-ADPCM is a little bit more complicated than other formats and I don't
- want to duplicate that code.
- */
- drwav_uint64 totalFramesRead = 0;
- drwav_int16 samples16[2048];
- while (framesToRead > 0) {
- drwav_uint64 framesRead = drwav_read_pcm_frames_s16(pWav, drwav_min(framesToRead, drwav_countof(samples16)/pWav->channels), samples16);
- if (framesRead == 0) {
- break;
- }
-
- drwav_s16_to_f32(pBufferOut, samples16, (size_t)(framesRead*pWav->channels)); /* <-- Safe cast because we're clamping to 2048. */
-
- pBufferOut += framesRead*pWav->channels;
- framesToRead -= framesRead;
- totalFramesRead += framesRead;
- }
-
- return totalFramesRead;
-}
-
-static drwav_uint64 drwav_read_pcm_frames_f32__ieee(drwav* pWav, drwav_uint64 framesToRead, float* pBufferOut)
-{
- drwav_uint64 totalFramesRead;
- drwav_uint8 sampleData[4096];
- drwav_uint32 bytesPerFrame;
-
- /* Fast path. */
- if (pWav->translatedFormatTag == DR_WAVE_FORMAT_IEEE_FLOAT && pWav->bitsPerSample == 32) {
- return drwav_read_pcm_frames(pWav, framesToRead, pBufferOut);
- }
-
- bytesPerFrame = drwav_get_bytes_per_pcm_frame(pWav);
- if (bytesPerFrame == 0) {
- return 0;
- }
-
- totalFramesRead = 0;
-
- while (framesToRead > 0) {
- drwav_uint64 framesRead = drwav_read_pcm_frames(pWav, drwav_min(framesToRead, sizeof(sampleData)/bytesPerFrame), sampleData);
- if (framesRead == 0) {
- break;
- }
-
- drwav__ieee_to_f32(pBufferOut, sampleData, (size_t)(framesRead*pWav->channels), bytesPerFrame/pWav->channels);
-
- pBufferOut += framesRead*pWav->channels;
- framesToRead -= framesRead;
- totalFramesRead += framesRead;
- }
-
- return totalFramesRead;
-}
-
-static drwav_uint64 drwav_read_pcm_frames_f32__alaw(drwav* pWav, drwav_uint64 framesToRead, float* pBufferOut)
-{
- drwav_uint64 totalFramesRead;
- drwav_uint8 sampleData[4096];
- drwav_uint32 bytesPerFrame = drwav_get_bytes_per_pcm_frame(pWav);
- if (bytesPerFrame == 0) {
- return 0;
- }
-
- totalFramesRead = 0;
-
- while (framesToRead > 0) {
- drwav_uint64 framesRead = drwav_read_pcm_frames(pWav, drwav_min(framesToRead, sizeof(sampleData)/bytesPerFrame), sampleData);
- if (framesRead == 0) {
- break;
- }
-
- drwav_alaw_to_f32(pBufferOut, sampleData, (size_t)(framesRead*pWav->channels));
-
- pBufferOut += framesRead*pWav->channels;
- framesToRead -= framesRead;
- totalFramesRead += framesRead;
- }
-
- return totalFramesRead;
-}
-
-static drwav_uint64 drwav_read_pcm_frames_f32__mulaw(drwav* pWav, drwav_uint64 framesToRead, float* pBufferOut)
-{
- drwav_uint64 totalFramesRead;
- drwav_uint8 sampleData[4096];
-
- drwav_uint32 bytesPerFrame = drwav_get_bytes_per_pcm_frame(pWav);
- if (bytesPerFrame == 0) {
- return 0;
- }
-
- totalFramesRead = 0;
-
- while (framesToRead > 0) {
- drwav_uint64 framesRead = drwav_read_pcm_frames(pWav, drwav_min(framesToRead, sizeof(sampleData)/bytesPerFrame), sampleData);
- if (framesRead == 0) {
- break;
- }
-
- drwav_mulaw_to_f32(pBufferOut, sampleData, (size_t)(framesRead*pWav->channels));
-
- pBufferOut += framesRead*pWav->channels;
- framesToRead -= framesRead;
- totalFramesRead += framesRead;
- }
-
- return totalFramesRead;
-}
-
-DRWAV_API drwav_uint64 drwav_read_pcm_frames_f32(drwav* pWav, drwav_uint64 framesToRead, float* pBufferOut)
-{
- if (pWav == NULL || framesToRead == 0) {
- return 0;
- }
-
- if (pBufferOut == NULL) {
- return drwav_read_pcm_frames(pWav, framesToRead, NULL);
- }
-
- /* Don't try to read more samples than can potentially fit in the output buffer. */
- if (framesToRead * pWav->channels * sizeof(float) > DRWAV_SIZE_MAX) {
- framesToRead = DRWAV_SIZE_MAX / sizeof(float) / pWav->channels;
- }
-
- if (pWav->translatedFormatTag == DR_WAVE_FORMAT_PCM) {
- return drwav_read_pcm_frames_f32__pcm(pWav, framesToRead, pBufferOut);
- }
-
- if (pWav->translatedFormatTag == DR_WAVE_FORMAT_ADPCM) {
- return drwav_read_pcm_frames_f32__msadpcm(pWav, framesToRead, pBufferOut);
- }
-
- if (pWav->translatedFormatTag == DR_WAVE_FORMAT_IEEE_FLOAT) {
- return drwav_read_pcm_frames_f32__ieee(pWav, framesToRead, pBufferOut);
- }
-
- if (pWav->translatedFormatTag == DR_WAVE_FORMAT_ALAW) {
- return drwav_read_pcm_frames_f32__alaw(pWav, framesToRead, pBufferOut);
- }
-
- if (pWav->translatedFormatTag == DR_WAVE_FORMAT_MULAW) {
- return drwav_read_pcm_frames_f32__mulaw(pWav, framesToRead, pBufferOut);
- }
-
- if (pWav->translatedFormatTag == DR_WAVE_FORMAT_DVI_ADPCM) {
- return drwav_read_pcm_frames_f32__ima(pWav, framesToRead, pBufferOut);
- }
-
- return 0;
-}
-
-DRWAV_API drwav_uint64 drwav_read_pcm_frames_f32le(drwav* pWav, drwav_uint64 framesToRead, float* pBufferOut)
-{
- drwav_uint64 framesRead = drwav_read_pcm_frames_f32(pWav, framesToRead, pBufferOut);
- if (pBufferOut != NULL && drwav__is_little_endian() == DRWAV_FALSE) {
- drwav__bswap_samples_f32(pBufferOut, framesRead*pWav->channels);
- }
-
- return framesRead;
-}
-
-DRWAV_API drwav_uint64 drwav_read_pcm_frames_f32be(drwav* pWav, drwav_uint64 framesToRead, float* pBufferOut)
-{
- drwav_uint64 framesRead = drwav_read_pcm_frames_f32(pWav, framesToRead, pBufferOut);
- if (pBufferOut != NULL && drwav__is_little_endian() == DRWAV_TRUE) {
- drwav__bswap_samples_f32(pBufferOut, framesRead*pWav->channels);
- }
-
- return framesRead;
-}
-
-
-DRWAV_API void drwav_u8_to_f32(float* pOut, const drwav_uint8* pIn, size_t sampleCount)
-{
- size_t i;
-
- if (pOut == NULL || pIn == NULL) {
- return;
- }
-
-#ifdef DR_WAV_LIBSNDFILE_COMPAT
- /*
- It appears libsndfile uses slightly different logic for the u8 -> f32 conversion to dr_wav, which in my opinion is incorrect. It appears
- libsndfile performs the conversion something like "f32 = (u8 / 256) * 2 - 1", however I think it should be "f32 = (u8 / 255) * 2 - 1" (note
- the divisor of 256 vs 255). I use libsndfile as a benchmark for testing, so I'm therefore leaving this block here just for my automated
- correctness testing. This is disabled by default.
- */
- for (i = 0; i < sampleCount; ++i) {
- *pOut++ = (pIn[i] / 256.0f) * 2 - 1;
- }
-#else
- for (i = 0; i < sampleCount; ++i) {
- float x = pIn[i];
- x = x * 0.00784313725490196078f; /* 0..255 to 0..2 */
- x = x - 1; /* 0..2 to -1..1 */
-
- *pOut++ = x;
- }
-#endif
-}
-
-DRWAV_API void drwav_s16_to_f32(float* pOut, const drwav_int16* pIn, size_t sampleCount)
-{
- size_t i;
-
- if (pOut == NULL || pIn == NULL) {
- return;
- }
-
- for (i = 0; i < sampleCount; ++i) {
- *pOut++ = pIn[i] * 0.000030517578125f;
- }
-}
-
-DRWAV_API void drwav_s24_to_f32(float* pOut, const drwav_uint8* pIn, size_t sampleCount)
-{
- size_t i;
-
- if (pOut == NULL || pIn == NULL) {
- return;
- }
-
- for (i = 0; i < sampleCount; ++i) {
- double x;
- drwav_uint32 a = ((drwav_uint32)(pIn[i*3+0]) << 8);
- drwav_uint32 b = ((drwav_uint32)(pIn[i*3+1]) << 16);
- drwav_uint32 c = ((drwav_uint32)(pIn[i*3+2]) << 24);
-
- x = (double)((drwav_int32)(a | b | c) >> 8);
- *pOut++ = (float)(x * 0.00000011920928955078125);
- }
-}
-
-DRWAV_API void drwav_s32_to_f32(float* pOut, const drwav_int32* pIn, size_t sampleCount)
-{
- size_t i;
- if (pOut == NULL || pIn == NULL) {
- return;
- }
-
- for (i = 0; i < sampleCount; ++i) {
- *pOut++ = (float)(pIn[i] / 2147483648.0);
- }
-}
-
-DRWAV_API void drwav_f64_to_f32(float* pOut, const double* pIn, size_t sampleCount)
-{
- size_t i;
-
- if (pOut == NULL || pIn == NULL) {
- return;
- }
-
- for (i = 0; i < sampleCount; ++i) {
- *pOut++ = (float)pIn[i];
- }
-}
-
-DRWAV_API void drwav_alaw_to_f32(float* pOut, const drwav_uint8* pIn, size_t sampleCount)
-{
- size_t i;
-
- if (pOut == NULL || pIn == NULL) {
- return;
- }
-
- for (i = 0; i < sampleCount; ++i) {
- *pOut++ = drwav__alaw_to_s16(pIn[i]) / 32768.0f;
- }
-}
-
-DRWAV_API void drwav_mulaw_to_f32(float* pOut, const drwav_uint8* pIn, size_t sampleCount)
-{
- size_t i;
-
- if (pOut == NULL || pIn == NULL) {
- return;
- }
-
- for (i = 0; i < sampleCount; ++i) {
- *pOut++ = drwav__mulaw_to_s16(pIn[i]) / 32768.0f;
- }
-}
-
-
-
-static void drwav__pcm_to_s32(drwav_int32* pOut, const drwav_uint8* pIn, size_t totalSampleCount, unsigned int bytesPerSample)
-{
- unsigned int i;
-
- /* Special case for 8-bit sample data because it's treated as unsigned. */
- if (bytesPerSample == 1) {
- drwav_u8_to_s32(pOut, pIn, totalSampleCount);
- return;
- }
-
- /* Slightly more optimal implementation for common formats. */
- if (bytesPerSample == 2) {
- drwav_s16_to_s32(pOut, (const drwav_int16*)pIn, totalSampleCount);
- return;
- }
- if (bytesPerSample == 3) {
- drwav_s24_to_s32(pOut, pIn, totalSampleCount);
- return;
- }
- if (bytesPerSample == 4) {
- for (i = 0; i < totalSampleCount; ++i) {
- *pOut++ = ((const drwav_int32*)pIn)[i];
- }
- return;
- }
-
-
- /* Anything more than 64 bits per sample is not supported. */
- if (bytesPerSample > 8) {
- DRWAV_ZERO_MEMORY(pOut, totalSampleCount * sizeof(*pOut));
- return;
- }
-
-
- /* Generic, slow converter. */
- for (i = 0; i < totalSampleCount; ++i) {
- drwav_uint64 sample = 0;
- unsigned int shift = (8 - bytesPerSample) * 8;
-
- unsigned int j;
- for (j = 0; j < bytesPerSample; j += 1) {
- DRWAV_ASSERT(j < 8);
- sample |= (drwav_uint64)(pIn[j]) << shift;
- shift += 8;
- }
-
- pIn += j;
- *pOut++ = (drwav_int32)((drwav_int64)sample >> 32);
- }
-}
-
-static void drwav__ieee_to_s32(drwav_int32* pOut, const drwav_uint8* pIn, size_t totalSampleCount, unsigned int bytesPerSample)
-{
- if (bytesPerSample == 4) {
- drwav_f32_to_s32(pOut, (const float*)pIn, totalSampleCount);
- return;
- } else if (bytesPerSample == 8) {
- drwav_f64_to_s32(pOut, (const double*)pIn, totalSampleCount);
- return;
- } else {
- /* Only supporting 32- and 64-bit float. Output silence in all other cases. Contributions welcome for 16-bit float. */
- DRWAV_ZERO_MEMORY(pOut, totalSampleCount * sizeof(*pOut));
- return;
- }
-}
-
-
-static drwav_uint64 drwav_read_pcm_frames_s32__pcm(drwav* pWav, drwav_uint64 framesToRead, drwav_int32* pBufferOut)
-{
- drwav_uint64 totalFramesRead;
- drwav_uint8 sampleData[4096];
- drwav_uint32 bytesPerFrame;
-
- /* Fast path. */
- if (pWav->translatedFormatTag == DR_WAVE_FORMAT_PCM && pWav->bitsPerSample == 32) {
- return drwav_read_pcm_frames(pWav, framesToRead, pBufferOut);
- }
-
- bytesPerFrame = drwav_get_bytes_per_pcm_frame(pWav);
- if (bytesPerFrame == 0) {
- return 0;
- }
-
- totalFramesRead = 0;
-
- while (framesToRead > 0) {
- drwav_uint64 framesRead = drwav_read_pcm_frames(pWav, drwav_min(framesToRead, sizeof(sampleData)/bytesPerFrame), sampleData);
- if (framesRead == 0) {
- break;
- }
-
- drwav__pcm_to_s32(pBufferOut, sampleData, (size_t)(framesRead*pWav->channels), bytesPerFrame/pWav->channels);
-
- pBufferOut += framesRead*pWav->channels;
- framesToRead -= framesRead;
- totalFramesRead += framesRead;
- }
-
- return totalFramesRead;
-}
-
-static drwav_uint64 drwav_read_pcm_frames_s32__msadpcm(drwav* pWav, drwav_uint64 framesToRead, drwav_int32* pBufferOut)
-{
- /*
- We're just going to borrow the implementation from the drwav_read_s16() since ADPCM is a little bit more complicated than other formats and I don't
- want to duplicate that code.
- */
- drwav_uint64 totalFramesRead = 0;
- drwav_int16 samples16[2048];
- while (framesToRead > 0) {
- drwav_uint64 framesRead = drwav_read_pcm_frames_s16(pWav, drwav_min(framesToRead, drwav_countof(samples16)/pWav->channels), samples16);
- if (framesRead == 0) {
- break;
- }
-
- drwav_s16_to_s32(pBufferOut, samples16, (size_t)(framesRead*pWav->channels)); /* <-- Safe cast because we're clamping to 2048. */
-
- pBufferOut += framesRead*pWav->channels;
- framesToRead -= framesRead;
- totalFramesRead += framesRead;
- }
-
- return totalFramesRead;
-}
-
-static drwav_uint64 drwav_read_pcm_frames_s32__ima(drwav* pWav, drwav_uint64 framesToRead, drwav_int32* pBufferOut)
-{
- /*
- We're just going to borrow the implementation from the drwav_read_s16() since IMA-ADPCM is a little bit more complicated than other formats and I don't
- want to duplicate that code.
- */
- drwav_uint64 totalFramesRead = 0;
- drwav_int16 samples16[2048];
- while (framesToRead > 0) {
- drwav_uint64 framesRead = drwav_read_pcm_frames_s16(pWav, drwav_min(framesToRead, drwav_countof(samples16)/pWav->channels), samples16);
- if (framesRead == 0) {
- break;
- }
-
- drwav_s16_to_s32(pBufferOut, samples16, (size_t)(framesRead*pWav->channels)); /* <-- Safe cast because we're clamping to 2048. */
-
- pBufferOut += framesRead*pWav->channels;
- framesToRead -= framesRead;
- totalFramesRead += framesRead;
- }
-
- return totalFramesRead;
-}
-
-static drwav_uint64 drwav_read_pcm_frames_s32__ieee(drwav* pWav, drwav_uint64 framesToRead, drwav_int32* pBufferOut)
-{
- drwav_uint64 totalFramesRead;
- drwav_uint8 sampleData[4096];
-
- drwav_uint32 bytesPerFrame = drwav_get_bytes_per_pcm_frame(pWav);
- if (bytesPerFrame == 0) {
- return 0;
- }
-
- totalFramesRead = 0;
-
- while (framesToRead > 0) {
- drwav_uint64 framesRead = drwav_read_pcm_frames(pWav, drwav_min(framesToRead, sizeof(sampleData)/bytesPerFrame), sampleData);
- if (framesRead == 0) {
- break;
- }
-
- drwav__ieee_to_s32(pBufferOut, sampleData, (size_t)(framesRead*pWav->channels), bytesPerFrame/pWav->channels);
-
- pBufferOut += framesRead*pWav->channels;
- framesToRead -= framesRead;
- totalFramesRead += framesRead;
- }
-
- return totalFramesRead;
-}
-
-static drwav_uint64 drwav_read_pcm_frames_s32__alaw(drwav* pWav, drwav_uint64 framesToRead, drwav_int32* pBufferOut)
-{
- drwav_uint64 totalFramesRead;
- drwav_uint8 sampleData[4096];
-
- drwav_uint32 bytesPerFrame = drwav_get_bytes_per_pcm_frame(pWav);
- if (bytesPerFrame == 0) {
- return 0;
- }
-
- totalFramesRead = 0;
-
- while (framesToRead > 0) {
- drwav_uint64 framesRead = drwav_read_pcm_frames(pWav, drwav_min(framesToRead, sizeof(sampleData)/bytesPerFrame), sampleData);
- if (framesRead == 0) {
- break;
- }
-
- drwav_alaw_to_s32(pBufferOut, sampleData, (size_t)(framesRead*pWav->channels));
-
- pBufferOut += framesRead*pWav->channels;
- framesToRead -= framesRead;
- totalFramesRead += framesRead;
- }
-
- return totalFramesRead;
-}
-
-static drwav_uint64 drwav_read_pcm_frames_s32__mulaw(drwav* pWav, drwav_uint64 framesToRead, drwav_int32* pBufferOut)
-{
- drwav_uint64 totalFramesRead;
- drwav_uint8 sampleData[4096];
-
- drwav_uint32 bytesPerFrame = drwav_get_bytes_per_pcm_frame(pWav);
- if (bytesPerFrame == 0) {
- return 0;
- }
-
- totalFramesRead = 0;
-
- while (framesToRead > 0) {
- drwav_uint64 framesRead = drwav_read_pcm_frames(pWav, drwav_min(framesToRead, sizeof(sampleData)/bytesPerFrame), sampleData);
- if (framesRead == 0) {
- break;
- }
-
- drwav_mulaw_to_s32(pBufferOut, sampleData, (size_t)(framesRead*pWav->channels));
-
- pBufferOut += framesRead*pWav->channels;
- framesToRead -= framesRead;
- totalFramesRead += framesRead;
- }
-
- return totalFramesRead;
-}
-
-DRWAV_API drwav_uint64 drwav_read_pcm_frames_s32(drwav* pWav, drwav_uint64 framesToRead, drwav_int32* pBufferOut)
-{
- if (pWav == NULL || framesToRead == 0) {
- return 0;
- }
-
- if (pBufferOut == NULL) {
- return drwav_read_pcm_frames(pWav, framesToRead, NULL);
- }
-
- /* Don't try to read more samples than can potentially fit in the output buffer. */
- if (framesToRead * pWav->channels * sizeof(drwav_int32) > DRWAV_SIZE_MAX) {
- framesToRead = DRWAV_SIZE_MAX / sizeof(drwav_int32) / pWav->channels;
- }
-
- if (pWav->translatedFormatTag == DR_WAVE_FORMAT_PCM) {
- return drwav_read_pcm_frames_s32__pcm(pWav, framesToRead, pBufferOut);
- }
-
- if (pWav->translatedFormatTag == DR_WAVE_FORMAT_ADPCM) {
- return drwav_read_pcm_frames_s32__msadpcm(pWav, framesToRead, pBufferOut);
- }
-
- if (pWav->translatedFormatTag == DR_WAVE_FORMAT_IEEE_FLOAT) {
- return drwav_read_pcm_frames_s32__ieee(pWav, framesToRead, pBufferOut);
- }
-
- if (pWav->translatedFormatTag == DR_WAVE_FORMAT_ALAW) {
- return drwav_read_pcm_frames_s32__alaw(pWav, framesToRead, pBufferOut);
- }
-
- if (pWav->translatedFormatTag == DR_WAVE_FORMAT_MULAW) {
- return drwav_read_pcm_frames_s32__mulaw(pWav, framesToRead, pBufferOut);
- }
-
- if (pWav->translatedFormatTag == DR_WAVE_FORMAT_DVI_ADPCM) {
- return drwav_read_pcm_frames_s32__ima(pWav, framesToRead, pBufferOut);
- }
-
- return 0;
-}
-
-DRWAV_API drwav_uint64 drwav_read_pcm_frames_s32le(drwav* pWav, drwav_uint64 framesToRead, drwav_int32* pBufferOut)
-{
- drwav_uint64 framesRead = drwav_read_pcm_frames_s32(pWav, framesToRead, pBufferOut);
- if (pBufferOut != NULL && drwav__is_little_endian() == DRWAV_FALSE) {
- drwav__bswap_samples_s32(pBufferOut, framesRead*pWav->channels);
- }
-
- return framesRead;
-}
-
-DRWAV_API drwav_uint64 drwav_read_pcm_frames_s32be(drwav* pWav, drwav_uint64 framesToRead, drwav_int32* pBufferOut)
-{
- drwav_uint64 framesRead = drwav_read_pcm_frames_s32(pWav, framesToRead, pBufferOut);
- if (pBufferOut != NULL && drwav__is_little_endian() == DRWAV_TRUE) {
- drwav__bswap_samples_s32(pBufferOut, framesRead*pWav->channels);
- }
-
- return framesRead;
-}
-
-
-DRWAV_API void drwav_u8_to_s32(drwav_int32* pOut, const drwav_uint8* pIn, size_t sampleCount)
-{
- size_t i;
-
- if (pOut == NULL || pIn == NULL) {
- return;
- }
-
- for (i = 0; i < sampleCount; ++i) {
- *pOut++ = ((int)pIn[i] - 128) << 24;
- }
-}
-
-DRWAV_API void drwav_s16_to_s32(drwav_int32* pOut, const drwav_int16* pIn, size_t sampleCount)
-{
- size_t i;
-
- if (pOut == NULL || pIn == NULL) {
- return;
- }
-
- for (i = 0; i < sampleCount; ++i) {
- *pOut++ = pIn[i] << 16;
- }
-}
-
-DRWAV_API void drwav_s24_to_s32(drwav_int32* pOut, const drwav_uint8* pIn, size_t sampleCount)
-{
- size_t i;
-
- if (pOut == NULL || pIn == NULL) {
- return;
- }
-
- for (i = 0; i < sampleCount; ++i) {
- unsigned int s0 = pIn[i*3 + 0];
- unsigned int s1 = pIn[i*3 + 1];
- unsigned int s2 = pIn[i*3 + 2];
-
- drwav_int32 sample32 = (drwav_int32)((s0 << 8) | (s1 << 16) | (s2 << 24));
- *pOut++ = sample32;
- }
-}
-
-DRWAV_API void drwav_f32_to_s32(drwav_int32* pOut, const float* pIn, size_t sampleCount)
-{
- size_t i;
-
- if (pOut == NULL || pIn == NULL) {
- return;
- }
-
- for (i = 0; i < sampleCount; ++i) {
- *pOut++ = (drwav_int32)(2147483648.0 * pIn[i]);
- }
-}
-
-DRWAV_API void drwav_f64_to_s32(drwav_int32* pOut, const double* pIn, size_t sampleCount)
-{
- size_t i;
-
- if (pOut == NULL || pIn == NULL) {
- return;
- }
-
- for (i = 0; i < sampleCount; ++i) {
- *pOut++ = (drwav_int32)(2147483648.0 * pIn[i]);
- }
-}
-
-DRWAV_API void drwav_alaw_to_s32(drwav_int32* pOut, const drwav_uint8* pIn, size_t sampleCount)
-{
- size_t i;
-
- if (pOut == NULL || pIn == NULL) {
- return;
- }
-
- for (i = 0; i < sampleCount; ++i) {
- *pOut++ = ((drwav_int32)drwav__alaw_to_s16(pIn[i])) << 16;
- }
-}
-
-DRWAV_API void drwav_mulaw_to_s32(drwav_int32* pOut, const drwav_uint8* pIn, size_t sampleCount)
-{
- size_t i;
-
- if (pOut == NULL || pIn == NULL) {
- return;
- }
-
- for (i= 0; i < sampleCount; ++i) {
- *pOut++ = ((drwav_int32)drwav__mulaw_to_s16(pIn[i])) << 16;
- }
-}
-
-
-
-static drwav_int16* drwav__read_pcm_frames_and_close_s16(drwav* pWav, unsigned int* channels, unsigned int* sampleRate, drwav_uint64* totalFrameCount)
-{
- drwav_uint64 sampleDataSize;
- drwav_int16* pSampleData;
- drwav_uint64 framesRead;
-
- DRWAV_ASSERT(pWav != NULL);
-
- sampleDataSize = pWav->totalPCMFrameCount * pWav->channels * sizeof(drwav_int16);
- if (sampleDataSize > DRWAV_SIZE_MAX) {
- drwav_uninit(pWav);
- return NULL; /* File's too big. */
- }
-
- pSampleData = (drwav_int16*)drwav__malloc_from_callbacks((size_t)sampleDataSize, &pWav->allocationCallbacks); /* <-- Safe cast due to the check above. */
- if (pSampleData == NULL) {
- drwav_uninit(pWav);
- return NULL; /* Failed to allocate memory. */
- }
-
- framesRead = drwav_read_pcm_frames_s16(pWav, (size_t)pWav->totalPCMFrameCount, pSampleData);
- if (framesRead != pWav->totalPCMFrameCount) {
- drwav__free_from_callbacks(pSampleData, &pWav->allocationCallbacks);
- drwav_uninit(pWav);
- return NULL; /* There was an error reading the samples. */
- }
-
- drwav_uninit(pWav);
-
- if (sampleRate) {
- *sampleRate = pWav->sampleRate;
- }
- if (channels) {
- *channels = pWav->channels;
- }
- if (totalFrameCount) {
- *totalFrameCount = pWav->totalPCMFrameCount;
- }
-
- return pSampleData;
-}
-
-static float* drwav__read_pcm_frames_and_close_f32(drwav* pWav, unsigned int* channels, unsigned int* sampleRate, drwav_uint64* totalFrameCount)
-{
- drwav_uint64 sampleDataSize;
- float* pSampleData;
- drwav_uint64 framesRead;
-
- DRWAV_ASSERT(pWav != NULL);
-
- sampleDataSize = pWav->totalPCMFrameCount * pWav->channels * sizeof(float);
- if (sampleDataSize > DRWAV_SIZE_MAX) {
- drwav_uninit(pWav);
- return NULL; /* File's too big. */
- }
-
- pSampleData = (float*)drwav__malloc_from_callbacks((size_t)sampleDataSize, &pWav->allocationCallbacks); /* <-- Safe cast due to the check above. */
- if (pSampleData == NULL) {
- drwav_uninit(pWav);
- return NULL; /* Failed to allocate memory. */
- }
-
- framesRead = drwav_read_pcm_frames_f32(pWav, (size_t)pWav->totalPCMFrameCount, pSampleData);
- if (framesRead != pWav->totalPCMFrameCount) {
- drwav__free_from_callbacks(pSampleData, &pWav->allocationCallbacks);
- drwav_uninit(pWav);
- return NULL; /* There was an error reading the samples. */
- }
-
- drwav_uninit(pWav);
-
- if (sampleRate) {
- *sampleRate = pWav->sampleRate;
- }
- if (channels) {
- *channels = pWav->channels;
- }
- if (totalFrameCount) {
- *totalFrameCount = pWav->totalPCMFrameCount;
- }
-
- return pSampleData;
-}
-
-static drwav_int32* drwav__read_pcm_frames_and_close_s32(drwav* pWav, unsigned int* channels, unsigned int* sampleRate, drwav_uint64* totalFrameCount)
-{
- drwav_uint64 sampleDataSize;
- drwav_int32* pSampleData;
- drwav_uint64 framesRead;
-
- DRWAV_ASSERT(pWav != NULL);
-
- sampleDataSize = pWav->totalPCMFrameCount * pWav->channels * sizeof(drwav_int32);
- if (sampleDataSize > DRWAV_SIZE_MAX) {
- drwav_uninit(pWav);
- return NULL; /* File's too big. */
- }
-
- pSampleData = (drwav_int32*)drwav__malloc_from_callbacks((size_t)sampleDataSize, &pWav->allocationCallbacks); /* <-- Safe cast due to the check above. */
- if (pSampleData == NULL) {
- drwav_uninit(pWav);
- return NULL; /* Failed to allocate memory. */
- }
-
- framesRead = drwav_read_pcm_frames_s32(pWav, (size_t)pWav->totalPCMFrameCount, pSampleData);
- if (framesRead != pWav->totalPCMFrameCount) {
- drwav__free_from_callbacks(pSampleData, &pWav->allocationCallbacks);
- drwav_uninit(pWav);
- return NULL; /* There was an error reading the samples. */
- }
-
- drwav_uninit(pWav);
-
- if (sampleRate) {
- *sampleRate = pWav->sampleRate;
- }
- if (channels) {
- *channels = pWav->channels;
- }
- if (totalFrameCount) {
- *totalFrameCount = pWav->totalPCMFrameCount;
- }
-
- return pSampleData;
-}
-
-
-
-DRWAV_API drwav_int16* drwav_open_and_read_pcm_frames_s16(drwav_read_proc onRead, drwav_seek_proc onSeek, void* pUserData, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
- drwav wav;
-
- if (channelsOut) {
- *channelsOut = 0;
- }
- if (sampleRateOut) {
- *sampleRateOut = 0;
- }
- if (totalFrameCountOut) {
- *totalFrameCountOut = 0;
- }
-
- if (!drwav_init(&wav, onRead, onSeek, pUserData, pAllocationCallbacks)) {
- return NULL;
- }
-
- return drwav__read_pcm_frames_and_close_s16(&wav, channelsOut, sampleRateOut, totalFrameCountOut);
-}
-
-DRWAV_API float* drwav_open_and_read_pcm_frames_f32(drwav_read_proc onRead, drwav_seek_proc onSeek, void* pUserData, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
- drwav wav;
-
- if (channelsOut) {
- *channelsOut = 0;
- }
- if (sampleRateOut) {
- *sampleRateOut = 0;
- }
- if (totalFrameCountOut) {
- *totalFrameCountOut = 0;
- }
-
- if (!drwav_init(&wav, onRead, onSeek, pUserData, pAllocationCallbacks)) {
- return NULL;
- }
-
- return drwav__read_pcm_frames_and_close_f32(&wav, channelsOut, sampleRateOut, totalFrameCountOut);
-}
-
-DRWAV_API drwav_int32* drwav_open_and_read_pcm_frames_s32(drwav_read_proc onRead, drwav_seek_proc onSeek, void* pUserData, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
- drwav wav;
-
- if (channelsOut) {
- *channelsOut = 0;
- }
- if (sampleRateOut) {
- *sampleRateOut = 0;
- }
- if (totalFrameCountOut) {
- *totalFrameCountOut = 0;
- }
-
- if (!drwav_init(&wav, onRead, onSeek, pUserData, pAllocationCallbacks)) {
- return NULL;
- }
-
- return drwav__read_pcm_frames_and_close_s32(&wav, channelsOut, sampleRateOut, totalFrameCountOut);
-}
-
-#ifndef DR_WAV_NO_STDIO
-DRWAV_API drwav_int16* drwav_open_file_and_read_pcm_frames_s16(const char* filename, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
- drwav wav;
-
- if (channelsOut) {
- *channelsOut = 0;
- }
- if (sampleRateOut) {
- *sampleRateOut = 0;
- }
- if (totalFrameCountOut) {
- *totalFrameCountOut = 0;
- }
-
- if (!drwav_init_file(&wav, filename, pAllocationCallbacks)) {
- return NULL;
- }
-
- return drwav__read_pcm_frames_and_close_s16(&wav, channelsOut, sampleRateOut, totalFrameCountOut);
-}
-
-DRWAV_API float* drwav_open_file_and_read_pcm_frames_f32(const char* filename, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
- drwav wav;
-
- if (channelsOut) {
- *channelsOut = 0;
- }
- if (sampleRateOut) {
- *sampleRateOut = 0;
- }
- if (totalFrameCountOut) {
- *totalFrameCountOut = 0;
- }
-
- if (!drwav_init_file(&wav, filename, pAllocationCallbacks)) {
- return NULL;
- }
-
- return drwav__read_pcm_frames_and_close_f32(&wav, channelsOut, sampleRateOut, totalFrameCountOut);
-}
-
-DRWAV_API drwav_int32* drwav_open_file_and_read_pcm_frames_s32(const char* filename, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
- drwav wav;
-
- if (channelsOut) {
- *channelsOut = 0;
- }
- if (sampleRateOut) {
- *sampleRateOut = 0;
- }
- if (totalFrameCountOut) {
- *totalFrameCountOut = 0;
- }
-
- if (!drwav_init_file(&wav, filename, pAllocationCallbacks)) {
- return NULL;
- }
-
- return drwav__read_pcm_frames_and_close_s32(&wav, channelsOut, sampleRateOut, totalFrameCountOut);
-}
-
-
-DRWAV_API drwav_int16* drwav_open_file_and_read_pcm_frames_s16_w(const wchar_t* filename, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
- drwav wav;
-
- if (sampleRateOut) {
- *sampleRateOut = 0;
- }
- if (channelsOut) {
- *channelsOut = 0;
- }
- if (totalFrameCountOut) {
- *totalFrameCountOut = 0;
- }
-
- if (!drwav_init_file_w(&wav, filename, pAllocationCallbacks)) {
- return NULL;
- }
-
- return drwav__read_pcm_frames_and_close_s16(&wav, channelsOut, sampleRateOut, totalFrameCountOut);
-}
-
-DRWAV_API float* drwav_open_file_and_read_pcm_frames_f32_w(const wchar_t* filename, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
- drwav wav;
-
- if (sampleRateOut) {
- *sampleRateOut = 0;
- }
- if (channelsOut) {
- *channelsOut = 0;
- }
- if (totalFrameCountOut) {
- *totalFrameCountOut = 0;
- }
-
- if (!drwav_init_file_w(&wav, filename, pAllocationCallbacks)) {
- return NULL;
- }
-
- return drwav__read_pcm_frames_and_close_f32(&wav, channelsOut, sampleRateOut, totalFrameCountOut);
-}
-
-DRWAV_API drwav_int32* drwav_open_file_and_read_pcm_frames_s32_w(const wchar_t* filename, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
- drwav wav;
-
- if (sampleRateOut) {
- *sampleRateOut = 0;
- }
- if (channelsOut) {
- *channelsOut = 0;
- }
- if (totalFrameCountOut) {
- *totalFrameCountOut = 0;
- }
-
- if (!drwav_init_file_w(&wav, filename, pAllocationCallbacks)) {
- return NULL;
- }
-
- return drwav__read_pcm_frames_and_close_s32(&wav, channelsOut, sampleRateOut, totalFrameCountOut);
-}
-#endif
-
-DRWAV_API drwav_int16* drwav_open_memory_and_read_pcm_frames_s16(const void* data, size_t dataSize, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
- drwav wav;
-
- if (channelsOut) {
- *channelsOut = 0;
- }
- if (sampleRateOut) {
- *sampleRateOut = 0;
- }
- if (totalFrameCountOut) {
- *totalFrameCountOut = 0;
- }
-
- if (!drwav_init_memory(&wav, data, dataSize, pAllocationCallbacks)) {
- return NULL;
- }
-
- return drwav__read_pcm_frames_and_close_s16(&wav, channelsOut, sampleRateOut, totalFrameCountOut);
-}
-
-DRWAV_API float* drwav_open_memory_and_read_pcm_frames_f32(const void* data, size_t dataSize, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
- drwav wav;
-
- if (channelsOut) {
- *channelsOut = 0;
- }
- if (sampleRateOut) {
- *sampleRateOut = 0;
- }
- if (totalFrameCountOut) {
- *totalFrameCountOut = 0;
- }
-
- if (!drwav_init_memory(&wav, data, dataSize, pAllocationCallbacks)) {
- return NULL;
- }
-
- return drwav__read_pcm_frames_and_close_f32(&wav, channelsOut, sampleRateOut, totalFrameCountOut);
-}
-
-DRWAV_API drwav_int32* drwav_open_memory_and_read_pcm_frames_s32(const void* data, size_t dataSize, unsigned int* channelsOut, unsigned int* sampleRateOut, drwav_uint64* totalFrameCountOut, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
- drwav wav;
-
- if (channelsOut) {
- *channelsOut = 0;
- }
- if (sampleRateOut) {
- *sampleRateOut = 0;
- }
- if (totalFrameCountOut) {
- *totalFrameCountOut = 0;
- }
-
- if (!drwav_init_memory(&wav, data, dataSize, pAllocationCallbacks)) {
- return NULL;
- }
-
- return drwav__read_pcm_frames_and_close_s32(&wav, channelsOut, sampleRateOut, totalFrameCountOut);
-}
-#endif /* DR_WAV_NO_CONVERSION_API */
-
-
-DRWAV_API void drwav_free(void* p, const drwav_allocation_callbacks* pAllocationCallbacks)
-{
- if (pAllocationCallbacks != NULL) {
- drwav__free_from_callbacks(p, pAllocationCallbacks);
- } else {
- drwav__free_default(p, NULL);
- }
-}
-
-DRWAV_API drwav_uint16 drwav_bytes_to_u16(const drwav_uint8* data)
-{
- return drwav__bytes_to_u16(data);
-}
-
-DRWAV_API drwav_int16 drwav_bytes_to_s16(const drwav_uint8* data)
-{
- return drwav__bytes_to_s16(data);
-}
-
-DRWAV_API drwav_uint32 drwav_bytes_to_u32(const drwav_uint8* data)
-{
- return drwav__bytes_to_u32(data);
-}
-
-DRWAV_API drwav_int32 drwav_bytes_to_s32(const drwav_uint8* data)
-{
- return drwav__bytes_to_s32(data);
-}
-
-DRWAV_API drwav_uint64 drwav_bytes_to_u64(const drwav_uint8* data)
-{
- return drwav__bytes_to_u64(data);
-}
-
-DRWAV_API drwav_int64 drwav_bytes_to_s64(const drwav_uint8* data)
-{
- return drwav__bytes_to_s64(data);
-}
-
-
-DRWAV_API drwav_bool32 drwav_guid_equal(const drwav_uint8 a[16], const drwav_uint8 b[16])
-{
- return drwav__guid_equal(a, b);
-}
-
-DRWAV_API drwav_bool32 drwav_fourcc_equal(const drwav_uint8* a, const char* b)
-{
- return drwav__fourcc_equal(a, b);
-}
-
-#endif /* dr_wav_c */
-#endif /* DR_WAV_IMPLEMENTATION */
-
-/*
-RELEASE NOTES - v0.11.0
-=======================
-Version 0.11.0 has breaking API changes.
-
-Improved Client-Defined Memory Allocation
------------------------------------------
-The main change with this release is the addition of a more flexible way of implementing custom memory allocation routines. The
-existing system of DRWAV_MALLOC, DRWAV_REALLOC and DRWAV_FREE are still in place and will be used by default when no custom
-allocation callbacks are specified.
-
-To use the new system, you pass in a pointer to a drwav_allocation_callbacks object to drwav_init() and family, like this:
-
- void* my_malloc(size_t sz, void* pUserData)
- {
- return malloc(sz);
- }
- void* my_realloc(void* p, size_t sz, void* pUserData)
- {
- return realloc(p, sz);
- }
- void my_free(void* p, void* pUserData)
- {
- free(p);
- }
-
- ...
-
- drwav_allocation_callbacks allocationCallbacks;
- allocationCallbacks.pUserData = &myData;
- allocationCallbacks.onMalloc = my_malloc;
- allocationCallbacks.onRealloc = my_realloc;
- allocationCallbacks.onFree = my_free;
- drwav_init_file(&wav, "my_file.wav", &allocationCallbacks);
-
-The advantage of this new system is that it allows you to specify user data which will be passed in to the allocation routines.
-
-Passing in null for the allocation callbacks object will cause dr_wav to use defaults which is the same as DRWAV_MALLOC,
-DRWAV_REALLOC and DRWAV_FREE and the equivalent of how it worked in previous versions.
-
-Every API that opens a drwav object now takes this extra parameter. These include the following:
-
- drwav_init()
- drwav_init_ex()
- drwav_init_file()
- drwav_init_file_ex()
- drwav_init_file_w()
- drwav_init_file_w_ex()
- drwav_init_memory()
- drwav_init_memory_ex()
- drwav_init_write()
- drwav_init_write_sequential()
- drwav_init_write_sequential_pcm_frames()
- drwav_init_file_write()
- drwav_init_file_write_sequential()
- drwav_init_file_write_sequential_pcm_frames()
- drwav_init_file_write_w()
- drwav_init_file_write_sequential_w()
- drwav_init_file_write_sequential_pcm_frames_w()
- drwav_init_memory_write()
- drwav_init_memory_write_sequential()
- drwav_init_memory_write_sequential_pcm_frames()
- drwav_open_and_read_pcm_frames_s16()
- drwav_open_and_read_pcm_frames_f32()
- drwav_open_and_read_pcm_frames_s32()
- drwav_open_file_and_read_pcm_frames_s16()
- drwav_open_file_and_read_pcm_frames_f32()
- drwav_open_file_and_read_pcm_frames_s32()
- drwav_open_file_and_read_pcm_frames_s16_w()
- drwav_open_file_and_read_pcm_frames_f32_w()
- drwav_open_file_and_read_pcm_frames_s32_w()
- drwav_open_memory_and_read_pcm_frames_s16()
- drwav_open_memory_and_read_pcm_frames_f32()
- drwav_open_memory_and_read_pcm_frames_s32()
-
-Endian Improvements
--------------------
-Previously, the following APIs returned little-endian audio data. These now return native-endian data. This improves compatibility
-on big-endian architectures.
-
- drwav_read_pcm_frames()
- drwav_read_pcm_frames_s16()
- drwav_read_pcm_frames_s32()
- drwav_read_pcm_frames_f32()
- drwav_open_and_read_pcm_frames_s16()
- drwav_open_and_read_pcm_frames_s32()
- drwav_open_and_read_pcm_frames_f32()
- drwav_open_file_and_read_pcm_frames_s16()
- drwav_open_file_and_read_pcm_frames_s32()
- drwav_open_file_and_read_pcm_frames_f32()
- drwav_open_file_and_read_pcm_frames_s16_w()
- drwav_open_file_and_read_pcm_frames_s32_w()
- drwav_open_file_and_read_pcm_frames_f32_w()
- drwav_open_memory_and_read_pcm_frames_s16()
- drwav_open_memory_and_read_pcm_frames_s32()
- drwav_open_memory_and_read_pcm_frames_f32()
-
-APIs have been added to give you explicit control over whether or not audio data is read or written in big- or little-endian byte
-order:
-
- drwav_read_pcm_frames_le()
- drwav_read_pcm_frames_be()
- drwav_read_pcm_frames_s16le()
- drwav_read_pcm_frames_s16be()
- drwav_read_pcm_frames_f32le()
- drwav_read_pcm_frames_f32be()
- drwav_read_pcm_frames_s32le()
- drwav_read_pcm_frames_s32be()
- drwav_write_pcm_frames_le()
- drwav_write_pcm_frames_be()
-
-Removed APIs
-------------
-The following APIs were deprecated in version 0.10.0 and have now been removed:
-
- drwav_open()
- drwav_open_ex()
- drwav_open_write()
- drwav_open_write_sequential()
- drwav_open_file()
- drwav_open_file_ex()
- drwav_open_file_write()
- drwav_open_file_write_sequential()
- drwav_open_memory()
- drwav_open_memory_ex()
- drwav_open_memory_write()
- drwav_open_memory_write_sequential()
- drwav_close()
-
-
-
-RELEASE NOTES - v0.10.0
-=======================
-Version 0.10.0 has breaking API changes. There are no significant bug fixes in this release, so if you are affected you do
-not need to upgrade.
-
-Removed APIs
-------------
-The following APIs were deprecated in version 0.9.0 and have been completely removed in version 0.10.0:
-
- drwav_read()
- drwav_read_s16()
- drwav_read_f32()
- drwav_read_s32()
- drwav_seek_to_sample()
- drwav_write()
- drwav_open_and_read_s16()
- drwav_open_and_read_f32()
- drwav_open_and_read_s32()
- drwav_open_file_and_read_s16()
- drwav_open_file_and_read_f32()
- drwav_open_file_and_read_s32()
- drwav_open_memory_and_read_s16()
- drwav_open_memory_and_read_f32()
- drwav_open_memory_and_read_s32()
- drwav::totalSampleCount
-
-See release notes for version 0.9.0 at the bottom of this file for replacement APIs.
-
-Deprecated APIs
----------------
-The following APIs have been deprecated. There is a confusing and completely arbitrary difference between drwav_init*() and
-drwav_open*(), where drwav_init*() initializes a pre-allocated drwav object, whereas drwav_open*() will first allocated a
-drwav object on the heap and then initialize it. drwav_open*() has been deprecated which means you must now use a pre-
-allocated drwav object with drwav_init*(). If you need the previous functionality, you can just do a malloc() followed by
-a called to one of the drwav_init*() APIs.
-
- drwav_open()
- drwav_open_ex()
- drwav_open_write()
- drwav_open_write_sequential()
- drwav_open_file()
- drwav_open_file_ex()
- drwav_open_file_write()
- drwav_open_file_write_sequential()
- drwav_open_memory()
- drwav_open_memory_ex()
- drwav_open_memory_write()
- drwav_open_memory_write_sequential()
- drwav_close()
-
-These APIs will be removed completely in a future version. The rationale for this change is to remove confusion between the
-two different ways to initialize a drwav object.
-*/
-
-/*
-REVISION HISTORY
-================
-v0.12.16 - 2020-12-02
- - Fix a bug when trying to read more bytes than can fit in a size_t.
-
-v0.12.15 - 2020-11-21
- - Fix compilation with OpenWatcom.
-
-v0.12.14 - 2020-11-13
- - Minor code clean up.
-
-v0.12.13 - 2020-11-01
- - Improve compiler support for older versions of GCC.
-
-v0.12.12 - 2020-09-28
- - Add support for RF64.
- - Fix a bug in writing mode where the size of the RIFF chunk incorrectly includes the header section.
-
-v0.12.11 - 2020-09-08
- - Fix a compilation error on older compilers.
-
-v0.12.10 - 2020-08-24
- - Fix a bug when seeking with ADPCM formats.
-
-v0.12.9 - 2020-08-02
- - Simplify sized types.
-
-v0.12.8 - 2020-07-25
- - Fix a compilation warning.
-
-v0.12.7 - 2020-07-15
- - Fix some bugs on big-endian architectures.
- - Fix an error in s24 to f32 conversion.
-
-v0.12.6 - 2020-06-23
- - Change drwav_read_*() to allow NULL to be passed in as the output buffer which is equivalent to a forward seek.
- - Fix a buffer overflow when trying to decode invalid IMA-ADPCM files.
- - Add include guard for the implementation section.
-
-v0.12.5 - 2020-05-27
- - Minor documentation fix.
-
-v0.12.4 - 2020-05-16
- - Replace assert() with DRWAV_ASSERT().
- - Add compile-time and run-time version querying.
- - DRWAV_VERSION_MINOR
- - DRWAV_VERSION_MAJOR
- - DRWAV_VERSION_REVISION
- - DRWAV_VERSION_STRING
- - drwav_version()
- - drwav_version_string()
-
-v0.12.3 - 2020-04-30
- - Fix compilation errors with VC6.
-
-v0.12.2 - 2020-04-21
- - Fix a bug where drwav_init_file() does not close the file handle after attempting to load an erroneous file.
-
-v0.12.1 - 2020-04-13
- - Fix some pedantic warnings.
-
-v0.12.0 - 2020-04-04
- - API CHANGE: Add container and format parameters to the chunk callback.
- - Minor documentation updates.
-
-v0.11.5 - 2020-03-07
- - Fix compilation error with Visual Studio .NET 2003.
-
-v0.11.4 - 2020-01-29
- - Fix some static analysis warnings.
- - Fix a bug when reading f32 samples from an A-law encoded stream.
-
-v0.11.3 - 2020-01-12
- - Minor changes to some f32 format conversion routines.
- - Minor bug fix for ADPCM conversion when end of file is reached.
-
-v0.11.2 - 2019-12-02
- - Fix a possible crash when using custom memory allocators without a custom realloc() implementation.
- - Fix an integer overflow bug.
- - Fix a null pointer dereference bug.
- - Add limits to sample rate, channels and bits per sample to tighten up some validation.
-
-v0.11.1 - 2019-10-07
- - Internal code clean up.
-
-v0.11.0 - 2019-10-06
- - API CHANGE: Add support for user defined memory allocation routines. This system allows the program to specify their own memory allocation
- routines with a user data pointer for client-specific contextual data. This adds an extra parameter to the end of the following APIs:
- - drwav_init()
- - drwav_init_ex()
- - drwav_init_file()
- - drwav_init_file_ex()
- - drwav_init_file_w()
- - drwav_init_file_w_ex()
- - drwav_init_memory()
- - drwav_init_memory_ex()
- - drwav_init_write()
- - drwav_init_write_sequential()
- - drwav_init_write_sequential_pcm_frames()
- - drwav_init_file_write()
- - drwav_init_file_write_sequential()
- - drwav_init_file_write_sequential_pcm_frames()
- - drwav_init_file_write_w()
- - drwav_init_file_write_sequential_w()
- - drwav_init_file_write_sequential_pcm_frames_w()
- - drwav_init_memory_write()
- - drwav_init_memory_write_sequential()
- - drwav_init_memory_write_sequential_pcm_frames()
- - drwav_open_and_read_pcm_frames_s16()
- - drwav_open_and_read_pcm_frames_f32()
- - drwav_open_and_read_pcm_frames_s32()
- - drwav_open_file_and_read_pcm_frames_s16()
- - drwav_open_file_and_read_pcm_frames_f32()
- - drwav_open_file_and_read_pcm_frames_s32()
- - drwav_open_file_and_read_pcm_frames_s16_w()
- - drwav_open_file_and_read_pcm_frames_f32_w()
- - drwav_open_file_and_read_pcm_frames_s32_w()
- - drwav_open_memory_and_read_pcm_frames_s16()
- - drwav_open_memory_and_read_pcm_frames_f32()
- - drwav_open_memory_and_read_pcm_frames_s32()
- Set this extra parameter to NULL to use defaults which is the same as the previous behaviour. Setting this NULL will use
- DRWAV_MALLOC, DRWAV_REALLOC and DRWAV_FREE.
- - Add support for reading and writing PCM frames in an explicit endianness. New APIs:
- - drwav_read_pcm_frames_le()
- - drwav_read_pcm_frames_be()
- - drwav_read_pcm_frames_s16le()
- - drwav_read_pcm_frames_s16be()
- - drwav_read_pcm_frames_f32le()
- - drwav_read_pcm_frames_f32be()
- - drwav_read_pcm_frames_s32le()
- - drwav_read_pcm_frames_s32be()
- - drwav_write_pcm_frames_le()
- - drwav_write_pcm_frames_be()
- - Remove deprecated APIs.
- - API CHANGE: The following APIs now return native-endian data. Previously they returned little-endian data.
- - drwav_read_pcm_frames()
- - drwav_read_pcm_frames_s16()
- - drwav_read_pcm_frames_s32()
- - drwav_read_pcm_frames_f32()
- - drwav_open_and_read_pcm_frames_s16()
- - drwav_open_and_read_pcm_frames_s32()
- - drwav_open_and_read_pcm_frames_f32()
- - drwav_open_file_and_read_pcm_frames_s16()
- - drwav_open_file_and_read_pcm_frames_s32()
- - drwav_open_file_and_read_pcm_frames_f32()
- - drwav_open_file_and_read_pcm_frames_s16_w()
- - drwav_open_file_and_read_pcm_frames_s32_w()
- - drwav_open_file_and_read_pcm_frames_f32_w()
- - drwav_open_memory_and_read_pcm_frames_s16()
- - drwav_open_memory_and_read_pcm_frames_s32()
- - drwav_open_memory_and_read_pcm_frames_f32()
-
-v0.10.1 - 2019-08-31
- - Correctly handle partial trailing ADPCM blocks.
-
-v0.10.0 - 2019-08-04
- - Remove deprecated APIs.
- - Add wchar_t variants for file loading APIs:
- drwav_init_file_w()
- drwav_init_file_ex_w()
- drwav_init_file_write_w()
- drwav_init_file_write_sequential_w()
- - Add drwav_target_write_size_bytes() which calculates the total size in bytes of a WAV file given a format and sample count.
- - Add APIs for specifying the PCM frame count instead of the sample count when opening in sequential write mode:
- drwav_init_write_sequential_pcm_frames()
- drwav_init_file_write_sequential_pcm_frames()
- drwav_init_file_write_sequential_pcm_frames_w()
- drwav_init_memory_write_sequential_pcm_frames()
- - Deprecate drwav_open*() and drwav_close():
- drwav_open()
- drwav_open_ex()
- drwav_open_write()
- drwav_open_write_sequential()
- drwav_open_file()
- drwav_open_file_ex()
- drwav_open_file_write()
- drwav_open_file_write_sequential()
- drwav_open_memory()
- drwav_open_memory_ex()
- drwav_open_memory_write()
- drwav_open_memory_write_sequential()
- drwav_close()
- - Minor documentation updates.
-
-v0.9.2 - 2019-05-21
- - Fix warnings.
-
-v0.9.1 - 2019-05-05
- - Add support for C89.
- - Change license to choice of public domain or MIT-0.
-
-v0.9.0 - 2018-12-16
- - API CHANGE: Add new reading APIs for reading by PCM frames instead of samples. Old APIs have been deprecated and
- will be removed in v0.10.0. Deprecated APIs and their replacements:
- drwav_read() -> drwav_read_pcm_frames()
- drwav_read_s16() -> drwav_read_pcm_frames_s16()
- drwav_read_f32() -> drwav_read_pcm_frames_f32()
- drwav_read_s32() -> drwav_read_pcm_frames_s32()
- drwav_seek_to_sample() -> drwav_seek_to_pcm_frame()
- drwav_write() -> drwav_write_pcm_frames()
- drwav_open_and_read_s16() -> drwav_open_and_read_pcm_frames_s16()
- drwav_open_and_read_f32() -> drwav_open_and_read_pcm_frames_f32()
- drwav_open_and_read_s32() -> drwav_open_and_read_pcm_frames_s32()
- drwav_open_file_and_read_s16() -> drwav_open_file_and_read_pcm_frames_s16()
- drwav_open_file_and_read_f32() -> drwav_open_file_and_read_pcm_frames_f32()
- drwav_open_file_and_read_s32() -> drwav_open_file_and_read_pcm_frames_s32()
- drwav_open_memory_and_read_s16() -> drwav_open_memory_and_read_pcm_frames_s16()
- drwav_open_memory_and_read_f32() -> drwav_open_memory_and_read_pcm_frames_f32()
- drwav_open_memory_and_read_s32() -> drwav_open_memory_and_read_pcm_frames_s32()
- drwav::totalSampleCount -> drwav::totalPCMFrameCount
- - API CHANGE: Rename drwav_open_and_read_file_*() to drwav_open_file_and_read_*().
- - API CHANGE: Rename drwav_open_and_read_memory_*() to drwav_open_memory_and_read_*().
- - Add built-in support for smpl chunks.
- - Add support for firing a callback for each chunk in the file at initialization time.
- - This is enabled through the drwav_init_ex(), etc. family of APIs.
- - Handle invalid FMT chunks more robustly.
-
-v0.8.5 - 2018-09-11
- - Const correctness.
- - Fix a potential stack overflow.
-
-v0.8.4 - 2018-08-07
- - Improve 64-bit detection.
-
-v0.8.3 - 2018-08-05
- - Fix C++ build on older versions of GCC.
-
-v0.8.2 - 2018-08-02
- - Fix some big-endian bugs.
-
-v0.8.1 - 2018-06-29
- - Add support for sequential writing APIs.
- - Disable seeking in write mode.
- - Fix bugs with Wave64.
- - Fix typos.
-
-v0.8 - 2018-04-27
- - Bug fix.
- - Start using major.minor.revision versioning.
-
-v0.7f - 2018-02-05
- - Restrict ADPCM formats to a maximum of 2 channels.
-
-v0.7e - 2018-02-02
- - Fix a crash.
-
-v0.7d - 2018-02-01
- - Fix a crash.
-
-v0.7c - 2018-02-01
- - Set drwav.bytesPerSample to 0 for all compressed formats.
- - Fix a crash when reading 16-bit floating point WAV files. In this case dr_wav will output silence for
- all format conversion reading APIs (*_s16, *_s32, *_f32 APIs).
- - Fix some divide-by-zero errors.
-
-v0.7b - 2018-01-22
- - Fix errors with seeking of compressed formats.
- - Fix compilation error when DR_WAV_NO_CONVERSION_API
-
-v0.7a - 2017-11-17
- - Fix some GCC warnings.
-
-v0.7 - 2017-11-04
- - Add writing APIs.
-
-v0.6 - 2017-08-16
- - API CHANGE: Rename dr_* types to drwav_*.
- - Add support for custom implementations of malloc(), realloc(), etc.
- - Add support for Microsoft ADPCM.
- - Add support for IMA ADPCM (DVI, format code 0x11).
- - Optimizations to drwav_read_s16().
- - Bug fixes.
-
-v0.5g - 2017-07-16
- - Change underlying type for booleans to unsigned.
-
-v0.5f - 2017-04-04
- - Fix a minor bug with drwav_open_and_read_s16() and family.
-
-v0.5e - 2016-12-29
- - Added support for reading samples as signed 16-bit integers. Use the _s16() family of APIs for this.
- - Minor fixes to documentation.
-
-v0.5d - 2016-12-28
- - Use drwav_int* and drwav_uint* sized types to improve compiler support.
-
-v0.5c - 2016-11-11
- - Properly handle JUNK chunks that come before the FMT chunk.
-
-v0.5b - 2016-10-23
- - A minor change to drwav_bool8 and drwav_bool32 types.
-
-v0.5a - 2016-10-11
- - Fixed a bug with drwav_open_and_read() and family due to incorrect argument ordering.
- - Improve A-law and mu-law efficiency.
-
-v0.5 - 2016-09-29
- - API CHANGE. Swap the order of "channels" and "sampleRate" parameters in drwav_open_and_read*(). Rationale for this is to
- keep it consistent with dr_audio and dr_flac.
-
-v0.4b - 2016-09-18
- - Fixed a typo in documentation.
-
-v0.4a - 2016-09-18
- - Fixed a typo.
- - Change date format to ISO 8601 (YYYY-MM-DD)
-
-v0.4 - 2016-07-13
- - API CHANGE. Make onSeek consistent with dr_flac.
- - API CHANGE. Rename drwav_seek() to drwav_seek_to_sample() for clarity and consistency with dr_flac.
- - Added support for Sony Wave64.
-
-v0.3a - 2016-05-28
- - API CHANGE. Return drwav_bool32 instead of int in onSeek callback.
- - Fixed a memory leak.
-
-v0.3 - 2016-05-22
- - Lots of API changes for consistency.
-
-v0.2a - 2016-05-16
- - Fixed Linux/GCC build.
-
-v0.2 - 2016-05-11
- - Added support for reading data as signed 32-bit PCM for consistency with dr_flac.
-
-v0.1a - 2016-05-07
- - Fixed a bug in drwav_open_file() where the file handle would not be closed if the loader failed to initialize.
-
-v0.1 - 2016-05-04
- - Initial versioned release.
-*/
-
-/*
-This software is available as a choice of the following licenses. Choose
-whichever you prefer.
-
-===============================================================================
-ALTERNATIVE 1 - Public Domain (www.unlicense.org)
-===============================================================================
-This is free and unencumbered software released into the public domain.
-
-Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
-software, either in source code form or as a compiled binary, for any purpose,
-commercial or non-commercial, and by any means.
-
-In jurisdictions that recognize copyright laws, the author or authors of this
-software dedicate any and all copyright interest in the software to the public
-domain. We make this dedication for the benefit of the public at large and to
-the detriment of our heirs and successors. We intend this dedication to be an
-overt act of relinquishment in perpetuity of all present and future rights to
-this software under copyright law.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
-ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-For more information, please refer to <http://unlicense.org/>
-
-===============================================================================
-ALTERNATIVE 2 - MIT No Attribution
-===============================================================================
-Copyright 2020 David Reid
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-of the Software, and to permit persons to whom the Software is furnished to do
-so.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-*/
diff --git a/whisper.cpp/grammar-parser.cpp b/whisper.cpp/grammar-parser.cpp
deleted file mode 100644
index 9967417f..00000000
--- a/whisper.cpp/grammar-parser.cpp
+++ /dev/null
@@ -1,425 +0,0 @@
-// -*- mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8 -*-
-// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
-#include "grammar-parser.h"
-#include <cstdint>
-#include <cwchar>
-#include <string>
-#include <utility>
-#include <stdexcept>
-#include <exception>
-
-namespace whisper_grammar_parser {
- // NOTE: assumes valid utf8 (but checks for overrun)
- // copied from whisper.cpp
- static std::pair<uint32_t, const char *> decode_utf8(const char * src) {
- static const int lookup[] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 3, 4 };
- uint8_t first_byte = static_cast<uint8_t>(*src);
- uint8_t highbits = first_byte >> 4;
- int len = lookup[highbits];
- uint8_t mask = (1 << (8 - len)) - 1;
- uint32_t value = first_byte & mask;
- const char * end = src + len; // may overrun!
- const char * pos = src + 1;
- for ( ; pos < end && *pos; pos++) {
- value = (value << 6) + (static_cast<uint8_t>(*pos) & 0x3F);
- }
- return std::make_pair(value, pos);
- }
-
- static uint32_t get_symbol_id(parse_state & state, const char * src, size_t len) {
- uint32_t next_id = static_cast<uint32_t>(state.symbol_ids.size());
- auto result = state.symbol_ids.insert(std::make_pair(std::string(src, len), next_id));
- return result.first->second;
- }
-
- static uint32_t generate_symbol_id(parse_state & state, const std::string & base_name) {
- uint32_t next_id = static_cast<uint32_t>(state.symbol_ids.size());
- state.symbol_ids[base_name + '_' + std::to_string(next_id)] = next_id;
- return next_id;
- }
-
- static void add_rule(
- parse_state & state,
- uint32_t rule_id,
- const std::vector<whisper_grammar_element> & rule) {
- if (state.rules.size() <= rule_id) {
- state.rules.resize(rule_id + 1);
- }
- state.rules[rule_id] = rule;
- }
-
- static bool is_word_char(char c) {
- return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || c == '-' || ('0' <= c && c <= '9');
- }
-
- static std::pair<uint32_t, const char *> parse_hex(const char * src, int size) {
- const char * pos = src;
- const char * end = src + size;
- uint32_t value = 0;
- for ( ; pos < end && *pos; pos++) {
- value <<= 4;
- char c = *pos;
- if ('a' <= c && c <= 'f') {
- value += c - 'a' + 10;
- } else if ('A' <= c && c <= 'F') {
- value += c - 'A' + 10;
- } else if ('0' <= c && c <= '9') {
- value += c - '0';
- } else {
- break;
- }
- }
- if (pos != end) {
- throw std::runtime_error("expecting " + std::to_string(size) + " hex chars at " + src);
- }
- return std::make_pair(value, pos);
- }
-
- static const char * parse_space(const char * src, bool newline_ok) {
- const char * pos = src;
- while (*pos == ' ' || *pos == '\t' || *pos == '#' ||
- (newline_ok && (*pos == '\r' || *pos == '\n'))) {
- if (*pos == '#') {
- while (*pos && *pos != '\r' && *pos != '\n') {
- pos++;
- }
- } else {
- pos++;
- }
- }
- return pos;
- }
-
- static const char * parse_name(const char * src) {
- const char * pos = src;
- while (is_word_char(*pos)) {
- pos++;
- }
- if (pos == src) {
- throw std::runtime_error(std::string("expecting name at ") + src);
- }
- return pos;
- }
-
- static std::pair<uint32_t, const char *> parse_char(const char * src) {
- if (*src == '\\') {
- switch (src[1]) {
- case 'x': return parse_hex(src + 2, 2);
- case 'u': return parse_hex(src + 2, 4);
- case 'U': return parse_hex(src + 2, 8);
- case 't': return std::make_pair('\t', src + 2);
- case 'r': return std::make_pair('\r', src + 2);
- case 'n': return std::make_pair('\n', src + 2);
- case '\\':
- case '"':
- case '[':
- case ']':
- return std::make_pair(src[1], src + 2);
- default:
- throw std::runtime_error(std::string("unknown escape at ") + src);
- }
- } else if (*src) {
- return decode_utf8(src);
- }
- throw std::runtime_error("unexpected end of input");
- }
-
- static const char * parse_alternates(
- parse_state & state,
- const char * src,
- const std::string & rule_name,
- uint32_t rule_id,
- bool is_nested);
-
- static const char * parse_sequence(
- parse_state & state,
- const char * src,
- const std::string & rule_name,
- std::vector<whisper_grammar_element> & out_elements,
- bool is_nested) {
- size_t last_sym_start = out_elements.size();
- const char * pos = src;
- while (*pos) {
- if (*pos == '"') { // literal string
- pos++;
- last_sym_start = out_elements.size();
- while (*pos != '"') {
- auto char_pair = parse_char(pos);
- pos = char_pair.second;
- out_elements.push_back({WHISPER_GRETYPE_CHAR, char_pair.first});
- }
- pos = parse_space(pos + 1, is_nested);
- } else if (*pos == '[') { // char range(s)
- pos++;
- enum whisper_gretype start_type = WHISPER_GRETYPE_CHAR;
- if (*pos == '^') {
- pos++;
- start_type = WHISPER_GRETYPE_CHAR_NOT;
- }
- last_sym_start = out_elements.size();
- while (*pos != ']') {
- auto char_pair = parse_char(pos);
- pos = char_pair.second;
- enum whisper_gretype type = last_sym_start < out_elements.size()
- ? WHISPER_GRETYPE_CHAR_ALT
- : start_type;
-
- out_elements.push_back({type, char_pair.first});
- if (pos[0] == '-' && pos[1] != ']') {
- auto endchar_pair = parse_char(pos + 1);
- pos = endchar_pair.second;
- out_elements.push_back({WHISPER_GRETYPE_CHAR_RNG_UPPER, endchar_pair.first});
- }
- }
- pos = parse_space(pos + 1, is_nested);
- } else if (is_word_char(*pos)) { // rule reference
- const char * name_end = parse_name(pos);
- uint32_t ref_rule_id = get_symbol_id(state, pos, name_end - pos);
- pos = parse_space(name_end, is_nested);
- last_sym_start = out_elements.size();
- out_elements.push_back({WHISPER_GRETYPE_RULE_REF, ref_rule_id});
- } else if (*pos == '(') { // grouping
- // parse nested alternates into synthesized rule
- pos = parse_space(pos + 1, true);
- uint32_t sub_rule_id = generate_symbol_id(state, rule_name);
- pos = parse_alternates(state, pos, rule_name, sub_rule_id, true);
- last_sym_start = out_elements.size();
- // output reference to synthesized rule
- out_elements.push_back({WHISPER_GRETYPE_RULE_REF, sub_rule_id});
- if (*pos != ')') {
- throw std::runtime_error(std::string("expecting ')' at ") + pos);
- }
- pos = parse_space(pos + 1, is_nested);
- } else if (*pos == '*' || *pos == '+' || *pos == '?') { // repetition operator
- if (last_sym_start == out_elements.size()) {
- throw std::runtime_error(std::string("expecting preceding item to */+/? at ") + pos);
- }
-
- // apply transformation to previous symbol (last_sym_start to end) according to
- // rewrite rules:
- // S* --> S' ::= S S' |
- // S+ --> S' ::= S S' | S
- // S? --> S' ::= S |
- uint32_t sub_rule_id = generate_symbol_id(state, rule_name);
- std::vector<whisper_grammar_element> sub_rule;
- // add preceding symbol to generated rule
- sub_rule.insert(
- sub_rule.end(), out_elements.begin() + last_sym_start, out_elements.end());
- if (*pos == '*' || *pos == '+') {
- // cause generated rule to recurse
- sub_rule.push_back({WHISPER_GRETYPE_RULE_REF, sub_rule_id});
- }
- // mark start of alternate def
- sub_rule.push_back({WHISPER_GRETYPE_ALT, 0});
- if (*pos == '+') {
- // add preceding symbol as alternate only for '+' (otherwise empty)
- sub_rule.insert(
- sub_rule.end(), out_elements.begin() + last_sym_start, out_elements.end());
- }
- sub_rule.push_back({WHISPER_GRETYPE_END, 0});
- add_rule(state, sub_rule_id, sub_rule);
-
- // in original rule, replace previous symbol with reference to generated rule
- out_elements.resize(last_sym_start);
- out_elements.push_back({WHISPER_GRETYPE_RULE_REF, sub_rule_id});
-
- pos = parse_space(pos + 1, is_nested);
- } else {
- break;
- }
- }
- return pos;
- }
-
- static const char * parse_alternates(
- parse_state & state,
- const char * src,
- const std::string & rule_name,
- uint32_t rule_id,
- bool is_nested) {
- std::vector<whisper_grammar_element> rule;
- const char * pos = parse_sequence(state, src, rule_name, rule, is_nested);
- while (*pos == '|') {
- rule.push_back({WHISPER_GRETYPE_ALT, 0});
- pos = parse_space(pos + 1, true);
- pos = parse_sequence(state, pos, rule_name, rule, is_nested);
- }
- rule.push_back({WHISPER_GRETYPE_END, 0});
- add_rule(state, rule_id, rule);
- return pos;
- }
-
- static const char * parse_rule(parse_state & state, const char * src) {
- const char * name_end = parse_name(src);
- const char * pos = parse_space(name_end, false);
- size_t name_len = name_end - src;
- uint32_t rule_id = get_symbol_id(state, src, name_len);
- const std::string name(src, name_len);
-
- if (!(pos[0] == ':' && pos[1] == ':' && pos[2] == '=')) {
- throw std::runtime_error(std::string("expecting ::= at ") + pos);
- }
- pos = parse_space(pos + 3, true);
-
- pos = parse_alternates(state, pos, name, rule_id, false);
-
- if (*pos == '\r') {
- pos += pos[1] == '\n' ? 2 : 1;
- } else if (*pos == '\n') {
- pos++;
- } else if (*pos) {
- throw std::runtime_error(std::string("expecting newline or end at ") + pos);
- }
- return parse_space(pos, true);
- }
-
- parse_state parse(const char * src) {
- try {
- parse_state state;
- const char * pos = parse_space(src, true);
- while (*pos) {
- pos = parse_rule(state, pos);
- }
- return state;
- } catch (const std::exception & err) {
- fprintf(stderr, "%s: error parsing grammar: %s\n", __func__, err.what());
- return parse_state();
- }
- }
-
- static void print_grammar_char(FILE * file, uint32_t c) {
- if (0x20 <= c && c <= 0x7f) {
- fprintf(file, "%c", static_cast<char>(c));
- } else {
- // cop out of encoding UTF-8
- fprintf(file, "<U+%04X>", c);
- }
- }
-
- static bool is_char_element(whisper_grammar_element elem) {
- switch (elem.type) {
- case WHISPER_GRETYPE_CHAR: return true;
- case WHISPER_GRETYPE_CHAR_NOT: return true;
- case WHISPER_GRETYPE_CHAR_ALT: return true;
- case WHISPER_GRETYPE_CHAR_RNG_UPPER: return true;
- default: return false;
- }
- }
-
- static void print_rule_binary(FILE * file, const std::vector<whisper_grammar_element> & rule) {
- for (auto elem : rule) {
- switch (elem.type) {
- case WHISPER_GRETYPE_END: fprintf(file, "END"); break;
- case WHISPER_GRETYPE_ALT: fprintf(file, "ALT"); break;
- case WHISPER_GRETYPE_RULE_REF: fprintf(file, "RULE_REF"); break;
- case WHISPER_GRETYPE_CHAR: fprintf(file, "CHAR"); break;
- case WHISPER_GRETYPE_CHAR_NOT: fprintf(file, "CHAR_NOT"); break;
- case WHISPER_GRETYPE_CHAR_RNG_UPPER: fprintf(file, "CHAR_RNG_UPPER"); break;
- case WHISPER_GRETYPE_CHAR_ALT: fprintf(file, "CHAR_ALT"); break;
- }
- switch (elem.type) {
- case WHISPER_GRETYPE_END:
- case WHISPER_GRETYPE_ALT:
- case WHISPER_GRETYPE_RULE_REF:
- fprintf(file, "(%u) ", elem.value);
- break;
- case WHISPER_GRETYPE_CHAR:
- case WHISPER_GRETYPE_CHAR_NOT:
- case WHISPER_GRETYPE_CHAR_RNG_UPPER:
- case WHISPER_GRETYPE_CHAR_ALT:
- fprintf(file, "(\"");
- print_grammar_char(file, elem.value);
- fprintf(file, "\") ");
- break;
- }
- }
- fprintf(file, "\n");
- }
-
- static void print_rule(
- FILE * file,
- uint32_t rule_id,
- const std::vector<whisper_grammar_element> & rule,
- const std::map<uint32_t, std::string> & symbol_id_names) {
- if (rule.empty() || rule.back().type != WHISPER_GRETYPE_END) {
- throw std::runtime_error(
- "malformed rule, does not end with WHISPER_GRETYPE_END: " + std::to_string(rule_id));
- }
- fprintf(file, "%s ::= ", symbol_id_names.at(rule_id).c_str());
- for (size_t i = 0, end = rule.size() - 1; i < end; i++) {
- whisper_grammar_element elem = rule[i];
- switch (elem.type) {
- case WHISPER_GRETYPE_END:
- throw std::runtime_error(
- "unexpected end of rule: " + std::to_string(rule_id) + "," +
- std::to_string(i));
- case WHISPER_GRETYPE_ALT:
- fprintf(file, "| ");
- break;
- case WHISPER_GRETYPE_RULE_REF:
- fprintf(file, "%s ", symbol_id_names.at(elem.value).c_str());
- break;
- case WHISPER_GRETYPE_CHAR:
- fprintf(file, "[");
- print_grammar_char(file, elem.value);
- break;
- case WHISPER_GRETYPE_CHAR_NOT:
- fprintf(file, "[^");
- print_grammar_char(file, elem.value);
- break;
- case WHISPER_GRETYPE_CHAR_RNG_UPPER:
- if (i == 0 || !is_char_element(rule[i - 1])) {
- throw std::runtime_error(
- "WHISPER_GRETYPE_CHAR_RNG_UPPER without preceding char: " +
- std::to_string(rule_id) + "," + std::to_string(i));
- }
- fprintf(file, "-");
- print_grammar_char(file, elem.value);
- break;
- case WHISPER_GRETYPE_CHAR_ALT:
- if (i == 0 || !is_char_element(rule[i - 1])) {
- throw std::runtime_error(
- "WHISPER_GRETYPE_CHAR_ALT without preceding char: " +
- std::to_string(rule_id) + "," + std::to_string(i));
- }
- print_grammar_char(file, elem.value);
- break;
- }
- if (is_char_element(elem)) {
- switch (rule[i + 1].type) {
- case WHISPER_GRETYPE_CHAR_ALT:
- case WHISPER_GRETYPE_CHAR_RNG_UPPER:
- break;
- default:
- fprintf(file, "] ");
- }
- }
- }
- fprintf(file, "\n");
- }
-
- void print_grammar(FILE * file, const parse_state & state) {
- try {
- std::map<uint32_t, std::string> symbol_id_names;
- for (auto kv : state.symbol_ids) {
- symbol_id_names[kv.second] = kv.first;
- }
- for (size_t i = 0, end = state.rules.size(); i < end; i++) {
- // fprintf(file, "%zu: ", i);
- // print_rule_binary(file, state.rules[i]);
- print_rule(file, uint32_t(i), state.rules[i], symbol_id_names);
- // fprintf(file, "\n");
- }
- } catch (const std::exception & err) {
- fprintf(stderr, "\n%s: error printing grammar: %s\n", __func__, err.what());
- }
- }
-
- std::vector<const whisper_grammar_element *> parse_state::c_rules() const {
- std::vector<const whisper_grammar_element *> ret;
- for (const auto & rule : rules) {
- ret.push_back(rule.data());
- }
- return ret;
- }
-}
diff --git a/whisper.cpp/grammar-parser.h b/whisper.cpp/grammar-parser.h
deleted file mode 100644
index d54e9c58..00000000
--- a/whisper.cpp/grammar-parser.h
+++ /dev/null
@@ -1,32 +0,0 @@
-// -*- mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8 -*-
-// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
-
-// Implements a parser for an extended Backus-Naur form (BNF), producing the
-// binary context-free grammar format specified by whisper.h. Supports character
-// ranges, grouping, and repetition operators. As an example, a grammar for
-// arithmetic might look like:
-//
-// root ::= expr
-// expr ::= term ([-+*/] term)*
-// term ::= num | "(" space expr ")" space
-// num ::= [0-9]+ space
-// space ::= [ \t\n]*
-
-#pragma once
-#include "whisper.h"
-#include <vector>
-#include <map>
-#include <cstdint>
-#include <string>
-
-namespace whisper_grammar_parser {
- struct parse_state {
- std::map<std::string, uint32_t> symbol_ids;
- std::vector<std::vector<whisper_grammar_element>> rules;
-
- std::vector<const whisper_grammar_element *> c_rules() const;
- };
-
- parse_state parse(const char * src);
- void print_grammar(FILE * file, const parse_state & state);
-}
diff --git a/whisper.cpp/httplib.h b/whisper.cpp/httplib.h
deleted file mode 100644
index a1cb6333..00000000
--- a/whisper.cpp/httplib.h
+++ /dev/null
@@ -1,9263 +0,0 @@
-//
-// httplib.h
-//
-// Copyright (c) 2023 Yuji Hirose. All rights reserved.
-// MIT License
-//
-
-#ifndef CPPHTTPLIB_HTTPLIB_H
-#define CPPHTTPLIB_HTTPLIB_H
-
-#define CPPHTTPLIB_VERSION "0.14.1"
-
-/*
- * Configuration
- */
-
-#ifndef CPPHTTPLIB_KEEPALIVE_TIMEOUT_SECOND
-#define CPPHTTPLIB_KEEPALIVE_TIMEOUT_SECOND 5
-#endif
-
-#ifndef CPPHTTPLIB_KEEPALIVE_MAX_COUNT
-#define CPPHTTPLIB_KEEPALIVE_MAX_COUNT 5
-#endif
-
-#ifndef CPPHTTPLIB_CONNECTION_TIMEOUT_SECOND
-#define CPPHTTPLIB_CONNECTION_TIMEOUT_SECOND 300
-#endif
-
-#ifndef CPPHTTPLIB_CONNECTION_TIMEOUT_USECOND
-#define CPPHTTPLIB_CONNECTION_TIMEOUT_USECOND 0
-#endif
-
-#ifndef CPPHTTPLIB_READ_TIMEOUT_SECOND
-#define CPPHTTPLIB_READ_TIMEOUT_SECOND 5
-#endif
-
-#ifndef CPPHTTPLIB_READ_TIMEOUT_USECOND
-#define CPPHTTPLIB_READ_TIMEOUT_USECOND 0
-#endif
-
-#ifndef CPPHTTPLIB_WRITE_TIMEOUT_SECOND
-#define CPPHTTPLIB_WRITE_TIMEOUT_SECOND 5
-#endif
-
-#ifndef CPPHTTPLIB_WRITE_TIMEOUT_USECOND
-#define CPPHTTPLIB_WRITE_TIMEOUT_USECOND 0
-#endif
-
-#ifndef CPPHTTPLIB_IDLE_INTERVAL_SECOND
-#define CPPHTTPLIB_IDLE_INTERVAL_SECOND 0
-#endif
-
-#ifndef CPPHTTPLIB_IDLE_INTERVAL_USECOND
-#ifdef _WIN32
-#define CPPHTTPLIB_IDLE_INTERVAL_USECOND 10000
-#else
-#define CPPHTTPLIB_IDLE_INTERVAL_USECOND 0
-#endif
-#endif
-
-#ifndef CPPHTTPLIB_REQUEST_URI_MAX_LENGTH
-#define CPPHTTPLIB_REQUEST_URI_MAX_LENGTH 8192
-#endif
-
-#ifndef CPPHTTPLIB_HEADER_MAX_LENGTH
-#define CPPHTTPLIB_HEADER_MAX_LENGTH 8192
-#endif
-
-#ifndef CPPHTTPLIB_REDIRECT_MAX_COUNT
-#define CPPHTTPLIB_REDIRECT_MAX_COUNT 20
-#endif
-
-#ifndef CPPHTTPLIB_MULTIPART_FORM_DATA_FILE_MAX_COUNT
-#define CPPHTTPLIB_MULTIPART_FORM_DATA_FILE_MAX_COUNT 1024
-#endif
-
-#ifndef CPPHTTPLIB_PAYLOAD_MAX_LENGTH
-#define CPPHTTPLIB_PAYLOAD_MAX_LENGTH ((std::numeric_limits<size_t>::max)())
-#endif
-
-#ifndef CPPHTTPLIB_FORM_URL_ENCODED_PAYLOAD_MAX_LENGTH
-#define CPPHTTPLIB_FORM_URL_ENCODED_PAYLOAD_MAX_LENGTH 8192
-#endif
-
-#ifndef CPPHTTPLIB_TCP_NODELAY
-#define CPPHTTPLIB_TCP_NODELAY false
-#endif
-
-#ifndef CPPHTTPLIB_RECV_BUFSIZ
-#define CPPHTTPLIB_RECV_BUFSIZ size_t(4096u)
-#endif
-
-#ifndef CPPHTTPLIB_COMPRESSION_BUFSIZ
-#define CPPHTTPLIB_COMPRESSION_BUFSIZ size_t(16384u)
-#endif
-
-#ifndef CPPHTTPLIB_THREAD_POOL_COUNT
-#define CPPHTTPLIB_THREAD_POOL_COUNT \
- ((std::max)(8u, std::thread::hardware_concurrency() > 0 \
- ? std::thread::hardware_concurrency() - 1 \
- : 0))
-#endif
-
-#ifndef CPPHTTPLIB_RECV_FLAGS
-#define CPPHTTPLIB_RECV_FLAGS 0
-#endif
-
-#ifndef CPPHTTPLIB_SEND_FLAGS
-#define CPPHTTPLIB_SEND_FLAGS 0
-#endif
-
-#ifndef CPPHTTPLIB_LISTEN_BACKLOG
-#define CPPHTTPLIB_LISTEN_BACKLOG 5
-#endif
-
-/*
- * Headers
- */
-
-#ifdef _WIN32
-#ifndef _CRT_SECURE_NO_WARNINGS
-#define _CRT_SECURE_NO_WARNINGS
-#endif //_CRT_SECURE_NO_WARNINGS
-
-#ifndef _CRT_NONSTDC_NO_DEPRECATE
-#define _CRT_NONSTDC_NO_DEPRECATE
-#endif //_CRT_NONSTDC_NO_DEPRECATE
-
-#if defined(_MSC_VER)
-#if _MSC_VER < 1900
-#error Sorry, Visual Studio versions prior to 2015 are not supported
-#endif
-
-#pragma comment(lib, "ws2_32.lib")
-
-#ifdef _WIN64
-using ssize_t = __int64;
-#else
-using ssize_t = long;
-#endif
-#endif // _MSC_VER
-
-#ifndef S_ISREG
-#define S_ISREG(m) (((m)&S_IFREG) == S_IFREG)
-#endif // S_ISREG
-
-#ifndef S_ISDIR
-#define S_ISDIR(m) (((m)&S_IFDIR) == S_IFDIR)
-#endif // S_ISDIR
-
-#ifndef NOMINMAX
-#define NOMINMAX
-#endif // NOMINMAX
-
-#include <io.h>
-#include <winsock2.h>
-#include <ws2tcpip.h>
-
-#ifndef WSA_FLAG_NO_HANDLE_INHERIT
-#define WSA_FLAG_NO_HANDLE_INHERIT 0x80
-#endif
-
-#ifndef strcasecmp
-#define strcasecmp _stricmp
-#endif // strcasecmp
-
-using socket_t = SOCKET;
-#ifdef CPPHTTPLIB_USE_POLL
-#define poll(fds, nfds, timeout) WSAPoll(fds, nfds, timeout)
-#endif
-
-#else // not _WIN32
-
-#include <arpa/inet.h>
-#if !defined(_AIX) && !defined(__MVS__)
-#include <ifaddrs.h>
-#endif
-#ifdef __MVS__
-#include <strings.h>
-#ifndef NI_MAXHOST
-#define NI_MAXHOST 1025
-#endif
-#endif
-#include <net/if.h>
-#include <netdb.h>
-#include <netinet/in.h>
-#ifdef __linux__
-#include <resolv.h>
-#endif
-#include <netinet/tcp.h>
-#ifdef CPPHTTPLIB_USE_POLL
-#include <poll.h>
-#endif
-#include <csignal>
-#include <pthread.h>
-#include <sys/mman.h>
-#include <sys/select.h>
-#include <sys/socket.h>
-#include <sys/un.h>
-#include <unistd.h>
-
-using socket_t = int;
-#ifndef INVALID_SOCKET
-#define INVALID_SOCKET (-1)
-#endif
-#endif //_WIN32
-
-#include <algorithm>
-#include <array>
-#include <atomic>
-#include <cassert>
-#include <cctype>
-#include <climits>
-#include <condition_variable>
-#include <cstring>
-#include <errno.h>
-#include <fcntl.h>
-#include <fstream>
-#include <functional>
-#include <iomanip>
-#include <iostream>
-#include <list>
-#include <map>
-#include <memory>
-#include <mutex>
-#include <random>
-#include <regex>
-#include <set>
-#include <sstream>
-#include <string>
-#include <sys/stat.h>
-#include <thread>
-#include <unordered_map>
-#include <unordered_set>
-#include <utility>
-#include <exception>
-
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-#ifdef _WIN32
-#include <wincrypt.h>
-
-// these are defined in wincrypt.h and it breaks compilation if BoringSSL is
-// used
-#undef X509_NAME
-#undef X509_CERT_PAIR
-#undef X509_EXTENSIONS
-#undef PKCS7_SIGNER_INFO
-
-#ifdef _MSC_VER
-#pragma comment(lib, "crypt32.lib")
-#pragma comment(lib, "cryptui.lib")
-#endif
-#elif defined(CPPHTTPLIB_USE_CERTS_FROM_MACOSX_KEYCHAIN) && defined(__APPLE__)
-#include <TargetConditionals.h>
-#if TARGET_OS_OSX
-#include <CoreFoundation/CoreFoundation.h>
-#include <Security/Security.h>
-#endif // TARGET_OS_OSX
-#endif // _WIN32
-
-#include <openssl/err.h>
-#include <openssl/evp.h>
-#include <openssl/ssl.h>
-#include <openssl/x509v3.h>
-
-#if defined(_WIN32) && defined(OPENSSL_USE_APPLINK)
-#include <openssl/applink.c>
-#endif
-
-#include <iostream>
-#include <sstream>
-
-#if OPENSSL_VERSION_NUMBER < 0x1010100fL
-#error Sorry, OpenSSL versions prior to 1.1.1 are not supported
-#elif OPENSSL_VERSION_NUMBER < 0x30000000L
-#define SSL_get1_peer_certificate SSL_get_peer_certificate
-#endif
-
-#endif
-
-#ifdef CPPHTTPLIB_ZLIB_SUPPORT
-#include <zlib.h>
-#endif
-
-#ifdef CPPHTTPLIB_BROTLI_SUPPORT
-#include <brotli/decode.h>
-#include <brotli/encode.h>
-#endif
-
-/*
- * Declaration
- */
-namespace httplib {
-
-namespace detail {
-
-/*
- * Backport std::make_unique from C++14.
- *
- * NOTE: This code came up with the following stackoverflow post:
- * https://stackoverflow.com/questions/10149840/c-arrays-and-make-unique
- *
- */
-
-template <class T, class... Args>
-typename std::enable_if<!std::is_array<T>::value, std::unique_ptr<T>>::type
-make_unique(Args &&...args) {
- return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
-}
-
-template <class T>
-typename std::enable_if<std::is_array<T>::value, std::unique_ptr<T>>::type
-make_unique(std::size_t n) {
- typedef typename std::remove_extent<T>::type RT;
- return std::unique_ptr<T>(new RT[n]);
-}
-
-struct ci {
- bool operator()(const std::string &s1, const std::string &s2) const {
- return std::lexicographical_compare(s1.begin(), s1.end(), s2.begin(),
- s2.end(),
- [](unsigned char c1, unsigned char c2) {
- return ::tolower(c1) < ::tolower(c2);
- });
- }
-};
-
-// This is based on
-// "http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4189".
-
-struct scope_exit {
- explicit scope_exit(std::function<void(void)> &&f)
- : exit_function(std::move(f)), execute_on_destruction{true} {}
-
- scope_exit(scope_exit &&rhs)
- : exit_function(std::move(rhs.exit_function)),
- execute_on_destruction{rhs.execute_on_destruction} {
- rhs.release();
- }
-
- ~scope_exit() {
- if (execute_on_destruction) { this->exit_function(); }
- }
-
- void release() { this->execute_on_destruction = false; }
-
-private:
- scope_exit(const scope_exit &) = delete;
- void operator=(const scope_exit &) = delete;
- scope_exit &operator=(scope_exit &&) = delete;
-
- std::function<void(void)> exit_function;
- bool execute_on_destruction;
-};
-
-} // namespace detail
-
-using Headers = std::multimap<std::string, std::string, detail::ci>;
-
-using Params = std::multimap<std::string, std::string>;
-using Match = std::smatch;
-
-using Progress = std::function<bool(uint64_t current, uint64_t total)>;
-
-struct Response;
-using ResponseHandler = std::function<bool(const Response &response)>;
-
-struct MultipartFormData {
- std::string name;
- std::string content;
- std::string filename;
- std::string content_type;
-};
-using MultipartFormDataItems = std::vector<MultipartFormData>;
-using MultipartFormDataMap = std::multimap<std::string, MultipartFormData>;
-
-class DataSink {
-public:
- DataSink() : os(&sb_), sb_(*this) {}
-
- DataSink(const DataSink &) = delete;
- DataSink &operator=(const DataSink &) = delete;
- DataSink(DataSink &&) = delete;
- DataSink &operator=(DataSink &&) = delete;
-
- std::function<bool(const char *data, size_t data_len)> write;
- std::function<void()> done;
- std::function<void(const Headers &trailer)> done_with_trailer;
- std::ostream os;
-
-private:
- class data_sink_streambuf : public std::streambuf {
- public:
- explicit data_sink_streambuf(DataSink &sink) : sink_(sink) {}
-
- protected:
- std::streamsize xsputn(const char *s, std::streamsize n) {
- sink_.write(s, static_cast<size_t>(n));
- return n;
- }
-
- private:
- DataSink &sink_;
- };
-
- data_sink_streambuf sb_;
-};
-
-using ContentProvider =
- std::function<bool(size_t offset, size_t length, DataSink &sink)>;
-
-using ContentProviderWithoutLength =
- std::function<bool(size_t offset, DataSink &sink)>;
-
-using ContentProviderResourceReleaser = std::function<void(bool success)>;
-
-struct MultipartFormDataProvider {
- std::string name;
- ContentProviderWithoutLength provider;
- std::string filename;
- std::string content_type;
-};
-using MultipartFormDataProviderItems = std::vector<MultipartFormDataProvider>;
-
-using ContentReceiverWithProgress =
- std::function<bool(const char *data, size_t data_length, uint64_t offset,
- uint64_t total_length)>;
-
-using ContentReceiver =
- std::function<bool(const char *data, size_t data_length)>;
-
-using MultipartContentHeader =
- std::function<bool(const MultipartFormData &file)>;
-
-class ContentReader {
-public:
- using Reader = std::function<bool(ContentReceiver receiver)>;
- using MultipartReader = std::function<bool(MultipartContentHeader header,
- ContentReceiver receiver)>;
-
- ContentReader(Reader reader, MultipartReader multipart_reader)
- : reader_(std::move(reader)),
- multipart_reader_(std::move(multipart_reader)) {}
-
- bool operator()(MultipartContentHeader header,
- ContentReceiver receiver) const {
- return multipart_reader_(std::move(header), std::move(receiver));
- }
-
- bool operator()(ContentReceiver receiver) const {
- return reader_(std::move(receiver));
- }
-
- Reader reader_;
- MultipartReader multipart_reader_;
-};
-
-using Range = std::pair<ssize_t, ssize_t>;
-using Ranges = std::vector<Range>;
-
-struct Request {
- std::string method;
- std::string path;
- Headers headers;
- std::string body;
-
- std::string remote_addr;
- int remote_port = -1;
- std::string local_addr;
- int local_port = -1;
-
- // for server
- std::string version;
- std::string target;
- Params params;
- MultipartFormDataMap files;
- Ranges ranges;
- Match matches;
- std::unordered_map<std::string, std::string> path_params;
-
- // for client
- ResponseHandler response_handler;
- ContentReceiverWithProgress content_receiver;
- Progress progress;
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
- const SSL *ssl = nullptr;
-#endif
-
- bool has_header(const std::string &key) const;
- std::string get_header_value(const std::string &key, size_t id = 0) const;
- uint64_t get_header_value_u64(const std::string &key, size_t id = 0) const;
- size_t get_header_value_count(const std::string &key) const;
- void set_header(const std::string &key, const std::string &val);
-
- bool has_param(const std::string &key) const;
- std::string get_param_value(const std::string &key, size_t id = 0) const;
- size_t get_param_value_count(const std::string &key) const;
-
- bool is_multipart_form_data() const;
-
- bool has_file(const std::string &key) const;
- MultipartFormData get_file_value(const std::string &key) const;
- std::vector<MultipartFormData> get_file_values(const std::string &key) const;
-
- // private members...
- size_t redirect_count_ = CPPHTTPLIB_REDIRECT_MAX_COUNT;
- size_t content_length_ = 0;
- ContentProvider content_provider_;
- bool is_chunked_content_provider_ = false;
- size_t authorization_count_ = 0;
-};
-
-struct Response {
- std::string version;
- int status = -1;
- std::string reason;
- Headers headers;
- std::string body;
- std::string location; // Redirect location
-
- bool has_header(const std::string &key) const;
- std::string get_header_value(const std::string &key, size_t id = 0) const;
- uint64_t get_header_value_u64(const std::string &key, size_t id = 0) const;
- size_t get_header_value_count(const std::string &key) const;
- void set_header(const std::string &key, const std::string &val);
-
- void set_redirect(const std::string &url, int status = 302);
- void set_content(const char *s, size_t n, const std::string &content_type);
- void set_content(const std::string &s, const std::string &content_type);
-
- void set_content_provider(
- size_t length, const std::string &content_type, ContentProvider provider,
- ContentProviderResourceReleaser resource_releaser = nullptr);
-
- void set_content_provider(
- const std::string &content_type, ContentProviderWithoutLength provider,
- ContentProviderResourceReleaser resource_releaser = nullptr);
-
- void set_chunked_content_provider(
- const std::string &content_type, ContentProviderWithoutLength provider,
- ContentProviderResourceReleaser resource_releaser = nullptr);
-
- Response() = default;
- Response(const Response &) = default;
- Response &operator=(const Response &) = default;
- Response(Response &&) = default;
- Response &operator=(Response &&) = default;
- ~Response() {
- if (content_provider_resource_releaser_) {
- content_provider_resource_releaser_(content_provider_success_);
- }
- }
-
- // private members...
- size_t content_length_ = 0;
- ContentProvider content_provider_;
- ContentProviderResourceReleaser content_provider_resource_releaser_;
- bool is_chunked_content_provider_ = false;
- bool content_provider_success_ = false;
-};
-
-class Stream {
-public:
- virtual ~Stream() = default;
-
- virtual bool is_readable() const = 0;
- virtual bool is_writable() const = 0;
-
- virtual ssize_t read(char *ptr, size_t size) = 0;
- virtual ssize_t write(const char *ptr, size_t size) = 0;
- virtual void get_remote_ip_and_port(std::string &ip, int &port) const = 0;
- virtual void get_local_ip_and_port(std::string &ip, int &port) const = 0;
- virtual socket_t socket() const = 0;
-
- template <typename... Args>
- ssize_t write_format(const char *fmt, const Args &...args);
- ssize_t write(const char *ptr);
- ssize_t write(const std::string &s);
-};
-
-class TaskQueue {
-public:
- TaskQueue() = default;
- virtual ~TaskQueue() = default;
-
- virtual void enqueue(std::function<void()> fn) = 0;
- virtual void shutdown() = 0;
-
- virtual void on_idle() {}
-};
-
-class ThreadPool : public TaskQueue {
-public:
- explicit ThreadPool(size_t n) : shutdown_(false) {
- while (n) {
- threads_.emplace_back(worker(*this));
- n--;
- }
- }
-
- ThreadPool(const ThreadPool &) = delete;
- ~ThreadPool() override = default;
-
- void enqueue(std::function<void()> fn) override {
- {
- std::unique_lock<std::mutex> lock(mutex_);
- jobs_.push_back(std::move(fn));
- }
-
- cond_.notify_one();
- }
-
- void shutdown() override {
- // Stop all worker threads...
- {
- std::unique_lock<std::mutex> lock(mutex_);
- shutdown_ = true;
- }
-
- cond_.notify_all();
-
- // Join...
- for (auto &t : threads_) {
- t.join();
- }
- }
-
-private:
- struct worker {
- explicit worker(ThreadPool &pool) : pool_(pool) {}
-
- void operator()() {
- for (;;) {
- std::function<void()> fn;
- {
- std::unique_lock<std::mutex> lock(pool_.mutex_);
-
- pool_.cond_.wait(
- lock, [&] { return !pool_.jobs_.empty() || pool_.shutdown_; });
-
- if (pool_.shutdown_ && pool_.jobs_.empty()) { break; }
-
- fn = std::move(pool_.jobs_.front());
- pool_.jobs_.pop_front();
- }
-
- assert(true == static_cast<bool>(fn));
- fn();
- }
- }
-
- ThreadPool &pool_;
- };
- friend struct worker;
-
- std::vector<std::thread> threads_;
- std::list<std::function<void()>> jobs_;
-
- bool shutdown_;
-
- std::condition_variable cond_;
- std::mutex mutex_;
-};
-
-using Logger = std::function<void(const Request &, const Response &)>;
-
-using SocketOptions = std::function<void(socket_t sock)>;
-
-void default_socket_options(socket_t sock);
-
-const char *status_message(int status);
-
-namespace detail {
-
-class MatcherBase {
-public:
- virtual ~MatcherBase() = default;
-
- // Match request path and populate its matches and
- virtual bool match(Request &request) const = 0;
-};
-
-/**
- * Captures parameters in request path and stores them in Request::path_params
- *
- * Capture name is a substring of a pattern from : to /.
- * The rest of the pattern is matched agains the request path directly
- * Parameters are captured starting from the next character after
- * the end of the last matched static pattern fragment until the next /.
- *
- * Example pattern:
- * "/path/fragments/:capture/more/fragments/:second_capture"
- * Static fragments:
- * "/path/fragments/", "more/fragments/"
- *
- * Given the following request path:
- * "/path/fragments/:1/more/fragments/:2"
- * the resulting capture will be
- * {{"capture", "1"}, {"second_capture", "2"}}
- */
-class PathParamsMatcher : public MatcherBase {
-public:
- PathParamsMatcher(const std::string &pattern);
-
- bool match(Request &request) const override;
-
-private:
- static constexpr char marker = ':';
- // Treat segment separators as the end of path parameter capture
- // Does not need to handle query parameters as they are parsed before path
- // matching
- static constexpr char separator = '/';
-
- // Contains static path fragments to match against, excluding the '/' after
- // path params
- // Fragments are separated by path params
- std::vector<std::string> static_fragments_;
- // Stores the names of the path parameters to be used as keys in the
- // Request::path_params map
- std::vector<std::string> param_names_;
-};
-
-/**
- * Performs std::regex_match on request path
- * and stores the result in Request::matches
- *
- * Note that regex match is performed directly on the whole request.
- * This means that wildcard patterns may match multiple path segments with /:
- * "/begin/(.*)/end" will match both "/begin/middle/end" and "/begin/1/2/end".
- */
-class RegexMatcher : public MatcherBase {
-public:
- RegexMatcher(const std::string &pattern) : regex_(pattern) {}
-
- bool match(Request &request) const override;
-
-private:
- std::regex regex_;
-};
-
-ssize_t write_headers(Stream &strm, const Headers &headers);
-
-} // namespace detail
-
-class Server {
-public:
- using Handler = std::function<void(const Request &, Response &)>;
-
- using ExceptionHandler =
- std::function<void(const Request &, Response &, std::exception_ptr ep)>;
-
- enum class HandlerResponse {
- Handled,
- Unhandled,
- };
- using HandlerWithResponse =
- std::function<HandlerResponse(const Request &, Response &)>;
-
- using HandlerWithContentReader = std::function<void(
- const Request &, Response &, const ContentReader &content_reader)>;
-
- using Expect100ContinueHandler =
- std::function<int(const Request &, Response &)>;
-
- Server();
-
- virtual ~Server();
-
- virtual bool is_valid() const;
-
- Server &Get(const std::string &pattern, Handler handler);
- Server &Post(const std::string &pattern, Handler handler);
- Server &Post(const std::string &pattern, HandlerWithContentReader handler);
- Server &Put(const std::string &pattern, Handler handler);
- Server &Put(const std::string &pattern, HandlerWithContentReader handler);
- Server &Patch(const std::string &pattern, Handler handler);
- Server &Patch(const std::string &pattern, HandlerWithContentReader handler);
- Server &Delete(const std::string &pattern, Handler handler);
- Server &Delete(const std::string &pattern, HandlerWithContentReader handler);
- Server &Options(const std::string &pattern, Handler handler);
-
- bool set_base_dir(const std::string &dir,
- const std::string &mount_point = std::string());
- bool set_mount_point(const std::string &mount_point, const std::string &dir,
- Headers headers = Headers());
- bool remove_mount_point(const std::string &mount_point);
- Server &set_file_extension_and_mimetype_mapping(const std::string &ext,
- const std::string &mime);
- Server &set_default_file_mimetype(const std::string &mime);
- Server &set_file_request_handler(Handler handler);
-
- Server &set_error_handler(HandlerWithResponse handler);
- Server &set_error_handler(Handler handler);
- Server &set_exception_handler(ExceptionHandler handler);
- Server &set_pre_routing_handler(HandlerWithResponse handler);
- Server &set_post_routing_handler(Handler handler);
-
- Server &set_expect_100_continue_handler(Expect100ContinueHandler handler);
- Server &set_logger(Logger logger);
-
- Server &set_address_family(int family);
- Server &set_tcp_nodelay(bool on);
- Server &set_socket_options(SocketOptions socket_options);
-
- Server &set_default_headers(Headers headers);
- Server &
- set_header_writer(std::function<ssize_t(Stream &, Headers &)> const &writer);
-
- Server &set_keep_alive_max_count(size_t count);
- Server &set_keep_alive_timeout(time_t sec);
-
- Server &set_read_timeout(time_t sec, time_t usec = 0);
- template <class Rep, class Period>
- Server &set_read_timeout(const std::chrono::duration<Rep, Period> &duration);
-
- Server &set_write_timeout(time_t sec, time_t usec = 0);
- template <class Rep, class Period>
- Server &set_write_timeout(const std::chrono::duration<Rep, Period> &duration);
-
- Server &set_idle_interval(time_t sec, time_t usec = 0);
- template <class Rep, class Period>
- Server &set_idle_interval(const std::chrono::duration<Rep, Period> &duration);
-
- Server &set_payload_max_length(size_t length);
-
- bool bind_to_port(const std::string &host, int port, int socket_flags = 0);
- int bind_to_any_port(const std::string &host, int socket_flags = 0);
- bool listen_after_bind();
-
- bool listen(const std::string &host, int port, int socket_flags = 0);
-
- bool is_running() const;
- void wait_until_ready() const;
- void stop();
-
- std::function<TaskQueue *(void)> new_task_queue;
-
-protected:
- bool process_request(Stream &strm, bool close_connection,
- bool &connection_closed,
- const std::function<void(Request &)> &setup_request);
-
- std::atomic<socket_t> svr_sock_{INVALID_SOCKET};
- size_t keep_alive_max_count_ = CPPHTTPLIB_KEEPALIVE_MAX_COUNT;
- time_t keep_alive_timeout_sec_ = CPPHTTPLIB_KEEPALIVE_TIMEOUT_SECOND;
- time_t read_timeout_sec_ = CPPHTTPLIB_READ_TIMEOUT_SECOND;
- time_t read_timeout_usec_ = CPPHTTPLIB_READ_TIMEOUT_USECOND;
- time_t write_timeout_sec_ = CPPHTTPLIB_WRITE_TIMEOUT_SECOND;
- time_t write_timeout_usec_ = CPPHTTPLIB_WRITE_TIMEOUT_USECOND;
- time_t idle_interval_sec_ = CPPHTTPLIB_IDLE_INTERVAL_SECOND;
- time_t idle_interval_usec_ = CPPHTTPLIB_IDLE_INTERVAL_USECOND;
- size_t payload_max_length_ = CPPHTTPLIB_PAYLOAD_MAX_LENGTH;
-
-private:
- using Handlers =
- std::vector<std::pair<std::unique_ptr<detail::MatcherBase>, Handler>>;
- using HandlersForContentReader =
- std::vector<std::pair<std::unique_ptr<detail::MatcherBase>,
- HandlerWithContentReader>>;
-
- static std::unique_ptr<detail::MatcherBase>
- make_matcher(const std::string &pattern);
-
- socket_t create_server_socket(const std::string &host, int port,
- int socket_flags,
- SocketOptions socket_options) const;
- int bind_internal(const std::string &host, int port, int socket_flags);
- bool listen_internal();
-
- bool routing(Request &req, Response &res, Stream &strm);
- bool handle_file_request(const Request &req, Response &res,
- bool head = false);
- bool dispatch_request(Request &req, Response &res, const Handlers &handlers);
- bool
- dispatch_request_for_content_reader(Request &req, Response &res,
- ContentReader content_reader,
- const HandlersForContentReader &handlers);
-
- bool parse_request_line(const char *s, Request &req);
- void apply_ranges(const Request &req, Response &res,
- std::string &content_type, std::string &boundary);
- bool write_response(Stream &strm, bool close_connection, const Request &req,
- Response &res);
- bool write_response_with_content(Stream &strm, bool close_connection,
- const Request &req, Response &res);
- bool write_response_core(Stream &strm, bool close_connection,
- const Request &req, Response &res,
- bool need_apply_ranges);
- bool write_content_with_provider(Stream &strm, const Request &req,
- Response &res, const std::string &boundary,
- const std::string &content_type);
- bool read_content(Stream &strm, Request &req, Response &res);
- bool
- read_content_with_content_receiver(Stream &strm, Request &req, Response &res,
- ContentReceiver receiver,
- MultipartContentHeader multipart_header,
- ContentReceiver multipart_receiver);
- bool read_content_core(Stream &strm, Request &req, Response &res,
- ContentReceiver receiver,
- MultipartContentHeader multipart_header,
- ContentReceiver multipart_receiver);
-
- virtual bool process_and_close_socket(socket_t sock);
-
- std::atomic<bool> is_running_{false};
- std::atomic<bool> done_{false};
-
- struct MountPointEntry {
- std::string mount_point;
- std::string base_dir;
- Headers headers;
- };
- std::vector<MountPointEntry> base_dirs_;
- std::map<std::string, std::string> file_extension_and_mimetype_map_;
- std::string default_file_mimetype_ = "application/octet-stream";
- Handler file_request_handler_;
-
- Handlers get_handlers_;
- Handlers post_handlers_;
- HandlersForContentReader post_handlers_for_content_reader_;
- Handlers put_handlers_;
- HandlersForContentReader put_handlers_for_content_reader_;
- Handlers patch_handlers_;
- HandlersForContentReader patch_handlers_for_content_reader_;
- Handlers delete_handlers_;
- HandlersForContentReader delete_handlers_for_content_reader_;
- Handlers options_handlers_;
-
- HandlerWithResponse error_handler_;
- ExceptionHandler exception_handler_;
- HandlerWithResponse pre_routing_handler_;
- Handler post_routing_handler_;
- Expect100ContinueHandler expect_100_continue_handler_;
-
- Logger logger_;
-
- int address_family_ = AF_UNSPEC;
- bool tcp_nodelay_ = CPPHTTPLIB_TCP_NODELAY;
- SocketOptions socket_options_ = default_socket_options;
-
- Headers default_headers_;
- std::function<ssize_t(Stream &, Headers &)> header_writer_ =
- detail::write_headers;
-};
-
-enum class Error {
- Success = 0,
- Unknown,
- Connection,
- BindIPAddress,
- Read,
- Write,
- ExceedRedirectCount,
- Canceled,
- SSLConnection,
- SSLLoadingCerts,
- SSLServerVerification,
- UnsupportedMultipartBoundaryChars,
- Compression,
- ConnectionTimeout,
- ProxyConnection,
-
- // For internal use only
- SSLPeerCouldBeClosed_,
-};
-
-std::string to_string(const Error error);
-
-std::ostream &operator<<(std::ostream &os, const Error &obj);
-
-class Result {
-public:
- Result() = default;
- Result(std::unique_ptr<Response> &&res, Error err,
- Headers &&request_headers = Headers{})
- : res_(std::move(res)), err_(err),
- request_headers_(std::move(request_headers)) {}
- // Response
- operator bool() const { return res_ != nullptr; }
- bool operator==(std::nullptr_t) const { return res_ == nullptr; }
- bool operator!=(std::nullptr_t) const { return res_ != nullptr; }
- const Response &value() const { return *res_; }
- Response &value() { return *res_; }
- const Response &operator*() const { return *res_; }
- Response &operator*() { return *res_; }
- const Response *operator->() const { return res_.get(); }
- Response *operator->() { return res_.get(); }
-
- // Error
- Error error() const { return err_; }
-
- // Request Headers
- bool has_request_header(const std::string &key) const;
- std::string get_request_header_value(const std::string &key,
- size_t id = 0) const;
- uint64_t get_request_header_value_u64(const std::string &key,
- size_t id = 0) const;
- size_t get_request_header_value_count(const std::string &key) const;
-
-private:
- std::unique_ptr<Response> res_;
- Error err_ = Error::Unknown;
- Headers request_headers_;
-};
-
-class ClientImpl {
-public:
- explicit ClientImpl(const std::string &host);
-
- explicit ClientImpl(const std::string &host, int port);
-
- explicit ClientImpl(const std::string &host, int port,
- const std::string &client_cert_path,
- const std::string &client_key_path);
-
- virtual ~ClientImpl();
-
- virtual bool is_valid() const;
-
- Result Get(const std::string &path);
- Result Get(const std::string &path, const Headers &headers);
- Result Get(const std::string &path, Progress progress);
- Result Get(const std::string &path, const Headers &headers,
- Progress progress);
- Result Get(const std::string &path, ContentReceiver content_receiver);
- Result Get(const std::string &path, const Headers &headers,
- ContentReceiver content_receiver);
- Result Get(const std::string &path, ContentReceiver content_receiver,
- Progress progress);
- Result Get(const std::string &path, const Headers &headers,
- ContentReceiver content_receiver, Progress progress);
- Result Get(const std::string &path, ResponseHandler response_handler,
- ContentReceiver content_receiver);
- Result Get(const std::string &path, const Headers &headers,
- ResponseHandler response_handler,
- ContentReceiver content_receiver);
- Result Get(const std::string &path, ResponseHandler response_handler,
- ContentReceiver content_receiver, Progress progress);
- Result Get(const std::string &path, const Headers &headers,
- ResponseHandler response_handler, ContentReceiver content_receiver,
- Progress progress);
-
- Result Get(const std::string &path, const Params &params,
- const Headers &headers, Progress progress = nullptr);
- Result Get(const std::string &path, const Params &params,
- const Headers &headers, ContentReceiver content_receiver,
- Progress progress = nullptr);
- Result Get(const std::string &path, const Params &params,
- const Headers &headers, ResponseHandler response_handler,
- ContentReceiver content_receiver, Progress progress = nullptr);
-
- Result Head(const std::string &path);
- Result Head(const std::string &path, const Headers &headers);
-
- Result Post(const std::string &path);
- Result Post(const std::string &path, const Headers &headers);
- Result Post(const std::string &path, const char *body, size_t content_length,
- const std::string &content_type);
- Result Post(const std::string &path, const Headers &headers, const char *body,
- size_t content_length, const std::string &content_type);
- Result Post(const std::string &path, const std::string &body,
- const std::string &content_type);
- Result Post(const std::string &path, const Headers &headers,
- const std::string &body, const std::string &content_type);
- Result Post(const std::string &path, size_t content_length,
- ContentProvider content_provider,
- const std::string &content_type);
- Result Post(const std::string &path,
- ContentProviderWithoutLength content_provider,
- const std::string &content_type);
- Result Post(const std::string &path, const Headers &headers,
- size_t content_length, ContentProvider content_provider,
- const std::string &content_type);
- Result Post(const std::string &path, const Headers &headers,
- ContentProviderWithoutLength content_provider,
- const std::string &content_type);
- Result Post(const std::string &path, const Params &params);
- Result Post(const std::string &path, const Headers &headers,
- const Params &params);
- Result Post(const std::string &path, const MultipartFormDataItems &items);
- Result Post(const std::string &path, const Headers &headers,
- const MultipartFormDataItems &items);
- Result Post(const std::string &path, const Headers &headers,
- const MultipartFormDataItems &items, const std::string &boundary);
- Result Post(const std::string &path, const Headers &headers,
- const MultipartFormDataItems &items,
- const MultipartFormDataProviderItems &provider_items);
-
- Result Put(const std::string &path);
- Result Put(const std::string &path, const char *body, size_t content_length,
- const std::string &content_type);
- Result Put(const std::string &path, const Headers &headers, const char *body,
- size_t content_length, const std::string &content_type);
- Result Put(const std::string &path, const std::string &body,
- const std::string &content_type);
- Result Put(const std::string &path, const Headers &headers,
- const std::string &body, const std::string &content_type);
- Result Put(const std::string &path, size_t content_length,
- ContentProvider content_provider, const std::string &content_type);
- Result Put(const std::string &path,
- ContentProviderWithoutLength content_provider,
- const std::string &content_type);
- Result Put(const std::string &path, const Headers &headers,
- size_t content_length, ContentProvider content_provider,
- const std::string &content_type);
- Result Put(const std::string &path, const Headers &headers,
- ContentProviderWithoutLength content_provider,
- const std::string &content_type);
- Result Put(const std::string &path, const Params &params);
- Result Put(const std::string &path, const Headers &headers,
- const Params &params);
- Result Put(const std::string &path, const MultipartFormDataItems &items);
- Result Put(const std::string &path, const Headers &headers,
- const MultipartFormDataItems &items);
- Result Put(const std::string &path, const Headers &headers,
- const MultipartFormDataItems &items, const std::string &boundary);
- Result Put(const std::string &path, const Headers &headers,
- const MultipartFormDataItems &items,
- const MultipartFormDataProviderItems &provider_items);
-
- Result Patch(const std::string &path);
- Result Patch(const std::string &path, const char *body, size_t content_length,
- const std::string &content_type);
- Result Patch(const std::string &path, const Headers &headers,
- const char *body, size_t content_length,
- const std::string &content_type);
- Result Patch(const std::string &path, const std::string &body,
- const std::string &content_type);
- Result Patch(const std::string &path, const Headers &headers,
- const std::string &body, const std::string &content_type);
- Result Patch(const std::string &path, size_t content_length,
- ContentProvider content_provider,
- const std::string &content_type);
- Result Patch(const std::string &path,
- ContentProviderWithoutLength content_provider,
- const std::string &content_type);
- Result Patch(const std::string &path, const Headers &headers,
- size_t content_length, ContentProvider content_provider,
- const std::string &content_type);
- Result Patch(const std::string &path, const Headers &headers,
- ContentProviderWithoutLength content_provider,
- const std::string &content_type);
-
- Result Delete(const std::string &path);
- Result Delete(const std::string &path, const Headers &headers);
- Result Delete(const std::string &path, const char *body,
- size_t content_length, const std::string &content_type);
- Result Delete(const std::string &path, const Headers &headers,
- const char *body, size_t content_length,
- const std::string &content_type);
- Result Delete(const std::string &path, const std::string &body,
- const std::string &content_type);
- Result Delete(const std::string &path, const Headers &headers,
- const std::string &body, const std::string &content_type);
-
- Result Options(const std::string &path);
- Result Options(const std::string &path, const Headers &headers);
-
- bool send(Request &req, Response &res, Error &error);
- Result send(const Request &req);
-
- void stop();
-
- std::string host() const;
- int port() const;
-
- size_t is_socket_open() const;
- socket_t socket() const;
-
- void set_hostname_addr_map(std::map<std::string, std::string> addr_map);
-
- void set_default_headers(Headers headers);
-
- void
- set_header_writer(std::function<ssize_t(Stream &, Headers &)> const &writer);
-
- void set_address_family(int family);
- void set_tcp_nodelay(bool on);
- void set_socket_options(SocketOptions socket_options);
-
- void set_connection_timeout(time_t sec, time_t usec = 0);
- template <class Rep, class Period>
- void
- set_connection_timeout(const std::chrono::duration<Rep, Period> &duration);
-
- void set_read_timeout(time_t sec, time_t usec = 0);
- template <class Rep, class Period>
- void set_read_timeout(const std::chrono::duration<Rep, Period> &duration);
-
- void set_write_timeout(time_t sec, time_t usec = 0);
- template <class Rep, class Period>
- void set_write_timeout(const std::chrono::duration<Rep, Period> &duration);
-
- void set_basic_auth(const std::string &username, const std::string &password);
- void set_bearer_token_auth(const std::string &token);
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
- void set_digest_auth(const std::string &username,
- const std::string &password);
-#endif
-
- void set_keep_alive(bool on);
- void set_follow_location(bool on);
-
- void set_url_encode(bool on);
-
- void set_compress(bool on);
-
- void set_decompress(bool on);
-
- void set_interface(const std::string &intf);
-
- void set_proxy(const std::string &host, int port);
- void set_proxy_basic_auth(const std::string &username,
- const std::string &password);
- void set_proxy_bearer_token_auth(const std::string &token);
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
- void set_proxy_digest_auth(const std::string &username,
- const std::string &password);
-#endif
-
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
- void set_ca_cert_path(const std::string &ca_cert_file_path,
- const std::string &ca_cert_dir_path = std::string());
- void set_ca_cert_store(X509_STORE *ca_cert_store);
- X509_STORE *create_ca_cert_store(const char *ca_cert, std::size_t size);
-#endif
-
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
- void enable_server_certificate_verification(bool enabled);
-#endif
-
- void set_logger(Logger logger);
-
-protected:
- struct Socket {
- socket_t sock = INVALID_SOCKET;
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
- SSL *ssl = nullptr;
-#endif
-
- bool is_open() const { return sock != INVALID_SOCKET; }
- };
-
- virtual bool create_and_connect_socket(Socket &socket, Error &error);
-
- // All of:
- // shutdown_ssl
- // shutdown_socket
- // close_socket
- // should ONLY be called when socket_mutex_ is locked.
- // Also, shutdown_ssl and close_socket should also NOT be called concurrently
- // with a DIFFERENT thread sending requests using that socket.
- virtual void shutdown_ssl(Socket &socket, bool shutdown_gracefully);
- void shutdown_socket(Socket &socket);
- void close_socket(Socket &socket);
-
- bool process_request(Stream &strm, Request &req, Response &res,
- bool close_connection, Error &error);
-
- bool write_content_with_provider(Stream &strm, const Request &req,
- Error &error);
-
- void copy_settings(const ClientImpl &rhs);
-
- // Socket endpoint information
- const std::string host_;
- const int port_;
- const std::string host_and_port_;
-
- // Current open socket
- Socket socket_;
- mutable std::mutex socket_mutex_;
- std::recursive_mutex request_mutex_;
-
- // These are all protected under socket_mutex
- size_t socket_requests_in_flight_ = 0;
- std::thread::id socket_requests_are_from_thread_ = std::thread::id();
- bool socket_should_be_closed_when_request_is_done_ = false;
-
- // Hostname-IP map
- std::map<std::string, std::string> addr_map_;
-
- // Default headers
- Headers default_headers_;
-
- // Header writer
- std::function<ssize_t(Stream &, Headers &)> header_writer_ =
- detail::write_headers;
-
- // Settings
- std::string client_cert_path_;
- std::string client_key_path_;
-
- time_t connection_timeout_sec_ = CPPHTTPLIB_CONNECTION_TIMEOUT_SECOND;
- time_t connection_timeout_usec_ = CPPHTTPLIB_CONNECTION_TIMEOUT_USECOND;
- time_t read_timeout_sec_ = CPPHTTPLIB_READ_TIMEOUT_SECOND;
- time_t read_timeout_usec_ = CPPHTTPLIB_READ_TIMEOUT_USECOND;
- time_t write_timeout_sec_ = CPPHTTPLIB_WRITE_TIMEOUT_SECOND;
- time_t write_timeout_usec_ = CPPHTTPLIB_WRITE_TIMEOUT_USECOND;
-
- std::string basic_auth_username_;
- std::string basic_auth_password_;
- std::string bearer_token_auth_token_;
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
- std::string digest_auth_username_;
- std::string digest_auth_password_;
-#endif
-
- bool keep_alive_ = false;
- bool follow_location_ = false;
-
- bool url_encode_ = true;
-
- int address_family_ = AF_UNSPEC;
- bool tcp_nodelay_ = CPPHTTPLIB_TCP_NODELAY;
- SocketOptions socket_options_ = nullptr;
-
- bool compress_ = false;
- bool decompress_ = true;
-
- std::string interface_;
-
- std::string proxy_host_;
- int proxy_port_ = -1;
-
- std::string proxy_basic_auth_username_;
- std::string proxy_basic_auth_password_;
- std::string proxy_bearer_token_auth_token_;
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
- std::string proxy_digest_auth_username_;
- std::string proxy_digest_auth_password_;
-#endif
-
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
- std::string ca_cert_file_path_;
- std::string ca_cert_dir_path_;
-
- X509_STORE *ca_cert_store_ = nullptr;
-#endif
-
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
- bool server_certificate_verification_ = true;
-#endif
-
- Logger logger_;
-
-private:
- bool send_(Request &req, Response &res, Error &error);
- Result send_(Request &&req);
-
- socket_t create_client_socket(Error &error) const;
- bool read_response_line(Stream &strm, const Request &req, Response &res);
- bool write_request(Stream &strm, Request &req, bool close_connection,
- Error &error);
- bool redirect(Request &req, Response &res, Error &error);
- bool handle_request(Stream &strm, Request &req, Response &res,
- bool close_connection, Error &error);
- std::unique_ptr<Response> send_with_content_provider(
- Request &req, const char *body, size_t content_length,
- ContentProvider content_provider,
- ContentProviderWithoutLength content_provider_without_length,
- const std::string &content_type, Error &error);
- Result send_with_content_provider(
- const std::string &method, const std::string &path,
- const Headers &headers, const char *body, size_t content_length,
- ContentProvider content_provider,
- ContentProviderWithoutLength content_provider_without_length,
- const std::string &content_type);
- ContentProviderWithoutLength get_multipart_content_provider(
- const std::string &boundary, const MultipartFormDataItems &items,
- const MultipartFormDataProviderItems &provider_items);
-
- std::string adjust_host_string(const std::string &host) const;
-
- virtual bool process_socket(const Socket &socket,
- std::function<bool(Stream &strm)> callback);
- virtual bool is_ssl() const;
-};
-
-class Client {
-public:
- // Universal interface
- explicit Client(const std::string &scheme_host_port);
-
- explicit Client(const std::string &scheme_host_port,
- const std::string &client_cert_path,
- const std::string &client_key_path);
-
- // HTTP only interface
- explicit Client(const std::string &host, int port);
-
- explicit Client(const std::string &host, int port,
- const std::string &client_cert_path,
- const std::string &client_key_path);
-
- Client(Client &&) = default;
-
- ~Client();
-
- bool is_valid() const;
-
- Result Get(const std::string &path);
- Result Get(const std::string &path, const Headers &headers);
- Result Get(const std::string &path, Progress progress);
- Result Get(const std::string &path, const Headers &headers,
- Progress progress);
- Result Get(const std::string &path, ContentReceiver content_receiver);
- Result Get(const std::string &path, const Headers &headers,
- ContentReceiver content_receiver);
- Result Get(const std::string &path, ContentReceiver content_receiver,
- Progress progress);
- Result Get(const std::string &path, const Headers &headers,
- ContentReceiver content_receiver, Progress progress);
- Result Get(const std::string &path, ResponseHandler response_handler,
- ContentReceiver content_receiver);
- Result Get(const std::string &path, const Headers &headers,
- ResponseHandler response_handler,
- ContentReceiver content_receiver);
- Result Get(const std::string &path, const Headers &headers,
- ResponseHandler response_handler, ContentReceiver content_receiver,
- Progress progress);
- Result Get(const std::string &path, ResponseHandler response_handler,
- ContentReceiver content_receiver, Progress progress);
-
- Result Get(const std::string &path, const Params &params,
- const Headers &headers, Progress progress = nullptr);
- Result Get(const std::string &path, const Params &params,
- const Headers &headers, ContentReceiver content_receiver,
- Progress progress = nullptr);
- Result Get(const std::string &path, const Params &params,
- const Headers &headers, ResponseHandler response_handler,
- ContentReceiver content_receiver, Progress progress = nullptr);
-
- Result Head(const std::string &path);
- Result Head(const std::string &path, const Headers &headers);
-
- Result Post(const std::string &path);
- Result Post(const std::string &path, const Headers &headers);
- Result Post(const std::string &path, const char *body, size_t content_length,
- const std::string &content_type);
- Result Post(const std::string &path, const Headers &headers, const char *body,
- size_t content_length, const std::string &content_type);
- Result Post(const std::string &path, const std::string &body,
- const std::string &content_type);
- Result Post(const std::string &path, const Headers &headers,
- const std::string &body, const std::string &content_type);
- Result Post(const std::string &path, size_t content_length,
- ContentProvider content_provider,
- const std::string &content_type);
- Result Post(const std::string &path,
- ContentProviderWithoutLength content_provider,
- const std::string &content_type);
- Result Post(const std::string &path, const Headers &headers,
- size_t content_length, ContentProvider content_provider,
- const std::string &content_type);
- Result Post(const std::string &path, const Headers &headers,
- ContentProviderWithoutLength content_provider,
- const std::string &content_type);
- Result Post(const std::string &path, const Params &params);
- Result Post(const std::string &path, const Headers &headers,
- const Params &params);
- Result Post(const std::string &path, const MultipartFormDataItems &items);
- Result Post(const std::string &path, const Headers &headers,
- const MultipartFormDataItems &items);
- Result Post(const std::string &path, const Headers &headers,
- const MultipartFormDataItems &items, const std::string &boundary);
- Result Post(const std::string &path, const Headers &headers,
- const MultipartFormDataItems &items,
- const MultipartFormDataProviderItems &provider_items);
-
- Result Put(const std::string &path);
- Result Put(const std::string &path, const char *body, size_t content_length,
- const std::string &content_type);
- Result Put(const std::string &path, const Headers &headers, const char *body,
- size_t content_length, const std::string &content_type);
- Result Put(const std::string &path, const std::string &body,
- const std::string &content_type);
- Result Put(const std::string &path, const Headers &headers,
- const std::string &body, const std::string &content_type);
- Result Put(const std::string &path, size_t content_length,
- ContentProvider content_provider, const std::string &content_type);
- Result Put(const std::string &path,
- ContentProviderWithoutLength content_provider,
- const std::string &content_type);
- Result Put(const std::string &path, const Headers &headers,
- size_t content_length, ContentProvider content_provider,
- const std::string &content_type);
- Result Put(const std::string &path, const Headers &headers,
- ContentProviderWithoutLength content_provider,
- const std::string &content_type);
- Result Put(const std::string &path, const Params &params);
- Result Put(const std::string &path, const Headers &headers,
- const Params &params);
- Result Put(const std::string &path, const MultipartFormDataItems &items);
- Result Put(const std::string &path, const Headers &headers,
- const MultipartFormDataItems &items);
- Result Put(const std::string &path, const Headers &headers,
- const MultipartFormDataItems &items, const std::string &boundary);
- Result Put(const std::string &path, const Headers &headers,
- const MultipartFormDataItems &items,
- const MultipartFormDataProviderItems &provider_items);
-
- Result Patch(const std::string &path);
- Result Patch(const std::string &path, const char *body, size_t content_length,
- const std::string &content_type);
- Result Patch(const std::string &path, const Headers &headers,
- const char *body, size_t content_length,
- const std::string &content_type);
- Result Patch(const std::string &path, const std::string &body,
- const std::string &content_type);
- Result Patch(const std::string &path, const Headers &headers,
- const std::string &body, const std::string &content_type);
- Result Patch(const std::string &path, size_t content_length,
- ContentProvider content_provider,
- const std::string &content_type);
- Result Patch(const std::string &path,
- ContentProviderWithoutLength content_provider,
- const std::string &content_type);
- Result Patch(const std::string &path, const Headers &headers,
- size_t content_length, ContentProvider content_provider,
- const std::string &content_type);
- Result Patch(const std::string &path, const Headers &headers,
- ContentProviderWithoutLength content_provider,
- const std::string &content_type);
-
- Result Delete(const std::string &path);
- Result Delete(const std::string &path, const Headers &headers);
- Result Delete(const std::string &path, const char *body,
- size_t content_length, const std::string &content_type);
- Result Delete(const std::string &path, const Headers &headers,
- const char *body, size_t content_length,
- const std::string &content_type);
- Result Delete(const std::string &path, const std::string &body,
- const std::string &content_type);
- Result Delete(const std::string &path, const Headers &headers,
- const std::string &body, const std::string &content_type);
-
- Result Options(const std::string &path);
- Result Options(const std::string &path, const Headers &headers);
-
- bool send(Request &req, Response &res, Error &error);
- Result send(const Request &req);
-
- void stop();
-
- std::string host() const;
- int port() const;
-
- size_t is_socket_open() const;
- socket_t socket() const;
-
- void set_hostname_addr_map(std::map<std::string, std::string> addr_map);
-
- void set_default_headers(Headers headers);
-
- void
- set_header_writer(std::function<ssize_t(Stream &, Headers &)> const &writer);
-
- void set_address_family(int family);
- void set_tcp_nodelay(bool on);
- void set_socket_options(SocketOptions socket_options);
-
- void set_connection_timeout(time_t sec, time_t usec = 0);
- template <class Rep, class Period>
- void
- set_connection_timeout(const std::chrono::duration<Rep, Period> &duration);
-
- void set_read_timeout(time_t sec, time_t usec = 0);
- template <class Rep, class Period>
- void set_read_timeout(const std::chrono::duration<Rep, Period> &duration);
-
- void set_write_timeout(time_t sec, time_t usec = 0);
- template <class Rep, class Period>
- void set_write_timeout(const std::chrono::duration<Rep, Period> &duration);
-
- void set_basic_auth(const std::string &username, const std::string &password);
- void set_bearer_token_auth(const std::string &token);
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
- void set_digest_auth(const std::string &username,
- const std::string &password);
-#endif
-
- void set_keep_alive(bool on);
- void set_follow_location(bool on);
-
- void set_url_encode(bool on);
-
- void set_compress(bool on);
-
- void set_decompress(bool on);
-
- void set_interface(const std::string &intf);
-
- void set_proxy(const std::string &host, int port);
- void set_proxy_basic_auth(const std::string &username,
- const std::string &password);
- void set_proxy_bearer_token_auth(const std::string &token);
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
- void set_proxy_digest_auth(const std::string &username,
- const std::string &password);
-#endif
-
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
- void enable_server_certificate_verification(bool enabled);
-#endif
-
- void set_logger(Logger logger);
-
- // SSL
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
- void set_ca_cert_path(const std::string &ca_cert_file_path,
- const std::string &ca_cert_dir_path = std::string());
-
- void set_ca_cert_store(X509_STORE *ca_cert_store);
- void load_ca_cert_store(const char *ca_cert, std::size_t size);
-
- long get_openssl_verify_result() const;
-
- SSL_CTX *ssl_context() const;
-#endif
-
-private:
- std::unique_ptr<ClientImpl> cli_;
-
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
- bool is_ssl_ = false;
-#endif
-};
-
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-class SSLServer : public Server {
-public:
- SSLServer(const char *cert_path, const char *private_key_path,
- const char *client_ca_cert_file_path = nullptr,
- const char *client_ca_cert_dir_path = nullptr,
- const char *private_key_password = nullptr);
-
- SSLServer(X509 *cert, EVP_PKEY *private_key,
- X509_STORE *client_ca_cert_store = nullptr);
-
- SSLServer(
- const std::function<bool(SSL_CTX &ssl_ctx)> &setup_ssl_ctx_callback);
-
- ~SSLServer() override;
-
- bool is_valid() const override;
-
- SSL_CTX *ssl_context() const;
-
-private:
- bool process_and_close_socket(socket_t sock) override;
-
- SSL_CTX *ctx_;
- std::mutex ctx_mutex_;
-};
-
-class SSLClient : public ClientImpl {
-public:
- explicit SSLClient(const std::string &host);
-
- explicit SSLClient(const std::string &host, int port);
-
- explicit SSLClient(const std::string &host, int port,
- const std::string &client_cert_path,
- const std::string &client_key_path);
-
- explicit SSLClient(const std::string &host, int port, X509 *client_cert,
- EVP_PKEY *client_key);
-
- ~SSLClient() override;
-
- bool is_valid() const override;
-
- void set_ca_cert_store(X509_STORE *ca_cert_store);
- void load_ca_cert_store(const char *ca_cert, std::size_t size);
-
- long get_openssl_verify_result() const;
-
- SSL_CTX *ssl_context() const;
-
-private:
- bool create_and_connect_socket(Socket &socket, Error &error) override;
- void shutdown_ssl(Socket &socket, bool shutdown_gracefully) override;
- void shutdown_ssl_impl(Socket &socket, bool shutdown_socket);
-
- bool process_socket(const Socket &socket,
- std::function<bool(Stream &strm)> callback) override;
- bool is_ssl() const override;
-
- bool connect_with_proxy(Socket &sock, Response &res, bool &success,
- Error &error);
- bool initialize_ssl(Socket &socket, Error &error);
-
- bool load_certs();
-
- bool verify_host(X509 *server_cert) const;
- bool verify_host_with_subject_alt_name(X509 *server_cert) const;
- bool verify_host_with_common_name(X509 *server_cert) const;
- bool check_host_name(const char *pattern, size_t pattern_len) const;
-
- SSL_CTX *ctx_;
- std::mutex ctx_mutex_;
- std::once_flag initialize_cert_;
-
- std::vector<std::string> host_components_;
-
- long verify_result_ = 0;
-
- friend class ClientImpl;
-};
-#endif
-
-/*
- * Implementation of template methods.
- */
-
-namespace detail {
-
-template <typename T, typename U>
-inline void duration_to_sec_and_usec(const T &duration, U callback) {
- auto sec = std::chrono::duration_cast<std::chrono::seconds>(duration).count();
- auto usec = std::chrono::duration_cast<std::chrono::microseconds>(
- duration - std::chrono::seconds(sec))
- .count();
- callback(static_cast<time_t>(sec), static_cast<time_t>(usec));
-}
-
-inline uint64_t get_header_value_u64(const Headers &headers,
- const std::string &key, size_t id,
- uint64_t def) {
- auto rng = headers.equal_range(key);
- auto it = rng.first;
- std::advance(it, static_cast<ssize_t>(id));
- if (it != rng.second) {
- return std::strtoull(it->second.data(), nullptr, 10);
- }
- return def;
-}
-
-} // namespace detail
-
-inline uint64_t Request::get_header_value_u64(const std::string &key,
- size_t id) const {
- return detail::get_header_value_u64(headers, key, id, 0);
-}
-
-inline uint64_t Response::get_header_value_u64(const std::string &key,
- size_t id) const {
- return detail::get_header_value_u64(headers, key, id, 0);
-}
-
-template <typename... Args>
-inline ssize_t Stream::write_format(const char *fmt, const Args &...args) {
- const auto bufsiz = 2048;
- std::array<char, bufsiz> buf{};
-
- auto sn = snprintf(buf.data(), buf.size() - 1, fmt, args...);
- if (sn <= 0) { return sn; }
-
- auto n = static_cast<size_t>(sn);
-
- if (n >= buf.size() - 1) {
- std::vector<char> glowable_buf(buf.size());
-
- while (n >= glowable_buf.size() - 1) {
- glowable_buf.resize(glowable_buf.size() * 2);
- n = static_cast<size_t>(
- snprintf(&glowable_buf[0], glowable_buf.size() - 1, fmt, args...));
- }
- return write(&glowable_buf[0], n);
- } else {
- return write(buf.data(), n);
- }
-}
-
-inline void default_socket_options(socket_t sock) {
- int yes = 1;
-#ifdef _WIN32
- setsockopt(sock, SOL_SOCKET, SO_REUSEADDR,
- reinterpret_cast<const char *>(&yes), sizeof(yes));
- setsockopt(sock, SOL_SOCKET, SO_EXCLUSIVEADDRUSE,
- reinterpret_cast<const char *>(&yes), sizeof(yes));
-#else
-#ifdef SO_REUSEPORT
- setsockopt(sock, SOL_SOCKET, SO_REUSEPORT,
- reinterpret_cast<const void *>(&yes), sizeof(yes));
-#else
- setsockopt(sock, SOL_SOCKET, SO_REUSEADDR,
- reinterpret_cast<const void *>(&yes), sizeof(yes));
-#endif
-#endif
-}
-
-inline const char *status_message(int status) {
- switch (status) {
- case 100: return "Continue";
- case 101: return "Switching Protocol";
- case 102: return "Processing";
- case 103: return "Early Hints";
- case 200: return "OK";
- case 201: return "Created";
- case 202: return "Accepted";
- case 203: return "Non-Authoritative Information";
- case 204: return "No Content";
- case 205: return "Reset Content";
- case 206: return "Partial Content";
- case 207: return "Multi-Status";
- case 208: return "Already Reported";
- case 226: return "IM Used";
- case 300: return "Multiple Choice";
- case 301: return "Moved Permanently";
- case 302: return "Found";
- case 303: return "See Other";
- case 304: return "Not Modified";
- case 305: return "Use Proxy";
- case 306: return "unused";
- case 307: return "Temporary Redirect";
- case 308: return "Permanent Redirect";
- case 400: return "Bad Request";
- case 401: return "Unauthorized";
- case 402: return "Payment Required";
- case 403: return "Forbidden";
- case 404: return "Not Found";
- case 405: return "Method Not Allowed";
- case 406: return "Not Acceptable";
- case 407: return "Proxy Authentication Required";
- case 408: return "Request Timeout";
- case 409: return "Conflict";
- case 410: return "Gone";
- case 411: return "Length Required";
- case 412: return "Precondition Failed";
- case 413: return "Payload Too Large";
- case 414: return "URI Too Long";
- case 415: return "Unsupported Media Type";
- case 416: return "Range Not Satisfiable";
- case 417: return "Expectation Failed";
- case 418: return "I'm a teapot";
- case 421: return "Misdirected Request";
- case 422: return "Unprocessable Entity";
- case 423: return "Locked";
- case 424: return "Failed Dependency";
- case 425: return "Too Early";
- case 426: return "Upgrade Required";
- case 428: return "Precondition Required";
- case 429: return "Too Many Requests";
- case 431: return "Request Header Fields Too Large";
- case 451: return "Unavailable For Legal Reasons";
- case 501: return "Not Implemented";
- case 502: return "Bad Gateway";
- case 503: return "Service Unavailable";
- case 504: return "Gateway Timeout";
- case 505: return "HTTP Version Not Supported";
- case 506: return "Variant Also Negotiates";
- case 507: return "Insufficient Storage";
- case 508: return "Loop Detected";
- case 510: return "Not Extended";
- case 511: return "Network Authentication Required";
-
- default:
- case 500: return "Internal Server Error";
- }
-}
-
-template <class Rep, class Period>
-inline Server &
-Server::set_read_timeout(const std::chrono::duration<Rep, Period> &duration) {
- detail::duration_to_sec_and_usec(
- duration, [&](time_t sec, time_t usec) { set_read_timeout(sec, usec); });
- return *this;
-}
-
-template <class Rep, class Period>
-inline Server &
-Server::set_write_timeout(const std::chrono::duration<Rep, Period> &duration) {
- detail::duration_to_sec_and_usec(
- duration, [&](time_t sec, time_t usec) { set_write_timeout(sec, usec); });
- return *this;
-}
-
-template <class Rep, class Period>
-inline Server &
-Server::set_idle_interval(const std::chrono::duration<Rep, Period> &duration) {
- detail::duration_to_sec_and_usec(
- duration, [&](time_t sec, time_t usec) { set_idle_interval(sec, usec); });
- return *this;
-}
-
-inline std::string to_string(const Error error) {
- switch (error) {
- case Error::Success: return "Success (no error)";
- case Error::Connection: return "Could not establish connection";
- case Error::BindIPAddress: return "Failed to bind IP address";
- case Error::Read: return "Failed to read connection";
- case Error::Write: return "Failed to write connection";
- case Error::ExceedRedirectCount: return "Maximum redirect count exceeded";
- case Error::Canceled: return "Connection handling canceled";
- case Error::SSLConnection: return "SSL connection failed";
- case Error::SSLLoadingCerts: return "SSL certificate loading failed";
- case Error::SSLServerVerification: return "SSL server verification failed";
- case Error::UnsupportedMultipartBoundaryChars:
- return "Unsupported HTTP multipart boundary characters";
- case Error::Compression: return "Compression failed";
- case Error::ConnectionTimeout: return "Connection timed out";
- case Error::ProxyConnection: return "Proxy connection failed";
- case Error::Unknown: return "Unknown";
- default: break;
- }
-
- return "Invalid";
-}
-
-inline std::ostream &operator<<(std::ostream &os, const Error &obj) {
- os << to_string(obj);
- os << " (" << static_cast<std::underlying_type<Error>::type>(obj) << ')';
- return os;
-}
-
-inline uint64_t Result::get_request_header_value_u64(const std::string &key,
- size_t id) const {
- return detail::get_header_value_u64(request_headers_, key, id, 0);
-}
-
-template <class Rep, class Period>
-inline void ClientImpl::set_connection_timeout(
- const std::chrono::duration<Rep, Period> &duration) {
- detail::duration_to_sec_and_usec(duration, [&](time_t sec, time_t usec) {
- set_connection_timeout(sec, usec);
- });
-}
-
-template <class Rep, class Period>
-inline void ClientImpl::set_read_timeout(
- const std::chrono::duration<Rep, Period> &duration) {
- detail::duration_to_sec_and_usec(
- duration, [&](time_t sec, time_t usec) { set_read_timeout(sec, usec); });
-}
-
-template <class Rep, class Period>
-inline void ClientImpl::set_write_timeout(
- const std::chrono::duration<Rep, Period> &duration) {
- detail::duration_to_sec_and_usec(
- duration, [&](time_t sec, time_t usec) { set_write_timeout(sec, usec); });
-}
-
-template <class Rep, class Period>
-inline void Client::set_connection_timeout(
- const std::chrono::duration<Rep, Period> &duration) {
- cli_->set_connection_timeout(duration);
-}
-
-template <class Rep, class Period>
-inline void
-Client::set_read_timeout(const std::chrono::duration<Rep, Period> &duration) {
- cli_->set_read_timeout(duration);
-}
-
-template <class Rep, class Period>
-inline void
-Client::set_write_timeout(const std::chrono::duration<Rep, Period> &duration) {
- cli_->set_write_timeout(duration);
-}
-
-/*
- * Forward declarations and types that will be part of the .h file if split into
- * .h + .cc.
- */
-
-std::string hosted_at(const std::string &hostname);
-
-void hosted_at(const std::string &hostname, std::vector<std::string> &addrs);
-
-std::string append_query_params(const std::string &path, const Params &params);
-
-std::pair<std::string, std::string> make_range_header(Ranges ranges);
-
-std::pair<std::string, std::string>
-make_basic_authentication_header(const std::string &username,
- const std::string &password,
- bool is_proxy = false);
-
-namespace detail {
-
-std::string encode_query_param(const std::string &value);
-
-std::string decode_url(const std::string &s, bool convert_plus_to_space);
-
-void read_file(const std::string &path, std::string &out);
-
-std::string trim_copy(const std::string &s);
-
-void split(const char *b, const char *e, char d,
- std::function<void(const char *, const char *)> fn);
-
-bool process_client_socket(socket_t sock, time_t read_timeout_sec,
- time_t read_timeout_usec, time_t write_timeout_sec,
- time_t write_timeout_usec,
- std::function<bool(Stream &)> callback);
-
-socket_t create_client_socket(
- const std::string &host, const std::string &ip, int port,
- int address_family, bool tcp_nodelay, SocketOptions socket_options,
- time_t connection_timeout_sec, time_t connection_timeout_usec,
- time_t read_timeout_sec, time_t read_timeout_usec, time_t write_timeout_sec,
- time_t write_timeout_usec, const std::string &intf, Error &error);
-
-const char *get_header_value(const Headers &headers, const std::string &key,
- size_t id = 0, const char *def = nullptr);
-
-std::string params_to_query_str(const Params &params);
-
-void parse_query_text(const std::string &s, Params &params);
-
-bool parse_multipart_boundary(const std::string &content_type,
- std::string &boundary);
-
-bool parse_range_header(const std::string &s, Ranges &ranges);
-
-int close_socket(socket_t sock);
-
-ssize_t send_socket(socket_t sock, const void *ptr, size_t size, int flags);
-
-ssize_t read_socket(socket_t sock, void *ptr, size_t size, int flags);
-
-enum class EncodingType { None = 0, Gzip, Brotli };
-
-EncodingType encoding_type(const Request &req, const Response &res);
-
-class BufferStream : public Stream {
-public:
- BufferStream() = default;
- ~BufferStream() override = default;
-
- bool is_readable() const override;
- bool is_writable() const override;
- ssize_t read(char *ptr, size_t size) override;
- ssize_t write(const char *ptr, size_t size) override;
- void get_remote_ip_and_port(std::string &ip, int &port) const override;
- void get_local_ip_and_port(std::string &ip, int &port) const override;
- socket_t socket() const override;
-
- const std::string &get_buffer() const;
-
-private:
- std::string buffer;
- size_t position = 0;
-};
-
-class compressor {
-public:
- virtual ~compressor() = default;
-
- typedef std::function<bool(const char *data, size_t data_len)> Callback;
- virtual bool compress(const char *data, size_t data_length, bool last,
- Callback callback) = 0;
-};
-
-class decompressor {
-public:
- virtual ~decompressor() = default;
-
- virtual bool is_valid() const = 0;
-
- typedef std::function<bool(const char *data, size_t data_len)> Callback;
- virtual bool decompress(const char *data, size_t data_length,
- Callback callback) = 0;
-};
-
-class nocompressor : public compressor {
-public:
- virtual ~nocompressor() = default;
-
- bool compress(const char *data, size_t data_length, bool /*last*/,
- Callback callback) override;
-};
-
-#ifdef CPPHTTPLIB_ZLIB_SUPPORT
-class gzip_compressor : public compressor {
-public:
- gzip_compressor();
- ~gzip_compressor();
-
- bool compress(const char *data, size_t data_length, bool last,
- Callback callback) override;
-
-private:
- bool is_valid_ = false;
- z_stream strm_;
-};
-
-class gzip_decompressor : public decompressor {
-public:
- gzip_decompressor();
- ~gzip_decompressor();
-
- bool is_valid() const override;
-
- bool decompress(const char *data, size_t data_length,
- Callback callback) override;
-
-private:
- bool is_valid_ = false;
- z_stream strm_;
-};
-#endif
-
-#ifdef CPPHTTPLIB_BROTLI_SUPPORT
-class brotli_compressor : public compressor {
-public:
- brotli_compressor();
- ~brotli_compressor();
-
- bool compress(const char *data, size_t data_length, bool last,
- Callback callback) override;
-
-private:
- BrotliEncoderState *state_ = nullptr;
-};
-
-class brotli_decompressor : public decompressor {
-public:
- brotli_decompressor();
- ~brotli_decompressor();
-
- bool is_valid() const override;
-
- bool decompress(const char *data, size_t data_length,
- Callback callback) override;
-
-private:
- BrotliDecoderResult decoder_r;
- BrotliDecoderState *decoder_s = nullptr;
-};
-#endif
-
-// NOTE: until the read size reaches `fixed_buffer_size`, use `fixed_buffer`
-// to store data. The call can set memory on stack for performance.
-class stream_line_reader {
-public:
- stream_line_reader(Stream &strm, char *fixed_buffer,
- size_t fixed_buffer_size);
- const char *ptr() const;
- size_t size() const;
- bool end_with_crlf() const;
- bool getline();
-
-private:
- void append(char c);
-
- Stream &strm_;
- char *fixed_buffer_;
- const size_t fixed_buffer_size_;
- size_t fixed_buffer_used_size_ = 0;
- std::string glowable_buffer_;
-};
-
-class mmap {
-public:
- mmap(const char *path);
- ~mmap();
-
- bool open(const char *path);
- void close();
-
- bool is_open() const;
- size_t size() const;
- const char *data() const;
-
-private:
-#if defined(_WIN32)
- HANDLE hFile_;
- HANDLE hMapping_;
-#else
- int fd_;
-#endif
- size_t size_;
- void *addr_;
-};
-
-} // namespace detail
-
-// ----------------------------------------------------------------------------
-
-/*
- * Implementation that will be part of the .cc file if split into .h + .cc.
- */
-
-namespace detail {
-
-inline bool is_hex(char c, int &v) {
- if (0x20 <= c && isdigit(c)) {
- v = c - '0';
- return true;
- } else if ('A' <= c && c <= 'F') {
- v = c - 'A' + 10;
- return true;
- } else if ('a' <= c && c <= 'f') {
- v = c - 'a' + 10;
- return true;
- }
- return false;
-}
-
-inline bool from_hex_to_i(const std::string &s, size_t i, size_t cnt,
- int &val) {
- if (i >= s.size()) { return false; }
-
- val = 0;
- for (; cnt; i++, cnt--) {
- if (!s[i]) { return false; }
- auto v = 0;
- if (is_hex(s[i], v)) {
- val = val * 16 + v;
- } else {
- return false;
- }
- }
- return true;
-}
-
-inline std::string from_i_to_hex(size_t n) {
- static const auto charset = "0123456789abcdef";
- std::string ret;
- do {
- ret = charset[n & 15] + ret;
- n >>= 4;
- } while (n > 0);
- return ret;
-}
-
-inline size_t to_utf8(int code, char *buff) {
- if (code < 0x0080) {
- buff[0] = (code & 0x7F);
- return 1;
- } else if (code < 0x0800) {
- buff[0] = static_cast<char>(0xC0 | ((code >> 6) & 0x1F));
- buff[1] = static_cast<char>(0x80 | (code & 0x3F));
- return 2;
- } else if (code < 0xD800) {
- buff[0] = static_cast<char>(0xE0 | ((code >> 12) & 0xF));
- buff[1] = static_cast<char>(0x80 | ((code >> 6) & 0x3F));
- buff[2] = static_cast<char>(0x80 | (code & 0x3F));
- return 3;
- } else if (code < 0xE000) { // D800 - DFFF is invalid...
- return 0;
- } else if (code < 0x10000) {
- buff[0] = static_cast<char>(0xE0 | ((code >> 12) & 0xF));
- buff[1] = static_cast<char>(0x80 | ((code >> 6) & 0x3F));
- buff[2] = static_cast<char>(0x80 | (code & 0x3F));
- return 3;
- } else if (code < 0x110000) {
- buff[0] = static_cast<char>(0xF0 | ((code >> 18) & 0x7));
- buff[1] = static_cast<char>(0x80 | ((code >> 12) & 0x3F));
- buff[2] = static_cast<char>(0x80 | ((code >> 6) & 0x3F));
- buff[3] = static_cast<char>(0x80 | (code & 0x3F));
- return 4;
- }
-
- // NOTREACHED
- return 0;
-}
-
-// NOTE: This code came up with the following stackoverflow post:
-// https://stackoverflow.com/questions/180947/base64-decode-snippet-in-c
-inline std::string base64_encode(const std::string &in) {
- static const auto lookup =
- "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-
- std::string out;
- out.reserve(in.size());
-
- auto val = 0;
- auto valb = -6;
-
- for (auto c : in) {
- val = (val << 8) + static_cast<uint8_t>(c);
- valb += 8;
- while (valb >= 0) {
- out.push_back(lookup[(val >> valb) & 0x3F]);
- valb -= 6;
- }
- }
-
- if (valb > -6) { out.push_back(lookup[((val << 8) >> (valb + 8)) & 0x3F]); }
-
- while (out.size() % 4) {
- out.push_back('=');
- }
-
- return out;
-}
-
-inline bool is_file(const std::string &path) {
-#ifdef _WIN32
- return _access_s(path.c_str(), 0) == 0;
-#else
- struct stat st;
- return stat(path.c_str(), &st) >= 0 && S_ISREG(st.st_mode);
-#endif
-}
-
-inline bool is_dir(const std::string &path) {
- struct stat st;
- return stat(path.c_str(), &st) >= 0 && S_ISDIR(st.st_mode);
-}
-
-inline bool is_valid_path(const std::string &path) {
- size_t level = 0;
- size_t i = 0;
-
- // Skip slash
- while (i < path.size() && path[i] == '/') {
- i++;
- }
-
- while (i < path.size()) {
- // Read component
- auto beg = i;
- while (i < path.size() && path[i] != '/') {
- i++;
- }
-
- auto len = i - beg;
- assert(len > 0);
-
- if (!path.compare(beg, len, ".")) {
- ;
- } else if (!path.compare(beg, len, "..")) {
- if (level == 0) { return false; }
- level--;
- } else {
- level++;
- }
-
- // Skip slash
- while (i < path.size() && path[i] == '/') {
- i++;
- }
- }
-
- return true;
-}
-
-inline std::string encode_query_param(const std::string &value) {
- std::ostringstream escaped;
- escaped.fill('0');
- escaped << std::hex;
-
- for (auto c : value) {
- if (std::isalnum(static_cast<uint8_t>(c)) || c == '-' || c == '_' ||
- c == '.' || c == '!' || c == '~' || c == '*' || c == '\'' || c == '(' ||
- c == ')') {
- escaped << c;
- } else {
- escaped << std::uppercase;
- escaped << '%' << std::setw(2)
- << static_cast<int>(static_cast<unsigned char>(c));
- escaped << std::nouppercase;
- }
- }
-
- return escaped.str();
-}
-
-inline std::string encode_url(const std::string &s) {
- std::string result;
- result.reserve(s.size());
-
- for (size_t i = 0; s[i]; i++) {
- switch (s[i]) {
- case ' ': result += "%20"; break;
- case '+': result += "%2B"; break;
- case '\r': result += "%0D"; break;
- case '\n': result += "%0A"; break;
- case '\'': result += "%27"; break;
- case ',': result += "%2C"; break;
- // case ':': result += "%3A"; break; // ok? probably...
- case ';': result += "%3B"; break;
- default:
- auto c = static_cast<uint8_t>(s[i]);
- if (c >= 0x80) {
- result += '%';
- char hex[4];
- auto len = snprintf(hex, sizeof(hex) - 1, "%02X", c);
- assert(len == 2);
- result.append(hex, static_cast<size_t>(len));
- } else {
- result += s[i];
- }
- break;
- }
- }
-
- return result;
-}
-
-inline std::string decode_url(const std::string &s,
- bool convert_plus_to_space) {
- std::string result;
-
- for (size_t i = 0; i < s.size(); i++) {
- if (s[i] == '%' && i + 1 < s.size()) {
- if (s[i + 1] == 'u') {
- auto val = 0;
- if (from_hex_to_i(s, i + 2, 4, val)) {
- // 4 digits Unicode codes
- char buff[4];
- size_t len = to_utf8(val, buff);
- if (len > 0) { result.append(buff, len); }
- i += 5; // 'u0000'
- } else {
- result += s[i];
- }
- } else {
- auto val = 0;
- if (from_hex_to_i(s, i + 1, 2, val)) {
- // 2 digits hex codes
- result += static_cast<char>(val);
- i += 2; // '00'
- } else {
- result += s[i];
- }
- }
- } else if (convert_plus_to_space && s[i] == '+') {
- result += ' ';
- } else {
- result += s[i];
- }
- }
-
- return result;
-}
-
-inline void read_file(const std::string &path, std::string &out) {
- std::ifstream fs(path, std::ios_base::binary);
- fs.seekg(0, std::ios_base::end);
- auto size = fs.tellg();
- fs.seekg(0);
- out.resize(static_cast<size_t>(size));
- fs.read(&out[0], static_cast<std::streamsize>(size));
-}
-
-inline std::string file_extension(const std::string &path) {
- std::smatch m;
- static auto re = std::regex("\\.([a-zA-Z0-9]+)$");
- if (std::regex_search(path, m, re)) { return m[1].str(); }
- return std::string();
-}
-
-inline bool is_space_or_tab(char c) { return c == ' ' || c == '\t'; }
-
-inline std::pair<size_t, size_t> trim(const char *b, const char *e, size_t left,
- size_t right) {
- while (b + left < e && is_space_or_tab(b[left])) {
- left++;
- }
- while (right > 0 && is_space_or_tab(b[right - 1])) {
- right--;
- }
- return std::make_pair(left, right);
-}
-
-inline std::string trim_copy(const std::string &s) {
- auto r = trim(s.data(), s.data() + s.size(), 0, s.size());
- return s.substr(r.first, r.second - r.first);
-}
-
-inline std::string trim_double_quotes_copy(const std::string &s) {
- if (s.length() >= 2 && s.front() == '"' && s.back() == '"') {
- return s.substr(1, s.size() - 2);
- }
- return s;
-}
-
-inline void split(const char *b, const char *e, char d,
- std::function<void(const char *, const char *)> fn) {
- size_t i = 0;
- size_t beg = 0;
-
- while (e ? (b + i < e) : (b[i] != '\0')) {
- if (b[i] == d) {
- auto r = trim(b, e, beg, i);
- if (r.first < r.second) { fn(&b[r.first], &b[r.second]); }
- beg = i + 1;
- }
- i++;
- }
-
- if (i) {
- auto r = trim(b, e, beg, i);
- if (r.first < r.second) { fn(&b[r.first], &b[r.second]); }
- }
-}
-
-inline stream_line_reader::stream_line_reader(Stream &strm, char *fixed_buffer,
- size_t fixed_buffer_size)
- : strm_(strm), fixed_buffer_(fixed_buffer),
- fixed_buffer_size_(fixed_buffer_size) {}
-
-inline const char *stream_line_reader::ptr() const {
- if (glowable_buffer_.empty()) {
- return fixed_buffer_;
- } else {
- return glowable_buffer_.data();
- }
-}
-
-inline size_t stream_line_reader::size() const {
- if (glowable_buffer_.empty()) {
- return fixed_buffer_used_size_;
- } else {
- return glowable_buffer_.size();
- }
-}
-
-inline bool stream_line_reader::end_with_crlf() const {
- auto end = ptr() + size();
- return size() >= 2 && end[-2] == '\r' && end[-1] == '\n';
-}
-
-inline bool stream_line_reader::getline() {
- fixed_buffer_used_size_ = 0;
- glowable_buffer_.clear();
-
- for (size_t i = 0;; i++) {
- char byte;
- auto n = strm_.read(&byte, 1);
-
- if (n < 0) {
- return false;
- } else if (n == 0) {
- if (i == 0) {
- return false;
- } else {
- break;
- }
- }
-
- append(byte);
-
- if (byte == '\n') { break; }
- }
-
- return true;
-}
-
-inline void stream_line_reader::append(char c) {
- if (fixed_buffer_used_size_ < fixed_buffer_size_ - 1) {
- fixed_buffer_[fixed_buffer_used_size_++] = c;
- fixed_buffer_[fixed_buffer_used_size_] = '\0';
- } else {
- if (glowable_buffer_.empty()) {
- assert(fixed_buffer_[fixed_buffer_used_size_] == '\0');
- glowable_buffer_.assign(fixed_buffer_, fixed_buffer_used_size_);
- }
- glowable_buffer_ += c;
- }
-}
-
-inline mmap::mmap(const char *path)
-#if defined(_WIN32)
- : hFile_(NULL), hMapping_(NULL)
-#else
- : fd_(-1)
-#endif
- ,
- size_(0), addr_(nullptr) {
- if (!open(path)) { std::runtime_error(""); }
-}
-
-inline mmap::~mmap() { close(); }
-
-inline bool mmap::open(const char *path) {
- close();
-
-#if defined(_WIN32)
- hFile_ = ::CreateFileA(path, GENERIC_READ, FILE_SHARE_READ, NULL,
- OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
-
- if (hFile_ == INVALID_HANDLE_VALUE) { return false; }
-
- size_ = ::GetFileSize(hFile_, NULL);
-
- hMapping_ = ::CreateFileMapping(hFile_, NULL, PAGE_READONLY, 0, 0, NULL);
-
- if (hMapping_ == NULL) {
- close();
- return false;
- }
-
- addr_ = ::MapViewOfFile(hMapping_, FILE_MAP_READ, 0, 0, 0);
-#else
- fd_ = ::open(path, O_RDONLY);
- if (fd_ == -1) { return false; }
-
- struct stat sb;
- if (fstat(fd_, &sb) == -1) {
- close();
- return false;
- }
- size_ = static_cast<size_t>(sb.st_size);
-
- addr_ = ::mmap(NULL, size_, PROT_READ, MAP_PRIVATE, fd_, 0);
-#endif
-
- if (addr_ == nullptr) {
- close();
- return false;
- }
-
- return true;
-}
-
-inline bool mmap::is_open() const { return addr_ != nullptr; }
-
-inline size_t mmap::size() const { return size_; }
-
-inline const char *mmap::data() const { return (const char *)addr_; }
-
-inline void mmap::close() {
-#if defined(_WIN32)
- if (addr_) {
- ::UnmapViewOfFile(addr_);
- addr_ = nullptr;
- }
-
- if (hMapping_) {
- ::CloseHandle(hMapping_);
- hMapping_ = NULL;
- }
-
- if (hFile_ != INVALID_HANDLE_VALUE) {
- ::CloseHandle(hFile_);
- hFile_ = INVALID_HANDLE_VALUE;
- }
-#else
- if (addr_ != nullptr) {
- munmap(addr_, size_);
- addr_ = nullptr;
- }
-
- if (fd_ != -1) {
- ::close(fd_);
- fd_ = -1;
- }
-#endif
- size_ = 0;
-}
-inline int close_socket(socket_t sock) {
-#ifdef _WIN32
- return closesocket(sock);
-#else
- return close(sock);
-#endif
-}
-
-template <typename T> inline ssize_t handle_EINTR(T fn) {
- ssize_t res = 0;
- while (true) {
- res = fn();
- if (res < 0 && errno == EINTR) { continue; }
- break;
- }
- return res;
-}
-
-inline ssize_t read_socket(socket_t sock, void *ptr, size_t size, int flags) {
- return handle_EINTR([&]() {
- return recv(sock,
-#ifdef _WIN32
- static_cast<char *>(ptr), static_cast<int>(size),
-#else
- ptr, size,
-#endif
- flags);
- });
-}
-
-inline ssize_t send_socket(socket_t sock, const void *ptr, size_t size,
- int flags) {
- return handle_EINTR([&]() {
- return send(sock,
-#ifdef _WIN32
- static_cast<const char *>(ptr), static_cast<int>(size),
-#else
- ptr, size,
-#endif
- flags);
- });
-}
-
-inline ssize_t select_read(socket_t sock, time_t sec, time_t usec) {
-#ifdef CPPHTTPLIB_USE_POLL
- struct pollfd pfd_read;
- pfd_read.fd = sock;
- pfd_read.events = POLLIN;
-
- auto timeout = static_cast<int>(sec * 1000 + usec / 1000);
-
- return handle_EINTR([&]() { return poll(&pfd_read, 1, timeout); });
-#else
-#ifndef _WIN32
- if (sock >= FD_SETSIZE) { return 1; }
-#endif
-
- fd_set fds;
- FD_ZERO(&fds);
- FD_SET(sock, &fds);
-
- timeval tv;
- tv.tv_sec = static_cast<long>(sec);
- tv.tv_usec = static_cast<decltype(tv.tv_usec)>(usec);
-
- return handle_EINTR([&]() {
- return select(static_cast<int>(sock + 1), &fds, nullptr, nullptr, &tv);
- });
-#endif
-}
-
-inline ssize_t select_write(socket_t sock, time_t sec, time_t usec) {
-#ifdef CPPHTTPLIB_USE_POLL
- struct pollfd pfd_read;
- pfd_read.fd = sock;
- pfd_read.events = POLLOUT;
-
- auto timeout = static_cast<int>(sec * 1000 + usec / 1000);
-
- return handle_EINTR([&]() { return poll(&pfd_read, 1, timeout); });
-#else
-#ifndef _WIN32
- if (sock >= FD_SETSIZE) { return 1; }
-#endif
-
- fd_set fds;
- FD_ZERO(&fds);
- FD_SET(sock, &fds);
-
- timeval tv;
- tv.tv_sec = static_cast<long>(sec);
- tv.tv_usec = static_cast<decltype(tv.tv_usec)>(usec);
-
- return handle_EINTR([&]() {
- return select(static_cast<int>(sock + 1), nullptr, &fds, nullptr, &tv);
- });
-#endif
-}
-
-inline Error wait_until_socket_is_ready(socket_t sock, time_t sec,
- time_t usec) {
-#ifdef CPPHTTPLIB_USE_POLL
- struct pollfd pfd_read;
- pfd_read.fd = sock;
- pfd_read.events = POLLIN | POLLOUT;
-
- auto timeout = static_cast<int>(sec * 1000 + usec / 1000);
-
- auto poll_res = handle_EINTR([&]() { return poll(&pfd_read, 1, timeout); });
-
- if (poll_res == 0) { return Error::ConnectionTimeout; }
-
- if (poll_res > 0 && pfd_read.revents & (POLLIN | POLLOUT)) {
- auto error = 0;
- socklen_t len = sizeof(error);
- auto res = getsockopt(sock, SOL_SOCKET, SO_ERROR,
- reinterpret_cast<char *>(&error), &len);
- auto successful = res >= 0 && !error;
- return successful ? Error::Success : Error::Connection;
- }
-
- return Error::Connection;
-#else
-#ifndef _WIN32
- if (sock >= FD_SETSIZE) { return Error::Connection; }
-#endif
-
- fd_set fdsr;
- FD_ZERO(&fdsr);
- FD_SET(sock, &fdsr);
-
- auto fdsw = fdsr;
- auto fdse = fdsr;
-
- timeval tv;
- tv.tv_sec = static_cast<long>(sec);
- tv.tv_usec = static_cast<decltype(tv.tv_usec)>(usec);
-
- auto ret = handle_EINTR([&]() {
- return select(static_cast<int>(sock + 1), &fdsr, &fdsw, &fdse, &tv);
- });
-
- if (ret == 0) { return Error::ConnectionTimeout; }
-
- if (ret > 0 && (FD_ISSET(sock, &fdsr) || FD_ISSET(sock, &fdsw))) {
- auto error = 0;
- socklen_t len = sizeof(error);
- auto res = getsockopt(sock, SOL_SOCKET, SO_ERROR,
- reinterpret_cast<char *>(&error), &len);
- auto successful = res >= 0 && !error;
- return successful ? Error::Success : Error::Connection;
- }
- return Error::Connection;
-#endif
-}
-
-inline bool is_socket_alive(socket_t sock) {
- const auto val = detail::select_read(sock, 0, 0);
- if (val == 0) {
- return true;
- } else if (val < 0 && errno == EBADF) {
- return false;
- }
- char buf[1];
- return detail::read_socket(sock, &buf[0], sizeof(buf), MSG_PEEK) > 0;
-}
-
-class SocketStream : public Stream {
-public:
- SocketStream(socket_t sock, time_t read_timeout_sec, time_t read_timeout_usec,
- time_t write_timeout_sec, time_t write_timeout_usec);
- ~SocketStream() override;
-
- bool is_readable() const override;
- bool is_writable() const override;
- ssize_t read(char *ptr, size_t size) override;
- ssize_t write(const char *ptr, size_t size) override;
- void get_remote_ip_and_port(std::string &ip, int &port) const override;
- void get_local_ip_and_port(std::string &ip, int &port) const override;
- socket_t socket() const override;
-
-private:
- socket_t sock_;
- time_t read_timeout_sec_;
- time_t read_timeout_usec_;
- time_t write_timeout_sec_;
- time_t write_timeout_usec_;
-
- std::vector<char> read_buff_;
- size_t read_buff_off_ = 0;
- size_t read_buff_content_size_ = 0;
-
- static const size_t read_buff_size_ = 1024 * 4;
-};
-
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-class SSLSocketStream : public Stream {
-public:
- SSLSocketStream(socket_t sock, SSL *ssl, time_t read_timeout_sec,
- time_t read_timeout_usec, time_t write_timeout_sec,
- time_t write_timeout_usec);
- ~SSLSocketStream() override;
-
- bool is_readable() const override;
- bool is_writable() const override;
- ssize_t read(char *ptr, size_t size) override;
- ssize_t write(const char *ptr, size_t size) override;
- void get_remote_ip_and_port(std::string &ip, int &port) const override;
- void get_local_ip_and_port(std::string &ip, int &port) const override;
- socket_t socket() const override;
-
-private:
- socket_t sock_;
- SSL *ssl_;
- time_t read_timeout_sec_;
- time_t read_timeout_usec_;
- time_t write_timeout_sec_;
- time_t write_timeout_usec_;
-};
-#endif
-
-inline bool keep_alive(socket_t sock, time_t keep_alive_timeout_sec) {
- using namespace std::chrono;
- auto start = steady_clock::now();
- while (true) {
- auto val = select_read(sock, 0, 10000);
- if (val < 0) {
- return false;
- } else if (val == 0) {
- auto current = steady_clock::now();
- auto duration = duration_cast<milliseconds>(current - start);
- auto timeout = keep_alive_timeout_sec * 1000;
- if (duration.count() > timeout) { return false; }
- std::this_thread::sleep_for(std::chrono::milliseconds(1));
- } else {
- return true;
- }
- }
-}
-
-template <typename T>
-inline bool
-process_server_socket_core(const std::atomic<socket_t> &svr_sock, socket_t sock,
- size_t keep_alive_max_count,
- time_t keep_alive_timeout_sec, T callback) {
- assert(keep_alive_max_count > 0);
- auto ret = false;
- auto count = keep_alive_max_count;
- while (svr_sock != INVALID_SOCKET && count > 0 &&
- keep_alive(sock, keep_alive_timeout_sec)) {
- auto close_connection = count == 1;
- auto connection_closed = false;
- ret = callback(close_connection, connection_closed);
- if (!ret || connection_closed) { break; }
- count--;
- }
- return ret;
-}
-
-template <typename T>
-inline bool
-process_server_socket(const std::atomic<socket_t> &svr_sock, socket_t sock,
- size_t keep_alive_max_count,
- time_t keep_alive_timeout_sec, time_t read_timeout_sec,
- time_t read_timeout_usec, time_t write_timeout_sec,
- time_t write_timeout_usec, T callback) {
- return process_server_socket_core(
- svr_sock, sock, keep_alive_max_count, keep_alive_timeout_sec,
- [&](bool close_connection, bool &connection_closed) {
- SocketStream strm(sock, read_timeout_sec, read_timeout_usec,
- write_timeout_sec, write_timeout_usec);
- return callback(strm, close_connection, connection_closed);
- });
-}
-
-inline bool process_client_socket(socket_t sock, time_t read_timeout_sec,
- time_t read_timeout_usec,
- time_t write_timeout_sec,
- time_t write_timeout_usec,
- std::function<bool(Stream &)> callback) {
- SocketStream strm(sock, read_timeout_sec, read_timeout_usec,
- write_timeout_sec, write_timeout_usec);
- return callback(strm);
-}
-
-inline int shutdown_socket(socket_t sock) {
-#ifdef _WIN32
- return shutdown(sock, SD_BOTH);
-#else
- return shutdown(sock, SHUT_RDWR);
-#endif
-}
-
-template <typename BindOrConnect>
-socket_t create_socket(const std::string &host, const std::string &ip, int port,
- int address_family, int socket_flags, bool tcp_nodelay,
- SocketOptions socket_options,
- BindOrConnect bind_or_connect) {
- // Get address info
- const char *node = nullptr;
- struct addrinfo hints;
- struct addrinfo *result;
-
- memset(&hints, 0, sizeof(struct addrinfo));
- hints.ai_socktype = SOCK_STREAM;
- hints.ai_protocol = 0;
-
- if (!ip.empty()) {
- node = ip.c_str();
- // Ask getaddrinfo to convert IP in c-string to address
- hints.ai_family = AF_UNSPEC;
- hints.ai_flags = AI_NUMERICHOST;
- } else {
- if (!host.empty()) { node = host.c_str(); }
- hints.ai_family = address_family;
- hints.ai_flags = socket_flags;
- }
-
-#ifndef _WIN32
- if (hints.ai_family == AF_UNIX) {
- const auto addrlen = host.length();
- if (addrlen > sizeof(sockaddr_un::sun_path)) return INVALID_SOCKET;
-
- auto sock = socket(hints.ai_family, hints.ai_socktype, hints.ai_protocol);
- if (sock != INVALID_SOCKET) {
- sockaddr_un addr{};
- addr.sun_family = AF_UNIX;
- std::copy(host.begin(), host.end(), addr.sun_path);
-
- hints.ai_addr = reinterpret_cast<sockaddr *>(&addr);
- hints.ai_addrlen = static_cast<socklen_t>(
- sizeof(addr) - sizeof(addr.sun_path) + addrlen);
-
- fcntl(sock, F_SETFD, FD_CLOEXEC);
- if (socket_options) { socket_options(sock); }
-
- if (!bind_or_connect(sock, hints)) {
- close_socket(sock);
- sock = INVALID_SOCKET;
- }
- }
- return sock;
- }
-#endif
-
- auto service = std::to_string(port);
-
- if (getaddrinfo(node, service.c_str(), &hints, &result)) {
-#if defined __linux__ && !defined __ANDROID__
- res_init();
-#endif
- return INVALID_SOCKET;
- }
-
- for (auto rp = result; rp; rp = rp->ai_next) {
- // Create a socket
-#ifdef _WIN32
- auto sock =
- WSASocketW(rp->ai_family, rp->ai_socktype, rp->ai_protocol, nullptr, 0,
- WSA_FLAG_NO_HANDLE_INHERIT | WSA_FLAG_OVERLAPPED);
- /**
- * Since the WSA_FLAG_NO_HANDLE_INHERIT is only supported on Windows 7 SP1
- * and above the socket creation fails on older Windows Systems.
- *
- * Let's try to create a socket the old way in this case.
- *
- * Reference:
- * https://docs.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-wsasocketa
- *
- * WSA_FLAG_NO_HANDLE_INHERIT:
- * This flag is supported on Windows 7 with SP1, Windows Server 2008 R2 with
- * SP1, and later
- *
- */
- if (sock == INVALID_SOCKET) {
- sock = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
- }
-#else
- auto sock = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
-#endif
- if (sock == INVALID_SOCKET) { continue; }
-
-#ifndef _WIN32
- if (fcntl(sock, F_SETFD, FD_CLOEXEC) == -1) {
- close_socket(sock);
- continue;
- }
-#endif
-
- if (tcp_nodelay) {
- auto yes = 1;
-#ifdef _WIN32
- setsockopt(sock, IPPROTO_TCP, TCP_NODELAY,
- reinterpret_cast<const char *>(&yes), sizeof(yes));
-#else
- setsockopt(sock, IPPROTO_TCP, TCP_NODELAY,
- reinterpret_cast<const void *>(&yes), sizeof(yes));
-#endif
- }
-
- if (socket_options) { socket_options(sock); }
-
- if (rp->ai_family == AF_INET6) {
- auto no = 0;
-#ifdef _WIN32
- setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY,
- reinterpret_cast<const char *>(&no), sizeof(no));
-#else
- setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY,
- reinterpret_cast<const void *>(&no), sizeof(no));
-#endif
- }
-
- // bind or connect
- if (bind_or_connect(sock, *rp)) {
- freeaddrinfo(result);
- return sock;
- }
-
- close_socket(sock);
- }
-
- freeaddrinfo(result);
- return INVALID_SOCKET;
-}
-
-inline void set_nonblocking(socket_t sock, bool nonblocking) {
-#ifdef _WIN32
- auto flags = nonblocking ? 1UL : 0UL;
- ioctlsocket(sock, FIONBIO, &flags);
-#else
- auto flags = fcntl(sock, F_GETFL, 0);
- fcntl(sock, F_SETFL,
- nonblocking ? (flags | O_NONBLOCK) : (flags & (~O_NONBLOCK)));
-#endif
-}
-
-inline bool is_connection_error() {
-#ifdef _WIN32
- return WSAGetLastError() != WSAEWOULDBLOCK;
-#else
- return errno != EINPROGRESS;
-#endif
-}
-
-inline bool bind_ip_address(socket_t sock, const std::string &host) {
- struct addrinfo hints;
- struct addrinfo *result;
-
- memset(&hints, 0, sizeof(struct addrinfo));
- hints.ai_family = AF_UNSPEC;
- hints.ai_socktype = SOCK_STREAM;
- hints.ai_protocol = 0;
-
- if (getaddrinfo(host.c_str(), "0", &hints, &result)) { return false; }
-
- auto ret = false;
- for (auto rp = result; rp; rp = rp->ai_next) {
- const auto &ai = *rp;
- if (!::bind(sock, ai.ai_addr, static_cast<socklen_t>(ai.ai_addrlen))) {
- ret = true;
- break;
- }
- }
-
- freeaddrinfo(result);
- return ret;
-}
-
-#if !defined _WIN32 && !defined ANDROID && !defined _AIX && !defined __MVS__
-#define USE_IF2IP
-#endif
-
-#ifdef USE_IF2IP
-inline std::string if2ip(int address_family, const std::string &ifn) {
- struct ifaddrs *ifap;
- getifaddrs(&ifap);
- std::string addr_candidate;
- for (auto ifa = ifap; ifa; ifa = ifa->ifa_next) {
- if (ifa->ifa_addr && ifn == ifa->ifa_name &&
- (AF_UNSPEC == address_family ||
- ifa->ifa_addr->sa_family == address_family)) {
- if (ifa->ifa_addr->sa_family == AF_INET) {
- auto sa = reinterpret_cast<struct sockaddr_in *>(ifa->ifa_addr);
- char buf[INET_ADDRSTRLEN];
- if (inet_ntop(AF_INET, &sa->sin_addr, buf, INET_ADDRSTRLEN)) {
- freeifaddrs(ifap);
- return std::string(buf, INET_ADDRSTRLEN);
- }
- } else if (ifa->ifa_addr->sa_family == AF_INET6) {
- auto sa = reinterpret_cast<struct sockaddr_in6 *>(ifa->ifa_addr);
- if (!IN6_IS_ADDR_LINKLOCAL(&sa->sin6_addr)) {
- char buf[INET6_ADDRSTRLEN] = {};
- if (inet_ntop(AF_INET6, &sa->sin6_addr, buf, INET6_ADDRSTRLEN)) {
- // equivalent to mac's IN6_IS_ADDR_UNIQUE_LOCAL
- auto s6_addr_head = sa->sin6_addr.s6_addr[0];
- if (s6_addr_head == 0xfc || s6_addr_head == 0xfd) {
- addr_candidate = std::string(buf, INET6_ADDRSTRLEN);
- } else {
- freeifaddrs(ifap);
- return std::string(buf, INET6_ADDRSTRLEN);
- }
- }
- }
- }
- }
- }
- freeifaddrs(ifap);
- return addr_candidate;
-}
-#endif
-
-inline socket_t create_client_socket(
- const std::string &host, const std::string &ip, int port,
- int address_family, bool tcp_nodelay, SocketOptions socket_options,
- time_t connection_timeout_sec, time_t connection_timeout_usec,
- time_t read_timeout_sec, time_t read_timeout_usec, time_t write_timeout_sec,
- time_t write_timeout_usec, const std::string &intf, Error &error) {
- auto sock = create_socket(
- host, ip, port, address_family, 0, tcp_nodelay, std::move(socket_options),
- [&](socket_t sock2, struct addrinfo &ai) -> bool {
- if (!intf.empty()) {
-#ifdef USE_IF2IP
- auto ip_from_if = if2ip(address_family, intf);
- if (ip_from_if.empty()) { ip_from_if = intf; }
- if (!bind_ip_address(sock2, ip_from_if.c_str())) {
- error = Error::BindIPAddress;
- return false;
- }
-#endif
- }
-
- set_nonblocking(sock2, true);
-
- auto ret =
- ::connect(sock2, ai.ai_addr, static_cast<socklen_t>(ai.ai_addrlen));
-
- if (ret < 0) {
- if (is_connection_error()) {
- error = Error::Connection;
- return false;
- }
- error = wait_until_socket_is_ready(sock2, connection_timeout_sec,
- connection_timeout_usec);
- if (error != Error::Success) { return false; }
- }
-
- set_nonblocking(sock2, false);
-
- {
-#ifdef _WIN32
- auto timeout = static_cast<uint32_t>(read_timeout_sec * 1000 +
- read_timeout_usec / 1000);
- setsockopt(sock2, SOL_SOCKET, SO_RCVTIMEO,
- reinterpret_cast<const char *>(&timeout), sizeof(timeout));
-#else
- timeval tv;
- tv.tv_sec = static_cast<long>(read_timeout_sec);
- tv.tv_usec = static_cast<decltype(tv.tv_usec)>(read_timeout_usec);
- setsockopt(sock2, SOL_SOCKET, SO_RCVTIMEO,
- reinterpret_cast<const void *>(&tv), sizeof(tv));
-#endif
- }
- {
-
-#ifdef _WIN32
- auto timeout = static_cast<uint32_t>(write_timeout_sec * 1000 +
- write_timeout_usec / 1000);
- setsockopt(sock2, SOL_SOCKET, SO_SNDTIMEO,
- reinterpret_cast<const char *>(&timeout), sizeof(timeout));
-#else
- timeval tv;
- tv.tv_sec = static_cast<long>(write_timeout_sec);
- tv.tv_usec = static_cast<decltype(tv.tv_usec)>(write_timeout_usec);
- setsockopt(sock2, SOL_SOCKET, SO_SNDTIMEO,
- reinterpret_cast<const void *>(&tv), sizeof(tv));
-#endif
- }
-
- error = Error::Success;
- return true;
- });
-
- if (sock != INVALID_SOCKET) {
- error = Error::Success;
- } else {
- if (error == Error::Success) { error = Error::Connection; }
- }
-
- return sock;
-}
-
-inline bool get_ip_and_port(const struct sockaddr_storage &addr,
- socklen_t addr_len, std::string &ip, int &port) {
- if (addr.ss_family == AF_INET) {
- port = ntohs(reinterpret_cast<const struct sockaddr_in *>(&addr)->sin_port);
- } else if (addr.ss_family == AF_INET6) {
- port =
- ntohs(reinterpret_cast<const struct sockaddr_in6 *>(&addr)->sin6_port);
- } else {
- return false;
- }
-
- std::array<char, NI_MAXHOST> ipstr{};
- if (getnameinfo(reinterpret_cast<const struct sockaddr *>(&addr), addr_len,
- ipstr.data(), static_cast<socklen_t>(ipstr.size()), nullptr,
- 0, NI_NUMERICHOST)) {
- return false;
- }
-
- ip = ipstr.data();
- return true;
-}
-
-inline void get_local_ip_and_port(socket_t sock, std::string &ip, int &port) {
- struct sockaddr_storage addr;
- socklen_t addr_len = sizeof(addr);
- if (!getsockname(sock, reinterpret_cast<struct sockaddr *>(&addr),
- &addr_len)) {
- get_ip_and_port(addr, addr_len, ip, port);
- }
-}
-
-inline void get_remote_ip_and_port(socket_t sock, std::string &ip, int &port) {
- struct sockaddr_storage addr;
- socklen_t addr_len = sizeof(addr);
-
- if (!getpeername(sock, reinterpret_cast<struct sockaddr *>(&addr),
- &addr_len)) {
-#ifndef _WIN32
- if (addr.ss_family == AF_UNIX) {
-#if defined(__linux__)
- struct ucred ucred;
- socklen_t len = sizeof(ucred);
- if (getsockopt(sock, SOL_SOCKET, SO_PEERCRED, &ucred, &len) == 0) {
- port = ucred.pid;
- }
-#elif defined(SOL_LOCAL) && defined(SO_PEERPID) // __APPLE__
- pid_t pid;
- socklen_t len = sizeof(pid);
- if (getsockopt(sock, SOL_LOCAL, SO_PEERPID, &pid, &len) == 0) {
- port = pid;
- }
-#endif
- return;
- }
-#endif
- get_ip_and_port(addr, addr_len, ip, port);
- }
-}
-
-inline constexpr unsigned int str2tag_core(const char *s, size_t l,
- unsigned int h) {
- return (l == 0)
- ? h
- : str2tag_core(
- s + 1, l - 1,
- // Unsets the 6 high bits of h, therefore no overflow happens
- (((std::numeric_limits<unsigned int>::max)() >> 6) &
- h * 33) ^
- static_cast<unsigned char>(*s));
-}
-
-inline unsigned int str2tag(const std::string &s) {
- return str2tag_core(s.data(), s.size(), 0);
-}
-
-namespace udl {
-
-inline constexpr unsigned int operator"" _t(const char *s, size_t l) {
- return str2tag_core(s, l, 0);
-}
-
-} // namespace udl
-
-inline std::string
-find_content_type(const std::string &path,
- const std::map<std::string, std::string> &user_data,
- const std::string &default_content_type) {
- auto ext = file_extension(path);
-
- auto it = user_data.find(ext);
- if (it != user_data.end()) { return it->second.c_str(); }
-
- using udl::operator""_t;
-
- switch (str2tag(ext)) {
- default: return default_content_type;
-
- case "css"_t: return "text/css";
- case "csv"_t: return "text/csv";
- case "htm"_t:
- case "html"_t: return "text/html";
- case "js"_t:
- case "mjs"_t: return "text/javascript";
- case "txt"_t: return "text/plain";
- case "vtt"_t: return "text/vtt";
-
- case "apng"_t: return "image/apng";
- case "avif"_t: return "image/avif";
- case "bmp"_t: return "image/bmp";
- case "gif"_t: return "image/gif";
- case "png"_t: return "image/png";
- case "svg"_t: return "image/svg+xml";
- case "webp"_t: return "image/webp";
- case "ico"_t: return "image/x-icon";
- case "tif"_t: return "image/tiff";
- case "tiff"_t: return "image/tiff";
- case "jpg"_t:
- case "jpeg"_t: return "image/jpeg";
-
- case "mp4"_t: return "video/mp4";
- case "mpeg"_t: return "video/mpeg";
- case "webm"_t: return "video/webm";
-
- case "mp3"_t: return "audio/mp3";
- case "mpga"_t: return "audio/mpeg";
- case "weba"_t: return "audio/webm";
- case "wav"_t: return "audio/wave";
-
- case "otf"_t: return "font/otf";
- case "ttf"_t: return "font/ttf";
- case "woff"_t: return "font/woff";
- case "woff2"_t: return "font/woff2";
-
- case "7z"_t: return "application/x-7z-compressed";
- case "atom"_t: return "application/atom+xml";
- case "pdf"_t: return "application/pdf";
- case "json"_t: return "application/json";
- case "rss"_t: return "application/rss+xml";
- case "tar"_t: return "application/x-tar";
- case "xht"_t:
- case "xhtml"_t: return "application/xhtml+xml";
- case "xslt"_t: return "application/xslt+xml";
- case "xml"_t: return "application/xml";
- case "gz"_t: return "application/gzip";
- case "zip"_t: return "application/zip";
- case "wasm"_t: return "application/wasm";
- }
-}
-
-inline bool can_compress_content_type(const std::string &content_type) {
- using udl::operator""_t;
-
- auto tag = str2tag(content_type);
-
- switch (tag) {
- case "image/svg+xml"_t:
- case "application/javascript"_t:
- case "application/json"_t:
- case "application/xml"_t:
- case "application/protobuf"_t:
- case "application/xhtml+xml"_t: return true;
-
- default:
- return !content_type.rfind("text/", 0) && tag != "text/event-stream"_t;
- }
-}
-
-inline EncodingType encoding_type(const Request &req, const Response &res) {
- auto ret =
- detail::can_compress_content_type(res.get_header_value("Content-Type"));
- if (!ret) { return EncodingType::None; }
-
- const auto &s = req.get_header_value("Accept-Encoding");
- (void)(s);
-
-#ifdef CPPHTTPLIB_BROTLI_SUPPORT
- // TODO: 'Accept-Encoding' has br, not br;q=0
- ret = s.find("br") != std::string::npos;
- if (ret) { return EncodingType::Brotli; }
-#endif
-
-#ifdef CPPHTTPLIB_ZLIB_SUPPORT
- // TODO: 'Accept-Encoding' has gzip, not gzip;q=0
- ret = s.find("gzip") != std::string::npos;
- if (ret) { return EncodingType::Gzip; }
-#endif
-
- return EncodingType::None;
-}
-
-inline bool nocompressor::compress(const char *data, size_t data_length,
- bool /*last*/, Callback callback) {
- if (!data_length) { return true; }
- return callback(data, data_length);
-}
-
-#ifdef CPPHTTPLIB_ZLIB_SUPPORT
-inline gzip_compressor::gzip_compressor() {
- std::memset(&strm_, 0, sizeof(strm_));
- strm_.zalloc = Z_NULL;
- strm_.zfree = Z_NULL;
- strm_.opaque = Z_NULL;
-
- is_valid_ = deflateInit2(&strm_, Z_DEFAULT_COMPRESSION, Z_DEFLATED, 31, 8,
- Z_DEFAULT_STRATEGY) == Z_OK;
-}
-
-inline gzip_compressor::~gzip_compressor() { deflateEnd(&strm_); }
-
-inline bool gzip_compressor::compress(const char *data, size_t data_length,
- bool last, Callback callback) {
- assert(is_valid_);
-
- do {
- constexpr size_t max_avail_in =
- (std::numeric_limits<decltype(strm_.avail_in)>::max)();
-
- strm_.avail_in = static_cast<decltype(strm_.avail_in)>(
- (std::min)(data_length, max_avail_in));
- strm_.next_in = const_cast<Bytef *>(reinterpret_cast<const Bytef *>(data));
-
- data_length -= strm_.avail_in;
- data += strm_.avail_in;
-
- auto flush = (last && data_length == 0) ? Z_FINISH : Z_NO_FLUSH;
- auto ret = Z_OK;
-
- std::array<char, CPPHTTPLIB_COMPRESSION_BUFSIZ> buff{};
- do {
- strm_.avail_out = static_cast<uInt>(buff.size());
- strm_.next_out = reinterpret_cast<Bytef *>(buff.data());
-
- ret = deflate(&strm_, flush);
- if (ret == Z_STREAM_ERROR) { return false; }
-
- if (!callback(buff.data(), buff.size() - strm_.avail_out)) {
- return false;
- }
- } while (strm_.avail_out == 0);
-
- assert((flush == Z_FINISH && ret == Z_STREAM_END) ||
- (flush == Z_NO_FLUSH && ret == Z_OK));
- assert(strm_.avail_in == 0);
- } while (data_length > 0);
-
- return true;
-}
-
-inline gzip_decompressor::gzip_decompressor() {
- std::memset(&strm_, 0, sizeof(strm_));
- strm_.zalloc = Z_NULL;
- strm_.zfree = Z_NULL;
- strm_.opaque = Z_NULL;
-
- // 15 is the value of wbits, which should be at the maximum possible value
- // to ensure that any gzip stream can be decoded. The offset of 32 specifies
- // that the stream type should be automatically detected either gzip or
- // deflate.
- is_valid_ = inflateInit2(&strm_, 32 + 15) == Z_OK;
-}
-
-inline gzip_decompressor::~gzip_decompressor() { inflateEnd(&strm_); }
-
-inline bool gzip_decompressor::is_valid() const { return is_valid_; }
-
-inline bool gzip_decompressor::decompress(const char *data, size_t data_length,
- Callback callback) {
- assert(is_valid_);
-
- auto ret = Z_OK;
-
- do {
- constexpr size_t max_avail_in =
- (std::numeric_limits<decltype(strm_.avail_in)>::max)();
-
- strm_.avail_in = static_cast<decltype(strm_.avail_in)>(
- (std::min)(data_length, max_avail_in));
- strm_.next_in = const_cast<Bytef *>(reinterpret_cast<const Bytef *>(data));
-
- data_length -= strm_.avail_in;
- data += strm_.avail_in;
-
- std::array<char, CPPHTTPLIB_COMPRESSION_BUFSIZ> buff{};
- while (strm_.avail_in > 0 && ret == Z_OK) {
- strm_.avail_out = static_cast<uInt>(buff.size());
- strm_.next_out = reinterpret_cast<Bytef *>(buff.data());
-
- ret = inflate(&strm_, Z_NO_FLUSH);
-
- assert(ret != Z_STREAM_ERROR);
- switch (ret) {
- case Z_NEED_DICT:
- case Z_DATA_ERROR:
- case Z_MEM_ERROR: inflateEnd(&strm_); return false;
- }
-
- if (!callback(buff.data(), buff.size() - strm_.avail_out)) {
- return false;
- }
- }
-
- if (ret != Z_OK && ret != Z_STREAM_END) return false;
-
- } while (data_length > 0);
-
- return true;
-}
-#endif
-
-#ifdef CPPHTTPLIB_BROTLI_SUPPORT
-inline brotli_compressor::brotli_compressor() {
- state_ = BrotliEncoderCreateInstance(nullptr, nullptr, nullptr);
-}
-
-inline brotli_compressor::~brotli_compressor() {
- BrotliEncoderDestroyInstance(state_);
-}
-
-inline bool brotli_compressor::compress(const char *data, size_t data_length,
- bool last, Callback callback) {
- std::array<uint8_t, CPPHTTPLIB_COMPRESSION_BUFSIZ> buff{};
-
- auto operation = last ? BROTLI_OPERATION_FINISH : BROTLI_OPERATION_PROCESS;
- auto available_in = data_length;
- auto next_in = reinterpret_cast<const uint8_t *>(data);
-
- for (;;) {
- if (last) {
- if (BrotliEncoderIsFinished(state_)) { break; }
- } else {
- if (!available_in) { break; }
- }
-
- auto available_out = buff.size();
- auto next_out = buff.data();
-
- if (!BrotliEncoderCompressStream(state_, operation, &available_in, &next_in,
- &available_out, &next_out, nullptr)) {
- return false;
- }
-
- auto output_bytes = buff.size() - available_out;
- if (output_bytes) {
- callback(reinterpret_cast<const char *>(buff.data()), output_bytes);
- }
- }
-
- return true;
-}
-
-inline brotli_decompressor::brotli_decompressor() {
- decoder_s = BrotliDecoderCreateInstance(0, 0, 0);
- decoder_r = decoder_s ? BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT
- : BROTLI_DECODER_RESULT_ERROR;
-}
-
-inline brotli_decompressor::~brotli_decompressor() {
- if (decoder_s) { BrotliDecoderDestroyInstance(decoder_s); }
-}
-
-inline bool brotli_decompressor::is_valid() const { return decoder_s; }
-
-inline bool brotli_decompressor::decompress(const char *data,
- size_t data_length,
- Callback callback) {
- if (decoder_r == BROTLI_DECODER_RESULT_SUCCESS ||
- decoder_r == BROTLI_DECODER_RESULT_ERROR) {
- return 0;
- }
-
- auto next_in = reinterpret_cast<const uint8_t *>(data);
- size_t avail_in = data_length;
- size_t total_out;
-
- decoder_r = BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT;
-
- std::array<char, CPPHTTPLIB_COMPRESSION_BUFSIZ> buff{};
- while (decoder_r == BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT) {
- char *next_out = buff.data();
- size_t avail_out = buff.size();
-
- decoder_r = BrotliDecoderDecompressStream(
- decoder_s, &avail_in, &next_in, &avail_out,
- reinterpret_cast<uint8_t **>(&next_out), &total_out);
-
- if (decoder_r == BROTLI_DECODER_RESULT_ERROR) { return false; }
-
- if (!callback(buff.data(), buff.size() - avail_out)) { return false; }
- }
-
- return decoder_r == BROTLI_DECODER_RESULT_SUCCESS ||
- decoder_r == BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT;
-}
-#endif
-
-inline bool has_header(const Headers &headers, const std::string &key) {
- return headers.find(key) != headers.end();
-}
-
-inline const char *get_header_value(const Headers &headers,
- const std::string &key, size_t id,
- const char *def) {
- auto rng = headers.equal_range(key);
- auto it = rng.first;
- std::advance(it, static_cast<ssize_t>(id));
- if (it != rng.second) { return it->second.c_str(); }
- return def;
-}
-
-inline bool compare_case_ignore(const std::string &a, const std::string &b) {
- if (a.size() != b.size()) { return false; }
- for (size_t i = 0; i < b.size(); i++) {
- if (::tolower(a[i]) != ::tolower(b[i])) { return false; }
- }
- return true;
-}
-
-template <typename T>
-inline bool parse_header(const char *beg, const char *end, T fn) {
- // Skip trailing spaces and tabs.
- while (beg < end && is_space_or_tab(end[-1])) {
- end--;
- }
-
- auto p = beg;
- while (p < end && *p != ':') {
- p++;
- }
-
- if (p == end) { return false; }
-
- auto key_end = p;
-
- if (*p++ != ':') { return false; }
-
- while (p < end && is_space_or_tab(*p)) {
- p++;
- }
-
- if (p < end) {
- auto key = std::string(beg, key_end);
- auto val = compare_case_ignore(key, "Location")
- ? std::string(p, end)
- : decode_url(std::string(p, end), false);
- fn(std::move(key), std::move(val));
- return true;
- }
-
- return false;
-}
-
-inline bool read_headers(Stream &strm, Headers &headers) {
- const auto bufsiz = 2048;
- char buf[bufsiz];
- stream_line_reader line_reader(strm, buf, bufsiz);
-
- for (;;) {
- if (!line_reader.getline()) { return false; }
-
- // Check if the line ends with CRLF.
- auto line_terminator_len = 2;
- if (line_reader.end_with_crlf()) {
- // Blank line indicates end of headers.
- if (line_reader.size() == 2) { break; }
-#ifdef CPPHTTPLIB_ALLOW_LF_AS_LINE_TERMINATOR
- } else {
- // Blank line indicates end of headers.
- if (line_reader.size() == 1) { break; }
- line_terminator_len = 1;
- }
-#else
- } else {
- continue; // Skip invalid line.
- }
-#endif
-
- if (line_reader.size() > CPPHTTPLIB_HEADER_MAX_LENGTH) { return false; }
-
- // Exclude line terminator
- auto end = line_reader.ptr() + line_reader.size() - line_terminator_len;
-
- parse_header(line_reader.ptr(), end,
- [&](std::string &&key, std::string &&val) {
- headers.emplace(std::move(key), std::move(val));
- });
- }
-
- return true;
-}
-
-inline bool read_content_with_length(Stream &strm, uint64_t len,
- Progress progress,
- ContentReceiverWithProgress out) {
- char buf[CPPHTTPLIB_RECV_BUFSIZ];
-
- uint64_t r = 0;
- while (r < len) {
- auto read_len = static_cast<size_t>(len - r);
- auto n = strm.read(buf, (std::min)(read_len, CPPHTTPLIB_RECV_BUFSIZ));
- if (n <= 0) { return false; }
-
- if (!out(buf, static_cast<size_t>(n), r, len)) { return false; }
- r += static_cast<uint64_t>(n);
-
- if (progress) {
- if (!progress(r, len)) { return false; }
- }
- }
-
- return true;
-}
-
-inline void skip_content_with_length(Stream &strm, uint64_t len) {
- char buf[CPPHTTPLIB_RECV_BUFSIZ];
- uint64_t r = 0;
- while (r < len) {
- auto read_len = static_cast<size_t>(len - r);
- auto n = strm.read(buf, (std::min)(read_len, CPPHTTPLIB_RECV_BUFSIZ));
- if (n <= 0) { return; }
- r += static_cast<uint64_t>(n);
- }
-}
-
-inline bool read_content_without_length(Stream &strm,
- ContentReceiverWithProgress out) {
- char buf[CPPHTTPLIB_RECV_BUFSIZ];
- uint64_t r = 0;
- for (;;) {
- auto n = strm.read(buf, CPPHTTPLIB_RECV_BUFSIZ);
- if (n < 0) {
- return false;
- } else if (n == 0) {
- return true;
- }
-
- if (!out(buf, static_cast<size_t>(n), r, 0)) { return false; }
- r += static_cast<uint64_t>(n);
- }
-
- return true;
-}
-
-template <typename T>
-inline bool read_content_chunked(Stream &strm, T &x,
- ContentReceiverWithProgress out) {
- const auto bufsiz = 16;
- char buf[bufsiz];
-
- stream_line_reader line_reader(strm, buf, bufsiz);
-
- if (!line_reader.getline()) { return false; }
-
- unsigned long chunk_len;
- while (true) {
- char *end_ptr;
-
- chunk_len = std::strtoul(line_reader.ptr(), &end_ptr, 16);
-
- if (end_ptr == line_reader.ptr()) { return false; }
- if (chunk_len == ULONG_MAX) { return false; }
-
- if (chunk_len == 0) { break; }
-
- if (!read_content_with_length(strm, chunk_len, nullptr, out)) {
- return false;
- }
-
- if (!line_reader.getline()) { return false; }
-
- if (strcmp(line_reader.ptr(), "\r\n")) { return false; }
-
- if (!line_reader.getline()) { return false; }
- }
-
- assert(chunk_len == 0);
-
- // Trailer
- if (!line_reader.getline()) { return false; }
-
- while (strcmp(line_reader.ptr(), "\r\n")) {
- if (line_reader.size() > CPPHTTPLIB_HEADER_MAX_LENGTH) { return false; }
-
- // Exclude line terminator
- constexpr auto line_terminator_len = 2;
- auto end = line_reader.ptr() + line_reader.size() - line_terminator_len;
-
- parse_header(line_reader.ptr(), end,
- [&](std::string &&key, std::string &&val) {
- x.headers.emplace(std::move(key), std::move(val));
- });
-
- if (!line_reader.getline()) { return false; }
- }
-
- return true;
-}
-
-inline bool is_chunked_transfer_encoding(const Headers &headers) {
- return !strcasecmp(get_header_value(headers, "Transfer-Encoding", 0, ""),
- "chunked");
-}
-
-template <typename T, typename U>
-bool prepare_content_receiver(T &x, int &status,
- ContentReceiverWithProgress receiver,
- bool decompress, U callback) {
- if (decompress) {
- std::string encoding = x.get_header_value("Content-Encoding");
- std::unique_ptr<decompressor> decompressor;
-
- if (encoding == "gzip" || encoding == "deflate") {
-#ifdef CPPHTTPLIB_ZLIB_SUPPORT
- decompressor = detail::make_unique<gzip_decompressor>();
-#else
- status = 415;
- return false;
-#endif
- } else if (encoding.find("br") != std::string::npos) {
-#ifdef CPPHTTPLIB_BROTLI_SUPPORT
- decompressor = detail::make_unique<brotli_decompressor>();
-#else
- status = 415;
- return false;
-#endif
- }
-
- if (decompressor) {
- if (decompressor->is_valid()) {
- ContentReceiverWithProgress out = [&](const char *buf, size_t n,
- uint64_t off, uint64_t len) {
- return decompressor->decompress(buf, n,
- [&](const char *buf2, size_t n2) {
- return receiver(buf2, n2, off, len);
- });
- };
- return callback(std::move(out));
- } else {
- status = 500;
- return false;
- }
- }
- }
-
- ContentReceiverWithProgress out = [&](const char *buf, size_t n, uint64_t off,
- uint64_t len) {
- return receiver(buf, n, off, len);
- };
- return callback(std::move(out));
-}
-
-template <typename T>
-bool read_content(Stream &strm, T &x, size_t payload_max_length, int &status,
- Progress progress, ContentReceiverWithProgress receiver,
- bool decompress) {
- return prepare_content_receiver(
- x, status, std::move(receiver), decompress,
- [&](const ContentReceiverWithProgress &out) {
- auto ret = true;
- auto exceed_payload_max_length = false;
-
- if (is_chunked_transfer_encoding(x.headers)) {
- ret = read_content_chunked(strm, x, out);
- } else if (!has_header(x.headers, "Content-Length")) {
- ret = read_content_without_length(strm, out);
- } else {
- auto len = get_header_value_u64(x.headers, "Content-Length", 0, 0);
- if (len > payload_max_length) {
- exceed_payload_max_length = true;
- skip_content_with_length(strm, len);
- ret = false;
- } else if (len > 0) {
- ret = read_content_with_length(strm, len, std::move(progress), out);
- }
- }
-
- if (!ret) { status = exceed_payload_max_length ? 413 : 400; }
- return ret;
- });
-} // namespace detail
-
-inline ssize_t write_headers(Stream &strm, const Headers &headers) {
- ssize_t write_len = 0;
- for (const auto &x : headers) {
- auto len =
- strm.write_format("%s: %s\r\n", x.first.c_str(), x.second.c_str());
- if (len < 0) { return len; }
- write_len += len;
- }
- auto len = strm.write("\r\n");
- if (len < 0) { return len; }
- write_len += len;
- return write_len;
-}
-
-inline bool write_data(Stream &strm, const char *d, size_t l) {
- size_t offset = 0;
- while (offset < l) {
- auto length = strm.write(d + offset, l - offset);
- if (length < 0) { return false; }
- offset += static_cast<size_t>(length);
- }
- return true;
-}
-
-template <typename T>
-inline bool write_content(Stream &strm, const ContentProvider &content_provider,
- size_t offset, size_t length, T is_shutting_down,
- Error &error) {
- size_t end_offset = offset + length;
- auto ok = true;
- DataSink data_sink;
-
- data_sink.write = [&](const char *d, size_t l) -> bool {
- if (ok) {
- if (strm.is_writable() && write_data(strm, d, l)) {
- offset += l;
- } else {
- ok = false;
- }
- }
- return ok;
- };
-
- while (offset < end_offset && !is_shutting_down()) {
- if (!strm.is_writable()) {
- error = Error::Write;
- return false;
- } else if (!content_provider(offset, end_offset - offset, data_sink)) {
- error = Error::Canceled;
- return false;
- } else if (!ok) {
- error = Error::Write;
- return false;
- }
- }
-
- error = Error::Success;
- return true;
-}
-
-template <typename T>
-inline bool write_content(Stream &strm, const ContentProvider &content_provider,
- size_t offset, size_t length,
- const T &is_shutting_down) {
- auto error = Error::Success;
- return write_content(strm, content_provider, offset, length, is_shutting_down,
- error);
-}
-
-template <typename T>
-inline bool
-write_content_without_length(Stream &strm,
- const ContentProvider &content_provider,
- const T &is_shutting_down) {
- size_t offset = 0;
- auto data_available = true;
- auto ok = true;
- DataSink data_sink;
-
- data_sink.write = [&](const char *d, size_t l) -> bool {
- if (ok) {
- offset += l;
- if (!strm.is_writable() || !write_data(strm, d, l)) { ok = false; }
- }
- return ok;
- };
-
- data_sink.done = [&](void) { data_available = false; };
-
- while (data_available && !is_shutting_down()) {
- if (!strm.is_writable()) {
- return false;
- } else if (!content_provider(offset, 0, data_sink)) {
- return false;
- } else if (!ok) {
- return false;
- }
- }
- return true;
-}
-
-template <typename T, typename U>
-inline bool
-write_content_chunked(Stream &strm, const ContentProvider &content_provider,
- const T &is_shutting_down, U &compressor, Error &error) {
- size_t offset = 0;
- auto data_available = true;
- auto ok = true;
- DataSink data_sink;
-
- data_sink.write = [&](const char *d, size_t l) -> bool {
- if (ok) {
- data_available = l > 0;
- offset += l;
-
- std::string payload;
- if (compressor.compress(d, l, false,
- [&](const char *data, size_t data_len) {
- payload.append(data, data_len);
- return true;
- })) {
- if (!payload.empty()) {
- // Emit chunked response header and footer for each chunk
- auto chunk =
- from_i_to_hex(payload.size()) + "\r\n" + payload + "\r\n";
- if (!strm.is_writable() ||
- !write_data(strm, chunk.data(), chunk.size())) {
- ok = false;
- }
- }
- } else {
- ok = false;
- }
- }
- return ok;
- };
-
- auto done_with_trailer = [&](const Headers *trailer) {
- if (!ok) { return; }
-
- data_available = false;
-
- std::string payload;
- if (!compressor.compress(nullptr, 0, true,
- [&](const char *data, size_t data_len) {
- payload.append(data, data_len);
- return true;
- })) {
- ok = false;
- return;
- }
-
- if (!payload.empty()) {
- // Emit chunked response header and footer for each chunk
- auto chunk = from_i_to_hex(payload.size()) + "\r\n" + payload + "\r\n";
- if (!strm.is_writable() ||
- !write_data(strm, chunk.data(), chunk.size())) {
- ok = false;
- return;
- }
- }
-
- static const std::string done_marker("0\r\n");
- if (!write_data(strm, done_marker.data(), done_marker.size())) {
- ok = false;
- }
-
- // Trailer
- if (trailer) {
- for (const auto &kv : *trailer) {
- std::string field_line = kv.first + ": " + kv.second + "\r\n";
- if (!write_data(strm, field_line.data(), field_line.size())) {
- ok = false;
- }
- }
- }
-
- static const std::string crlf("\r\n");
- if (!write_data(strm, crlf.data(), crlf.size())) { ok = false; }
- };
-
- data_sink.done = [&](void) { done_with_trailer(nullptr); };
-
- data_sink.done_with_trailer = [&](const Headers &trailer) {
- done_with_trailer(&trailer);
- };
-
- while (data_available && !is_shutting_down()) {
- if (!strm.is_writable()) {
- error = Error::Write;
- return false;
- } else if (!content_provider(offset, 0, data_sink)) {
- error = Error::Canceled;
- return false;
- } else if (!ok) {
- error = Error::Write;
- return false;
- }
- }
-
- error = Error::Success;
- return true;
-}
-
-template <typename T, typename U>
-inline bool write_content_chunked(Stream &strm,
- const ContentProvider &content_provider,
- const T &is_shutting_down, U &compressor) {
- auto error = Error::Success;
- return write_content_chunked(strm, content_provider, is_shutting_down,
- compressor, error);
-}
-
-template <typename T>
-inline bool redirect(T &cli, Request &req, Response &res,
- const std::string &path, const std::string &location,
- Error &error) {
- Request new_req = req;
- new_req.path = path;
- new_req.redirect_count_ -= 1;
-
- if (res.status == 303 && (req.method != "GET" && req.method != "HEAD")) {
- new_req.method = "GET";
- new_req.body.clear();
- new_req.headers.clear();
- }
-
- Response new_res;
-
- auto ret = cli.send(new_req, new_res, error);
- if (ret) {
- req = new_req;
- res = new_res;
-
- if (res.location.empty()) res.location = location;
- }
- return ret;
-}
-
-inline std::string params_to_query_str(const Params &params) {
- std::string query;
-
- for (auto it = params.begin(); it != params.end(); ++it) {
- if (it != params.begin()) { query += "&"; }
- query += it->first;
- query += "=";
- query += encode_query_param(it->second);
- }
- return query;
-}
-
-inline void parse_query_text(const std::string &s, Params &params) {
- std::set<std::string> cache;
- split(s.data(), s.data() + s.size(), '&', [&](const char *b, const char *e) {
- std::string kv(b, e);
- if (cache.find(kv) != cache.end()) { return; }
- cache.insert(kv);
-
- std::string key;
- std::string val;
- split(b, e, '=', [&](const char *b2, const char *e2) {
- if (key.empty()) {
- key.assign(b2, e2);
- } else {
- val.assign(b2, e2);
- }
- });
-
- if (!key.empty()) {
- params.emplace(decode_url(key, true), decode_url(val, true));
- }
- });
-}
-
-inline bool parse_multipart_boundary(const std::string &content_type,
- std::string &boundary) {
- auto boundary_keyword = "boundary=";
- auto pos = content_type.find(boundary_keyword);
- if (pos == std::string::npos) { return false; }
- auto end = content_type.find(';', pos);
- auto beg = pos + strlen(boundary_keyword);
- boundary = trim_double_quotes_copy(content_type.substr(beg, end - beg));
- return !boundary.empty();
-}
-
-inline void parse_disposition_params(const std::string &s, Params &params) {
- std::set<std::string> cache;
- split(s.data(), s.data() + s.size(), ';', [&](const char *b, const char *e) {
- std::string kv(b, e);
- if (cache.find(kv) != cache.end()) { return; }
- cache.insert(kv);
-
- std::string key;
- std::string val;
- split(b, e, '=', [&](const char *b2, const char *e2) {
- if (key.empty()) {
- key.assign(b2, e2);
- } else {
- val.assign(b2, e2);
- }
- });
-
- if (!key.empty()) {
- params.emplace(trim_double_quotes_copy((key)),
- trim_double_quotes_copy((val)));
- }
- });
-}
-
-#ifdef CPPHTTPLIB_NO_EXCEPTIONS
-inline bool parse_range_header(const std::string &s, Ranges &ranges) {
-#else
-inline bool parse_range_header(const std::string &s, Ranges &ranges) try {
-#endif
- static auto re_first_range = std::regex(R"(bytes=(\d*-\d*(?:,\s*\d*-\d*)*))");
- std::smatch m;
- if (std::regex_match(s, m, re_first_range)) {
- auto pos = static_cast<size_t>(m.position(1));
- auto len = static_cast<size_t>(m.length(1));
- auto all_valid_ranges = true;
- split(&s[pos], &s[pos + len], ',', [&](const char *b, const char *e) {
- if (!all_valid_ranges) return;
- static auto re_another_range = std::regex(R"(\s*(\d*)-(\d*))");
- std::cmatch cm;
- if (std::regex_match(b, e, cm, re_another_range)) {
- ssize_t first = -1;
- if (!cm.str(1).empty()) {
- first = static_cast<ssize_t>(std::stoll(cm.str(1)));
- }
-
- ssize_t last = -1;
- if (!cm.str(2).empty()) {
- last = static_cast<ssize_t>(std::stoll(cm.str(2)));
- }
-
- if (first != -1 && last != -1 && first > last) {
- all_valid_ranges = false;
- return;
- }
- ranges.emplace_back(std::make_pair(first, last));
- }
- });
- return all_valid_ranges;
- }
- return false;
-#ifdef CPPHTTPLIB_NO_EXCEPTIONS
-}
-#else
-} catch (...) { return false; }
-#endif
-
-class MultipartFormDataParser {
-public:
- MultipartFormDataParser() = default;
-
- void set_boundary(std::string &&boundary) {
- boundary_ = boundary;
- dash_boundary_crlf_ = dash_ + boundary_ + crlf_;
- crlf_dash_boundary_ = crlf_ + dash_ + boundary_;
- }
-
- bool is_valid() const { return is_valid_; }
-
- bool parse(const char *buf, size_t n, const ContentReceiver &content_callback,
- const MultipartContentHeader &header_callback) {
-
- buf_append(buf, n);
-
- while (buf_size() > 0) {
- switch (state_) {
- case 0: { // Initial boundary
- buf_erase(buf_find(dash_boundary_crlf_));
- if (dash_boundary_crlf_.size() > buf_size()) { return true; }
- if (!buf_start_with(dash_boundary_crlf_)) { return false; }
- buf_erase(dash_boundary_crlf_.size());
- state_ = 1;
- break;
- }
- case 1: { // New entry
- clear_file_info();
- state_ = 2;
- break;
- }
- case 2: { // Headers
- auto pos = buf_find(crlf_);
- if (pos > CPPHTTPLIB_HEADER_MAX_LENGTH) { return false; }
- while (pos < buf_size()) {
- // Empty line
- if (pos == 0) {
- if (!header_callback(file_)) {
- is_valid_ = false;
- return false;
- }
- buf_erase(crlf_.size());
- state_ = 3;
- break;
- }
-
- static const std::string header_name = "content-type:";
- const auto header = buf_head(pos);
- if (start_with_case_ignore(header, header_name)) {
- file_.content_type = trim_copy(header.substr(header_name.size()));
- } else {
- static const std::regex re_content_disposition(
- R"~(^Content-Disposition:\s*form-data;\s*(.*)$)~",
- std::regex_constants::icase);
-
- std::smatch m;
- if (std::regex_match(header, m, re_content_disposition)) {
- Params params;
- parse_disposition_params(m[1], params);
-
- auto it = params.find("name");
- if (it != params.end()) {
- file_.name = it->second;
- } else {
- is_valid_ = false;
- return false;
- }
-
- it = params.find("filename");
- if (it != params.end()) { file_.filename = it->second; }
-
- it = params.find("filename*");
- if (it != params.end()) {
- // Only allow UTF-8 enconnding...
- static const std::regex re_rfc5987_encoding(
- R"~(^UTF-8''(.+?)$)~", std::regex_constants::icase);
-
- std::smatch m2;
- if (std::regex_match(it->second, m2, re_rfc5987_encoding)) {
- file_.filename = decode_url(m2[1], false); // override...
- } else {
- is_valid_ = false;
- return false;
- }
- }
- } else {
- is_valid_ = false;
- return false;
- }
- }
- buf_erase(pos + crlf_.size());
- pos = buf_find(crlf_);
- }
- if (state_ != 3) { return true; }
- break;
- }
- case 3: { // Body
- if (crlf_dash_boundary_.size() > buf_size()) { return true; }
- auto pos = buf_find(crlf_dash_boundary_);
- if (pos < buf_size()) {
- if (!content_callback(buf_data(), pos)) {
- is_valid_ = false;
- return false;
- }
- buf_erase(pos + crlf_dash_boundary_.size());
- state_ = 4;
- } else {
- auto len = buf_size() - crlf_dash_boundary_.size();
- if (len > 0) {
- if (!content_callback(buf_data(), len)) {
- is_valid_ = false;
- return false;
- }
- buf_erase(len);
- }
- return true;
- }
- break;
- }
- case 4: { // Boundary
- if (crlf_.size() > buf_size()) { return true; }
- if (buf_start_with(crlf_)) {
- buf_erase(crlf_.size());
- state_ = 1;
- } else {
- if (dash_.size() > buf_size()) { return true; }
- if (buf_start_with(dash_)) {
- buf_erase(dash_.size());
- is_valid_ = true;
- buf_erase(buf_size()); // Remove epilogue
- } else {
- return true;
- }
- }
- break;
- }
- }
- }
-
- return true;
- }
-
-private:
- void clear_file_info() {
- file_.name.clear();
- file_.filename.clear();
- file_.content_type.clear();
- }
-
- bool start_with_case_ignore(const std::string &a,
- const std::string &b) const {
- if (a.size() < b.size()) { return false; }
- for (size_t i = 0; i < b.size(); i++) {
- if (::tolower(a[i]) != ::tolower(b[i])) { return false; }
- }
- return true;
- }
-
- const std::string dash_ = "--";
- const std::string crlf_ = "\r\n";
- std::string boundary_;
- std::string dash_boundary_crlf_;
- std::string crlf_dash_boundary_;
-
- size_t state_ = 0;
- bool is_valid_ = false;
- MultipartFormData file_;
-
- // Buffer
- bool start_with(const std::string &a, size_t spos, size_t epos,
- const std::string &b) const {
- if (epos - spos < b.size()) { return false; }
- for (size_t i = 0; i < b.size(); i++) {
- if (a[i + spos] != b[i]) { return false; }
- }
- return true;
- }
-
- size_t buf_size() const { return buf_epos_ - buf_spos_; }
-
- const char *buf_data() const { return &buf_[buf_spos_]; }
-
- std::string buf_head(size_t l) const { return buf_.substr(buf_spos_, l); }
-
- bool buf_start_with(const std::string &s) const {
- return start_with(buf_, buf_spos_, buf_epos_, s);
- }
-
- size_t buf_find(const std::string &s) const {
- auto c = s.front();
-
- size_t off = buf_spos_;
- while (off < buf_epos_) {
- auto pos = off;
- while (true) {
- if (pos == buf_epos_) { return buf_size(); }
- if (buf_[pos] == c) { break; }
- pos++;
- }
-
- auto remaining_size = buf_epos_ - pos;
- if (s.size() > remaining_size) { return buf_size(); }
-
- if (start_with(buf_, pos, buf_epos_, s)) { return pos - buf_spos_; }
-
- off = pos + 1;
- }
-
- return buf_size();
- }
-
- void buf_append(const char *data, size_t n) {
- auto remaining_size = buf_size();
- if (remaining_size > 0 && buf_spos_ > 0) {
- for (size_t i = 0; i < remaining_size; i++) {
- buf_[i] = buf_[buf_spos_ + i];
- }
- }
- buf_spos_ = 0;
- buf_epos_ = remaining_size;
-
- if (remaining_size + n > buf_.size()) { buf_.resize(remaining_size + n); }
-
- for (size_t i = 0; i < n; i++) {
- buf_[buf_epos_ + i] = data[i];
- }
- buf_epos_ += n;
- }
-
- void buf_erase(size_t size) { buf_spos_ += size; }
-
- std::string buf_;
- size_t buf_spos_ = 0;
- size_t buf_epos_ = 0;
-};
-
-inline std::string to_lower(const char *beg, const char *end) {
- std::string out;
- auto it = beg;
- while (it != end) {
- out += static_cast<char>(::tolower(*it));
- it++;
- }
- return out;
-}
-
-inline std::string make_multipart_data_boundary() {
- static const char data[] =
- "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-
- // std::random_device might actually be deterministic on some
- // platforms, but due to lack of support in the c++ standard library,
- // doing better requires either some ugly hacks or breaking portability.
- std::random_device seed_gen;
-
- // Request 128 bits of entropy for initialization
- std::seed_seq seed_sequence{seed_gen(), seed_gen(), seed_gen(), seed_gen()};
- std::mt19937 engine(seed_sequence);
-
- std::string result = "--cpp-httplib-multipart-data-";
-
- for (auto i = 0; i < 16; i++) {
- result += data[engine() % (sizeof(data) - 1)];
- }
-
- return result;
-}
-
-inline bool is_multipart_boundary_chars_valid(const std::string &boundary) {
- auto valid = true;
- for (size_t i = 0; i < boundary.size(); i++) {
- auto c = boundary[i];
- if (!std::isalnum(c) && c != '-' && c != '_') {
- valid = false;
- break;
- }
- }
- return valid;
-}
-
-template <typename T>
-inline std::string
-serialize_multipart_formdata_item_begin(const T &item,
- const std::string &boundary) {
- std::string body = "--" + boundary + "\r\n";
- body += "Content-Disposition: form-data; name=\"" + item.name + "\"";
- if (!item.filename.empty()) {
- body += "; filename=\"" + item.filename + "\"";
- }
- body += "\r\n";
- if (!item.content_type.empty()) {
- body += "Content-Type: " + item.content_type + "\r\n";
- }
- body += "\r\n";
-
- return body;
-}
-
-inline std::string serialize_multipart_formdata_item_end() { return "\r\n"; }
-
-inline std::string
-serialize_multipart_formdata_finish(const std::string &boundary) {
- return "--" + boundary + "--\r\n";
-}
-
-inline std::string
-serialize_multipart_formdata_get_content_type(const std::string &boundary) {
- return "multipart/form-data; boundary=" + boundary;
-}
-
-inline std::string
-serialize_multipart_formdata(const MultipartFormDataItems &items,
- const std::string &boundary, bool finish = true) {
- std::string body;
-
- for (const auto &item : items) {
- body += serialize_multipart_formdata_item_begin(item, boundary);
- body += item.content + serialize_multipart_formdata_item_end();
- }
-
- if (finish) body += serialize_multipart_formdata_finish(boundary);
-
- return body;
-}
-
-inline std::pair<size_t, size_t>
-get_range_offset_and_length(const Request &req, size_t content_length,
- size_t index) {
- auto r = req.ranges[index];
-
- if (r.first == -1 && r.second == -1) {
- return std::make_pair(0, content_length);
- }
-
- auto slen = static_cast<ssize_t>(content_length);
-
- if (r.first == -1) {
- r.first = (std::max)(static_cast<ssize_t>(0), slen - r.second);
- r.second = slen - 1;
- }
-
- if (r.second == -1) { r.second = slen - 1; }
- return std::make_pair(r.first, static_cast<size_t>(r.second - r.first) + 1);
-}
-
-inline std::string
-make_content_range_header_field(const std::pair<ssize_t, ssize_t> &range,
- size_t content_length) {
- std::string field = "bytes ";
- if (range.first != -1) { field += std::to_string(range.first); }
- field += "-";
- if (range.second != -1) { field += std::to_string(range.second); }
- field += "/";
- field += std::to_string(content_length);
- return field;
-}
-
-template <typename SToken, typename CToken, typename Content>
-bool process_multipart_ranges_data(const Request &req, Response &res,
- const std::string &boundary,
- const std::string &content_type,
- SToken stoken, CToken ctoken,
- Content content) {
- for (size_t i = 0; i < req.ranges.size(); i++) {
- ctoken("--");
- stoken(boundary);
- ctoken("\r\n");
- if (!content_type.empty()) {
- ctoken("Content-Type: ");
- stoken(content_type);
- ctoken("\r\n");
- }
-
- ctoken("Content-Range: ");
- const auto &range = req.ranges[i];
- stoken(make_content_range_header_field(range, res.content_length_));
- ctoken("\r\n");
- ctoken("\r\n");
-
- auto offsets = get_range_offset_and_length(req, res.content_length_, i);
- auto offset = offsets.first;
- auto length = offsets.second;
- if (!content(offset, length)) { return false; }
- ctoken("\r\n");
- }
-
- ctoken("--");
- stoken(boundary);
- ctoken("--");
-
- return true;
-}
-
-inline bool make_multipart_ranges_data(const Request &req, Response &res,
- const std::string &boundary,
- const std::string &content_type,
- std::string &data) {
- return process_multipart_ranges_data(
- req, res, boundary, content_type,
- [&](const std::string &token) { data += token; },
- [&](const std::string &token) { data += token; },
- [&](size_t offset, size_t length) {
- if (offset < res.body.size()) {
- data += res.body.substr(offset, length);
- return true;
- }
- return false;
- });
-}
-
-inline size_t
-get_multipart_ranges_data_length(const Request &req, Response &res,
- const std::string &boundary,
- const std::string &content_type) {
- size_t data_length = 0;
-
- process_multipart_ranges_data(
- req, res, boundary, content_type,
- [&](const std::string &token) { data_length += token.size(); },
- [&](const std::string &token) { data_length += token.size(); },
- [&](size_t /*offset*/, size_t length) {
- data_length += length;
- return true;
- });
-
- return data_length;
-}
-
-template <typename T>
-inline bool write_multipart_ranges_data(Stream &strm, const Request &req,
- Response &res,
- const std::string &boundary,
- const std::string &content_type,
- const T &is_shutting_down) {
- return process_multipart_ranges_data(
- req, res, boundary, content_type,
- [&](const std::string &token) { strm.write(token); },
- [&](const std::string &token) { strm.write(token); },
- [&](size_t offset, size_t length) {
- return write_content(strm, res.content_provider_, offset, length,
- is_shutting_down);
- });
-}
-
-inline std::pair<size_t, size_t>
-get_range_offset_and_length(const Request &req, const Response &res,
- size_t index) {
- auto r = req.ranges[index];
-
- if (r.second == -1) {
- r.second = static_cast<ssize_t>(res.content_length_) - 1;
- }
-
- return std::make_pair(r.first, r.second - r.first + 1);
-}
-
-inline bool expect_content(const Request &req) {
- if (req.method == "POST" || req.method == "PUT" || req.method == "PATCH" ||
- req.method == "PRI" || req.method == "DELETE") {
- return true;
- }
- // TODO: check if Content-Length is set
- return false;
-}
-
-inline bool has_crlf(const std::string &s) {
- auto p = s.c_str();
- while (*p) {
- if (*p == '\r' || *p == '\n') { return true; }
- p++;
- }
- return false;
-}
-
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-inline std::string message_digest(const std::string &s, const EVP_MD *algo) {
- auto context = std::unique_ptr<EVP_MD_CTX, decltype(&EVP_MD_CTX_free)>(
- EVP_MD_CTX_new(), EVP_MD_CTX_free);
-
- unsigned int hash_length = 0;
- unsigned char hash[EVP_MAX_MD_SIZE];
-
- EVP_DigestInit_ex(context.get(), algo, nullptr);
- EVP_DigestUpdate(context.get(), s.c_str(), s.size());
- EVP_DigestFinal_ex(context.get(), hash, &hash_length);
-
- std::stringstream ss;
- for (auto i = 0u; i < hash_length; ++i) {
- ss << std::hex << std::setw(2) << std::setfill('0')
- << static_cast<unsigned int>(hash[i]);
- }
-
- return ss.str();
-}
-
-inline std::string MD5(const std::string &s) {
- return message_digest(s, EVP_md5());
-}
-
-inline std::string SHA_256(const std::string &s) {
- return message_digest(s, EVP_sha256());
-}
-
-inline std::string SHA_512(const std::string &s) {
- return message_digest(s, EVP_sha512());
-}
-#endif
-
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-#ifdef _WIN32
-// NOTE: This code came up with the following stackoverflow post:
-// https://stackoverflow.com/questions/9507184/can-openssl-on-windows-use-the-system-certificate-store
-inline bool load_system_certs_on_windows(X509_STORE *store) {
- auto hStore = CertOpenSystemStoreW((HCRYPTPROV_LEGACY)NULL, L"ROOT");
- if (!hStore) { return false; }
-
- auto result = false;
- PCCERT_CONTEXT pContext = NULL;
- while ((pContext = CertEnumCertificatesInStore(hStore, pContext)) !=
- nullptr) {
- auto encoded_cert =
- static_cast<const unsigned char *>(pContext->pbCertEncoded);
-
- auto x509 = d2i_X509(NULL, &encoded_cert, pContext->cbCertEncoded);
- if (x509) {
- X509_STORE_add_cert(store, x509);
- X509_free(x509);
- result = true;
- }
- }
-
- CertFreeCertificateContext(pContext);
- CertCloseStore(hStore, 0);
-
- return result;
-}
-#elif defined(CPPHTTPLIB_USE_CERTS_FROM_MACOSX_KEYCHAIN) && defined(__APPLE__)
-#if TARGET_OS_OSX
-template <typename T>
-using CFObjectPtr =
- std::unique_ptr<typename std::remove_pointer<T>::type, void (*)(CFTypeRef)>;
-
-inline void cf_object_ptr_deleter(CFTypeRef obj) {
- if (obj) { CFRelease(obj); }
-}
-
-inline bool retrieve_certs_from_keychain(CFObjectPtr<CFArrayRef> &certs) {
- CFStringRef keys[] = {kSecClass, kSecMatchLimit, kSecReturnRef};
- CFTypeRef values[] = {kSecClassCertificate, kSecMatchLimitAll,
- kCFBooleanTrue};
-
- CFObjectPtr<CFDictionaryRef> query(
- CFDictionaryCreate(nullptr, reinterpret_cast<const void **>(keys), values,
- sizeof(keys) / sizeof(keys[0]),
- &kCFTypeDictionaryKeyCallBacks,
- &kCFTypeDictionaryValueCallBacks),
- cf_object_ptr_deleter);
-
- if (!query) { return false; }
-
- CFTypeRef security_items = nullptr;
- if (SecItemCopyMatching(query.get(), &security_items) != errSecSuccess ||
- CFArrayGetTypeID() != CFGetTypeID(security_items)) {
- return false;
- }
-
- certs.reset(reinterpret_cast<CFArrayRef>(security_items));
- return true;
-}
-
-inline bool retrieve_root_certs_from_keychain(CFObjectPtr<CFArrayRef> &certs) {
- CFArrayRef root_security_items = nullptr;
- if (SecTrustCopyAnchorCertificates(&root_security_items) != errSecSuccess) {
- return false;
- }
-
- certs.reset(root_security_items);
- return true;
-}
-
-inline bool add_certs_to_x509_store(CFArrayRef certs, X509_STORE *store) {
- auto result = false;
- for (auto i = 0; i < CFArrayGetCount(certs); ++i) {
- const auto cert = reinterpret_cast<const __SecCertificate *>(
- CFArrayGetValueAtIndex(certs, i));
-
- if (SecCertificateGetTypeID() != CFGetTypeID(cert)) { continue; }
-
- CFDataRef cert_data = nullptr;
- if (SecItemExport(cert, kSecFormatX509Cert, 0, nullptr, &cert_data) !=
- errSecSuccess) {
- continue;
- }
-
- CFObjectPtr<CFDataRef> cert_data_ptr(cert_data, cf_object_ptr_deleter);
-
- auto encoded_cert = static_cast<const unsigned char *>(
- CFDataGetBytePtr(cert_data_ptr.get()));
-
- auto x509 =
- d2i_X509(NULL, &encoded_cert, CFDataGetLength(cert_data_ptr.get()));
-
- if (x509) {
- X509_STORE_add_cert(store, x509);
- X509_free(x509);
- result = true;
- }
- }
-
- return result;
-}
-
-inline bool load_system_certs_on_macos(X509_STORE *store) {
- auto result = false;
- CFObjectPtr<CFArrayRef> certs(nullptr, cf_object_ptr_deleter);
- if (retrieve_certs_from_keychain(certs) && certs) {
- result = add_certs_to_x509_store(certs.get(), store);
- }
-
- if (retrieve_root_certs_from_keychain(certs) && certs) {
- result = add_certs_to_x509_store(certs.get(), store) || result;
- }
-
- return result;
-}
-#endif // TARGET_OS_OSX
-#endif // _WIN32
-#endif // CPPHTTPLIB_OPENSSL_SUPPORT
-
-#ifdef _WIN32
-class WSInit {
-public:
- WSInit() {
- WSADATA wsaData;
- if (WSAStartup(0x0002, &wsaData) == 0) is_valid_ = true;
- }
-
- ~WSInit() {
- if (is_valid_) WSACleanup();
- }
-
- bool is_valid_ = false;
-};
-
-static WSInit wsinit_;
-#endif
-
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-inline std::pair<std::string, std::string> make_digest_authentication_header(
- const Request &req, const std::map<std::string, std::string> &auth,
- size_t cnonce_count, const std::string &cnonce, const std::string &username,
- const std::string &password, bool is_proxy = false) {
- std::string nc;
- {
- std::stringstream ss;
- ss << std::setfill('0') << std::setw(8) << std::hex << cnonce_count;
- nc = ss.str();
- }
-
- std::string qop;
- if (auth.find("qop") != auth.end()) {
- qop = auth.at("qop");
- if (qop.find("auth-int") != std::string::npos) {
- qop = "auth-int";
- } else if (qop.find("auth") != std::string::npos) {
- qop = "auth";
- } else {
- qop.clear();
- }
- }
-
- std::string algo = "MD5";
- if (auth.find("algorithm") != auth.end()) { algo = auth.at("algorithm"); }
-
- std::string response;
- {
- auto H = algo == "SHA-256" ? detail::SHA_256
- : algo == "SHA-512" ? detail::SHA_512
- : detail::MD5;
-
- auto A1 = username + ":" + auth.at("realm") + ":" + password;
-
- auto A2 = req.method + ":" + req.path;
- if (qop == "auth-int") { A2 += ":" + H(req.body); }
-
- if (qop.empty()) {
- response = H(H(A1) + ":" + auth.at("nonce") + ":" + H(A2));
- } else {
- response = H(H(A1) + ":" + auth.at("nonce") + ":" + nc + ":" + cnonce +
- ":" + qop + ":" + H(A2));
- }
- }
-
- auto opaque = (auth.find("opaque") != auth.end()) ? auth.at("opaque") : "";
-
- auto field = "Digest username=\"" + username + "\", realm=\"" +
- auth.at("realm") + "\", nonce=\"" + auth.at("nonce") +
- "\", uri=\"" + req.path + "\", algorithm=" + algo +
- (qop.empty() ? ", response=\""
- : ", qop=" + qop + ", nc=" + nc + ", cnonce=\"" +
- cnonce + "\", response=\"") +
- response + "\"" +
- (opaque.empty() ? "" : ", opaque=\"" + opaque + "\"");
-
- auto key = is_proxy ? "Proxy-Authorization" : "Authorization";
- return std::make_pair(key, field);
-}
-#endif
-
-inline bool parse_www_authenticate(const Response &res,
- std::map<std::string, std::string> &auth,
- bool is_proxy) {
- auto auth_key = is_proxy ? "Proxy-Authenticate" : "WWW-Authenticate";
- if (res.has_header(auth_key)) {
- static auto re = std::regex(R"~((?:(?:,\s*)?(.+?)=(?:"(.*?)"|([^,]*))))~");
- auto s = res.get_header_value(auth_key);
- auto pos = s.find(' ');
- if (pos != std::string::npos) {
- auto type = s.substr(0, pos);
- if (type == "Basic") {
- return false;
- } else if (type == "Digest") {
- s = s.substr(pos + 1);
- auto beg = std::sregex_iterator(s.begin(), s.end(), re);
- for (auto i = beg; i != std::sregex_iterator(); ++i) {
- const auto &m = *i;
- auto key = s.substr(static_cast<size_t>(m.position(1)),
- static_cast<size_t>(m.length(1)));
- auto val = m.length(2) > 0
- ? s.substr(static_cast<size_t>(m.position(2)),
- static_cast<size_t>(m.length(2)))
- : s.substr(static_cast<size_t>(m.position(3)),
- static_cast<size_t>(m.length(3)));
- auth[key] = val;
- }
- return true;
- }
- }
- }
- return false;
-}
-
-// https://stackoverflow.com/questions/440133/how-do-i-create-a-random-alpha-numeric-string-in-c/440240#answer-440240
-inline std::string random_string(size_t length) {
- auto randchar = []() -> char {
- const char charset[] = "0123456789"
- "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
- "abcdefghijklmnopqrstuvwxyz";
- const size_t max_index = (sizeof(charset) - 1);
- return charset[static_cast<size_t>(std::rand()) % max_index];
- };
- std::string str(length, 0);
- std::generate_n(str.begin(), length, randchar);
- return str;
-}
-
-class ContentProviderAdapter {
-public:
- explicit ContentProviderAdapter(
- ContentProviderWithoutLength &&content_provider)
- : content_provider_(content_provider) {}
-
- bool operator()(size_t offset, size_t, DataSink &sink) {
- return content_provider_(offset, sink);
- }
-
-private:
- ContentProviderWithoutLength content_provider_;
-};
-
-} // namespace detail
-
-inline std::string hosted_at(const std::string &hostname) {
- std::vector<std::string> addrs;
- hosted_at(hostname, addrs);
- if (addrs.empty()) { return std::string(); }
- return addrs[0];
-}
-
-inline void hosted_at(const std::string &hostname,
- std::vector<std::string> &addrs) {
- struct addrinfo hints;
- struct addrinfo *result;
-
- memset(&hints, 0, sizeof(struct addrinfo));
- hints.ai_family = AF_UNSPEC;
- hints.ai_socktype = SOCK_STREAM;
- hints.ai_protocol = 0;
-
- if (getaddrinfo(hostname.c_str(), nullptr, &hints, &result)) {
-#if defined __linux__ && !defined __ANDROID__
- res_init();
-#endif
- return;
- }
-
- for (auto rp = result; rp; rp = rp->ai_next) {
- const auto &addr =
- *reinterpret_cast<struct sockaddr_storage *>(rp->ai_addr);
- std::string ip;
- auto dummy = -1;
- if (detail::get_ip_and_port(addr, sizeof(struct sockaddr_storage), ip,
- dummy)) {
- addrs.push_back(ip);
- }
- }
-
- freeaddrinfo(result);
-}
-
-inline std::string append_query_params(const std::string &path,
- const Params &params) {
- std::string path_with_query = path;
- const static std::regex re("[^?]+\\?.*");
- auto delm = std::regex_match(path, re) ? '&' : '?';
- path_with_query += delm + detail::params_to_query_str(params);
- return path_with_query;
-}
-
-// Header utilities
-inline std::pair<std::string, std::string> make_range_header(Ranges ranges) {
- std::string field = "bytes=";
- auto i = 0;
- for (auto r : ranges) {
- if (i != 0) { field += ", "; }
- if (r.first != -1) { field += std::to_string(r.first); }
- field += '-';
- if (r.second != -1) { field += std::to_string(r.second); }
- i++;
- }
- return std::make_pair("Range", std::move(field));
-}
-
-inline std::pair<std::string, std::string>
-make_basic_authentication_header(const std::string &username,
- const std::string &password, bool is_proxy) {
- auto field = "Basic " + detail::base64_encode(username + ":" + password);
- auto key = is_proxy ? "Proxy-Authorization" : "Authorization";
- return std::make_pair(key, std::move(field));
-}
-
-inline std::pair<std::string, std::string>
-make_bearer_token_authentication_header(const std::string &token,
- bool is_proxy = false) {
- auto field = "Bearer " + token;
- auto key = is_proxy ? "Proxy-Authorization" : "Authorization";
- return std::make_pair(key, std::move(field));
-}
-
-// Request implementation
-inline bool Request::has_header(const std::string &key) const {
- return detail::has_header(headers, key);
-}
-
-inline std::string Request::get_header_value(const std::string &key,
- size_t id) const {
- return detail::get_header_value(headers, key, id, "");
-}
-
-inline size_t Request::get_header_value_count(const std::string &key) const {
- auto r = headers.equal_range(key);
- return static_cast<size_t>(std::distance(r.first, r.second));
-}
-
-inline void Request::set_header(const std::string &key,
- const std::string &val) {
- if (!detail::has_crlf(key) && !detail::has_crlf(val)) {
- headers.emplace(key, val);
- }
-}
-
-inline bool Request::has_param(const std::string &key) const {
- return params.find(key) != params.end();
-}
-
-inline std::string Request::get_param_value(const std::string &key,
- size_t id) const {
- auto rng = params.equal_range(key);
- auto it = rng.first;
- std::advance(it, static_cast<ssize_t>(id));
- if (it != rng.second) { return it->second; }
- return std::string();
-}
-
-inline size_t Request::get_param_value_count(const std::string &key) const {
- auto r = params.equal_range(key);
- return static_cast<size_t>(std::distance(r.first, r.second));
-}
-
-inline bool Request::is_multipart_form_data() const {
- const auto &content_type = get_header_value("Content-Type");
- return !content_type.rfind("multipart/form-data", 0);
-}
-
-inline bool Request::has_file(const std::string &key) const {
- return files.find(key) != files.end();
-}
-
-inline MultipartFormData Request::get_file_value(const std::string &key) const {
- auto it = files.find(key);
- if (it != files.end()) { return it->second; }
- return MultipartFormData();
-}
-
-inline std::vector<MultipartFormData>
-Request::get_file_values(const std::string &key) const {
- std::vector<MultipartFormData> values;
- auto rng = files.equal_range(key);
- for (auto it = rng.first; it != rng.second; it++) {
- values.push_back(it->second);
- }
- return values;
-}
-
-// Response implementation
-inline bool Response::has_header(const std::string &key) const {
- return headers.find(key) != headers.end();
-}
-
-inline std::string Response::get_header_value(const std::string &key,
- size_t id) const {
- return detail::get_header_value(headers, key, id, "");
-}
-
-inline size_t Response::get_header_value_count(const std::string &key) const {
- auto r = headers.equal_range(key);
- return static_cast<size_t>(std::distance(r.first, r.second));
-}
-
-inline void Response::set_header(const std::string &key,
- const std::string &val) {
- if (!detail::has_crlf(key) && !detail::has_crlf(val)) {
- headers.emplace(key, val);
- }
-}
-
-inline void Response::set_redirect(const std::string &url, int stat) {
- if (!detail::has_crlf(url)) {
- set_header("Location", url);
- if (300 <= stat && stat < 400) {
- this->status = stat;
- } else {
- this->status = 302;
- }
- }
-}
-
-inline void Response::set_content(const char *s, size_t n,
- const std::string &content_type) {
- body.assign(s, n);
-
- auto rng = headers.equal_range("Content-Type");
- headers.erase(rng.first, rng.second);
- set_header("Content-Type", content_type);
-}
-
-inline void Response::set_content(const std::string &s,
- const std::string &content_type) {
- set_content(s.data(), s.size(), content_type);
-}
-
-inline void Response::set_content_provider(
- size_t in_length, const std::string &content_type, ContentProvider provider,
- ContentProviderResourceReleaser resource_releaser) {
- set_header("Content-Type", content_type);
- content_length_ = in_length;
- if (in_length > 0) { content_provider_ = std::move(provider); }
- content_provider_resource_releaser_ = resource_releaser;
- is_chunked_content_provider_ = false;
-}
-
-inline void Response::set_content_provider(
- const std::string &content_type, ContentProviderWithoutLength provider,
- ContentProviderResourceReleaser resource_releaser) {
- set_header("Content-Type", content_type);
- content_length_ = 0;
- content_provider_ = detail::ContentProviderAdapter(std::move(provider));
- content_provider_resource_releaser_ = resource_releaser;
- is_chunked_content_provider_ = false;
-}
-
-inline void Response::set_chunked_content_provider(
- const std::string &content_type, ContentProviderWithoutLength provider,
- ContentProviderResourceReleaser resource_releaser) {
- set_header("Content-Type", content_type);
- content_length_ = 0;
- content_provider_ = detail::ContentProviderAdapter(std::move(provider));
- content_provider_resource_releaser_ = resource_releaser;
- is_chunked_content_provider_ = true;
-}
-
-// Result implementation
-inline bool Result::has_request_header(const std::string &key) const {
- return request_headers_.find(key) != request_headers_.end();
-}
-
-inline std::string Result::get_request_header_value(const std::string &key,
- size_t id) const {
- return detail::get_header_value(request_headers_, key, id, "");
-}
-
-inline size_t
-Result::get_request_header_value_count(const std::string &key) const {
- auto r = request_headers_.equal_range(key);
- return static_cast<size_t>(std::distance(r.first, r.second));
-}
-
-// Stream implementation
-inline ssize_t Stream::write(const char *ptr) {
- return write(ptr, strlen(ptr));
-}
-
-inline ssize_t Stream::write(const std::string &s) {
- return write(s.data(), s.size());
-}
-
-namespace detail {
-
-// Socket stream implementation
-inline SocketStream::SocketStream(socket_t sock, time_t read_timeout_sec,
- time_t read_timeout_usec,
- time_t write_timeout_sec,
- time_t write_timeout_usec)
- : sock_(sock), read_timeout_sec_(read_timeout_sec),
- read_timeout_usec_(read_timeout_usec),
- write_timeout_sec_(write_timeout_sec),
- write_timeout_usec_(write_timeout_usec), read_buff_(read_buff_size_, 0) {}
-
-inline SocketStream::~SocketStream() {}
-
-inline bool SocketStream::is_readable() const {
- return select_read(sock_, read_timeout_sec_, read_timeout_usec_) > 0;
-}
-
-inline bool SocketStream::is_writable() const {
- return select_write(sock_, write_timeout_sec_, write_timeout_usec_) > 0 &&
- is_socket_alive(sock_);
-}
-
-inline ssize_t SocketStream::read(char *ptr, size_t size) {
-#ifdef _WIN32
- size =
- (std::min)(size, static_cast<size_t>((std::numeric_limits<int>::max)()));
-#else
- size = (std::min)(size,
- static_cast<size_t>((std::numeric_limits<ssize_t>::max)()));
-#endif
-
- if (read_buff_off_ < read_buff_content_size_) {
- auto remaining_size = read_buff_content_size_ - read_buff_off_;
- if (size <= remaining_size) {
- memcpy(ptr, read_buff_.data() + read_buff_off_, size);
- read_buff_off_ += size;
- return static_cast<ssize_t>(size);
- } else {
- memcpy(ptr, read_buff_.data() + read_buff_off_, remaining_size);
- read_buff_off_ += remaining_size;
- return static_cast<ssize_t>(remaining_size);
- }
- }
-
- if (!is_readable()) { return -1; }
-
- read_buff_off_ = 0;
- read_buff_content_size_ = 0;
-
- if (size < read_buff_size_) {
- auto n = read_socket(sock_, read_buff_.data(), read_buff_size_,
- CPPHTTPLIB_RECV_FLAGS);
- if (n <= 0) {
- return n;
- } else if (n <= static_cast<ssize_t>(size)) {
- memcpy(ptr, read_buff_.data(), static_cast<size_t>(n));
- return n;
- } else {
- memcpy(ptr, read_buff_.data(), size);
- read_buff_off_ = size;
- read_buff_content_size_ = static_cast<size_t>(n);
- return static_cast<ssize_t>(size);
- }
- } else {
- return read_socket(sock_, ptr, size, CPPHTTPLIB_RECV_FLAGS);
- }
-}
-
-inline ssize_t SocketStream::write(const char *ptr, size_t size) {
- if (!is_writable()) { return -1; }
-
-#if defined(_WIN32) && !defined(_WIN64)
- size =
- (std::min)(size, static_cast<size_t>((std::numeric_limits<int>::max)()));
-#endif
-
- return send_socket(sock_, ptr, size, CPPHTTPLIB_SEND_FLAGS);
-}
-
-inline void SocketStream::get_remote_ip_and_port(std::string &ip,
- int &port) const {
- return detail::get_remote_ip_and_port(sock_, ip, port);
-}
-
-inline void SocketStream::get_local_ip_and_port(std::string &ip,
- int &port) const {
- return detail::get_local_ip_and_port(sock_, ip, port);
-}
-
-inline socket_t SocketStream::socket() const { return sock_; }
-
-// Buffer stream implementation
-inline bool BufferStream::is_readable() const { return true; }
-
-inline bool BufferStream::is_writable() const { return true; }
-
-inline ssize_t BufferStream::read(char *ptr, size_t size) {
-#if defined(_MSC_VER) && _MSC_VER < 1910
- auto len_read = buffer._Copy_s(ptr, size, size, position);
-#else
- auto len_read = buffer.copy(ptr, size, position);
-#endif
- position += static_cast<size_t>(len_read);
- return static_cast<ssize_t>(len_read);
-}
-
-inline ssize_t BufferStream::write(const char *ptr, size_t size) {
- buffer.append(ptr, size);
- return static_cast<ssize_t>(size);
-}
-
-inline void BufferStream::get_remote_ip_and_port(std::string & /*ip*/,
- int & /*port*/) const {}
-
-inline void BufferStream::get_local_ip_and_port(std::string & /*ip*/,
- int & /*port*/) const {}
-
-inline socket_t BufferStream::socket() const { return 0; }
-
-inline const std::string &BufferStream::get_buffer() const { return buffer; }
-
-inline PathParamsMatcher::PathParamsMatcher(const std::string &pattern) {
- // One past the last ending position of a path param substring
- std::size_t last_param_end = 0;
-
-#ifndef CPPHTTPLIB_NO_EXCEPTIONS
- // Needed to ensure that parameter names are unique during matcher
- // construction
- // If exceptions are disabled, only last duplicate path
- // parameter will be set
- std::unordered_set<std::string> param_name_set;
-#endif
-
- while (true) {
- const auto marker_pos = pattern.find(marker, last_param_end);
- if (marker_pos == std::string::npos) { break; }
-
- static_fragments_.push_back(
- pattern.substr(last_param_end, marker_pos - last_param_end));
-
- const auto param_name_start = marker_pos + 1;
-
- auto sep_pos = pattern.find(separator, param_name_start);
- if (sep_pos == std::string::npos) { sep_pos = pattern.length(); }
-
- auto param_name =
- pattern.substr(param_name_start, sep_pos - param_name_start);
-
-#ifndef CPPHTTPLIB_NO_EXCEPTIONS
- if (param_name_set.find(param_name) != param_name_set.cend()) {
- std::string msg = "Encountered path parameter '" + param_name +
- "' multiple times in route pattern '" + pattern + "'.";
- throw std::invalid_argument(msg);
- }
-#endif
-
- param_names_.push_back(std::move(param_name));
-
- last_param_end = sep_pos + 1;
- }
-
- if (last_param_end < pattern.length()) {
- static_fragments_.push_back(pattern.substr(last_param_end));
- }
-}
-
-inline bool PathParamsMatcher::match(Request &request) const {
- request.matches = std::smatch();
- request.path_params.clear();
- request.path_params.reserve(param_names_.size());
-
- // One past the position at which the path matched the pattern last time
- std::size_t starting_pos = 0;
- for (size_t i = 0; i < static_fragments_.size(); ++i) {
- const auto &fragment = static_fragments_[i];
-
- if (starting_pos + fragment.length() > request.path.length()) {
- return false;
- }
-
- // Avoid unnecessary allocation by using strncmp instead of substr +
- // comparison
- if (std::strncmp(request.path.c_str() + starting_pos, fragment.c_str(),
- fragment.length()) != 0) {
- return false;
- }
-
- starting_pos += fragment.length();
-
- // Should only happen when we have a static fragment after a param
- // Example: '/users/:id/subscriptions'
- // The 'subscriptions' fragment here does not have a corresponding param
- if (i >= param_names_.size()) { continue; }
-
- auto sep_pos = request.path.find(separator, starting_pos);
- if (sep_pos == std::string::npos) { sep_pos = request.path.length(); }
-
- const auto &param_name = param_names_[i];
-
- request.path_params.emplace(
- param_name, request.path.substr(starting_pos, sep_pos - starting_pos));
-
- // Mark everythin up to '/' as matched
- starting_pos = sep_pos + 1;
- }
- // Returns false if the path is longer than the pattern
- return starting_pos >= request.path.length();
-}
-
-inline bool RegexMatcher::match(Request &request) const {
- request.path_params.clear();
- return std::regex_match(request.path, request.matches, regex_);
-}
-
-} // namespace detail
-
-// HTTP server implementation
-inline Server::Server()
- : new_task_queue(
- [] { return new ThreadPool(CPPHTTPLIB_THREAD_POOL_COUNT); }) {
-#ifndef _WIN32
- signal(SIGPIPE, SIG_IGN);
-#endif
-}
-
-inline Server::~Server() {}
-
-inline std::unique_ptr<detail::MatcherBase>
-Server::make_matcher(const std::string &pattern) {
- if (pattern.find("/:") != std::string::npos) {
- return detail::make_unique<detail::PathParamsMatcher>(pattern);
- } else {
- return detail::make_unique<detail::RegexMatcher>(pattern);
- }
-}
-
-inline Server &Server::Get(const std::string &pattern, Handler handler) {
- get_handlers_.push_back(
- std::make_pair(make_matcher(pattern), std::move(handler)));
- return *this;
-}
-
-inline Server &Server::Post(const std::string &pattern, Handler handler) {
- post_handlers_.push_back(
- std::make_pair(make_matcher(pattern), std::move(handler)));
- return *this;
-}
-
-inline Server &Server::Post(const std::string &pattern,
- HandlerWithContentReader handler) {
- post_handlers_for_content_reader_.push_back(
- std::make_pair(make_matcher(pattern), std::move(handler)));
- return *this;
-}
-
-inline Server &Server::Put(const std::string &pattern, Handler handler) {
- put_handlers_.push_back(
- std::make_pair(make_matcher(pattern), std::move(handler)));
- return *this;
-}
-
-inline Server &Server::Put(const std::string &pattern,
- HandlerWithContentReader handler) {
- put_handlers_for_content_reader_.push_back(
- std::make_pair(make_matcher(pattern), std::move(handler)));
- return *this;
-}
-
-inline Server &Server::Patch(const std::string &pattern, Handler handler) {
- patch_handlers_.push_back(
- std::make_pair(make_matcher(pattern), std::move(handler)));
- return *this;
-}
-
-inline Server &Server::Patch(const std::string &pattern,
- HandlerWithContentReader handler) {
- patch_handlers_for_content_reader_.push_back(
- std::make_pair(make_matcher(pattern), std::move(handler)));
- return *this;
-}
-
-inline Server &Server::Delete(const std::string &pattern, Handler handler) {
- delete_handlers_.push_back(
- std::make_pair(make_matcher(pattern), std::move(handler)));
- return *this;
-}
-
-inline Server &Server::Delete(const std::string &pattern,
- HandlerWithContentReader handler) {
- delete_handlers_for_content_reader_.push_back(
- std::make_pair(make_matcher(pattern), std::move(handler)));
- return *this;
-}
-
-inline Server &Server::Options(const std::string &pattern, Handler handler) {
- options_handlers_.push_back(
- std::make_pair(make_matcher(pattern), std::move(handler)));
- return *this;
-}
-
-inline bool Server::set_base_dir(const std::string &dir,
- const std::string &mount_point) {
- return set_mount_point(mount_point, dir);
-}
-
-inline bool Server::set_mount_point(const std::string &mount_point,
- const std::string &dir, Headers headers) {
- if (detail::is_dir(dir)) {
- std::string mnt = !mount_point.empty() ? mount_point : "/";
- if (!mnt.empty() && mnt[0] == '/') {
- base_dirs_.push_back({mnt, dir, std::move(headers)});
- return true;
- }
- }
- return false;
-}
-
-inline bool Server::remove_mount_point(const std::string &mount_point) {
- for (auto it = base_dirs_.begin(); it != base_dirs_.end(); ++it) {
- if (it->mount_point == mount_point) {
- base_dirs_.erase(it);
- return true;
- }
- }
- return false;
-}
-
-inline Server &
-Server::set_file_extension_and_mimetype_mapping(const std::string &ext,
- const std::string &mime) {
- file_extension_and_mimetype_map_[ext] = mime;
- return *this;
-}
-
-inline Server &Server::set_default_file_mimetype(const std::string &mime) {
- default_file_mimetype_ = mime;
- return *this;
-}
-
-inline Server &Server::set_file_request_handler(Handler handler) {
- file_request_handler_ = std::move(handler);
- return *this;
-}
-
-inline Server &Server::set_error_handler(HandlerWithResponse handler) {
- error_handler_ = std::move(handler);
- return *this;
-}
-
-inline Server &Server::set_error_handler(Handler handler) {
- error_handler_ = [handler](const Request &req, Response &res) {
- handler(req, res);
- return HandlerResponse::Handled;
- };
- return *this;
-}
-
-inline Server &Server::set_exception_handler(ExceptionHandler handler) {
- exception_handler_ = std::move(handler);
- return *this;
-}
-
-inline Server &Server::set_pre_routing_handler(HandlerWithResponse handler) {
- pre_routing_handler_ = std::move(handler);
- return *this;
-}
-
-inline Server &Server::set_post_routing_handler(Handler handler) {
- post_routing_handler_ = std::move(handler);
- return *this;
-}
-
-inline Server &Server::set_logger(Logger logger) {
- logger_ = std::move(logger);
- return *this;
-}
-
-inline Server &
-Server::set_expect_100_continue_handler(Expect100ContinueHandler handler) {
- expect_100_continue_handler_ = std::move(handler);
- return *this;
-}
-
-inline Server &Server::set_address_family(int family) {
- address_family_ = family;
- return *this;
-}
-
-inline Server &Server::set_tcp_nodelay(bool on) {
- tcp_nodelay_ = on;
- return *this;
-}
-
-inline Server &Server::set_socket_options(SocketOptions socket_options) {
- socket_options_ = std::move(socket_options);
- return *this;
-}
-
-inline Server &Server::set_default_headers(Headers headers) {
- default_headers_ = std::move(headers);
- return *this;
-}
-
-inline Server &Server::set_header_writer(
- std::function<ssize_t(Stream &, Headers &)> const &writer) {
- header_writer_ = writer;
- return *this;
-}
-
-inline Server &Server::set_keep_alive_max_count(size_t count) {
- keep_alive_max_count_ = count;
- return *this;
-}
-
-inline Server &Server::set_keep_alive_timeout(time_t sec) {
- keep_alive_timeout_sec_ = sec;
- return *this;
-}
-
-inline Server &Server::set_read_timeout(time_t sec, time_t usec) {
- read_timeout_sec_ = sec;
- read_timeout_usec_ = usec;
- return *this;
-}
-
-inline Server &Server::set_write_timeout(time_t sec, time_t usec) {
- write_timeout_sec_ = sec;
- write_timeout_usec_ = usec;
- return *this;
-}
-
-inline Server &Server::set_idle_interval(time_t sec, time_t usec) {
- idle_interval_sec_ = sec;
- idle_interval_usec_ = usec;
- return *this;
-}
-
-inline Server &Server::set_payload_max_length(size_t length) {
- payload_max_length_ = length;
- return *this;
-}
-
-inline bool Server::bind_to_port(const std::string &host, int port,
- int socket_flags) {
- if (bind_internal(host, port, socket_flags) < 0) return false;
- return true;
-}
-inline int Server::bind_to_any_port(const std::string &host, int socket_flags) {
- return bind_internal(host, 0, socket_flags);
-}
-
-inline bool Server::listen_after_bind() {
- auto se = detail::scope_exit([&]() { done_ = true; });
- return listen_internal();
-}
-
-inline bool Server::listen(const std::string &host, int port,
- int socket_flags) {
- auto se = detail::scope_exit([&]() { done_ = true; });
- return bind_to_port(host, port, socket_flags) && listen_internal();
-}
-
-inline bool Server::is_running() const { return is_running_; }
-
-inline void Server::wait_until_ready() const {
- while (!is_running() && !done_) {
- std::this_thread::sleep_for(std::chrono::milliseconds{1});
- }
-}
-
-inline void Server::stop() {
- if (is_running_) {
- assert(svr_sock_ != INVALID_SOCKET);
- std::atomic<socket_t> sock(svr_sock_.exchange(INVALID_SOCKET));
- detail::shutdown_socket(sock);
- detail::close_socket(sock);
- }
-}
-
-inline bool Server::parse_request_line(const char *s, Request &req) {
- auto len = strlen(s);
- if (len < 2 || s[len - 2] != '\r' || s[len - 1] != '\n') { return false; }
- len -= 2;
-
- {
- size_t count = 0;
-
- detail::split(s, s + len, ' ', [&](const char *b, const char *e) {
- switch (count) {
- case 0: req.method = std::string(b, e); break;
- case 1: req.target = std::string(b, e); break;
- case 2: req.version = std::string(b, e); break;
- default: break;
- }
- count++;
- });
-
- if (count != 3) { return false; }
- }
-
- static const std::set<std::string> methods{
- "GET", "HEAD", "POST", "PUT", "DELETE",
- "CONNECT", "OPTIONS", "TRACE", "PATCH", "PRI"};
-
- if (methods.find(req.method) == methods.end()) { return false; }
-
- if (req.version != "HTTP/1.1" && req.version != "HTTP/1.0") { return false; }
-
- {
- // Skip URL fragment
- for (size_t i = 0; i < req.target.size(); i++) {
- if (req.target[i] == '#') {
- req.target.erase(i);
- break;
- }
- }
-
- size_t count = 0;
-
- detail::split(req.target.data(), req.target.data() + req.target.size(), '?',
- [&](const char *b, const char *e) {
- switch (count) {
- case 0:
- req.path = detail::decode_url(std::string(b, e), false);
- break;
- case 1: {
- if (e - b > 0) {
- detail::parse_query_text(std::string(b, e), req.params);
- }
- break;
- }
- default: break;
- }
- count++;
- });
-
- if (count > 2) { return false; }
- }
-
- return true;
-}
-
-inline bool Server::write_response(Stream &strm, bool close_connection,
- const Request &req, Response &res) {
- return write_response_core(strm, close_connection, req, res, false);
-}
-
-inline bool Server::write_response_with_content(Stream &strm,
- bool close_connection,
- const Request &req,
- Response &res) {
- return write_response_core(strm, close_connection, req, res, true);
-}
-
-inline bool Server::write_response_core(Stream &strm, bool close_connection,
- const Request &req, Response &res,
- bool need_apply_ranges) {
- assert(res.status != -1);
-
- if (400 <= res.status && error_handler_ &&
- error_handler_(req, res) == HandlerResponse::Handled) {
- need_apply_ranges = true;
- }
-
- std::string content_type;
- std::string boundary;
- if (need_apply_ranges) { apply_ranges(req, res, content_type, boundary); }
-
- // Prepare additional headers
- if (close_connection || req.get_header_value("Connection") == "close") {
- res.set_header("Connection", "close");
- } else {
- std::stringstream ss;
- ss << "timeout=" << keep_alive_timeout_sec_
- << ", max=" << keep_alive_max_count_;
- res.set_header("Keep-Alive", ss.str());
- }
-
- if (!res.has_header("Content-Type") &&
- (!res.body.empty() || res.content_length_ > 0 || res.content_provider_)) {
- res.set_header("Content-Type", "text/plain");
- }
-
- if (!res.has_header("Content-Length") && res.body.empty() &&
- !res.content_length_ && !res.content_provider_) {
- res.set_header("Content-Length", "0");
- }
-
- if (!res.has_header("Accept-Ranges") && req.method == "HEAD") {
- res.set_header("Accept-Ranges", "bytes");
- }
-
- if (post_routing_handler_) { post_routing_handler_(req, res); }
-
- // Response line and headers
- {
- detail::BufferStream bstrm;
-
- if (!bstrm.write_format("HTTP/1.1 %d %s\r\n", res.status,
- status_message(res.status))) {
- return false;
- }
-
- if (!header_writer_(bstrm, res.headers)) { return false; }
-
- // Flush buffer
- auto &data = bstrm.get_buffer();
- detail::write_data(strm, data.data(), data.size());
- }
-
- // Body
- auto ret = true;
- if (req.method != "HEAD") {
- if (!res.body.empty()) {
- if (!detail::write_data(strm, res.body.data(), res.body.size())) {
- ret = false;
- }
- } else if (res.content_provider_) {
- if (write_content_with_provider(strm, req, res, boundary, content_type)) {
- res.content_provider_success_ = true;
- } else {
- res.content_provider_success_ = false;
- ret = false;
- }
- }
- }
-
- // Log
- if (logger_) { logger_(req, res); }
-
- return ret;
-}
-
-inline bool
-Server::write_content_with_provider(Stream &strm, const Request &req,
- Response &res, const std::string &boundary,
- const std::string &content_type) {
- auto is_shutting_down = [this]() {
- return this->svr_sock_ == INVALID_SOCKET;
- };
-
- if (res.content_length_ > 0) {
- if (req.ranges.empty()) {
- return detail::write_content(strm, res.content_provider_, 0,
- res.content_length_, is_shutting_down);
- } else if (req.ranges.size() == 1) {
- auto offsets =
- detail::get_range_offset_and_length(req, res.content_length_, 0);
- auto offset = offsets.first;
- auto length = offsets.second;
- return detail::write_content(strm, res.content_provider_, offset, length,
- is_shutting_down);
- } else {
- return detail::write_multipart_ranges_data(
- strm, req, res, boundary, content_type, is_shutting_down);
- }
- } else {
- if (res.is_chunked_content_provider_) {
- auto type = detail::encoding_type(req, res);
-
- std::unique_ptr<detail::compressor> compressor;
- if (type == detail::EncodingType::Gzip) {
-#ifdef CPPHTTPLIB_ZLIB_SUPPORT
- compressor = detail::make_unique<detail::gzip_compressor>();
-#endif
- } else if (type == detail::EncodingType::Brotli) {
-#ifdef CPPHTTPLIB_BROTLI_SUPPORT
- compressor = detail::make_unique<detail::brotli_compressor>();
-#endif
- } else {
- compressor = detail::make_unique<detail::nocompressor>();
- }
- assert(compressor != nullptr);
-
- return detail::write_content_chunked(strm, res.content_provider_,
- is_shutting_down, *compressor);
- } else {
- return detail::write_content_without_length(strm, res.content_provider_,
- is_shutting_down);
- }
- }
-}
-
-inline bool Server::read_content(Stream &strm, Request &req, Response &res) {
- MultipartFormDataMap::iterator cur;
- auto file_count = 0;
- if (read_content_core(
- strm, req, res,
- // Regular
- [&](const char *buf, size_t n) {
- if (req.body.size() + n > req.body.max_size()) { return false; }
- req.body.append(buf, n);
- return true;
- },
- // Multipart
- [&](const MultipartFormData &file) {
- if (file_count++ == CPPHTTPLIB_MULTIPART_FORM_DATA_FILE_MAX_COUNT) {
- return false;
- }
- cur = req.files.emplace(file.name, file);
- return true;
- },
- [&](const char *buf, size_t n) {
- auto &content = cur->second.content;
- if (content.size() + n > content.max_size()) { return false; }
- content.append(buf, n);
- return true;
- })) {
- const auto &content_type = req.get_header_value("Content-Type");
- if (!content_type.find("application/x-www-form-urlencoded")) {
- if (req.body.size() > CPPHTTPLIB_FORM_URL_ENCODED_PAYLOAD_MAX_LENGTH) {
- res.status = 413; // NOTE: should be 414?
- return false;
- }
- detail::parse_query_text(req.body, req.params);
- }
- return true;
- }
- return false;
-}
-
-inline bool Server::read_content_with_content_receiver(
- Stream &strm, Request &req, Response &res, ContentReceiver receiver,
- MultipartContentHeader multipart_header,
- ContentReceiver multipart_receiver) {
- return read_content_core(strm, req, res, std::move(receiver),
- std::move(multipart_header),
- std::move(multipart_receiver));
-}
-
-inline bool Server::read_content_core(Stream &strm, Request &req, Response &res,
- ContentReceiver receiver,
- MultipartContentHeader multipart_header,
- ContentReceiver multipart_receiver) {
- detail::MultipartFormDataParser multipart_form_data_parser;
- ContentReceiverWithProgress out;
-
- if (req.is_multipart_form_data()) {
- const auto &content_type = req.get_header_value("Content-Type");
- std::string boundary;
- if (!detail::parse_multipart_boundary(content_type, boundary)) {
- res.status = 400;
- return false;
- }
-
- multipart_form_data_parser.set_boundary(std::move(boundary));
- out = [&](const char *buf, size_t n, uint64_t /*off*/, uint64_t /*len*/) {
- /* For debug
- size_t pos = 0;
- while (pos < n) {
- auto read_size = (std::min)<size_t>(1, n - pos);
- auto ret = multipart_form_data_parser.parse(
- buf + pos, read_size, multipart_receiver, multipart_header);
- if (!ret) { return false; }
- pos += read_size;
- }
- return true;
- */
- return multipart_form_data_parser.parse(buf, n, multipart_receiver,
- multipart_header);
- };
- } else {
- out = [receiver](const char *buf, size_t n, uint64_t /*off*/,
- uint64_t /*len*/) { return receiver(buf, n); };
- }
-
- if (req.method == "DELETE" && !req.has_header("Content-Length")) {
- return true;
- }
-
- if (!detail::read_content(strm, req, payload_max_length_, res.status, nullptr,
- out, true)) {
- return false;
- }
-
- if (req.is_multipart_form_data()) {
- if (!multipart_form_data_parser.is_valid()) {
- res.status = 400;
- return false;
- }
- }
-
- return true;
-}
-
-inline bool Server::handle_file_request(const Request &req, Response &res,
- bool head) {
- for (const auto &entry : base_dirs_) {
- // Prefix match
- if (!req.path.compare(0, entry.mount_point.size(), entry.mount_point)) {
- std::string sub_path = "/" + req.path.substr(entry.mount_point.size());
- if (detail::is_valid_path(sub_path)) {
- auto path = entry.base_dir + sub_path;
- if (path.back() == '/') { path += "index.html"; }
-
- if (detail::is_file(path)) {
- for (const auto &kv : entry.headers) {
- res.set_header(kv.first.c_str(), kv.second);
- }
-
- auto mm = std::make_shared<detail::mmap>(path.c_str());
- if (!mm->is_open()) { return false; }
-
- res.set_content_provider(
- mm->size(),
- detail::find_content_type(path, file_extension_and_mimetype_map_,
- default_file_mimetype_),
- [mm](size_t offset, size_t length, DataSink &sink) -> bool {
- sink.write(mm->data() + offset, length);
- return true;
- });
-
- if (!head && file_request_handler_) {
- file_request_handler_(req, res);
- }
-
- return true;
- }
- }
- }
- }
- return false;
-}
-
-inline socket_t
-Server::create_server_socket(const std::string &host, int port,
- int socket_flags,
- SocketOptions socket_options) const {
- return detail::create_socket(
- host, std::string(), port, address_family_, socket_flags, tcp_nodelay_,
- std::move(socket_options),
- [](socket_t sock, struct addrinfo &ai) -> bool {
- if (::bind(sock, ai.ai_addr, static_cast<socklen_t>(ai.ai_addrlen))) {
- return false;
- }
- if (::listen(sock, CPPHTTPLIB_LISTEN_BACKLOG)) { return false; }
- return true;
- });
-}
-
-inline int Server::bind_internal(const std::string &host, int port,
- int socket_flags) {
- if (!is_valid()) { return -1; }
-
- svr_sock_ = create_server_socket(host, port, socket_flags, socket_options_);
- if (svr_sock_ == INVALID_SOCKET) { return -1; }
-
- if (port == 0) {
- struct sockaddr_storage addr;
- socklen_t addr_len = sizeof(addr);
- if (getsockname(svr_sock_, reinterpret_cast<struct sockaddr *>(&addr),
- &addr_len) == -1) {
- return -1;
- }
- if (addr.ss_family == AF_INET) {
- return ntohs(reinterpret_cast<struct sockaddr_in *>(&addr)->sin_port);
- } else if (addr.ss_family == AF_INET6) {
- return ntohs(reinterpret_cast<struct sockaddr_in6 *>(&addr)->sin6_port);
- } else {
- return -1;
- }
- } else {
- return port;
- }
-}
-
-inline bool Server::listen_internal() {
- auto ret = true;
- is_running_ = true;
- auto se = detail::scope_exit([&]() { is_running_ = false; });
-
- {
- std::unique_ptr<TaskQueue> task_queue(new_task_queue());
-
- while (svr_sock_ != INVALID_SOCKET) {
-#ifndef _WIN32
- if (idle_interval_sec_ > 0 || idle_interval_usec_ > 0) {
-#endif
- auto val = detail::select_read(svr_sock_, idle_interval_sec_,
- idle_interval_usec_);
- if (val == 0) { // Timeout
- task_queue->on_idle();
- continue;
- }
-#ifndef _WIN32
- }
-#endif
- socket_t sock = accept(svr_sock_, nullptr, nullptr);
-
- if (sock == INVALID_SOCKET) {
- if (errno == EMFILE) {
- // The per-process limit of open file descriptors has been reached.
- // Try to accept new connections after a short sleep.
- std::this_thread::sleep_for(std::chrono::milliseconds(1));
- continue;
- } else if (errno == EINTR || errno == EAGAIN) {
- continue;
- }
- if (svr_sock_ != INVALID_SOCKET) {
- detail::close_socket(svr_sock_);
- ret = false;
- } else {
- ; // The server socket was closed by user.
- }
- break;
- }
-
- {
-#ifdef _WIN32
- auto timeout = static_cast<uint32_t>(read_timeout_sec_ * 1000 +
- read_timeout_usec_ / 1000);
- setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO,
- reinterpret_cast<const char *>(&timeout), sizeof(timeout));
-#else
- timeval tv;
- tv.tv_sec = static_cast<long>(read_timeout_sec_);
- tv.tv_usec = static_cast<decltype(tv.tv_usec)>(read_timeout_usec_);
- setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO,
- reinterpret_cast<const void *>(&tv), sizeof(tv));
-#endif
- }
- {
-
-#ifdef _WIN32
- auto timeout = static_cast<uint32_t>(write_timeout_sec_ * 1000 +
- write_timeout_usec_ / 1000);
- setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO,
- reinterpret_cast<const char *>(&timeout), sizeof(timeout));
-#else
- timeval tv;
- tv.tv_sec = static_cast<long>(write_timeout_sec_);
- tv.tv_usec = static_cast<decltype(tv.tv_usec)>(write_timeout_usec_);
- setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO,
- reinterpret_cast<const void *>(&tv), sizeof(tv));
-#endif
- }
-
- task_queue->enqueue([this, sock]() { process_and_close_socket(sock); });
- }
-
- task_queue->shutdown();
- }
-
- return ret;
-}
-
-inline bool Server::routing(Request &req, Response &res, Stream &strm) {
- if (pre_routing_handler_ &&
- pre_routing_handler_(req, res) == HandlerResponse::Handled) {
- return true;
- }
-
- // File handler
- auto is_head_request = req.method == "HEAD";
- if ((req.method == "GET" || is_head_request) &&
- handle_file_request(req, res, is_head_request)) {
- return true;
- }
-
- if (detail::expect_content(req)) {
- // Content reader handler
- {
- ContentReader reader(
- [&](ContentReceiver receiver) {
- return read_content_with_content_receiver(
- strm, req, res, std::move(receiver), nullptr, nullptr);
- },
- [&](MultipartContentHeader header, ContentReceiver receiver) {
- return read_content_with_content_receiver(strm, req, res, nullptr,
- std::move(header),
- std::move(receiver));
- });
-
- if (req.method == "POST") {
- if (dispatch_request_for_content_reader(
- req, res, std::move(reader),
- post_handlers_for_content_reader_)) {
- return true;
- }
- } else if (req.method == "PUT") {
- if (dispatch_request_for_content_reader(
- req, res, std::move(reader),
- put_handlers_for_content_reader_)) {
- return true;
- }
- } else if (req.method == "PATCH") {
- if (dispatch_request_for_content_reader(
- req, res, std::move(reader),
- patch_handlers_for_content_reader_)) {
- return true;
- }
- } else if (req.method == "DELETE") {
- if (dispatch_request_for_content_reader(
- req, res, std::move(reader),
- delete_handlers_for_content_reader_)) {
- return true;
- }
- }
- }
-
- // Read content into `req.body`
- if (!read_content(strm, req, res)) { return false; }
- }
-
- // Regular handler
- if (req.method == "GET" || req.method == "HEAD") {
- return dispatch_request(req, res, get_handlers_);
- } else if (req.method == "POST") {
- return dispatch_request(req, res, post_handlers_);
- } else if (req.method == "PUT") {
- return dispatch_request(req, res, put_handlers_);
- } else if (req.method == "DELETE") {
- return dispatch_request(req, res, delete_handlers_);
- } else if (req.method == "OPTIONS") {
- return dispatch_request(req, res, options_handlers_);
- } else if (req.method == "PATCH") {
- return dispatch_request(req, res, patch_handlers_);
- }
-
- res.status = 400;
- return false;
-}
-
-inline bool Server::dispatch_request(Request &req, Response &res,
- const Handlers &handlers) {
- for (const auto &x : handlers) {
- const auto &matcher = x.first;
- const auto &handler = x.second;
-
- if (matcher->match(req)) {
- handler(req, res);
- return true;
- }
- }
- return false;
-}
-
-inline void Server::apply_ranges(const Request &req, Response &res,
- std::string &content_type,
- std::string &boundary) {
- if (req.ranges.size() > 1) {
- boundary = detail::make_multipart_data_boundary();
-
- auto it = res.headers.find("Content-Type");
- if (it != res.headers.end()) {
- content_type = it->second;
- res.headers.erase(it);
- }
-
- res.set_header("Content-Type",
- "multipart/byteranges; boundary=" + boundary);
- }
-
- auto type = detail::encoding_type(req, res);
-
- if (res.body.empty()) {
- if (res.content_length_ > 0) {
- size_t length = 0;
- if (req.ranges.empty()) {
- length = res.content_length_;
- } else if (req.ranges.size() == 1) {
- auto offsets =
- detail::get_range_offset_and_length(req, res.content_length_, 0);
- length = offsets.second;
-
- auto content_range = detail::make_content_range_header_field(
- req.ranges[0], res.content_length_);
- res.set_header("Content-Range", content_range);
- } else {
- length = detail::get_multipart_ranges_data_length(req, res, boundary,
- content_type);
- }
- res.set_header("Content-Length", std::to_string(length));
- } else {
- if (res.content_provider_) {
- if (res.is_chunked_content_provider_) {
- res.set_header("Transfer-Encoding", "chunked");
- if (type == detail::EncodingType::Gzip) {
- res.set_header("Content-Encoding", "gzip");
- } else if (type == detail::EncodingType::Brotli) {
- res.set_header("Content-Encoding", "br");
- }
- }
- }
- }
- } else {
- if (req.ranges.empty()) {
- ;
- } else if (req.ranges.size() == 1) {
- auto content_range = detail::make_content_range_header_field(
- req.ranges[0], res.body.size());
- res.set_header("Content-Range", content_range);
-
- auto offsets =
- detail::get_range_offset_and_length(req, res.body.size(), 0);
- auto offset = offsets.first;
- auto length = offsets.second;
-
- if (offset < res.body.size()) {
- res.body = res.body.substr(offset, length);
- } else {
- res.body.clear();
- res.status = 416;
- }
- } else {
- std::string data;
- if (detail::make_multipart_ranges_data(req, res, boundary, content_type,
- data)) {
- res.body.swap(data);
- } else {
- res.body.clear();
- res.status = 416;
- }
- }
-
- if (type != detail::EncodingType::None) {
- std::unique_ptr<detail::compressor> compressor;
- std::string content_encoding;
-
- if (type == detail::EncodingType::Gzip) {
-#ifdef CPPHTTPLIB_ZLIB_SUPPORT
- compressor = detail::make_unique<detail::gzip_compressor>();
- content_encoding = "gzip";
-#endif
- } else if (type == detail::EncodingType::Brotli) {
-#ifdef CPPHTTPLIB_BROTLI_SUPPORT
- compressor = detail::make_unique<detail::brotli_compressor>();
- content_encoding = "br";
-#endif
- }
-
- if (compressor) {
- std::string compressed;
- if (compressor->compress(res.body.data(), res.body.size(), true,
- [&](const char *data, size_t data_len) {
- compressed.append(data, data_len);
- return true;
- })) {
- res.body.swap(compressed);
- res.set_header("Content-Encoding", content_encoding);
- }
- }
- }
-
- auto length = std::to_string(res.body.size());
- res.set_header("Content-Length", length);
- }
-}
-
-inline bool Server::dispatch_request_for_content_reader(
- Request &req, Response &res, ContentReader content_reader,
- const HandlersForContentReader &handlers) {
- for (const auto &x : handlers) {
- const auto &matcher = x.first;
- const auto &handler = x.second;
-
- if (matcher->match(req)) {
- handler(req, res, content_reader);
- return true;
- }
- }
- return false;
-}
-
-inline bool
-Server::process_request(Stream &strm, bool close_connection,
- bool &connection_closed,
- const std::function<void(Request &)> &setup_request) {
- std::array<char, 2048> buf{};
-
- detail::stream_line_reader line_reader(strm, buf.data(), buf.size());
-
- // Connection has been closed on client
- if (!line_reader.getline()) { return false; }
-
- Request req;
-
- Response res;
- res.version = "HTTP/1.1";
- res.headers = default_headers_;
-
-#ifdef _WIN32
- // TODO: Increase FD_SETSIZE statically (libzmq), dynamically (MySQL).
-#else
-#ifndef CPPHTTPLIB_USE_POLL
- // Socket file descriptor exceeded FD_SETSIZE...
- if (strm.socket() >= FD_SETSIZE) {
- Headers dummy;
- detail::read_headers(strm, dummy);
- res.status = 500;
- return write_response(strm, close_connection, req, res);
- }
-#endif
-#endif
-
- // Check if the request URI doesn't exceed the limit
- if (line_reader.size() > CPPHTTPLIB_REQUEST_URI_MAX_LENGTH) {
- Headers dummy;
- detail::read_headers(strm, dummy);
- res.status = 414;
- return write_response(strm, close_connection, req, res);
- }
-
- // Request line and headers
- if (!parse_request_line(line_reader.ptr(), req) ||
- !detail::read_headers(strm, req.headers)) {
- res.status = 400;
- return write_response(strm, close_connection, req, res);
- }
-
- if (req.get_header_value("Connection") == "close") {
- connection_closed = true;
- }
-
- if (req.version == "HTTP/1.0" &&
- req.get_header_value("Connection") != "Keep-Alive") {
- connection_closed = true;
- }
-
- strm.get_remote_ip_and_port(req.remote_addr, req.remote_port);
- req.set_header("REMOTE_ADDR", req.remote_addr);
- req.set_header("REMOTE_PORT", std::to_string(req.remote_port));
-
- strm.get_local_ip_and_port(req.local_addr, req.local_port);
- req.set_header("LOCAL_ADDR", req.local_addr);
- req.set_header("LOCAL_PORT", std::to_string(req.local_port));
-
- if (req.has_header("Range")) {
- const auto &range_header_value = req.get_header_value("Range");
- if (!detail::parse_range_header(range_header_value, req.ranges)) {
- res.status = 416;
- return write_response(strm, close_connection, req, res);
- }
- }
-
- if (setup_request) { setup_request(req); }
-
- if (req.get_header_value("Expect") == "100-continue") {
- auto status = 100;
- if (expect_100_continue_handler_) {
- status = expect_100_continue_handler_(req, res);
- }
- switch (status) {
- case 100:
- case 417:
- strm.write_format("HTTP/1.1 %d %s\r\n\r\n", status,
- status_message(status));
- break;
- default: return write_response(strm, close_connection, req, res);
- }
- }
-
- // Rounting
- auto routed = false;
-#ifdef CPPHTTPLIB_NO_EXCEPTIONS
- routed = routing(req, res, strm);
-#else
- try {
- routed = routing(req, res, strm);
- } catch (std::exception &e) {
- if (exception_handler_) {
- auto ep = std::current_exception();
- exception_handler_(req, res, ep);
- routed = true;
- } else {
- res.status = 500;
- std::string val;
- auto s = e.what();
- for (size_t i = 0; s[i]; i++) {
- switch (s[i]) {
- case '\r': val += "\\r"; break;
- case '\n': val += "\\n"; break;
- default: val += s[i]; break;
- }
- }
- res.set_header("EXCEPTION_WHAT", val);
- }
- } catch (...) {
- if (exception_handler_) {
- auto ep = std::current_exception();
- exception_handler_(req, res, ep);
- routed = true;
- } else {
- res.status = 500;
- res.set_header("EXCEPTION_WHAT", "UNKNOWN");
- }
- }
-#endif
-
- if (routed) {
- if (res.status == -1) { res.status = req.ranges.empty() ? 200 : 206; }
- return write_response_with_content(strm, close_connection, req, res);
- } else {
- if (res.status == -1) { res.status = 404; }
- return write_response(strm, close_connection, req, res);
- }
-}
-
-inline bool Server::is_valid() const { return true; }
-
-inline bool Server::process_and_close_socket(socket_t sock) {
- auto ret = detail::process_server_socket(
- svr_sock_, sock, keep_alive_max_count_, keep_alive_timeout_sec_,
- read_timeout_sec_, read_timeout_usec_, write_timeout_sec_,
- write_timeout_usec_,
- [this](Stream &strm, bool close_connection, bool &connection_closed) {
- return process_request(strm, close_connection, connection_closed,
- nullptr);
- });
-
- detail::shutdown_socket(sock);
- detail::close_socket(sock);
- return ret;
-}
-
-// HTTP client implementation
-inline ClientImpl::ClientImpl(const std::string &host)
- : ClientImpl(host, 80, std::string(), std::string()) {}
-
-inline ClientImpl::ClientImpl(const std::string &host, int port)
- : ClientImpl(host, port, std::string(), std::string()) {}
-
-inline ClientImpl::ClientImpl(const std::string &host, int port,
- const std::string &client_cert_path,
- const std::string &client_key_path)
- : host_(host), port_(port),
- host_and_port_(adjust_host_string(host) + ":" + std::to_string(port)),
- client_cert_path_(client_cert_path), client_key_path_(client_key_path) {}
-
-inline ClientImpl::~ClientImpl() {
- std::lock_guard<std::mutex> guard(socket_mutex_);
- shutdown_socket(socket_);
- close_socket(socket_);
-}
-
-inline bool ClientImpl::is_valid() const { return true; }
-
-inline void ClientImpl::copy_settings(const ClientImpl &rhs) {
- client_cert_path_ = rhs.client_cert_path_;
- client_key_path_ = rhs.client_key_path_;
- connection_timeout_sec_ = rhs.connection_timeout_sec_;
- read_timeout_sec_ = rhs.read_timeout_sec_;
- read_timeout_usec_ = rhs.read_timeout_usec_;
- write_timeout_sec_ = rhs.write_timeout_sec_;
- write_timeout_usec_ = rhs.write_timeout_usec_;
- basic_auth_username_ = rhs.basic_auth_username_;
- basic_auth_password_ = rhs.basic_auth_password_;
- bearer_token_auth_token_ = rhs.bearer_token_auth_token_;
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
- digest_auth_username_ = rhs.digest_auth_username_;
- digest_auth_password_ = rhs.digest_auth_password_;
-#endif
- keep_alive_ = rhs.keep_alive_;
- follow_location_ = rhs.follow_location_;
- url_encode_ = rhs.url_encode_;
- address_family_ = rhs.address_family_;
- tcp_nodelay_ = rhs.tcp_nodelay_;
- socket_options_ = rhs.socket_options_;
- compress_ = rhs.compress_;
- decompress_ = rhs.decompress_;
- interface_ = rhs.interface_;
- proxy_host_ = rhs.proxy_host_;
- proxy_port_ = rhs.proxy_port_;
- proxy_basic_auth_username_ = rhs.proxy_basic_auth_username_;
- proxy_basic_auth_password_ = rhs.proxy_basic_auth_password_;
- proxy_bearer_token_auth_token_ = rhs.proxy_bearer_token_auth_token_;
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
- proxy_digest_auth_username_ = rhs.proxy_digest_auth_username_;
- proxy_digest_auth_password_ = rhs.proxy_digest_auth_password_;
-#endif
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
- ca_cert_file_path_ = rhs.ca_cert_file_path_;
- ca_cert_dir_path_ = rhs.ca_cert_dir_path_;
- ca_cert_store_ = rhs.ca_cert_store_;
-#endif
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
- server_certificate_verification_ = rhs.server_certificate_verification_;
-#endif
- logger_ = rhs.logger_;
-}
-
-inline socket_t ClientImpl::create_client_socket(Error &error) const {
- if (!proxy_host_.empty() && proxy_port_ != -1) {
- return detail::create_client_socket(
- proxy_host_, std::string(), proxy_port_, address_family_, tcp_nodelay_,
- socket_options_, connection_timeout_sec_, connection_timeout_usec_,
- read_timeout_sec_, read_timeout_usec_, write_timeout_sec_,
- write_timeout_usec_, interface_, error);
- }
-
- // Check is custom IP specified for host_
- std::string ip;
- auto it = addr_map_.find(host_);
- if (it != addr_map_.end()) ip = it->second;
-
- return detail::create_client_socket(
- host_, ip, port_, address_family_, tcp_nodelay_, socket_options_,
- connection_timeout_sec_, connection_timeout_usec_, read_timeout_sec_,
- read_timeout_usec_, write_timeout_sec_, write_timeout_usec_, interface_,
- error);
-}
-
-inline bool ClientImpl::create_and_connect_socket(Socket &socket,
- Error &error) {
- auto sock = create_client_socket(error);
- if (sock == INVALID_SOCKET) { return false; }
- socket.sock = sock;
- return true;
-}
-
-inline void ClientImpl::shutdown_ssl(Socket & /*socket*/,
- bool /*shutdown_gracefully*/) {
- // If there are any requests in flight from threads other than us, then it's
- // a thread-unsafe race because individual ssl* objects are not thread-safe.
- assert(socket_requests_in_flight_ == 0 ||
- socket_requests_are_from_thread_ == std::this_thread::get_id());
-}
-
-inline void ClientImpl::shutdown_socket(Socket &socket) {
- if (socket.sock == INVALID_SOCKET) { return; }
- detail::shutdown_socket(socket.sock);
-}
-
-inline void ClientImpl::close_socket(Socket &socket) {
- // If there are requests in flight in another thread, usually closing
- // the socket will be fine and they will simply receive an error when
- // using the closed socket, but it is still a bug since rarely the OS
- // may reassign the socket id to be used for a new socket, and then
- // suddenly they will be operating on a live socket that is different
- // than the one they intended!
- assert(socket_requests_in_flight_ == 0 ||
- socket_requests_are_from_thread_ == std::this_thread::get_id());
-
- // It is also a bug if this happens while SSL is still active
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
- assert(socket.ssl == nullptr);
-#endif
- if (socket.sock == INVALID_SOCKET) { return; }
- detail::close_socket(socket.sock);
- socket.sock = INVALID_SOCKET;
-}
-
-inline bool ClientImpl::read_response_line(Stream &strm, const Request &req,
- Response &res) {
- std::array<char, 2048> buf{};
-
- detail::stream_line_reader line_reader(strm, buf.data(), buf.size());
-
- if (!line_reader.getline()) { return false; }
-
-#ifdef CPPHTTPLIB_ALLOW_LF_AS_LINE_TERMINATOR
- const static std::regex re("(HTTP/1\\.[01]) (\\d{3})(?: (.*?))?\r?\n");
-#else
- const static std::regex re("(HTTP/1\\.[01]) (\\d{3})(?: (.*?))?\r\n");
-#endif
-
- std::cmatch m;
- if (!std::regex_match(line_reader.ptr(), m, re)) {
- return req.method == "CONNECT";
- }
- res.version = std::string(m[1]);
- res.status = std::stoi(std::string(m[2]));
- res.reason = std::string(m[3]);
-
- // Ignore '100 Continue'
- while (res.status == 100) {
- if (!line_reader.getline()) { return false; } // CRLF
- if (!line_reader.getline()) { return false; } // next response line
-
- if (!std::regex_match(line_reader.ptr(), m, re)) { return false; }
- res.version = std::string(m[1]);
- res.status = std::stoi(std::string(m[2]));
- res.reason = std::string(m[3]);
- }
-
- return true;
-}
-
-inline bool ClientImpl::send(Request &req, Response &res, Error &error) {
- std::lock_guard<std::recursive_mutex> request_mutex_guard(request_mutex_);
- auto ret = send_(req, res, error);
- if (error == Error::SSLPeerCouldBeClosed_) {
- assert(!ret);
- ret = send_(req, res, error);
- }
- return ret;
-}
-
-inline bool ClientImpl::send_(Request &req, Response &res, Error &error) {
- {
- std::lock_guard<std::mutex> guard(socket_mutex_);
-
- // Set this to false immediately - if it ever gets set to true by the end of
- // the request, we know another thread instructed us to close the socket.
- socket_should_be_closed_when_request_is_done_ = false;
-
- auto is_alive = false;
- if (socket_.is_open()) {
- is_alive = detail::is_socket_alive(socket_.sock);
- if (!is_alive) {
- // Attempt to avoid sigpipe by shutting down nongracefully if it seems
- // like the other side has already closed the connection Also, there
- // cannot be any requests in flight from other threads since we locked
- // request_mutex_, so safe to close everything immediately
- const bool shutdown_gracefully = false;
- shutdown_ssl(socket_, shutdown_gracefully);
- shutdown_socket(socket_);
- close_socket(socket_);
- }
- }
-
- if (!is_alive) {
- if (!create_and_connect_socket(socket_, error)) { return false; }
-
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
- // TODO: refactoring
- if (is_ssl()) {
- auto &scli = static_cast<SSLClient &>(*this);
- if (!proxy_host_.empty() && proxy_port_ != -1) {
- auto success = false;
- if (!scli.connect_with_proxy(socket_, res, success, error)) {
- return success;
- }
- }
-
- if (!scli.initialize_ssl(socket_, error)) { return false; }
- }
-#endif
- }
-
- // Mark the current socket as being in use so that it cannot be closed by
- // anyone else while this request is ongoing, even though we will be
- // releasing the mutex.
- if (socket_requests_in_flight_ > 1) {
- assert(socket_requests_are_from_thread_ == std::this_thread::get_id());
- }
- socket_requests_in_flight_ += 1;
- socket_requests_are_from_thread_ = std::this_thread::get_id();
- }
-
- for (const auto &header : default_headers_) {
- if (req.headers.find(header.first) == req.headers.end()) {
- req.headers.insert(header);
- }
- }
-
- auto ret = false;
- auto close_connection = !keep_alive_;
-
- auto se = detail::scope_exit([&]() {
- // Briefly lock mutex in order to mark that a request is no longer ongoing
- std::lock_guard<std::mutex> guard(socket_mutex_);
- socket_requests_in_flight_ -= 1;
- if (socket_requests_in_flight_ <= 0) {
- assert(socket_requests_in_flight_ == 0);
- socket_requests_are_from_thread_ = std::thread::id();
- }
-
- if (socket_should_be_closed_when_request_is_done_ || close_connection ||
- !ret) {
- shutdown_ssl(socket_, true);
- shutdown_socket(socket_);
- close_socket(socket_);
- }
- });
-
- ret = process_socket(socket_, [&](Stream &strm) {
- return handle_request(strm, req, res, close_connection, error);
- });
-
- if (!ret) {
- if (error == Error::Success) { error = Error::Unknown; }
- }
-
- return ret;
-}
-
-inline Result ClientImpl::send(const Request &req) {
- auto req2 = req;
- return send_(std::move(req2));
-}
-
-inline Result ClientImpl::send_(Request &&req) {
- auto res = detail::make_unique<Response>();
- auto error = Error::Success;
- auto ret = send(req, *res, error);
- return Result{ret ? std::move(res) : nullptr, error, std::move(req.headers)};
-}
-
-inline bool ClientImpl::handle_request(Stream &strm, Request &req,
- Response &res, bool close_connection,
- Error &error) {
- if (req.path.empty()) {
- error = Error::Connection;
- return false;
- }
-
- auto req_save = req;
-
- bool ret;
-
- if (!is_ssl() && !proxy_host_.empty() && proxy_port_ != -1) {
- auto req2 = req;
- req2.path = "http://" + host_and_port_ + req.path;
- ret = process_request(strm, req2, res, close_connection, error);
- req = req2;
- req.path = req_save.path;
- } else {
- ret = process_request(strm, req, res, close_connection, error);
- }
-
- if (!ret) { return false; }
-
- if (res.get_header_value("Connection") == "close" ||
- (res.version == "HTTP/1.0" && res.reason != "Connection established")) {
- // TODO this requires a not-entirely-obvious chain of calls to be correct
- // for this to be safe.
-
- // This is safe to call because handle_request is only called by send_
- // which locks the request mutex during the process. It would be a bug
- // to call it from a different thread since it's a thread-safety issue
- // to do these things to the socket if another thread is using the socket.
- std::lock_guard<std::mutex> guard(socket_mutex_);
- shutdown_ssl(socket_, true);
- shutdown_socket(socket_);
- close_socket(socket_);
- }
-
- if (300 < res.status && res.status < 400 && follow_location_) {
- req = req_save;
- ret = redirect(req, res, error);
- }
-
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
- if ((res.status == 401 || res.status == 407) &&
- req.authorization_count_ < 5) {
- auto is_proxy = res.status == 407;
- const auto &username =
- is_proxy ? proxy_digest_auth_username_ : digest_auth_username_;
- const auto &password =
- is_proxy ? proxy_digest_auth_password_ : digest_auth_password_;
-
- if (!username.empty() && !password.empty()) {
- std::map<std::string, std::string> auth;
- if (detail::parse_www_authenticate(res, auth, is_proxy)) {
- Request new_req = req;
- new_req.authorization_count_ += 1;
- new_req.headers.erase(is_proxy ? "Proxy-Authorization"
- : "Authorization");
- new_req.headers.insert(detail::make_digest_authentication_header(
- req, auth, new_req.authorization_count_, detail::random_string(10),
- username, password, is_proxy));
-
- Response new_res;
-
- ret = send(new_req, new_res, error);
- if (ret) { res = new_res; }
- }
- }
- }
-#endif
-
- return ret;
-}
-
-inline bool ClientImpl::redirect(Request &req, Response &res, Error &error) {
- if (req.redirect_count_ == 0) {
- error = Error::ExceedRedirectCount;
- return false;
- }
-
- auto location = res.get_header_value("location");
- if (location.empty()) { return false; }
-
- const static std::regex re(
- R"((?:(https?):)?(?://(?:\[([\d:]+)\]|([^:/?#]+))(?::(\d+))?)?([^?#]*)(\?[^#]*)?(?:#.*)?)");
-
- std::smatch m;
- if (!std::regex_match(location, m, re)) { return false; }
-
- auto scheme = is_ssl() ? "https" : "http";
-
- auto next_scheme = m[1].str();
- auto next_host = m[2].str();
- if (next_host.empty()) { next_host = m[3].str(); }
- auto port_str = m[4].str();
- auto next_path = m[5].str();
- auto next_query = m[6].str();
-
- auto next_port = port_;
- if (!port_str.empty()) {
- next_port = std::stoi(port_str);
- } else if (!next_scheme.empty()) {
- next_port = next_scheme == "https" ? 443 : 80;
- }
-
- if (next_scheme.empty()) { next_scheme = scheme; }
- if (next_host.empty()) { next_host = host_; }
- if (next_path.empty()) { next_path = "/"; }
-
- auto path = detail::decode_url(next_path, true) + next_query;
-
- if (next_scheme == scheme && next_host == host_ && next_port == port_) {
- return detail::redirect(*this, req, res, path, location, error);
- } else {
- if (next_scheme == "https") {
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
- SSLClient cli(next_host.c_str(), next_port);
- cli.copy_settings(*this);
- if (ca_cert_store_) { cli.set_ca_cert_store(ca_cert_store_); }
- return detail::redirect(cli, req, res, path, location, error);
-#else
- return false;
-#endif
- } else {
- ClientImpl cli(next_host.c_str(), next_port);
- cli.copy_settings(*this);
- return detail::redirect(cli, req, res, path, location, error);
- }
- }
-}
-
-inline bool ClientImpl::write_content_with_provider(Stream &strm,
- const Request &req,
- Error &error) {
- auto is_shutting_down = []() { return false; };
-
- if (req.is_chunked_content_provider_) {
- // TODO: Brotli support
- std::unique_ptr<detail::compressor> compressor;
-#ifdef CPPHTTPLIB_ZLIB_SUPPORT
- if (compress_) {
- compressor = detail::make_unique<detail::gzip_compressor>();
- } else
-#endif
- {
- compressor = detail::make_unique<detail::nocompressor>();
- }
-
- return detail::write_content_chunked(strm, req.content_provider_,
- is_shutting_down, *compressor, error);
- } else {
- return detail::write_content(strm, req.content_provider_, 0,
- req.content_length_, is_shutting_down, error);
- }
-}
-
-inline bool ClientImpl::write_request(Stream &strm, Request &req,
- bool close_connection, Error &error) {
- // Prepare additional headers
- if (close_connection) {
- if (!req.has_header("Connection")) {
- req.set_header("Connection", "close");
- }
- }
-
- if (!req.has_header("Host")) {
- if (is_ssl()) {
- if (port_ == 443) {
- req.set_header("Host", host_);
- } else {
- req.set_header("Host", host_and_port_);
- }
- } else {
- if (port_ == 80) {
- req.set_header("Host", host_);
- } else {
- req.set_header("Host", host_and_port_);
- }
- }
- }
-
- if (!req.has_header("Accept")) { req.set_header("Accept", "*/*"); }
-
-#ifndef CPPHTTPLIB_NO_DEFAULT_USER_AGENT
- if (!req.has_header("User-Agent")) {
- auto agent = std::string("cpp-httplib/") + CPPHTTPLIB_VERSION;
- req.set_header("User-Agent", agent);
- }
-#endif
-
- if (req.body.empty()) {
- if (req.content_provider_) {
- if (!req.is_chunked_content_provider_) {
- if (!req.has_header("Content-Length")) {
- auto length = std::to_string(req.content_length_);
- req.set_header("Content-Length", length);
- }
- }
- } else {
- if (req.method == "POST" || req.method == "PUT" ||
- req.method == "PATCH") {
- req.set_header("Content-Length", "0");
- }
- }
- } else {
- if (!req.has_header("Content-Type")) {
- req.set_header("Content-Type", "text/plain");
- }
-
- if (!req.has_header("Content-Length")) {
- auto length = std::to_string(req.body.size());
- req.set_header("Content-Length", length);
- }
- }
-
- if (!basic_auth_password_.empty() || !basic_auth_username_.empty()) {
- if (!req.has_header("Authorization")) {
- req.headers.insert(make_basic_authentication_header(
- basic_auth_username_, basic_auth_password_, false));
- }
- }
-
- if (!proxy_basic_auth_username_.empty() &&
- !proxy_basic_auth_password_.empty()) {
- if (!req.has_header("Proxy-Authorization")) {
- req.headers.insert(make_basic_authentication_header(
- proxy_basic_auth_username_, proxy_basic_auth_password_, true));
- }
- }
-
- if (!bearer_token_auth_token_.empty()) {
- if (!req.has_header("Authorization")) {
- req.headers.insert(make_bearer_token_authentication_header(
- bearer_token_auth_token_, false));
- }
- }
-
- if (!proxy_bearer_token_auth_token_.empty()) {
- if (!req.has_header("Proxy-Authorization")) {
- req.headers.insert(make_bearer_token_authentication_header(
- proxy_bearer_token_auth_token_, true));
- }
- }
-
- // Request line and headers
- {
- detail::BufferStream bstrm;
-
- const auto &path = url_encode_ ? detail::encode_url(req.path) : req.path;
- bstrm.write_format("%s %s HTTP/1.1\r\n", req.method.c_str(), path.c_str());
-
- header_writer_(bstrm, req.headers);
-
- // Flush buffer
- auto &data = bstrm.get_buffer();
- if (!detail::write_data(strm, data.data(), data.size())) {
- error = Error::Write;
- return false;
- }
- }
-
- // Body
- if (req.body.empty()) {
- return write_content_with_provider(strm, req, error);
- }
-
- if (!detail::write_data(strm, req.body.data(), req.body.size())) {
- error = Error::Write;
- return false;
- }
-
- return true;
-}
-
-inline std::unique_ptr<Response> ClientImpl::send_with_content_provider(
- Request &req, const char *body, size_t content_length,
- ContentProvider content_provider,
- ContentProviderWithoutLength content_provider_without_length,
- const std::string &content_type, Error &error) {
- if (!content_type.empty()) { req.set_header("Content-Type", content_type); }
-
-#ifdef CPPHTTPLIB_ZLIB_SUPPORT
- if (compress_) { req.set_header("Content-Encoding", "gzip"); }
-#endif
-
-#ifdef CPPHTTPLIB_ZLIB_SUPPORT
- if (compress_ && !content_provider_without_length) {
- // TODO: Brotli support
- detail::gzip_compressor compressor;
-
- if (content_provider) {
- auto ok = true;
- size_t offset = 0;
- DataSink data_sink;
-
- data_sink.write = [&](const char *data, size_t data_len) -> bool {
- if (ok) {
- auto last = offset + data_len == content_length;
-
- auto ret = compressor.compress(
- data, data_len, last,
- [&](const char *compressed_data, size_t compressed_data_len) {
- req.body.append(compressed_data, compressed_data_len);
- return true;
- });
-
- if (ret) {
- offset += data_len;
- } else {
- ok = false;
- }
- }
- return ok;
- };
-
- while (ok && offset < content_length) {
- if (!content_provider(offset, content_length - offset, data_sink)) {
- error = Error::Canceled;
- return nullptr;
- }
- }
- } else {
- if (!compressor.compress(body, content_length, true,
- [&](const char *data, size_t data_len) {
- req.body.append(data, data_len);
- return true;
- })) {
- error = Error::Compression;
- return nullptr;
- }
- }
- } else
-#endif
- {
- if (content_provider) {
- req.content_length_ = content_length;
- req.content_provider_ = std::move(content_provider);
- req.is_chunked_content_provider_ = false;
- } else if (content_provider_without_length) {
- req.content_length_ = 0;
- req.content_provider_ = detail::ContentProviderAdapter(
- std::move(content_provider_without_length));
- req.is_chunked_content_provider_ = true;
- req.set_header("Transfer-Encoding", "chunked");
- } else {
- req.body.assign(body, content_length);
- }
- }
-
- auto res = detail::make_unique<Response>();
- return send(req, *res, error) ? std::move(res) : nullptr;
-}
-
-inline Result ClientImpl::send_with_content_provider(
- const std::string &method, const std::string &path, const Headers &headers,
- const char *body, size_t content_length, ContentProvider content_provider,
- ContentProviderWithoutLength content_provider_without_length,
- const std::string &content_type) {
- Request req;
- req.method = method;
- req.headers = headers;
- req.path = path;
-
- auto error = Error::Success;
-
- auto res = send_with_content_provider(
- req, body, content_length, std::move(content_provider),
- std::move(content_provider_without_length), content_type, error);
-
- return Result{std::move(res), error, std::move(req.headers)};
-}
-
-inline std::string
-ClientImpl::adjust_host_string(const std::string &host) const {
- if (host.find(':') != std::string::npos) { return "[" + host + "]"; }
- return host;
-}
-
-inline bool ClientImpl::process_request(Stream &strm, Request &req,
- Response &res, bool close_connection,
- Error &error) {
- // Send request
- if (!write_request(strm, req, close_connection, error)) { return false; }
-
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
- if (is_ssl()) {
- auto is_proxy_enabled = !proxy_host_.empty() && proxy_port_ != -1;
- if (!is_proxy_enabled) {
- char buf[1];
- if (SSL_peek(socket_.ssl, buf, 1) == 0 &&
- SSL_get_error(socket_.ssl, 0) == SSL_ERROR_ZERO_RETURN) {
- error = Error::SSLPeerCouldBeClosed_;
- return false;
- }
- }
- }
-#endif
-
- // Receive response and headers
- if (!read_response_line(strm, req, res) ||
- !detail::read_headers(strm, res.headers)) {
- error = Error::Read;
- return false;
- }
-
- // Body
- if ((res.status != 204) && req.method != "HEAD" && req.method != "CONNECT") {
- auto redirect = 300 < res.status && res.status < 400 && follow_location_;
-
- if (req.response_handler && !redirect) {
- if (!req.response_handler(res)) {
- error = Error::Canceled;
- return false;
- }
- }
-
- auto out =
- req.content_receiver
- ? static_cast<ContentReceiverWithProgress>(
- [&](const char *buf, size_t n, uint64_t off, uint64_t len) {
- if (redirect) { return true; }
- auto ret = req.content_receiver(buf, n, off, len);
- if (!ret) { error = Error::Canceled; }
- return ret;
- })
- : static_cast<ContentReceiverWithProgress>(
- [&](const char *buf, size_t n, uint64_t /*off*/,
- uint64_t /*len*/) {
- if (res.body.size() + n > res.body.max_size()) {
- return false;
- }
- res.body.append(buf, n);
- return true;
- });
-
- auto progress = [&](uint64_t current, uint64_t total) {
- if (!req.progress || redirect) { return true; }
- auto ret = req.progress(current, total);
- if (!ret) { error = Error::Canceled; }
- return ret;
- };
-
- int dummy_status;
- if (!detail::read_content(strm, res, (std::numeric_limits<size_t>::max)(),
- dummy_status, std::move(progress), std::move(out),
- decompress_)) {
- if (error != Error::Canceled) { error = Error::Read; }
- return false;
- }
- }
-
- // Log
- if (logger_) { logger_(req, res); }
-
- return true;
-}
-
-inline ContentProviderWithoutLength ClientImpl::get_multipart_content_provider(
- const std::string &boundary, const MultipartFormDataItems &items,
- const MultipartFormDataProviderItems &provider_items) {
- size_t cur_item = 0, cur_start = 0;
- // cur_item and cur_start are copied to within the std::function and maintain
- // state between successive calls
- return [&, cur_item, cur_start](size_t offset,
- DataSink &sink) mutable -> bool {
- if (!offset && items.size()) {
- sink.os << detail::serialize_multipart_formdata(items, boundary, false);
- return true;
- } else if (cur_item < provider_items.size()) {
- if (!cur_start) {
- const auto &begin = detail::serialize_multipart_formdata_item_begin(
- provider_items[cur_item], boundary);
- offset += begin.size();
- cur_start = offset;
- sink.os << begin;
- }
-
- DataSink cur_sink;
- auto has_data = true;
- cur_sink.write = sink.write;
- cur_sink.done = [&]() { has_data = false; };
-
- if (!provider_items[cur_item].provider(offset - cur_start, cur_sink))
- return false;
-
- if (!has_data) {
- sink.os << detail::serialize_multipart_formdata_item_end();
- cur_item++;
- cur_start = 0;
- }
- return true;
- } else {
- sink.os << detail::serialize_multipart_formdata_finish(boundary);
- sink.done();
- return true;
- }
- };
-}
-
-inline bool
-ClientImpl::process_socket(const Socket &socket,
- std::function<bool(Stream &strm)> callback) {
- return detail::process_client_socket(
- socket.sock, read_timeout_sec_, read_timeout_usec_, write_timeout_sec_,
- write_timeout_usec_, std::move(callback));
-}
-
-inline bool ClientImpl::is_ssl() const { return false; }
-
-inline Result ClientImpl::Get(const std::string &path) {
- return Get(path, Headers(), Progress());
-}
-
-inline Result ClientImpl::Get(const std::string &path, Progress progress) {
- return Get(path, Headers(), std::move(progress));
-}
-
-inline Result ClientImpl::Get(const std::string &path, const Headers &headers) {
- return Get(path, headers, Progress());
-}
-
-inline Result ClientImpl::Get(const std::string &path, const Headers &headers,
- Progress progress) {
- Request req;
- req.method = "GET";
- req.path = path;
- req.headers = headers;
- req.progress = std::move(progress);
-
- return send_(std::move(req));
-}
-
-inline Result ClientImpl::Get(const std::string &path,
- ContentReceiver content_receiver) {
- return Get(path, Headers(), nullptr, std::move(content_receiver), nullptr);
-}
-
-inline Result ClientImpl::Get(const std::string &path,
- ContentReceiver content_receiver,
- Progress progress) {
- return Get(path, Headers(), nullptr, std::move(content_receiver),
- std::move(progress));
-}
-
-inline Result ClientImpl::Get(const std::string &path, const Headers &headers,
- ContentReceiver content_receiver) {
- return Get(path, headers, nullptr, std::move(content_receiver), nullptr);
-}
-
-inline Result ClientImpl::Get(const std::string &path, const Headers &headers,
- ContentReceiver content_receiver,
- Progress progress) {
- return Get(path, headers, nullptr, std::move(content_receiver),
- std::move(progress));
-}
-
-inline Result ClientImpl::Get(const std::string &path,
- ResponseHandler response_handler,
- ContentReceiver content_receiver) {
- return Get(path, Headers(), std::move(response_handler),
- std::move(content_receiver), nullptr);
-}
-
-inline Result ClientImpl::Get(const std::string &path, const Headers &headers,
- ResponseHandler response_handler,
- ContentReceiver content_receiver) {
- return Get(path, headers, std::move(response_handler),
- std::move(content_receiver), nullptr);
-}
-
-inline Result ClientImpl::Get(const std::string &path,
- ResponseHandler response_handler,
- ContentReceiver content_receiver,
- Progress progress) {
- return Get(path, Headers(), std::move(response_handler),
- std::move(content_receiver), std::move(progress));
-}
-
-inline Result ClientImpl::Get(const std::string &path, const Headers &headers,
- ResponseHandler response_handler,
- ContentReceiver content_receiver,
- Progress progress) {
- Request req;
- req.method = "GET";
- req.path = path;
- req.headers = headers;
- req.response_handler = std::move(response_handler);
- req.content_receiver =
- [content_receiver](const char *data, size_t data_length,
- uint64_t /*offset*/, uint64_t /*total_length*/) {
- return content_receiver(data, data_length);
- };
- req.progress = std::move(progress);
-
- return send_(std::move(req));
-}
-
-inline Result ClientImpl::Get(const std::string &path, const Params &params,
- const Headers &headers, Progress progress) {
- if (params.empty()) { return Get(path, headers); }
-
- std::string path_with_query = append_query_params(path, params);
- return Get(path_with_query.c_str(), headers, progress);
-}
-
-inline Result ClientImpl::Get(const std::string &path, const Params &params,
- const Headers &headers,
- ContentReceiver content_receiver,
- Progress progress) {
- return Get(path, params, headers, nullptr, content_receiver, progress);
-}
-
-inline Result ClientImpl::Get(const std::string &path, const Params &params,
- const Headers &headers,
- ResponseHandler response_handler,
- ContentReceiver content_receiver,
- Progress progress) {
- if (params.empty()) {
- return Get(path, headers, response_handler, content_receiver, progress);
- }
-
- std::string path_with_query = append_query_params(path, params);
- return Get(path_with_query.c_str(), headers, response_handler,
- content_receiver, progress);
-}
-
-inline Result ClientImpl::Head(const std::string &path) {
- return Head(path, Headers());
-}
-
-inline Result ClientImpl::Head(const std::string &path,
- const Headers &headers) {
- Request req;
- req.method = "HEAD";
- req.headers = headers;
- req.path = path;
-
- return send_(std::move(req));
-}
-
-inline Result ClientImpl::Post(const std::string &path) {
- return Post(path, std::string(), std::string());
-}
-
-inline Result ClientImpl::Post(const std::string &path,
- const Headers &headers) {
- return Post(path, headers, nullptr, 0, std::string());
-}
-
-inline Result ClientImpl::Post(const std::string &path, const char *body,
- size_t content_length,
- const std::string &content_type) {
- return Post(path, Headers(), body, content_length, content_type);
-}
-
-inline Result ClientImpl::Post(const std::string &path, const Headers &headers,
- const char *body, size_t content_length,
- const std::string &content_type) {
- return send_with_content_provider("POST", path, headers, body, content_length,
- nullptr, nullptr, content_type);
-}
-
-inline Result ClientImpl::Post(const std::string &path, const std::string &body,
- const std::string &content_type) {
- return Post(path, Headers(), body, content_type);
-}
-
-inline Result ClientImpl::Post(const std::string &path, const Headers &headers,
- const std::string &body,
- const std::string &content_type) {
- return send_with_content_provider("POST", path, headers, body.data(),
- body.size(), nullptr, nullptr,
- content_type);
-}
-
-inline Result ClientImpl::Post(const std::string &path, const Params &params) {
- return Post(path, Headers(), params);
-}
-
-inline Result ClientImpl::Post(const std::string &path, size_t content_length,
- ContentProvider content_provider,
- const std::string &content_type) {
- return Post(path, Headers(), content_length, std::move(content_provider),
- content_type);
-}
-
-inline Result ClientImpl::Post(const std::string &path,
- ContentProviderWithoutLength content_provider,
- const std::string &content_type) {
- return Post(path, Headers(), std::move(content_provider), content_type);
-}
-
-inline Result ClientImpl::Post(const std::string &path, const Headers &headers,
- size_t content_length,
- ContentProvider content_provider,
- const std::string &content_type) {
- return send_with_content_provider("POST", path, headers, nullptr,
- content_length, std::move(content_provider),
- nullptr, content_type);
-}
-
-inline Result ClientImpl::Post(const std::string &path, const Headers &headers,
- ContentProviderWithoutLength content_provider,
- const std::string &content_type) {
- return send_with_content_provider("POST", path, headers, nullptr, 0, nullptr,
- std::move(content_provider), content_type);
-}
-
-inline Result ClientImpl::Post(const std::string &path, const Headers &headers,
- const Params &params) {
- auto query = detail::params_to_query_str(params);
- return Post(path, headers, query, "application/x-www-form-urlencoded");
-}
-
-inline Result ClientImpl::Post(const std::string &path,
- const MultipartFormDataItems &items) {
- return Post(path, Headers(), items);
-}
-
-inline Result ClientImpl::Post(const std::string &path, const Headers &headers,
- const MultipartFormDataItems &items) {
- const auto &boundary = detail::make_multipart_data_boundary();
- const auto &content_type =
- detail::serialize_multipart_formdata_get_content_type(boundary);
- const auto &body = detail::serialize_multipart_formdata(items, boundary);
- return Post(path, headers, body, content_type.c_str());
-}
-
-inline Result ClientImpl::Post(const std::string &path, const Headers &headers,
- const MultipartFormDataItems &items,
- const std::string &boundary) {
- if (!detail::is_multipart_boundary_chars_valid(boundary)) {
- return Result{nullptr, Error::UnsupportedMultipartBoundaryChars};
- }
-
- const auto &content_type =
- detail::serialize_multipart_formdata_get_content_type(boundary);
- const auto &body = detail::serialize_multipart_formdata(items, boundary);
- return Post(path, headers, body, content_type.c_str());
-}
-
-inline Result
-ClientImpl::Post(const std::string &path, const Headers &headers,
- const MultipartFormDataItems &items,
- const MultipartFormDataProviderItems &provider_items) {
- const auto &boundary = detail::make_multipart_data_boundary();
- const auto &content_type =
- detail::serialize_multipart_formdata_get_content_type(boundary);
- return send_with_content_provider(
- "POST", path, headers, nullptr, 0, nullptr,
- get_multipart_content_provider(boundary, items, provider_items),
- content_type);
-}
-
-inline Result ClientImpl::Put(const std::string &path) {
- return Put(path, std::string(), std::string());
-}
-
-inline Result ClientImpl::Put(const std::string &path, const char *body,
- size_t content_length,
- const std::string &content_type) {
- return Put(path, Headers(), body, content_length, content_type);
-}
-
-inline Result ClientImpl::Put(const std::string &path, const Headers &headers,
- const char *body, size_t content_length,
- const std::string &content_type) {
- return send_with_content_provider("PUT", path, headers, body, content_length,
- nullptr, nullptr, content_type);
-}
-
-inline Result ClientImpl::Put(const std::string &path, const std::string &body,
- const std::string &content_type) {
- return Put(path, Headers(), body, content_type);
-}
-
-inline Result ClientImpl::Put(const std::string &path, const Headers &headers,
- const std::string &body,
- const std::string &content_type) {
- return send_with_content_provider("PUT", path, headers, body.data(),
- body.size(), nullptr, nullptr,
- content_type);
-}
-
-inline Result ClientImpl::Put(const std::string &path, size_t content_length,
- ContentProvider content_provider,
- const std::string &content_type) {
- return Put(path, Headers(), content_length, std::move(content_provider),
- content_type);
-}
-
-inline Result ClientImpl::Put(const std::string &path,
- ContentProviderWithoutLength content_provider,
- const std::string &content_type) {
- return Put(path, Headers(), std::move(content_provider), content_type);
-}
-
-inline Result ClientImpl::Put(const std::string &path, const Headers &headers,
- size_t content_length,
- ContentProvider content_provider,
- const std::string &content_type) {
- return send_with_content_provider("PUT", path, headers, nullptr,
- content_length, std::move(content_provider),
- nullptr, content_type);
-}
-
-inline Result ClientImpl::Put(const std::string &path, const Headers &headers,
- ContentProviderWithoutLength content_provider,
- const std::string &content_type) {
- return send_with_content_provider("PUT", path, headers, nullptr, 0, nullptr,
- std::move(content_provider), content_type);
-}
-
-inline Result ClientImpl::Put(const std::string &path, const Params &params) {
- return Put(path, Headers(), params);
-}
-
-inline Result ClientImpl::Put(const std::string &path, const Headers &headers,
- const Params &params) {
- auto query = detail::params_to_query_str(params);
- return Put(path, headers, query, "application/x-www-form-urlencoded");
-}
-
-inline Result ClientImpl::Put(const std::string &path,
- const MultipartFormDataItems &items) {
- return Put(path, Headers(), items);
-}
-
-inline Result ClientImpl::Put(const std::string &path, const Headers &headers,
- const MultipartFormDataItems &items) {
- const auto &boundary = detail::make_multipart_data_boundary();
- const auto &content_type =
- detail::serialize_multipart_formdata_get_content_type(boundary);
- const auto &body = detail::serialize_multipart_formdata(items, boundary);
- return Put(path, headers, body, content_type);
-}
-
-inline Result ClientImpl::Put(const std::string &path, const Headers &headers,
- const MultipartFormDataItems &items,
- const std::string &boundary) {
- if (!detail::is_multipart_boundary_chars_valid(boundary)) {
- return Result{nullptr, Error::UnsupportedMultipartBoundaryChars};
- }
-
- const auto &content_type =
- detail::serialize_multipart_formdata_get_content_type(boundary);
- const auto &body = detail::serialize_multipart_formdata(items, boundary);
- return Put(path, headers, body, content_type);
-}
-
-inline Result
-ClientImpl::Put(const std::string &path, const Headers &headers,
- const MultipartFormDataItems &items,
- const MultipartFormDataProviderItems &provider_items) {
- const auto &boundary = detail::make_multipart_data_boundary();
- const auto &content_type =
- detail::serialize_multipart_formdata_get_content_type(boundary);
- return send_with_content_provider(
- "PUT", path, headers, nullptr, 0, nullptr,
- get_multipart_content_provider(boundary, items, provider_items),
- content_type);
-}
-inline Result ClientImpl::Patch(const std::string &path) {
- return Patch(path, std::string(), std::string());
-}
-
-inline Result ClientImpl::Patch(const std::string &path, const char *body,
- size_t content_length,
- const std::string &content_type) {
- return Patch(path, Headers(), body, content_length, content_type);
-}
-
-inline Result ClientImpl::Patch(const std::string &path, const Headers &headers,
- const char *body, size_t content_length,
- const std::string &content_type) {
- return send_with_content_provider("PATCH", path, headers, body,
- content_length, nullptr, nullptr,
- content_type);
-}
-
-inline Result ClientImpl::Patch(const std::string &path,
- const std::string &body,
- const std::string &content_type) {
- return Patch(path, Headers(), body, content_type);
-}
-
-inline Result ClientImpl::Patch(const std::string &path, const Headers &headers,
- const std::string &body,
- const std::string &content_type) {
- return send_with_content_provider("PATCH", path, headers, body.data(),
- body.size(), nullptr, nullptr,
- content_type);
-}
-
-inline Result ClientImpl::Patch(const std::string &path, size_t content_length,
- ContentProvider content_provider,
- const std::string &content_type) {
- return Patch(path, Headers(), content_length, std::move(content_provider),
- content_type);
-}
-
-inline Result ClientImpl::Patch(const std::string &path,
- ContentProviderWithoutLength content_provider,
- const std::string &content_type) {
- return Patch(path, Headers(), std::move(content_provider), content_type);
-}
-
-inline Result ClientImpl::Patch(const std::string &path, const Headers &headers,
- size_t content_length,
- ContentProvider content_provider,
- const std::string &content_type) {
- return send_with_content_provider("PATCH", path, headers, nullptr,
- content_length, std::move(content_provider),
- nullptr, content_type);
-}
-
-inline Result ClientImpl::Patch(const std::string &path, const Headers &headers,
- ContentProviderWithoutLength content_provider,
- const std::string &content_type) {
- return send_with_content_provider("PATCH", path, headers, nullptr, 0, nullptr,
- std::move(content_provider), content_type);
-}
-
-inline Result ClientImpl::Delete(const std::string &path) {
- return Delete(path, Headers(), std::string(), std::string());
-}
-
-inline Result ClientImpl::Delete(const std::string &path,
- const Headers &headers) {
- return Delete(path, headers, std::string(), std::string());
-}
-
-inline Result ClientImpl::Delete(const std::string &path, const char *body,
- size_t content_length,
- const std::string &content_type) {
- return Delete(path, Headers(), body, content_length, content_type);
-}
-
-inline Result ClientImpl::Delete(const std::string &path,
- const Headers &headers, const char *body,
- size_t content_length,
- const std::string &content_type) {
- Request req;
- req.method = "DELETE";
- req.headers = headers;
- req.path = path;
-
- if (!content_type.empty()) { req.set_header("Content-Type", content_type); }
- req.body.assign(body, content_length);
-
- return send_(std::move(req));
-}
-
-inline Result ClientImpl::Delete(const std::string &path,
- const std::string &body,
- const std::string &content_type) {
- return Delete(path, Headers(), body.data(), body.size(), content_type);
-}
-
-inline Result ClientImpl::Delete(const std::string &path,
- const Headers &headers,
- const std::string &body,
- const std::string &content_type) {
- return Delete(path, headers, body.data(), body.size(), content_type);
-}
-
-inline Result ClientImpl::Options(const std::string &path) {
- return Options(path, Headers());
-}
-
-inline Result ClientImpl::Options(const std::string &path,
- const Headers &headers) {
- Request req;
- req.method = "OPTIONS";
- req.headers = headers;
- req.path = path;
-
- return send_(std::move(req));
-}
-
-inline void ClientImpl::stop() {
- std::lock_guard<std::mutex> guard(socket_mutex_);
-
- // If there is anything ongoing right now, the ONLY thread-safe thing we can
- // do is to shutdown_socket, so that threads using this socket suddenly
- // discover they can't read/write any more and error out. Everything else
- // (closing the socket, shutting ssl down) is unsafe because these actions are
- // not thread-safe.
- if (socket_requests_in_flight_ > 0) {
- shutdown_socket(socket_);
-
- // Aside from that, we set a flag for the socket to be closed when we're
- // done.
- socket_should_be_closed_when_request_is_done_ = true;
- return;
- }
-
- // Otherwise, still holding the mutex, we can shut everything down ourselves
- shutdown_ssl(socket_, true);
- shutdown_socket(socket_);
- close_socket(socket_);
-}
-
-inline std::string ClientImpl::host() const { return host_; }
-
-inline int ClientImpl::port() const { return port_; }
-
-inline size_t ClientImpl::is_socket_open() const {
- std::lock_guard<std::mutex> guard(socket_mutex_);
- return socket_.is_open();
-}
-
-inline socket_t ClientImpl::socket() const { return socket_.sock; }
-
-inline void ClientImpl::set_connection_timeout(time_t sec, time_t usec) {
- connection_timeout_sec_ = sec;
- connection_timeout_usec_ = usec;
-}
-
-inline void ClientImpl::set_read_timeout(time_t sec, time_t usec) {
- read_timeout_sec_ = sec;
- read_timeout_usec_ = usec;
-}
-
-inline void ClientImpl::set_write_timeout(time_t sec, time_t usec) {
- write_timeout_sec_ = sec;
- write_timeout_usec_ = usec;
-}
-
-inline void ClientImpl::set_basic_auth(const std::string &username,
- const std::string &password) {
- basic_auth_username_ = username;
- basic_auth_password_ = password;
-}
-
-inline void ClientImpl::set_bearer_token_auth(const std::string &token) {
- bearer_token_auth_token_ = token;
-}
-
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-inline void ClientImpl::set_digest_auth(const std::string &username,
- const std::string &password) {
- digest_auth_username_ = username;
- digest_auth_password_ = password;
-}
-#endif
-
-inline void ClientImpl::set_keep_alive(bool on) { keep_alive_ = on; }
-
-inline void ClientImpl::set_follow_location(bool on) { follow_location_ = on; }
-
-inline void ClientImpl::set_url_encode(bool on) { url_encode_ = on; }
-
-inline void
-ClientImpl::set_hostname_addr_map(std::map<std::string, std::string> addr_map) {
- addr_map_ = std::move(addr_map);
-}
-
-inline void ClientImpl::set_default_headers(Headers headers) {
- default_headers_ = std::move(headers);
-}
-
-inline void ClientImpl::set_header_writer(
- std::function<ssize_t(Stream &, Headers &)> const &writer) {
- header_writer_ = writer;
-}
-
-inline void ClientImpl::set_address_family(int family) {
- address_family_ = family;
-}
-
-inline void ClientImpl::set_tcp_nodelay(bool on) { tcp_nodelay_ = on; }
-
-inline void ClientImpl::set_socket_options(SocketOptions socket_options) {
- socket_options_ = std::move(socket_options);
-}
-
-inline void ClientImpl::set_compress(bool on) { compress_ = on; }
-
-inline void ClientImpl::set_decompress(bool on) { decompress_ = on; }
-
-inline void ClientImpl::set_interface(const std::string &intf) {
- interface_ = intf;
-}
-
-inline void ClientImpl::set_proxy(const std::string &host, int port) {
- proxy_host_ = host;
- proxy_port_ = port;
-}
-
-inline void ClientImpl::set_proxy_basic_auth(const std::string &username,
- const std::string &password) {
- proxy_basic_auth_username_ = username;
- proxy_basic_auth_password_ = password;
-}
-
-inline void ClientImpl::set_proxy_bearer_token_auth(const std::string &token) {
- proxy_bearer_token_auth_token_ = token;
-}
-
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-inline void ClientImpl::set_proxy_digest_auth(const std::string &username,
- const std::string &password) {
- proxy_digest_auth_username_ = username;
- proxy_digest_auth_password_ = password;
-}
-
-inline void ClientImpl::set_ca_cert_path(const std::string &ca_cert_file_path,
- const std::string &ca_cert_dir_path) {
- ca_cert_file_path_ = ca_cert_file_path;
- ca_cert_dir_path_ = ca_cert_dir_path;
-}
-
-inline void ClientImpl::set_ca_cert_store(X509_STORE *ca_cert_store) {
- if (ca_cert_store && ca_cert_store != ca_cert_store_) {
- ca_cert_store_ = ca_cert_store;
- }
-}
-
-inline X509_STORE *ClientImpl::create_ca_cert_store(const char *ca_cert,
- std::size_t size) {
- auto mem = BIO_new_mem_buf(ca_cert, static_cast<int>(size));
- if (!mem) return nullptr;
-
- auto inf = PEM_X509_INFO_read_bio(mem, nullptr, nullptr, nullptr);
- if (!inf) {
- BIO_free_all(mem);
- return nullptr;
- }
-
- auto cts = X509_STORE_new();
- if (cts) {
- for (auto i = 0; i < static_cast<int>(sk_X509_INFO_num(inf)); i++) {
- auto itmp = sk_X509_INFO_value(inf, i);
- if (!itmp) { continue; }
-
- if (itmp->x509) { X509_STORE_add_cert(cts, itmp->x509); }
- if (itmp->crl) { X509_STORE_add_crl(cts, itmp->crl); }
- }
- }
-
- sk_X509_INFO_pop_free(inf, X509_INFO_free);
- BIO_free_all(mem);
- return cts;
-}
-
-inline void ClientImpl::enable_server_certificate_verification(bool enabled) {
- server_certificate_verification_ = enabled;
-}
-#endif
-
-inline void ClientImpl::set_logger(Logger logger) {
- logger_ = std::move(logger);
-}
-
-/*
- * SSL Implementation
- */
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-namespace detail {
-
-template <typename U, typename V>
-inline SSL *ssl_new(socket_t sock, SSL_CTX *ctx, std::mutex &ctx_mutex,
- U SSL_connect_or_accept, V setup) {
- SSL *ssl = nullptr;
- {
- std::lock_guard<std::mutex> guard(ctx_mutex);
- ssl = SSL_new(ctx);
- }
-
- if (ssl) {
- set_nonblocking(sock, true);
- auto bio = BIO_new_socket(static_cast<int>(sock), BIO_NOCLOSE);
- BIO_set_nbio(bio, 1);
- SSL_set_bio(ssl, bio, bio);
-
- if (!setup(ssl) || SSL_connect_or_accept(ssl) != 1) {
- SSL_shutdown(ssl);
- {
- std::lock_guard<std::mutex> guard(ctx_mutex);
- SSL_free(ssl);
- }
- set_nonblocking(sock, false);
- return nullptr;
- }
- BIO_set_nbio(bio, 0);
- set_nonblocking(sock, false);
- }
-
- return ssl;
-}
-
-inline void ssl_delete(std::mutex &ctx_mutex, SSL *ssl,
- bool shutdown_gracefully) {
- // sometimes we may want to skip this to try to avoid SIGPIPE if we know
- // the remote has closed the network connection
- // Note that it is not always possible to avoid SIGPIPE, this is merely a
- // best-efforts.
- if (shutdown_gracefully) { SSL_shutdown(ssl); }
-
- std::lock_guard<std::mutex> guard(ctx_mutex);
- SSL_free(ssl);
-}
-
-template <typename U>
-bool ssl_connect_or_accept_nonblocking(socket_t sock, SSL *ssl,
- U ssl_connect_or_accept,
- time_t timeout_sec,
- time_t timeout_usec) {
- auto res = 0;
- while ((res = ssl_connect_or_accept(ssl)) != 1) {
- auto err = SSL_get_error(ssl, res);
- switch (err) {
- case SSL_ERROR_WANT_READ:
- if (select_read(sock, timeout_sec, timeout_usec) > 0) { continue; }
- break;
- case SSL_ERROR_WANT_WRITE:
- if (select_write(sock, timeout_sec, timeout_usec) > 0) { continue; }
- break;
- default: break;
- }
- return false;
- }
- return true;
-}
-
-template <typename T>
-inline bool process_server_socket_ssl(
- const std::atomic<socket_t> &svr_sock, SSL *ssl, socket_t sock,
- size_t keep_alive_max_count, time_t keep_alive_timeout_sec,
- time_t read_timeout_sec, time_t read_timeout_usec, time_t write_timeout_sec,
- time_t write_timeout_usec, T callback) {
- return process_server_socket_core(
- svr_sock, sock, keep_alive_max_count, keep_alive_timeout_sec,
- [&](bool close_connection, bool &connection_closed) {
- SSLSocketStream strm(sock, ssl, read_timeout_sec, read_timeout_usec,
- write_timeout_sec, write_timeout_usec);
- return callback(strm, close_connection, connection_closed);
- });
-}
-
-template <typename T>
-inline bool
-process_client_socket_ssl(SSL *ssl, socket_t sock, time_t read_timeout_sec,
- time_t read_timeout_usec, time_t write_timeout_sec,
- time_t write_timeout_usec, T callback) {
- SSLSocketStream strm(sock, ssl, read_timeout_sec, read_timeout_usec,
- write_timeout_sec, write_timeout_usec);
- return callback(strm);
-}
-
-class SSLInit {
-public:
- SSLInit() {
- OPENSSL_init_ssl(
- OPENSSL_INIT_LOAD_SSL_STRINGS | OPENSSL_INIT_LOAD_CRYPTO_STRINGS, NULL);
- }
-};
-
-// SSL socket stream implementation
-inline SSLSocketStream::SSLSocketStream(socket_t sock, SSL *ssl,
- time_t read_timeout_sec,
- time_t read_timeout_usec,
- time_t write_timeout_sec,
- time_t write_timeout_usec)
- : sock_(sock), ssl_(ssl), read_timeout_sec_(read_timeout_sec),
- read_timeout_usec_(read_timeout_usec),
- write_timeout_sec_(write_timeout_sec),
- write_timeout_usec_(write_timeout_usec) {
- SSL_clear_mode(ssl, SSL_MODE_AUTO_RETRY);
-}
-
-inline SSLSocketStream::~SSLSocketStream() {}
-
-inline bool SSLSocketStream::is_readable() const {
- return detail::select_read(sock_, read_timeout_sec_, read_timeout_usec_) > 0;
-}
-
-inline bool SSLSocketStream::is_writable() const {
- return select_write(sock_, write_timeout_sec_, write_timeout_usec_) > 0 &&
- is_socket_alive(sock_);
-}
-
-inline ssize_t SSLSocketStream::read(char *ptr, size_t size) {
- if (SSL_pending(ssl_) > 0) {
- return SSL_read(ssl_, ptr, static_cast<int>(size));
- } else if (is_readable()) {
- auto ret = SSL_read(ssl_, ptr, static_cast<int>(size));
- if (ret < 0) {
- auto err = SSL_get_error(ssl_, ret);
- auto n = 1000;
-#ifdef _WIN32
- while (--n >= 0 && (err == SSL_ERROR_WANT_READ ||
- (err == SSL_ERROR_SYSCALL &&
- WSAGetLastError() == WSAETIMEDOUT))) {
-#else
- while (--n >= 0 && err == SSL_ERROR_WANT_READ) {
-#endif
- if (SSL_pending(ssl_) > 0) {
- return SSL_read(ssl_, ptr, static_cast<int>(size));
- } else if (is_readable()) {
- std::this_thread::sleep_for(std::chrono::milliseconds(1));
- ret = SSL_read(ssl_, ptr, static_cast<int>(size));
- if (ret >= 0) { return ret; }
- err = SSL_get_error(ssl_, ret);
- } else {
- return -1;
- }
- }
- }
- return ret;
- }
- return -1;
-}
-
-inline ssize_t SSLSocketStream::write(const char *ptr, size_t size) {
- if (is_writable()) {
- auto handle_size = static_cast<int>(
- std::min<size_t>(size, (std::numeric_limits<int>::max)()));
-
- auto ret = SSL_write(ssl_, ptr, static_cast<int>(handle_size));
- if (ret < 0) {
- auto err = SSL_get_error(ssl_, ret);
- auto n = 1000;
-#ifdef _WIN32
- while (--n >= 0 && (err == SSL_ERROR_WANT_WRITE ||
- (err == SSL_ERROR_SYSCALL &&
- WSAGetLastError() == WSAETIMEDOUT))) {
-#else
- while (--n >= 0 && err == SSL_ERROR_WANT_WRITE) {
-#endif
- if (is_writable()) {
- std::this_thread::sleep_for(std::chrono::milliseconds(1));
- ret = SSL_write(ssl_, ptr, static_cast<int>(handle_size));
- if (ret >= 0) { return ret; }
- err = SSL_get_error(ssl_, ret);
- } else {
- return -1;
- }
- }
- }
- return ret;
- }
- return -1;
-}
-
-inline void SSLSocketStream::get_remote_ip_and_port(std::string &ip,
- int &port) const {
- detail::get_remote_ip_and_port(sock_, ip, port);
-}
-
-inline void SSLSocketStream::get_local_ip_and_port(std::string &ip,
- int &port) const {
- detail::get_local_ip_and_port(sock_, ip, port);
-}
-
-inline socket_t SSLSocketStream::socket() const { return sock_; }
-
-static SSLInit sslinit_;
-
-} // namespace detail
-
-// SSL HTTP server implementation
-inline SSLServer::SSLServer(const char *cert_path, const char *private_key_path,
- const char *client_ca_cert_file_path,
- const char *client_ca_cert_dir_path,
- const char *private_key_password) {
- ctx_ = SSL_CTX_new(TLS_server_method());
-
- if (ctx_) {
- SSL_CTX_set_options(ctx_,
- SSL_OP_NO_COMPRESSION |
- SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION);
-
- SSL_CTX_set_min_proto_version(ctx_, TLS1_1_VERSION);
-
- // add default password callback before opening encrypted private key
- if (private_key_password != nullptr && (private_key_password[0] != '\0')) {
- SSL_CTX_set_default_passwd_cb_userdata(
- ctx_,
- reinterpret_cast<void *>(const_cast<char *>(private_key_password)));
- }
-
- if (SSL_CTX_use_certificate_chain_file(ctx_, cert_path) != 1 ||
- SSL_CTX_use_PrivateKey_file(ctx_, private_key_path, SSL_FILETYPE_PEM) !=
- 1) {
- SSL_CTX_free(ctx_);
- ctx_ = nullptr;
- } else if (client_ca_cert_file_path || client_ca_cert_dir_path) {
- SSL_CTX_load_verify_locations(ctx_, client_ca_cert_file_path,
- client_ca_cert_dir_path);
-
- SSL_CTX_set_verify(
- ctx_, SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT, nullptr);
- }
- }
-}
-
-inline SSLServer::SSLServer(X509 *cert, EVP_PKEY *private_key,
- X509_STORE *client_ca_cert_store) {
- ctx_ = SSL_CTX_new(TLS_server_method());
-
- if (ctx_) {
- SSL_CTX_set_options(ctx_,
- SSL_OP_NO_COMPRESSION |
- SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION);
-
- SSL_CTX_set_min_proto_version(ctx_, TLS1_1_VERSION);
-
- if (SSL_CTX_use_certificate(ctx_, cert) != 1 ||
- SSL_CTX_use_PrivateKey(ctx_, private_key) != 1) {
- SSL_CTX_free(ctx_);
- ctx_ = nullptr;
- } else if (client_ca_cert_store) {
- SSL_CTX_set_cert_store(ctx_, client_ca_cert_store);
-
- SSL_CTX_set_verify(
- ctx_, SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT, nullptr);
- }
- }
-}
-
-inline SSLServer::SSLServer(
- const std::function<bool(SSL_CTX &ssl_ctx)> &setup_ssl_ctx_callback) {
- ctx_ = SSL_CTX_new(TLS_method());
- if (ctx_) {
- if (!setup_ssl_ctx_callback(*ctx_)) {
- SSL_CTX_free(ctx_);
- ctx_ = nullptr;
- }
- }
-}
-
-inline SSLServer::~SSLServer() {
- if (ctx_) { SSL_CTX_free(ctx_); }
-}
-
-inline bool SSLServer::is_valid() const { return ctx_; }
-
-inline SSL_CTX *SSLServer::ssl_context() const { return ctx_; }
-
-inline bool SSLServer::process_and_close_socket(socket_t sock) {
- auto ssl = detail::ssl_new(
- sock, ctx_, ctx_mutex_,
- [&](SSL *ssl2) {
- return detail::ssl_connect_or_accept_nonblocking(
- sock, ssl2, SSL_accept, read_timeout_sec_, read_timeout_usec_);
- },
- [](SSL * /*ssl2*/) { return true; });
-
- auto ret = false;
- if (ssl) {
- ret = detail::process_server_socket_ssl(
- svr_sock_, ssl, sock, keep_alive_max_count_, keep_alive_timeout_sec_,
- read_timeout_sec_, read_timeout_usec_, write_timeout_sec_,
- write_timeout_usec_,
- [this, ssl](Stream &strm, bool close_connection,
- bool &connection_closed) {
- return process_request(strm, close_connection, connection_closed,
- [&](Request &req) { req.ssl = ssl; });
- });
-
- // Shutdown gracefully if the result seemed successful, non-gracefully if
- // the connection appeared to be closed.
- const bool shutdown_gracefully = ret;
- detail::ssl_delete(ctx_mutex_, ssl, shutdown_gracefully);
- }
-
- detail::shutdown_socket(sock);
- detail::close_socket(sock);
- return ret;
-}
-
-// SSL HTTP client implementation
-inline SSLClient::SSLClient(const std::string &host)
- : SSLClient(host, 443, std::string(), std::string()) {}
-
-inline SSLClient::SSLClient(const std::string &host, int port)
- : SSLClient(host, port, std::string(), std::string()) {}
-
-inline SSLClient::SSLClient(const std::string &host, int port,
- const std::string &client_cert_path,
- const std::string &client_key_path)
- : ClientImpl(host, port, client_cert_path, client_key_path) {
- ctx_ = SSL_CTX_new(TLS_client_method());
-
- detail::split(&host_[0], &host_[host_.size()], '.',
- [&](const char *b, const char *e) {
- host_components_.emplace_back(std::string(b, e));
- });
-
- if (!client_cert_path.empty() && !client_key_path.empty()) {
- if (SSL_CTX_use_certificate_file(ctx_, client_cert_path.c_str(),
- SSL_FILETYPE_PEM) != 1 ||
- SSL_CTX_use_PrivateKey_file(ctx_, client_key_path.c_str(),
- SSL_FILETYPE_PEM) != 1) {
- SSL_CTX_free(ctx_);
- ctx_ = nullptr;
- }
- }
-}
-
-inline SSLClient::SSLClient(const std::string &host, int port,
- X509 *client_cert, EVP_PKEY *client_key)
- : ClientImpl(host, port) {
- ctx_ = SSL_CTX_new(TLS_client_method());
-
- detail::split(&host_[0], &host_[host_.size()], '.',
- [&](const char *b, const char *e) {
- host_components_.emplace_back(std::string(b, e));
- });
-
- if (client_cert != nullptr && client_key != nullptr) {
- if (SSL_CTX_use_certificate(ctx_, client_cert) != 1 ||
- SSL_CTX_use_PrivateKey(ctx_, client_key) != 1) {
- SSL_CTX_free(ctx_);
- ctx_ = nullptr;
- }
- }
-}
-
-inline SSLClient::~SSLClient() {
- if (ctx_) { SSL_CTX_free(ctx_); }
- // Make sure to shut down SSL since shutdown_ssl will resolve to the
- // base function rather than the derived function once we get to the
- // base class destructor, and won't free the SSL (causing a leak).
- shutdown_ssl_impl(socket_, true);
-}
-
-inline bool SSLClient::is_valid() const { return ctx_; }
-
-inline void SSLClient::set_ca_cert_store(X509_STORE *ca_cert_store) {
- if (ca_cert_store) {
- if (ctx_) {
- if (SSL_CTX_get_cert_store(ctx_) != ca_cert_store) {
- // Free memory allocated for old cert and use new store `ca_cert_store`
- SSL_CTX_set_cert_store(ctx_, ca_cert_store);
- }
- } else {
- X509_STORE_free(ca_cert_store);
- }
- }
-}
-
-inline void SSLClient::load_ca_cert_store(const char *ca_cert,
- std::size_t size) {
- set_ca_cert_store(ClientImpl::create_ca_cert_store(ca_cert, size));
-}
-
-inline long SSLClient::get_openssl_verify_result() const {
- return verify_result_;
-}
-
-inline SSL_CTX *SSLClient::ssl_context() const { return ctx_; }
-
-inline bool SSLClient::create_and_connect_socket(Socket &socket, Error &error) {
- return is_valid() && ClientImpl::create_and_connect_socket(socket, error);
-}
-
-// Assumes that socket_mutex_ is locked and that there are no requests in flight
-inline bool SSLClient::connect_with_proxy(Socket &socket, Response &res,
- bool &success, Error &error) {
- success = true;
- Response proxy_res;
- if (!detail::process_client_socket(
- socket.sock, read_timeout_sec_, read_timeout_usec_,
- write_timeout_sec_, write_timeout_usec_, [&](Stream &strm) {
- Request req2;
- req2.method = "CONNECT";
- req2.path = host_and_port_;
- return process_request(strm, req2, proxy_res, false, error);
- })) {
- // Thread-safe to close everything because we are assuming there are no
- // requests in flight
- shutdown_ssl(socket, true);
- shutdown_socket(socket);
- close_socket(socket);
- success = false;
- return false;
- }
-
- if (proxy_res.status == 407) {
- if (!proxy_digest_auth_username_.empty() &&
- !proxy_digest_auth_password_.empty()) {
- std::map<std::string, std::string> auth;
- if (detail::parse_www_authenticate(proxy_res, auth, true)) {
- proxy_res = Response();
- if (!detail::process_client_socket(
- socket.sock, read_timeout_sec_, read_timeout_usec_,
- write_timeout_sec_, write_timeout_usec_, [&](Stream &strm) {
- Request req3;
- req3.method = "CONNECT";
- req3.path = host_and_port_;
- req3.headers.insert(detail::make_digest_authentication_header(
- req3, auth, 1, detail::random_string(10),
- proxy_digest_auth_username_, proxy_digest_auth_password_,
- true));
- return process_request(strm, req3, proxy_res, false, error);
- })) {
- // Thread-safe to close everything because we are assuming there are
- // no requests in flight
- shutdown_ssl(socket, true);
- shutdown_socket(socket);
- close_socket(socket);
- success = false;
- return false;
- }
- }
- }
- }
-
- // If status code is not 200, proxy request is failed.
- // Set error to ProxyConnection and return proxy response
- // as the response of the request
- if (proxy_res.status != 200) {
- error = Error::ProxyConnection;
- res = std::move(proxy_res);
- // Thread-safe to close everything because we are assuming there are
- // no requests in flight
- shutdown_ssl(socket, true);
- shutdown_socket(socket);
- close_socket(socket);
- return false;
- }
-
- return true;
-}
-
-inline bool SSLClient::load_certs() {
- auto ret = true;
-
- std::call_once(initialize_cert_, [&]() {
- std::lock_guard<std::mutex> guard(ctx_mutex_);
- if (!ca_cert_file_path_.empty()) {
- if (!SSL_CTX_load_verify_locations(ctx_, ca_cert_file_path_.c_str(),
- nullptr)) {
- ret = false;
- }
- } else if (!ca_cert_dir_path_.empty()) {
- if (!SSL_CTX_load_verify_locations(ctx_, nullptr,
- ca_cert_dir_path_.c_str())) {
- ret = false;
- }
- } else {
- auto loaded = false;
-#ifdef _WIN32
- loaded =
- detail::load_system_certs_on_windows(SSL_CTX_get_cert_store(ctx_));
-#elif defined(CPPHTTPLIB_USE_CERTS_FROM_MACOSX_KEYCHAIN) && defined(__APPLE__)
-#if TARGET_OS_OSX
- loaded = detail::load_system_certs_on_macos(SSL_CTX_get_cert_store(ctx_));
-#endif // TARGET_OS_OSX
-#endif // _WIN32
- if (!loaded) { SSL_CTX_set_default_verify_paths(ctx_); }
- }
- });
-
- return ret;
-}
-
-inline bool SSLClient::initialize_ssl(Socket &socket, Error &error) {
- auto ssl = detail::ssl_new(
- socket.sock, ctx_, ctx_mutex_,
- [&](SSL *ssl2) {
- if (server_certificate_verification_) {
- if (!load_certs()) {
- error = Error::SSLLoadingCerts;
- return false;
- }
- SSL_set_verify(ssl2, SSL_VERIFY_NONE, nullptr);
- }
-
- if (!detail::ssl_connect_or_accept_nonblocking(
- socket.sock, ssl2, SSL_connect, connection_timeout_sec_,
- connection_timeout_usec_)) {
- error = Error::SSLConnection;
- return false;
- }
-
- if (server_certificate_verification_) {
- verify_result_ = SSL_get_verify_result(ssl2);
-
- if (verify_result_ != X509_V_OK) {
- error = Error::SSLServerVerification;
- return false;
- }
-
- auto server_cert = SSL_get1_peer_certificate(ssl2);
-
- if (server_cert == nullptr) {
- error = Error::SSLServerVerification;
- return false;
- }
-
- if (!verify_host(server_cert)) {
- X509_free(server_cert);
- error = Error::SSLServerVerification;
- return false;
- }
- X509_free(server_cert);
- }
-
- return true;
- },
- [&](SSL *ssl2) {
- // NOTE: With -Wold-style-cast, this can produce a warning, since
- // SSL_set_tlsext_host_name is a macro (in OpenSSL), which contains
- // an old style cast. Short of doing compiler specific pragma's
- // here, we can't get rid of this warning. :'(
- SSL_set_tlsext_host_name(ssl2, host_.c_str());
- return true;
- });
-
- if (ssl) {
- socket.ssl = ssl;
- return true;
- }
-
- shutdown_socket(socket);
- close_socket(socket);
- return false;
-}
-
-inline void SSLClient::shutdown_ssl(Socket &socket, bool shutdown_gracefully) {
- shutdown_ssl_impl(socket, shutdown_gracefully);
-}
-
-inline void SSLClient::shutdown_ssl_impl(Socket &socket,
- bool shutdown_gracefully) {
- if (socket.sock == INVALID_SOCKET) {
- assert(socket.ssl == nullptr);
- return;
- }
- if (socket.ssl) {
- detail::ssl_delete(ctx_mutex_, socket.ssl, shutdown_gracefully);
- socket.ssl = nullptr;
- }
- assert(socket.ssl == nullptr);
-}
-
-inline bool
-SSLClient::process_socket(const Socket &socket,
- std::function<bool(Stream &strm)> callback) {
- assert(socket.ssl);
- return detail::process_client_socket_ssl(
- socket.ssl, socket.sock, read_timeout_sec_, read_timeout_usec_,
- write_timeout_sec_, write_timeout_usec_, std::move(callback));
-}
-
-inline bool SSLClient::is_ssl() const { return true; }
-
-inline bool SSLClient::verify_host(X509 *server_cert) const {
- /* Quote from RFC2818 section 3.1 "Server Identity"
-
- If a subjectAltName extension of type dNSName is present, that MUST
- be used as the identity. Otherwise, the (most specific) Common Name
- field in the Subject field of the certificate MUST be used. Although
- the use of the Common Name is existing practice, it is deprecated and
- Certification Authorities are encouraged to use the dNSName instead.
-
- Matching is performed using the matching rules specified by
- [RFC2459]. If more than one identity of a given type is present in
- the certificate (e.g., more than one dNSName name, a match in any one
- of the set is considered acceptable.) Names may contain the wildcard
- character * which is considered to match any single domain name
- component or component fragment. E.g., *.a.com matches foo.a.com but
- not bar.foo.a.com. f*.com matches foo.com but not bar.com.
-
- In some cases, the URI is specified as an IP address rather than a
- hostname. In this case, the iPAddress subjectAltName must be present
- in the certificate and must exactly match the IP in the URI.
-
- */
- return verify_host_with_subject_alt_name(server_cert) ||
- verify_host_with_common_name(server_cert);
-}
-
-inline bool
-SSLClient::verify_host_with_subject_alt_name(X509 *server_cert) const {
- auto ret = false;
-
- auto type = GEN_DNS;
-
- struct in6_addr addr6;
- struct in_addr addr;
- size_t addr_len = 0;
-
-#ifndef __MINGW32__
- if (inet_pton(AF_INET6, host_.c_str(), &addr6)) {
- type = GEN_IPADD;
- addr_len = sizeof(struct in6_addr);
- } else if (inet_pton(AF_INET, host_.c_str(), &addr)) {
- type = GEN_IPADD;
- addr_len = sizeof(struct in_addr);
- }
-#endif
-
- auto alt_names = static_cast<const struct stack_st_GENERAL_NAME *>(
- X509_get_ext_d2i(server_cert, NID_subject_alt_name, nullptr, nullptr));
-
- if (alt_names) {
- auto dsn_matched = false;
- auto ip_matched = false;
-
- auto count = sk_GENERAL_NAME_num(alt_names);
-
- for (decltype(count) i = 0; i < count && !dsn_matched; i++) {
- auto val = sk_GENERAL_NAME_value(alt_names, i);
- if (val->type == type) {
- auto name =
- reinterpret_cast<const char *>(ASN1_STRING_get0_data(val->d.ia5));
- auto name_len = static_cast<size_t>(ASN1_STRING_length(val->d.ia5));
-
- switch (type) {
- case GEN_DNS: dsn_matched = check_host_name(name, name_len); break;
-
- case GEN_IPADD:
- if (!memcmp(&addr6, name, addr_len) ||
- !memcmp(&addr, name, addr_len)) {
- ip_matched = true;
- }
- break;
- }
- }
- }
-
- if (dsn_matched || ip_matched) { ret = true; }
- }
-
- GENERAL_NAMES_free(const_cast<STACK_OF(GENERAL_NAME) *>(
- reinterpret_cast<const STACK_OF(GENERAL_NAME) *>(alt_names)));
- return ret;
-}
-
-inline bool SSLClient::verify_host_with_common_name(X509 *server_cert) const {
- const auto subject_name = X509_get_subject_name(server_cert);
-
- if (subject_name != nullptr) {
- char name[BUFSIZ];
- auto name_len = X509_NAME_get_text_by_NID(subject_name, NID_commonName,
- name, sizeof(name));
-
- if (name_len != -1) {
- return check_host_name(name, static_cast<size_t>(name_len));
- }
- }
-
- return false;
-}
-
-inline bool SSLClient::check_host_name(const char *pattern,
- size_t pattern_len) const {
- if (host_.size() == pattern_len && host_ == pattern) { return true; }
-
- // Wildcard match
- // https://bugs.launchpad.net/ubuntu/+source/firefox-3.0/+bug/376484
- std::vector<std::string> pattern_components;
- detail::split(&pattern[0], &pattern[pattern_len], '.',
- [&](const char *b, const char *e) {
- pattern_components.emplace_back(std::string(b, e));
- });
-
- if (host_components_.size() != pattern_components.size()) { return false; }
-
- auto itr = pattern_components.begin();
- for (const auto &h : host_components_) {
- auto &p = *itr;
- if (p != h && p != "*") {
- auto partial_match = (p.size() > 0 && p[p.size() - 1] == '*' &&
- !p.compare(0, p.size() - 1, h));
- if (!partial_match) { return false; }
- }
- ++itr;
- }
-
- return true;
-}
-#endif
-
-// Universal client implementation
-inline Client::Client(const std::string &scheme_host_port)
- : Client(scheme_host_port, std::string(), std::string()) {}
-
-inline Client::Client(const std::string &scheme_host_port,
- const std::string &client_cert_path,
- const std::string &client_key_path) {
- const static std::regex re(
- R"((?:([a-z]+):\/\/)?(?:\[([\d:]+)\]|([^:/?#]+))(?::(\d+))?)");
-
- std::smatch m;
- if (std::regex_match(scheme_host_port, m, re)) {
- auto scheme = m[1].str();
-
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
- if (!scheme.empty() && (scheme != "http" && scheme != "https")) {
-#else
- if (!scheme.empty() && scheme != "http") {
-#endif
-#ifndef CPPHTTPLIB_NO_EXCEPTIONS
- std::string msg = "'" + scheme + "' scheme is not supported.";
- throw std::invalid_argument(msg);
-#endif
- return;
- }
-
- auto is_ssl = scheme == "https";
-
- auto host = m[2].str();
- if (host.empty()) { host = m[3].str(); }
-
- auto port_str = m[4].str();
- auto port = !port_str.empty() ? std::stoi(port_str) : (is_ssl ? 443 : 80);
-
- if (is_ssl) {
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
- cli_ = detail::make_unique<SSLClient>(host, port, client_cert_path,
- client_key_path);
- is_ssl_ = is_ssl;
-#endif
- } else {
- cli_ = detail::make_unique<ClientImpl>(host, port, client_cert_path,
- client_key_path);
- }
- } else {
- cli_ = detail::make_unique<ClientImpl>(scheme_host_port, 80,
- client_cert_path, client_key_path);
- }
-}
-
-inline Client::Client(const std::string &host, int port)
- : cli_(detail::make_unique<ClientImpl>(host, port)) {}
-
-inline Client::Client(const std::string &host, int port,
- const std::string &client_cert_path,
- const std::string &client_key_path)
- : cli_(detail::make_unique<ClientImpl>(host, port, client_cert_path,
- client_key_path)) {}
-
-inline Client::~Client() {}
-
-inline bool Client::is_valid() const {
- return cli_ != nullptr && cli_->is_valid();
-}
-
-inline Result Client::Get(const std::string &path) { return cli_->Get(path); }
-inline Result Client::Get(const std::string &path, const Headers &headers) {
- return cli_->Get(path, headers);
-}
-inline Result Client::Get(const std::string &path, Progress progress) {
- return cli_->Get(path, std::move(progress));
-}
-inline Result Client::Get(const std::string &path, const Headers &headers,
- Progress progress) {
- return cli_->Get(path, headers, std::move(progress));
-}
-inline Result Client::Get(const std::string &path,
- ContentReceiver content_receiver) {
- return cli_->Get(path, std::move(content_receiver));
-}
-inline Result Client::Get(const std::string &path, const Headers &headers,
- ContentReceiver content_receiver) {
- return cli_->Get(path, headers, std::move(content_receiver));
-}
-inline Result Client::Get(const std::string &path,
- ContentReceiver content_receiver, Progress progress) {
- return cli_->Get(path, std::move(content_receiver), std::move(progress));
-}
-inline Result Client::Get(const std::string &path, const Headers &headers,
- ContentReceiver content_receiver, Progress progress) {
- return cli_->Get(path, headers, std::move(content_receiver),
- std::move(progress));
-}
-inline Result Client::Get(const std::string &path,
- ResponseHandler response_handler,
- ContentReceiver content_receiver) {
- return cli_->Get(path, std::move(response_handler),
- std::move(content_receiver));
-}
-inline Result Client::Get(const std::string &path, const Headers &headers,
- ResponseHandler response_handler,
- ContentReceiver content_receiver) {
- return cli_->Get(path, headers, std::move(response_handler),
- std::move(content_receiver));
-}
-inline Result Client::Get(const std::string &path,
- ResponseHandler response_handler,
- ContentReceiver content_receiver, Progress progress) {
- return cli_->Get(path, std::move(response_handler),
- std::move(content_receiver), std::move(progress));
-}
-inline Result Client::Get(const std::string &path, const Headers &headers,
- ResponseHandler response_handler,
- ContentReceiver content_receiver, Progress progress) {
- return cli_->Get(path, headers, std::move(response_handler),
- std::move(content_receiver), std::move(progress));
-}
-inline Result Client::Get(const std::string &path, const Params &params,
- const Headers &headers, Progress progress) {
- return cli_->Get(path, params, headers, progress);
-}
-inline Result Client::Get(const std::string &path, const Params &params,
- const Headers &headers,
- ContentReceiver content_receiver, Progress progress) {
- return cli_->Get(path, params, headers, content_receiver, progress);
-}
-inline Result Client::Get(const std::string &path, const Params &params,
- const Headers &headers,
- ResponseHandler response_handler,
- ContentReceiver content_receiver, Progress progress) {
- return cli_->Get(path, params, headers, response_handler, content_receiver,
- progress);
-}
-
-inline Result Client::Head(const std::string &path) { return cli_->Head(path); }
-inline Result Client::Head(const std::string &path, const Headers &headers) {
- return cli_->Head(path, headers);
-}
-
-inline Result Client::Post(const std::string &path) { return cli_->Post(path); }
-inline Result Client::Post(const std::string &path, const Headers &headers) {
- return cli_->Post(path, headers);
-}
-inline Result Client::Post(const std::string &path, const char *body,
- size_t content_length,
- const std::string &content_type) {
- return cli_->Post(path, body, content_length, content_type);
-}
-inline Result Client::Post(const std::string &path, const Headers &headers,
- const char *body, size_t content_length,
- const std::string &content_type) {
- return cli_->Post(path, headers, body, content_length, content_type);
-}
-inline Result Client::Post(const std::string &path, const std::string &body,
- const std::string &content_type) {
- return cli_->Post(path, body, content_type);
-}
-inline Result Client::Post(const std::string &path, const Headers &headers,
- const std::string &body,
- const std::string &content_type) {
- return cli_->Post(path, headers, body, content_type);
-}
-inline Result Client::Post(const std::string &path, size_t content_length,
- ContentProvider content_provider,
- const std::string &content_type) {
- return cli_->Post(path, content_length, std::move(content_provider),
- content_type);
-}
-inline Result Client::Post(const std::string &path,
- ContentProviderWithoutLength content_provider,
- const std::string &content_type) {
- return cli_->Post(path, std::move(content_provider), content_type);
-}
-inline Result Client::Post(const std::string &path, const Headers &headers,
- size_t content_length,
- ContentProvider content_provider,
- const std::string &content_type) {
- return cli_->Post(path, headers, content_length, std::move(content_provider),
- content_type);
-}
-inline Result Client::Post(const std::string &path, const Headers &headers,
- ContentProviderWithoutLength content_provider,
- const std::string &content_type) {
- return cli_->Post(path, headers, std::move(content_provider), content_type);
-}
-inline Result Client::Post(const std::string &path, const Params &params) {
- return cli_->Post(path, params);
-}
-inline Result Client::Post(const std::string &path, const Headers &headers,
- const Params &params) {
- return cli_->Post(path, headers, params);
-}
-inline Result Client::Post(const std::string &path,
- const MultipartFormDataItems &items) {
- return cli_->Post(path, items);
-}
-inline Result Client::Post(const std::string &path, const Headers &headers,
- const MultipartFormDataItems &items) {
- return cli_->Post(path, headers, items);
-}
-inline Result Client::Post(const std::string &path, const Headers &headers,
- const MultipartFormDataItems &items,
- const std::string &boundary) {
- return cli_->Post(path, headers, items, boundary);
-}
-inline Result
-Client::Post(const std::string &path, const Headers &headers,
- const MultipartFormDataItems &items,
- const MultipartFormDataProviderItems &provider_items) {
- return cli_->Post(path, headers, items, provider_items);
-}
-inline Result Client::Put(const std::string &path) { return cli_->Put(path); }
-inline Result Client::Put(const std::string &path, const char *body,
- size_t content_length,
- const std::string &content_type) {
- return cli_->Put(path, body, content_length, content_type);
-}
-inline Result Client::Put(const std::string &path, const Headers &headers,
- const char *body, size_t content_length,
- const std::string &content_type) {
- return cli_->Put(path, headers, body, content_length, content_type);
-}
-inline Result Client::Put(const std::string &path, const std::string &body,
- const std::string &content_type) {
- return cli_->Put(path, body, content_type);
-}
-inline Result Client::Put(const std::string &path, const Headers &headers,
- const std::string &body,
- const std::string &content_type) {
- return cli_->Put(path, headers, body, content_type);
-}
-inline Result Client::Put(const std::string &path, size_t content_length,
- ContentProvider content_provider,
- const std::string &content_type) {
- return cli_->Put(path, content_length, std::move(content_provider),
- content_type);
-}
-inline Result Client::Put(const std::string &path,
- ContentProviderWithoutLength content_provider,
- const std::string &content_type) {
- return cli_->Put(path, std::move(content_provider), content_type);
-}
-inline Result Client::Put(const std::string &path, const Headers &headers,
- size_t content_length,
- ContentProvider content_provider,
- const std::string &content_type) {
- return cli_->Put(path, headers, content_length, std::move(content_provider),
- content_type);
-}
-inline Result Client::Put(const std::string &path, const Headers &headers,
- ContentProviderWithoutLength content_provider,
- const std::string &content_type) {
- return cli_->Put(path, headers, std::move(content_provider), content_type);
-}
-inline Result Client::Put(const std::string &path, const Params &params) {
- return cli_->Put(path, params);
-}
-inline Result Client::Put(const std::string &path, const Headers &headers,
- const Params &params) {
- return cli_->Put(path, headers, params);
-}
-inline Result Client::Put(const std::string &path,
- const MultipartFormDataItems &items) {
- return cli_->Put(path, items);
-}
-inline Result Client::Put(const std::string &path, const Headers &headers,
- const MultipartFormDataItems &items) {
- return cli_->Put(path, headers, items);
-}
-inline Result Client::Put(const std::string &path, const Headers &headers,
- const MultipartFormDataItems &items,
- const std::string &boundary) {
- return cli_->Put(path, headers, items, boundary);
-}
-inline Result
-Client::Put(const std::string &path, const Headers &headers,
- const MultipartFormDataItems &items,
- const MultipartFormDataProviderItems &provider_items) {
- return cli_->Put(path, headers, items, provider_items);
-}
-inline Result Client::Patch(const std::string &path) {
- return cli_->Patch(path);
-}
-inline Result Client::Patch(const std::string &path, const char *body,
- size_t content_length,
- const std::string &content_type) {
- return cli_->Patch(path, body, content_length, content_type);
-}
-inline Result Client::Patch(const std::string &path, const Headers &headers,
- const char *body, size_t content_length,
- const std::string &content_type) {
- return cli_->Patch(path, headers, body, content_length, content_type);
-}
-inline Result Client::Patch(const std::string &path, const std::string &body,
- const std::string &content_type) {
- return cli_->Patch(path, body, content_type);
-}
-inline Result Client::Patch(const std::string &path, const Headers &headers,
- const std::string &body,
- const std::string &content_type) {
- return cli_->Patch(path, headers, body, content_type);
-}
-inline Result Client::Patch(const std::string &path, size_t content_length,
- ContentProvider content_provider,
- const std::string &content_type) {
- return cli_->Patch(path, content_length, std::move(content_provider),
- content_type);
-}
-inline Result Client::Patch(const std::string &path,
- ContentProviderWithoutLength content_provider,
- const std::string &content_type) {
- return cli_->Patch(path, std::move(content_provider), content_type);
-}
-inline Result Client::Patch(const std::string &path, const Headers &headers,
- size_t content_length,
- ContentProvider content_provider,
- const std::string &content_type) {
- return cli_->Patch(path, headers, content_length, std::move(content_provider),
- content_type);
-}
-inline Result Client::Patch(const std::string &path, const Headers &headers,
- ContentProviderWithoutLength content_provider,
- const std::string &content_type) {
- return cli_->Patch(path, headers, std::move(content_provider), content_type);
-}
-inline Result Client::Delete(const std::string &path) {
- return cli_->Delete(path);
-}
-inline Result Client::Delete(const std::string &path, const Headers &headers) {
- return cli_->Delete(path, headers);
-}
-inline Result Client::Delete(const std::string &path, const char *body,
- size_t content_length,
- const std::string &content_type) {
- return cli_->Delete(path, body, content_length, content_type);
-}
-inline Result Client::Delete(const std::string &path, const Headers &headers,
- const char *body, size_t content_length,
- const std::string &content_type) {
- return cli_->Delete(path, headers, body, content_length, content_type);
-}
-inline Result Client::Delete(const std::string &path, const std::string &body,
- const std::string &content_type) {
- return cli_->Delete(path, body, content_type);
-}
-inline Result Client::Delete(const std::string &path, const Headers &headers,
- const std::string &body,
- const std::string &content_type) {
- return cli_->Delete(path, headers, body, content_type);
-}
-inline Result Client::Options(const std::string &path) {
- return cli_->Options(path);
-}
-inline Result Client::Options(const std::string &path, const Headers &headers) {
- return cli_->Options(path, headers);
-}
-
-inline bool Client::send(Request &req, Response &res, Error &error) {
- return cli_->send(req, res, error);
-}
-
-inline Result Client::send(const Request &req) { return cli_->send(req); }
-
-inline void Client::stop() { cli_->stop(); }
-
-inline std::string Client::host() const { return cli_->host(); }
-
-inline int Client::port() const { return cli_->port(); }
-
-inline size_t Client::is_socket_open() const { return cli_->is_socket_open(); }
-
-inline socket_t Client::socket() const { return cli_->socket(); }
-
-inline void
-Client::set_hostname_addr_map(std::map<std::string, std::string> addr_map) {
- cli_->set_hostname_addr_map(std::move(addr_map));
-}
-
-inline void Client::set_default_headers(Headers headers) {
- cli_->set_default_headers(std::move(headers));
-}
-
-inline void Client::set_header_writer(
- std::function<ssize_t(Stream &, Headers &)> const &writer) {
- cli_->set_header_writer(writer);
-}
-
-inline void Client::set_address_family(int family) {
- cli_->set_address_family(family);
-}
-
-inline void Client::set_tcp_nodelay(bool on) { cli_->set_tcp_nodelay(on); }
-
-inline void Client::set_socket_options(SocketOptions socket_options) {
- cli_->set_socket_options(std::move(socket_options));
-}
-
-inline void Client::set_connection_timeout(time_t sec, time_t usec) {
- cli_->set_connection_timeout(sec, usec);
-}
-
-inline void Client::set_read_timeout(time_t sec, time_t usec) {
- cli_->set_read_timeout(sec, usec);
-}
-
-inline void Client::set_write_timeout(time_t sec, time_t usec) {
- cli_->set_write_timeout(sec, usec);
-}
-
-inline void Client::set_basic_auth(const std::string &username,
- const std::string &password) {
- cli_->set_basic_auth(username, password);
-}
-inline void Client::set_bearer_token_auth(const std::string &token) {
- cli_->set_bearer_token_auth(token);
-}
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-inline void Client::set_digest_auth(const std::string &username,
- const std::string &password) {
- cli_->set_digest_auth(username, password);
-}
-#endif
-
-inline void Client::set_keep_alive(bool on) { cli_->set_keep_alive(on); }
-inline void Client::set_follow_location(bool on) {
- cli_->set_follow_location(on);
-}
-
-inline void Client::set_url_encode(bool on) { cli_->set_url_encode(on); }
-
-inline void Client::set_compress(bool on) { cli_->set_compress(on); }
-
-inline void Client::set_decompress(bool on) { cli_->set_decompress(on); }
-
-inline void Client::set_interface(const std::string &intf) {
- cli_->set_interface(intf);
-}
-
-inline void Client::set_proxy(const std::string &host, int port) {
- cli_->set_proxy(host, port);
-}
-inline void Client::set_proxy_basic_auth(const std::string &username,
- const std::string &password) {
- cli_->set_proxy_basic_auth(username, password);
-}
-inline void Client::set_proxy_bearer_token_auth(const std::string &token) {
- cli_->set_proxy_bearer_token_auth(token);
-}
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-inline void Client::set_proxy_digest_auth(const std::string &username,
- const std::string &password) {
- cli_->set_proxy_digest_auth(username, password);
-}
-#endif
-
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-inline void Client::enable_server_certificate_verification(bool enabled) {
- cli_->enable_server_certificate_verification(enabled);
-}
-#endif
-
-inline void Client::set_logger(Logger logger) {
- cli_->set_logger(std::move(logger));
-}
-
-#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
-inline void Client::set_ca_cert_path(const std::string &ca_cert_file_path,
- const std::string &ca_cert_dir_path) {
- cli_->set_ca_cert_path(ca_cert_file_path, ca_cert_dir_path);
-}
-
-inline void Client::set_ca_cert_store(X509_STORE *ca_cert_store) {
- if (is_ssl_) {
- static_cast<SSLClient &>(*cli_).set_ca_cert_store(ca_cert_store);
- } else {
- cli_->set_ca_cert_store(ca_cert_store);
- }
-}
-
-inline void Client::load_ca_cert_store(const char *ca_cert, std::size_t size) {
- set_ca_cert_store(cli_->create_ca_cert_store(ca_cert, size));
-}
-
-inline long Client::get_openssl_verify_result() const {
- if (is_ssl_) {
- return static_cast<SSLClient &>(*cli_).get_openssl_verify_result();
- }
- return -1; // NOTE: -1 doesn't match any of X509_V_ERR_???
-}
-
-inline SSL_CTX *Client::ssl_context() const {
- if (is_ssl_) { return static_cast<SSLClient &>(*cli_).ssl_context(); }
- return nullptr;
-}
-#endif
-
-// ----------------------------------------------------------------------------
-
-} // namespace httplib
-
-#if defined(_WIN32) && defined(CPPHTTPLIB_USE_POLL)
-#undef poll
-#endif
-
-#endif // CPPHTTPLIB_HTTPLIB_H
diff --git a/whisper.cpp/main.cpp b/whisper.cpp/main.cpp
deleted file mode 100644
index dc390175..00000000
--- a/whisper.cpp/main.cpp
+++ /dev/null
@@ -1,1309 +0,0 @@
-// -*- mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8 -*-
-// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
-
-#include "llamafile/version.h"
-#include "llamafile/llamafile.h"
-#include "llama.cpp/cores.h"
-#include "common.h"
-#include "slurp.h"
-
-#include "whisper.h"
-#include "grammar-parser.h"
-
-#include <cmath>
-#include <fstream>
-#include <cstdio>
-#include <regex>
-#include <string>
-#include <thread>
-#include <vector>
-#include <cstring>
-#include <cosmo.h>
-
-#include "llamafile/llamafile.h"
-#include "llamafile/debug.h"
-#include "llama.cpp/string.h"
-
-#if defined(_MSC_VER)
-#pragma warning(disable: 4244 4267) // possible loss of data
-#endif
-
-// command-line parameters
-struct whisper_params {
- int32_t n_threads = std::min(16, cpu_get_num_math());
- int32_t n_processors = 1;
- int32_t offset_t_ms = 0;
- int32_t offset_n = 0;
- int32_t duration_ms = 0;
- int32_t progress_step = 5;
- int32_t max_context = -1;
- int32_t max_len = 0;
- int32_t best_of = whisper_full_default_params(WHISPER_SAMPLING_GREEDY).greedy.best_of;
- int32_t beam_size = whisper_full_default_params(WHISPER_SAMPLING_BEAM_SEARCH).beam_search.beam_size;
- int32_t audio_ctx = 0;
-
- float word_thold = 0.01f;
- float entropy_thold = 2.40f;
- float logprob_thold = -1.00f;
- float grammar_penalty = 100.0f;
- float temperature = 0.0f;
- float temperature_inc = 0.2f;
-
- bool debug_mode = false;
- bool translate = false;
- bool detect_language = false;
- bool diarize = false;
- bool tinydiarize = false;
- bool split_on_word = false;
- bool no_fallback = false;
- bool output_txt = false;
- bool output_vtt = false;
- bool output_srt = false;
- bool output_wts = false;
- bool output_csv = false;
- bool output_jsn = false;
- bool output_jsn_full = false;
- bool output_lrc = false;
- bool no_prints = false;
- bool print_special = false;
- bool print_colors = false;
- bool print_progress = false;
- bool no_timestamps = false;
- bool log_score = false;
- bool flash_attn = false;
-
- std::string language = "en";
- std::string prompt;
- std::string font_path = "/System/Library/Fonts/Supplemental/Courier New Bold.ttf";
- std::string model = "models/ggml-base.en.bin";
- std::string grammar;
- std::string grammar_rule;
-
- // [TDRZ] speaker turn string
- std::string tdrz_speaker_turn = " [SPEAKER_TURN]"; // TODO: set from command line
-
- // A regular expression that matches tokens to suppress
- std::string suppress_regex;
-
- std::string openvino_encode_device = "CPU";
-
- std::string dtw = "";
-
- std::vector<std::string> fname_inp = {};
- std::vector<std::string> fname_out = {};
-
- whisper_grammar_parser::parse_state grammar_parsed;
-};
-
-static void whisper_print_usage(int argc, char ** argv, const whisper_params & params);
-
-static char * whisper_param_turn_lowercase(char * in){
- int string_len = strlen(in);
- for (int i = 0; i < string_len; i++){
- *(in+i) = tolower((unsigned char)*(in+i));
- }
- return in;
-}
-
-static bool whisper_params_parse(int argc, char ** argv, whisper_params & params) {
- for (int i = 1; i < argc; i++) {
- std::string arg = argv[i];
-
- if (arg == "-"){
- params.fname_inp.push_back(arg);
- continue;
- }
-
- if (arg[0] != '-') {
- params.fname_inp.push_back(arg);
- continue;
- }
-
- if (arg == "--log-disable") {
- FLAG_log_disable = true;
- } else if (arg == "--cli") {
- } else if (arg == "--server") {
- } else if (arg == "--fast") {
- FLAG_fast = true;
- } else if (arg == "--precise") {
- FLAG_precise = true;
- } else if (arg == "--trace") {
- FLAG_trace = true;
- } else if (arg == "--trap") {
- FLAG_trap = true;
- FLAG_unsecure = true; // for better backtraces
- llamafile_trapping_enabled(+1);
- } else if (arg == "--unsecure") {
- FLAG_unsecure = true;
- } else if (arg == "--nocompile") {
- FLAG_nocompile = true;
- } else if (arg == "--recompile") {
- FLAG_recompile = true;
- } else if (arg == "--tinyblas") {
- FLAG_tinyblas = true; // undocumented
- } else if (arg == "--gpu") {
- if (++i >= argc) {
- fprintf(stderr, "error: missing --gpu flag value\n");
- exit(1);
- }
- FLAG_gpu = llamafile_gpu_parse(argv[i]);
- if (FLAG_gpu == LLAMAFILE_GPU_ERROR) {
- fprintf(stderr, "error: invalid --gpu flag value: %s\n", argv[i]);
- exit(1);
- }
- } else
-
- if (arg == "-h" || arg == "--help") {
- whisper_print_usage(argc, argv, params);
- exit(0);
- }
- else if (arg == "-t" || arg == "--threads") { params.n_threads = std::stoi(argv[++i]); }
- else if (arg == "-p" || arg == "--processors") { params.n_processors = std::stoi(argv[++i]); }
- else if (arg == "-ot" || arg == "--offset-t") { params.offset_t_ms = std::stoi(argv[++i]); }
- else if (arg == "-on" || arg == "--offset-n") { params.offset_n = std::stoi(argv[++i]); }
- else if (arg == "-d" || arg == "--duration") { params.duration_ms = std::stoi(argv[++i]); }
- else if (arg == "-mc" || arg == "--max-context") { params.max_context = std::stoi(argv[++i]); }
- else if (arg == "-ml" || arg == "--max-len") { params.max_len = std::stoi(argv[++i]); }
- else if (arg == "-bo" || arg == "--best-of") { params.best_of = std::stoi(argv[++i]); }
- else if (arg == "-bs" || arg == "--beam-size") { params.beam_size = std::stoi(argv[++i]); }
- else if (arg == "-ac" || arg == "--audio-ctx") { params.audio_ctx = std::stoi(argv[++i]); }
- else if (arg == "-wt" || arg == "--word-thold") { params.word_thold = std::stof(argv[++i]); }
- else if (arg == "-et" || arg == "--entropy-thold") { params.entropy_thold = std::stof(argv[++i]); }
- else if (arg == "-lpt" || arg == "--logprob-thold") { params.logprob_thold = std::stof(argv[++i]); }
- else if (arg == "-tp" || arg == "--temperature") { params.temperature = std::stof(argv[++i]); }
- else if (arg == "-tpi" || arg == "--temperature-inc") { params.temperature_inc = std::stof(argv[++i]); }
- else if (arg == "-debug"|| arg == "--debug-mode") { params.debug_mode = true; }
- else if (arg == "-tr" || arg == "--translate") { params.translate = true; }
- else if (arg == "-di" || arg == "--diarize") { params.diarize = true; }
- else if (arg == "-tdrz" || arg == "--tinydiarize") { params.tinydiarize = true; }
- else if (arg == "-sow" || arg == "--split-on-word") { params.split_on_word = true; }
- else if (arg == "-nf" || arg == "--no-fallback") { params.no_fallback = true; }
- else if (arg == "-otxt" || arg == "--output-txt") { params.output_txt = true; }
- else if (arg == "-ovtt" || arg == "--output-vtt") { params.output_vtt = true; }
- else if (arg == "-osrt" || arg == "--output-srt") { params.output_srt = true; }
- else if (arg == "-owts" || arg == "--output-words") { params.output_wts = true; }
- else if (arg == "-olrc" || arg == "--output-lrc") { params.output_lrc = true; }
- else if (arg == "-fp" || arg == "--font-path") { params.font_path = argv[++i]; }
- else if (arg == "-ocsv" || arg == "--output-csv") { params.output_csv = true; }
- else if (arg == "-oj" || arg == "--output-json") { params.output_jsn = true; }
- else if (arg == "-ojf" || arg == "--output-json-full"){ params.output_jsn_full = params.output_jsn = true; }
- else if (arg == "-of" || arg == "--output-file") { params.fname_out.emplace_back(argv[++i]); }
- else if (arg == "-np" || arg == "--no-prints") { params.no_prints = true; FLAG_log_disable = true; }
- else if (arg == "-ps" || arg == "--print-special") { params.print_special = true; }
- else if (arg == "-pc" || arg == "--print-colors") { params.print_colors = true; }
- else if (arg == "-pp" || arg == "--print-progress") { params.print_progress = true; }
- else if (arg == "-nt" || arg == "--no-timestamps") { params.no_timestamps = true; }
- else if (arg == "-l" || arg == "--language") { params.language = whisper_param_turn_lowercase(argv[++i]); }
- else if (arg == "-dl" || arg == "--detect-language") { params.detect_language = true; }
- else if ( arg == "--prompt") { params.prompt = argv[++i]; }
- else if (arg == "-m" || arg == "--model") { params.model = argv[++i]; }
- else if (arg == "-f" || arg == "--file") { params.fname_inp.emplace_back(argv[++i]); }
- else if (arg == "-oved" || arg == "--ov-e-device") { params.openvino_encode_device = argv[++i]; }
- else if (arg == "-dtw" || arg == "--dtw") { params.dtw = argv[++i]; }
- else if (arg == "-ls" || arg == "--log-score") { params.log_score = true; }
- else if (arg == "-ng" || arg == "--no-gpu") { FLAG_gpu = LLAMAFILE_GPU_DISABLE; }
- else if (arg == "-fa" || arg == "--flash-attn") { params.flash_attn = true; }
- else if ( arg == "--suppress-regex") { params.suppress_regex = argv[++i]; }
- else if ( arg == "--grammar") { params.grammar = argv[++i]; }
- else if ( arg == "--grammar-rule") { params.grammar_rule = argv[++i]; }
- else if ( arg == "--grammar-penalty") { params.grammar_penalty = std::stof(argv[++i]); }
- else {
- fprintf(stderr, "error: unknown argument: %s\n", arg.c_str()); // [jart]
- // whisper_print_usage(argc, argv, params); // [jart]
- exit(0);
- }
- }
-
- FLAGS_READY = true;
-
- return true;
-}
-
-static void whisper_print_usage(int /*argc*/, char ** argv, const whisper_params & params) {
- fprintf(stderr, "\n");
- fprintf(stderr, "usage: %s [options] file0.wav file1.wav ...\n", argv[0]);
- fprintf(stderr, "\n");
- fprintf(stderr, "options:\n");
- fprintf(stderr, " -h, --help [default] show this help message and exit\n");
- fprintf(stderr, " -t N, --threads N [%-7d] number of threads to use during computation\n", params.n_threads);
- fprintf(stderr, " -p N, --processors N [%-7d] number of processors to use during computation\n", params.n_processors);
- fprintf(stderr, " -ot N, --offset-t N [%-7d] time offset in milliseconds\n", params.offset_t_ms);
- fprintf(stderr, " -on N, --offset-n N [%-7d] segment index offset\n", params.offset_n);
- fprintf(stderr, " -d N, --duration N [%-7d] duration of audio to process in milliseconds\n", params.duration_ms);
- fprintf(stderr, " -mc N, --max-context N [%-7d] maximum number of text context tokens to store\n", params.max_context);
- fprintf(stderr, " -ml N, --max-len N [%-7d] maximum segment length in characters\n", params.max_len);
- fprintf(stderr, " -sow, --split-on-word [%-7s] split on word rather than on token\n", params.split_on_word ? "true" : "false");
- fprintf(stderr, " -bo N, --best-of N [%-7d] number of best candidates to keep\n", params.best_of);
- fprintf(stderr, " -bs N, --beam-size N [%-7d] beam size for beam search\n", params.beam_size);
- fprintf(stderr, " -ac N, --audio-ctx N [%-7d] audio context size (0 - all)\n", params.audio_ctx);
- fprintf(stderr, " -wt N, --word-thold N [%-7.2f] word timestamp probability threshold\n", params.word_thold);
- fprintf(stderr, " -et N, --entropy-thold N [%-7.2f] entropy threshold for decoder fail\n", params.entropy_thold);
- fprintf(stderr, " -lpt N, --logprob-thold N [%-7.2f] log probability threshold for decoder fail\n", params.logprob_thold);
- fprintf(stderr, " -tp, --temperature N [%-7.2f] The sampling temperature, between 0 and 1\n", params.temperature);
- fprintf(stderr, " -tpi, --temperature-inc N [%-7.2f] The increment of temperature, between 0 and 1\n",params.temperature_inc);
- fprintf(stderr, " -debug, --debug-mode [%-7s] enable debug mode (eg. dump log_mel)\n", params.debug_mode ? "true" : "false");
- fprintf(stderr, " -tr, --translate [%-7s] translate from source language to english\n", params.translate ? "true" : "false");
- fprintf(stderr, " -di, --diarize [%-7s] stereo audio diarization\n", params.diarize ? "true" : "false");
- fprintf(stderr, " -tdrz, --tinydiarize [%-7s] enable tinydiarize (requires a tdrz model)\n", params.tinydiarize ? "true" : "false");
- fprintf(stderr, " -nf, --no-fallback [%-7s] do not use temperature fallback while decoding\n", params.no_fallback ? "true" : "false");
- fprintf(stderr, " -otxt, --output-txt [%-7s] output result in a text file\n", params.output_txt ? "true" : "false");
- fprintf(stderr, " -ovtt, --output-vtt [%-7s] output result in a vtt file\n", params.output_vtt ? "true" : "false");
- fprintf(stderr, " -osrt, --output-srt [%-7s] output result in a srt file\n", params.output_srt ? "true" : "false");
- fprintf(stderr, " -olrc, --output-lrc [%-7s] output result in a lrc file\n", params.output_lrc ? "true" : "false");
- fprintf(stderr, " -owts, --output-words [%-7s] output script for generating karaoke video\n", params.output_wts ? "true" : "false");
- fprintf(stderr, " -fp, --font-path [%-7s] path to a monospace font for karaoke video\n", params.font_path.c_str());
- fprintf(stderr, " -ocsv, --output-csv [%-7s] output result in a CSV file\n", params.output_csv ? "true" : "false");
- fprintf(stderr, " -oj, --output-json [%-7s] output result in a JSON file\n", params.output_jsn ? "true" : "false");
- fprintf(stderr, " -ojf, --output-json-full [%-7s] include more information in the JSON file\n", params.output_jsn_full ? "true" : "false");
- fprintf(stderr, " -of FNAME, --output-file FNAME [%-7s] output file path (without file extension)\n", "");
- fprintf(stderr, " -np, --no-prints [%-7s] do not print anything other than the results\n", params.no_prints ? "true" : "false");
- fprintf(stderr, " -ps, --print-special [%-7s] print special tokens\n", params.print_special ? "true" : "false");
- fprintf(stderr, " -pc, --print-colors [%-7s] print colors\n", params.print_colors ? "true" : "false");
- fprintf(stderr, " -pp, --print-progress [%-7s] print progress\n", params.print_progress ? "true" : "false");
- fprintf(stderr, " -nt, --no-timestamps [%-7s] do not print timestamps\n", params.no_timestamps ? "true" : "false");
- fprintf(stderr, " -l LANG, --language LANG [%-7s] spoken language ('auto' for auto-detect)\n", params.language.c_str());
- fprintf(stderr, " -dl, --detect-language [%-7s] exit after automatically detecting language\n", params.detect_language ? "true" : "false");
- fprintf(stderr, " --prompt PROMPT [%-7s] initial prompt (max n_text_ctx/2 tokens)\n", params.prompt.c_str());
- fprintf(stderr, " -m FNAME, --model FNAME [%-7s] model path\n", params.model.c_str());
- fprintf(stderr, " -f FNAME, --file FNAME [%-7s] input WAV file path\n", "");
- fprintf(stderr, " -oved D, --ov-e-device DNAME [%-7s] the OpenVINO device used for encode inference\n", params.openvino_encode_device.c_str());
- fprintf(stderr, " -dtw MODEL --dtw MODEL [%-7s] compute token-level timestamps\n", params.dtw.c_str());
- fprintf(stderr, " -ls, --log-score [%-7s] log best decoder scores of tokens\n", params.log_score?"true":"false");
- fprintf(stderr, " -ng, --no-gpu [%-7s] disable GPU\n", FLAG_gpu == LLAMAFILE_GPU_DISABLE ? "false" : "true");
- fprintf(stderr, " -fa, --flash-attn [%-7s] flash attention\n", params.flash_attn ? "true" : "false");
- fprintf(stderr, " --suppress-regex REGEX [%-7s] regular expression matching tokens to suppress\n", params.suppress_regex.c_str());
- fprintf(stderr, " --grammar GRAMMAR [%-7s] GBNF grammar to guide decoding\n", params.grammar.c_str());
- fprintf(stderr, " --grammar-rule RULE [%-7s] top-level GBNF grammar rule name\n", params.grammar_rule.c_str());
- fprintf(stderr, " --grammar-penalty N [%-7.1f] scales down logits of nongrammar tokens\n", params.grammar_penalty);
- fprintf(stderr, "\n");
-}
-
-struct whisper_print_user_data {
- const whisper_params * params;
-
- const std::vector<std::vector<float>> * pcmf32s;
- int progress_prev;
-};
-
-static std::string estimate_diarization_speaker(std::vector<std::vector<float>> pcmf32s, int64_t t0, int64_t t1, bool id_only = false) {
- std::string speaker = "";
- const int64_t n_samples = pcmf32s[0].size();
-
- const int64_t is0 = timestamp_to_sample(t0, n_samples, WHISPER_SAMPLE_RATE);
- const int64_t is1 = timestamp_to_sample(t1, n_samples, WHISPER_SAMPLE_RATE);
-
- double energy0 = 0.0f;
- double energy1 = 0.0f;
-
- for (int64_t j = is0; j < is1; j++) {
- energy0 += fabs(pcmf32s[0][j]);
- energy1 += fabs(pcmf32s[1][j]);
- }
-
- if (energy0 > 1.1*energy1) {
- speaker = "0";
- } else if (energy1 > 1.1*energy0) {
- speaker = "1";
- } else {
- speaker = "?";
- }
-
- //printf("is0 = %lld, is1 = %lld, energy0 = %f, energy1 = %f, speaker = %s\n", is0, is1, energy0, energy1, speaker.c_str());
-
- if (!id_only) {
- speaker.insert(0, "(speaker ");
- speaker.append(")");
- }
-
- return speaker;
-}
-
-static void whisper_print_progress_callback(struct whisper_context * /*ctx*/, struct whisper_state * /*state*/, int progress, void * user_data) {
- int progress_step = ((whisper_print_user_data *) user_data)->params->progress_step;
- int * progress_prev = &(((whisper_print_user_data *) user_data)->progress_prev);
- if (progress >= *progress_prev + progress_step) {
- *progress_prev += progress_step;
- fprintf(stderr, "%s: progress = %3d%%\n", __func__, progress);
- }
-}
-
-static void whisper_print_segment_callback(struct whisper_context * ctx, struct whisper_state * /*state*/, int n_new, void * user_data) {
- const auto & params = *((whisper_print_user_data *) user_data)->params;
- const auto & pcmf32s = *((whisper_print_user_data *) user_data)->pcmf32s;
-
- const int n_segments = whisper_full_n_segments(ctx);
-
- std::string speaker = "";
-
- int64_t t0 = 0;
- int64_t t1 = 0;
-
- // print the last n_new segments
- const int s0 = n_segments - n_new;
-
- if (s0 == 0) {
- printf("\n");
- }
-
- for (int i = s0; i < n_segments; i++) {
- if (!params.no_timestamps || params.diarize) {
- t0 = whisper_full_get_segment_t0(ctx, i);
- t1 = whisper_full_get_segment_t1(ctx, i);
- }
-
- if (!params.no_timestamps) {
- printf("[%s --> %s] ", to_timestamp(t0).c_str(), to_timestamp(t1).c_str());
- }
-
- if (params.diarize && pcmf32s.size() == 2) {
- speaker = estimate_diarization_speaker(pcmf32s, t0, t1);
- }
-
- if (params.print_colors) {
- for (int j = 0; j < whisper_full_n_tokens(ctx, i); ++j) {
- if (params.print_special == false) {
- const whisper_token id = whisper_full_get_token_id(ctx, i, j);
- if (id >= whisper_token_eot(ctx)) {
- continue;
- }
- }
-
- const char * text = whisper_full_get_token_text(ctx, i, j);
- const float p = whisper_full_get_token_p (ctx, i, j);
-
- const int col = std::max(0, std::min((int) k_colors.size() - 1, (int) (std::pow(p, 3)*float(k_colors.size()))));
-
- printf("%s%s%s%s", speaker.c_str(), k_colors[col].c_str(), text, "\033[0m");
- }
- } else {
- const char * text = whisper_full_get_segment_text(ctx, i);
-
- printf("%s%s", speaker.c_str(), text);
- }
-
- if (params.tinydiarize) {
- if (whisper_full_get_segment_speaker_turn_next(ctx, i)) {
- printf("%s", params.tdrz_speaker_turn.c_str());
- }
- }
-
- // with timestamps or speakers: each segment on new line
- if (!params.no_timestamps || params.diarize) {
- printf("\n");
- }
-
- fflush(stdout);
- }
-}
-
-static bool output_txt(struct whisper_context * ctx, const char * fname, const whisper_params & params, std::vector<std::vector<float>> pcmf32s) {
- std::ofstream fout(fname);
- if (!fout.is_open()) {
- fprintf(stderr, "%s: failed to open '%s' for writing\n", __func__, fname);
- return false;
- }
-
- fprintf(stderr, "%s: saving output to '%s'\n", __func__, fname);
-
- const int n_segments = whisper_full_n_segments(ctx);
- for (int i = 0; i < n_segments; ++i) {
- const char * text = whisper_full_get_segment_text(ctx, i);
- std::string speaker = "";
-
- if (params.diarize && pcmf32s.size() == 2)
- {
- const int64_t t0 = whisper_full_get_segment_t0(ctx, i);
- const int64_t t1 = whisper_full_get_segment_t1(ctx, i);
- speaker = estimate_diarization_speaker(pcmf32s, t0, t1);
- }
-
- fout << speaker << text << "\n";
- }
-
- return true;
-}
-
-static bool output_vtt(struct whisper_context * ctx, const char * fname, const whisper_params & params, std::vector<std::vector<float>> pcmf32s) {
- std::ofstream fout(fname);
- if (!fout.is_open()) {
- fprintf(stderr, "%s: failed to open '%s' for writing\n", __func__, fname);
- return false;
- }
-
- fprintf(stderr, "%s: saving output to '%s'\n", __func__, fname);
-
- fout << "WEBVTT\n\n";
-
- const int n_segments = whisper_full_n_segments(ctx);
- for (int i = 0; i < n_segments; ++i) {
- const char * text = whisper_full_get_segment_text(ctx, i);
- const int64_t t0 = whisper_full_get_segment_t0(ctx, i);
- const int64_t t1 = whisper_full_get_segment_t1(ctx, i);
- std::string speaker = "";
-
- if (params.diarize && pcmf32s.size() == 2)
- {
- speaker = estimate_diarization_speaker(pcmf32s, t0, t1, true);
- speaker.insert(0, "<v Speaker");
- speaker.append(">");
- }
-
- fout << to_timestamp(t0) << " --> " << to_timestamp(t1) << "\n";
- fout << speaker << text << "\n\n";
- }
-
- return true;
-}
-
-static bool output_srt(struct whisper_context * ctx, const char * fname, const whisper_params & params, std::vector<std::vector<float>> pcmf32s) {
- std::ofstream fout(fname);
- if (!fout.is_open()) {
- fprintf(stderr, "%s: failed to open '%s' for writing\n", __func__, fname);
- return false;
- }
-
- fprintf(stderr, "%s: saving output to '%s'\n", __func__, fname);
-
- const int n_segments = whisper_full_n_segments(ctx);
- for (int i = 0; i < n_segments; ++i) {
- const char * text = whisper_full_get_segment_text(ctx, i);
- const int64_t t0 = whisper_full_get_segment_t0(ctx, i);
- const int64_t t1 = whisper_full_get_segment_t1(ctx, i);
- std::string speaker = "";
-
- if (params.diarize && pcmf32s.size() == 2)
- {
- speaker = estimate_diarization_speaker(pcmf32s, t0, t1);
- }
-
- fout << i + 1 + params.offset_n << "\n";
- fout << to_timestamp(t0, true) << " --> " << to_timestamp(t1, true) << "\n";
- fout << speaker << text << "\n\n";
- }
-
- return true;
-}
-
-static char * escape_double_quotes_and_backslashes(const char * str) {
- if (str == NULL) {
- return NULL;
- }
-
- size_t escaped_length = strlen(str) + 1;
-
- for (size_t i = 0; str[i] != '\0'; i++) {
- if (str[i] == '"' || str[i] == '\\') {
- escaped_length++;
- }
- }
-
- char * escaped = (char *)calloc(escaped_length, 1); // pre-zeroed
- if (escaped == NULL) {
- return NULL;
- }
-
- size_t pos = 0;
- for (size_t i = 0; str[i] != '\0'; i++) {
- if (str[i] == '"' || str[i] == '\\') {
- escaped[pos++] = '\\';
- }
- escaped[pos++] = str[i];
- }
-
- // no need to set zero due to calloc() being used prior
-
- return escaped;
-}
-
-// double quote should be escaped by another double quote. (rfc4180)
-static char * escape_double_quotes_in_csv(const char * str) {
- if (str == NULL) {
- return NULL;
- }
-
- size_t escaped_length = strlen(str) + 1;
-
- for (size_t i = 0; str[i] != '\0'; i++) {
- if (str[i] == '"') {
- escaped_length++;
- }
- }
-
- char *escaped = (char *)calloc(escaped_length, 1); // pre-zeroed
- if (escaped == NULL) {
- return NULL;
- }
-
- size_t pos = 0;
- for (size_t i = 0; str[i] != '\0'; i++) {
- if (str[i] == '"') {
- escaped[pos++] = '"';
- }
- escaped[pos++] = str[i];
- }
-
- // no need to set zero due to calloc() being used prior
-
- return escaped;
-}
-
-static bool output_csv(struct whisper_context * ctx, const char * fname, const whisper_params & params, std::vector<std::vector<float>> pcmf32s) {
- std::ofstream fout(fname);
- if (!fout.is_open()) {
- fprintf(stderr, "%s: failed to open '%s' for writing\n", __func__, fname);
- return false;
- }
-
- fprintf(stderr, "%s: saving output to '%s'\n", __func__, fname);
-
- const int n_segments = whisper_full_n_segments(ctx);
- fout << "start,end,";
- if (params.diarize && pcmf32s.size() == 2)
- {
- fout << "speaker,";
- }
- fout << "text\n";
-
- for (int i = 0; i < n_segments; ++i) {
- const char * text = whisper_full_get_segment_text(ctx, i);
- const int64_t t0 = whisper_full_get_segment_t0(ctx, i);
- const int64_t t1 = whisper_full_get_segment_t1(ctx, i);
- char * text_escaped = escape_double_quotes_in_csv(text);
-
- //need to multiply times returned from whisper_full_get_segment_t{0,1}() by 10 to get milliseconds.
- fout << 10 * t0 << "," << 10 * t1 << ",";
- if (params.diarize && pcmf32s.size() == 2)
- {
- fout << estimate_diarization_speaker(pcmf32s, t0, t1, true) << ",";
- }
- fout << "\"" << text_escaped << "\"\n";
- }
-
- return true;
-}
-
-static bool output_score(struct whisper_context * ctx, const char * fname, const whisper_params & /*params*/, std::vector<std::vector<float>> /*pcmf32s*/) {
- std::ofstream fout(fname);
- fprintf(stderr, "%s: saving output to '%s'\n", __func__, fname);
-
- const int n_segments = whisper_full_n_segments(ctx);
- // fprintf(stderr,"segments: %d\n",n_segments);
- for (int i = 0; i < n_segments; ++i) {
- const int n_tokens = whisper_full_n_tokens(ctx, i);
- // fprintf(stderr,"tokens: %d\n",n_tokens);
- for (int j = 0; j < n_tokens; j++) {
- auto token = whisper_full_get_token_text(ctx, i, j);
- auto probability = whisper_full_get_token_p(ctx, i, j);
- fout << token << '\t' << probability << std::endl;
- // fprintf(stderr,"token: %s %f\n",token,probability);
- }
- }
- return true;
-}
-
-static bool output_json(
- struct whisper_context * ctx,
- const char * fname,
- const whisper_params & params,
- std::vector<std::vector<float>> pcmf32s,
- bool full) {
- std::ofstream fout(fname);
- int indent = 0;
-
- auto doindent = [&]() {
- for (int i = 0; i < indent; i++) fout << "\t";
- };
-
- auto start_arr = [&](const char *name) {
- doindent();
- fout << "\"" << name << "\": [\n";
- indent++;
- };
-
- auto end_arr = [&](bool end) {
- indent--;
- doindent();
- fout << (end ? "]\n" : "],\n");
- };
-
- auto start_obj = [&](const char *name) {
- doindent();
- if (name) {
- fout << "\"" << name << "\": {\n";
- } else {
- fout << "{\n";
- }
- indent++;
- };
-
- auto end_obj = [&](bool end) {
- indent--;
- doindent();
- fout << (end ? "}\n" : "},\n");
- };
-
- auto start_value = [&](const char *name) {
- doindent();
- fout << "\"" << name << "\": ";
- };
-
- auto value_s = [&](const char *name, const char *val, bool end) {
- start_value(name);
- char * val_escaped = escape_double_quotes_and_backslashes(val);
- fout << "\"" << val_escaped << (end ? "\"\n" : "\",\n");
- free(val_escaped);
- };
-
- auto end_value = [&](bool end) {
- fout << (end ? "\n" : ",\n");
- };
-
- auto value_i = [&](const char *name, const int64_t val, bool end) {
- start_value(name);
- fout << val;
- end_value(end);
- };
-
- auto value_f = [&](const char *name, const float val, bool end) {
- start_value(name);
- fout << val;
- end_value(end);
- };
-
- auto value_b = [&](const char *name, const bool val, bool end) {
- start_value(name);
- fout << (val ? "true" : "false");
- end_value(end);
- };
-
- auto times_o = [&](int64_t t0, int64_t t1, bool end) {
- start_obj("timestamps");
- value_s("from", to_timestamp(t0, true).c_str(), false);
- value_s("to", to_timestamp(t1, true).c_str(), true);
- end_obj(false);
- start_obj("offsets");
- value_i("from", t0 * 10, false);
- value_i("to", t1 * 10, true);
- end_obj(end);
- };
-
- if (!fout.is_open()) {
- fprintf(stderr, "%s: failed to open '%s' for writing\n", __func__, fname);
- return false;
- }
-
- fprintf(stderr, "%s: saving output to '%s'\n", __func__, fname);
- start_obj(nullptr);
- value_s("systeminfo", whisper_print_system_info(), false);
- start_obj("model");
- value_s("type", whisper_model_type_readable(ctx), false);
- value_b("multilingual", whisper_is_multilingual(ctx), false);
- value_i("vocab", whisper_model_n_vocab(ctx), false);
- start_obj("audio");
- value_i("ctx", whisper_model_n_audio_ctx(ctx), false);
- value_i("state", whisper_model_n_audio_state(ctx), false);
- value_i("head", whisper_model_n_audio_head(ctx), false);
- value_i("layer", whisper_model_n_audio_layer(ctx), true);
- end_obj(false);
- start_obj("text");
- value_i("ctx", whisper_model_n_text_ctx(ctx), false);
- value_i("state", whisper_model_n_text_state(ctx), false);
- value_i("head", whisper_model_n_text_head(ctx), false);
- value_i("layer", whisper_model_n_text_layer(ctx), true);
- end_obj(false);
- value_i("mels", whisper_model_n_mels(ctx), false);
- value_i("ftype", whisper_model_ftype(ctx), true);
- end_obj(false);
- start_obj("params");
- value_s("model", params.model.c_str(), false);
- value_s("language", params.language.c_str(), false);
- value_b("translate", params.translate, true);
- end_obj(false);
- start_obj("result");
- value_s("language", whisper_lang_str(whisper_full_lang_id(ctx)), true);
- end_obj(false);
- start_arr("transcription");
-
- const int n_segments = whisper_full_n_segments(ctx);
- for (int i = 0; i < n_segments; ++i) {
- const char * text = whisper_full_get_segment_text(ctx, i);
-
- const int64_t t0 = whisper_full_get_segment_t0(ctx, i);
- const int64_t t1 = whisper_full_get_segment_t1(ctx, i);
-
- start_obj(nullptr);
- times_o(t0, t1, false);
- value_s("text", text, !params.diarize && !params.tinydiarize && !full);
-
- if (full) {
- start_arr("tokens");
- const int n = whisper_full_n_tokens(ctx, i);
- for (int j = 0; j < n; ++j) {
- auto token = whisper_full_get_token_data(ctx, i, j);
- start_obj(nullptr);
- value_s("text", whisper_token_to_str(ctx, token.id), false);
- if(token.t0 > -1 && token.t1 > -1) {
- // If we have per-token timestamps, write them out
- times_o(token.t0, token.t1, false);
- }
- value_i("id", token.id, false);
- value_f("p", token.p, false);
- value_f("t_dtw", token.t_dtw, true);
- end_obj(j == (n - 1));
- }
- end_arr(!params.diarize && !params.tinydiarize);
- }
-
- if (params.diarize && pcmf32s.size() == 2) {
- value_s("speaker", estimate_diarization_speaker(pcmf32s, t0, t1, true).c_str(), true);
- }
-
- if (params.tinydiarize) {
- value_b("speaker_turn_next", whisper_full_get_segment_speaker_turn_next(ctx, i), true);
- }
- end_obj(i == (n_segments - 1));
- }
-
- end_arr(true);
- end_obj(true);
- return true;
-}
-
-// karaoke video generation
-// outputs a bash script that uses ffmpeg to generate a video with the subtitles
-// TODO: font parameter adjustments
-static bool output_wts(struct whisper_context * ctx, const char * fname, const char * fname_inp, const whisper_params & params, float t_sec, std::vector<std::vector<float>> pcmf32s) {
- std::ofstream fout(fname);
-
- fprintf(stderr, "%s: saving output to '%s'\n", __func__, fname);
-
- static const char * font = params.font_path.c_str();
-
- std::ifstream fin(font);
- if (!fin.is_open()) {
- fprintf(stderr, "%s: font not found at '%s', please specify a monospace font with -fp\n", __func__, font);
- return false;
- }
-
- fout << "#!/bin/bash" << "\n";
- fout << "\n";
-
- fout << "ffmpeg -i " << fname_inp << " -f lavfi -i color=size=1200x120:duration=" << t_sec << ":rate=25:color=black -vf \"";
-
- for (int i = 0; i < whisper_full_n_segments(ctx); i++) {
- const int64_t t0 = whisper_full_get_segment_t0(ctx, i);
- const int64_t t1 = whisper_full_get_segment_t1(ctx, i);
-
- const int n = whisper_full_n_tokens(ctx, i);
-
- std::vector<whisper_token_data> tokens(n);
- for (int j = 0; j < n; ++j) {
- tokens[j] = whisper_full_get_token_data(ctx, i, j);
- }
-
- if (i > 0) {
- fout << ",";
- }
-
- // background text
- fout << "drawtext=fontfile='" << font << "':fontsize=24:fontcolor=gray:x=(w-text_w)/2:y=h/2:text='':enable='between(t," << t0/100.0 << "," << t0/100.0 << ")'";
-
- bool is_first = true;
- std::string speaker = "";
-
- if (params.diarize && pcmf32s.size() == 2) {
- speaker = estimate_diarization_speaker(pcmf32s, t0, t1);
- }
-
- for (int j = 0; j < n; ++j) {
- const auto & token = tokens[j];
-
- if (tokens[j].id >= whisper_token_eot(ctx)) {
- continue;
- }
-
- std::string txt_bg = "";
- std::string txt_fg = ""; // highlight token
- std::string txt_ul = ""; // underline
-
- if (params.diarize && pcmf32s.size() == 2) {
- txt_bg = speaker;
- txt_fg = speaker;
- txt_ul = "\\ \\ \\ \\ \\ \\ \\ \\ \\ \\ \\ ";
- }
-
- txt_bg.append("> ");
- txt_fg.append("> ");
- txt_ul.append("\\ \\ ");
-
- {
- for (int k = 0; k < n; ++k) {
- const auto & token2 = tokens[k];
-
- if (tokens[k].id >= whisper_token_eot(ctx)) {
- continue;
- }
-
- const std::string txt = whisper_token_to_str(ctx, token2.id);
-
- txt_bg += txt;
-
- if (k == j) {
- for (int l = 0; l < (int) txt.size(); ++l) {
- txt_fg += txt[l];
- txt_ul += "_";
- }
- txt_fg += "|";
- } else {
- for (int l = 0; l < (int) txt.size(); ++l) {
- txt_fg += "\\ ";
- txt_ul += "\\ ";
- }
- }
- }
-
- txt_bg = replace_all(txt_bg, "'", "\u2019");
- txt_bg = replace_all(txt_bg, "\"", "\\\"");
- txt_fg = replace_all(txt_fg, "'", "\u2019");
- txt_fg = replace_all(txt_fg, "\"", "\\\"");
- }
-
- if (is_first) {
- // background text
- fout << ",drawtext=fontfile='" << font << "':fontsize=24:fontcolor=gray:x=(w-text_w)/2:y=h/2:text='" << txt_bg << "':enable='between(t," << t0/100.0 << "," << t1/100.0 << ")'";
- is_first = false;
- }
-
- // foreground text
- fout << ",drawtext=fontfile='" << font << "':fontsize=24:fontcolor=lightgreen:x=(w-text_w)/2+8:y=h/2:text='" << txt_fg << "':enable='between(t," << token.t0/100.0 << "," << token.t1/100.0 << ")'";
-
- // underline
- fout << ",drawtext=fontfile='" << font << "':fontsize=24:fontcolor=lightgreen:x=(w-text_w)/2+8:y=h/2+16:text='" << txt_ul << "':enable='between(t," << token.t0/100.0 << "," << token.t1/100.0 << ")'";
- }
- }
-
- fout << "\" -c:v libx264 -pix_fmt yuv420p -y " << fname_inp << ".mp4" << "\n";
-
- fout << "\n\n";
- fout << "echo \"Your video has been saved to " << fname_inp << ".mp4\"" << "\n";
- fout << "\n";
- fout << "echo \" ffplay " << fname_inp << ".mp4\"\n";
- fout << "\n";
-
- fout.close();
-
- fprintf(stderr, "%s: run 'source %s' to generate karaoke video\n", __func__, fname);
-
- return true;
-}
-
-static bool output_lrc(struct whisper_context * ctx, const char * fname, const whisper_params & params, std::vector<std::vector<float>> pcmf32s) {
- std::ofstream fout(fname);
- if (!fout.is_open()) {
- fprintf(stderr, "%s: failed to open '%s' for writing\n", __func__, fname);
- return false;
- }
-
- fprintf(stderr, "%s: saving output to '%s'\n", __func__, fname);
-
- fout << "[by:whisper.cpp]\n";
-
- const int n_segments = whisper_full_n_segments(ctx);
- for (int i = 0; i < n_segments; ++i) {
- const char * text = whisper_full_get_segment_text(ctx, i);
- const int64_t t = whisper_full_get_segment_t0(ctx, i);
-
- int64_t msec = t * 10;
- int64_t min = msec / (1000 * 60);
- msec = msec - min * (1000 * 60);
- int64_t sec = msec / 1000;
- msec = msec - sec * 1000;
-
- char buf[16];
- snprintf(buf, sizeof(buf), "%02d:%02d.%02d", (int) min, (int) sec, (int) ( msec / 10));
- std::string timestamp_lrc = std::string(buf);
- std::string speaker = "";
-
- if (params.diarize && pcmf32s.size() == 2)
- {
- const int64_t t0 = whisper_full_get_segment_t0(ctx, i);
- const int64_t t1 = whisper_full_get_segment_t1(ctx, i);
- speaker = estimate_diarization_speaker(pcmf32s, t0, t1);
- }
-
- fout << '[' << timestamp_lrc << ']' << speaker << text << "\n";
- }
-
- return true;
-}
-
-
-static void cb_log_disable(enum ggml_log_level , const char * , void * ) { }
-
-int whisper_server_main(int argc, char ** argv);
-
-int main(int argc, char ** argv) {
-
- mallopt(M_GRANULARITY, 1 * 1024 * 1024);
- mallopt(M_MMAP_THRESHOLD, 1 * 1024 * 1024);
- mallopt(M_TRIM_THRESHOLD, 32 * 1024 * 1024);
- FLAG_gpu = LLAMAFILE_GPU_DISABLE; // pass `--gpu auto` to enable it
- llamafile_check_cpu();
- ShowCrashReports();
-
- if (llamafile_has(argv, "--version")) {
- puts("whisperfile v" LLAMAFILE_VERSION_STRING);
- return 0;
- }
-
- if (llamafile_has(argv, "-h") ||
- llamafile_has(argv, "-help") ||
- llamafile_has(argv, "--help")) {
- llamafile_help("/zip/whisper.cpp/main.1.asc");
- __builtin_unreachable();
- }
-
- argc = cosmo_args("/zip/.args", &argv);
-
- if (!llamafile_has(argv, "--cli") &&
- (llamafile_has(argv, "--server") ||
- !llamafile_has(argv, "-f"))) {
- return whisper_server_main(argc, argv);
- }
-
- // If the only argument starts with "@", read arguments line-by-line
- // from the given file.
- std::vector<std::string> vec_args;
- if (argc == 2 && argv != nullptr && argv[1] != nullptr && argv[1][0] == '@') {
- // Save the name of the executable.
- vec_args.push_back(argv[0]);
-
- // Open the response file.
- char const * rspfile = argv[1] + sizeof(char);
- std::ifstream fin(rspfile);
- if (fin.is_open() == false) {
- fprintf(stderr, "error: response file '%s' not found\n", rspfile);
- return 1;
- }
-
- // Read the entire response file.
- std::string line;
- while (std::getline(fin, line)) {
- vec_args.push_back(line);
- }
-
- // Use the contents of the response file as the command-line arguments.
- argc = static_cast<int>(vec_args.size());
- argv = static_cast<char **>(alloca(argc * sizeof (char *)));
- for (int i = 0; i < argc; ++i) {
- argv[i] = const_cast<char *>(vec_args[i].c_str());
- }
- }
-
- whisper_params params;
- if (whisper_params_parse(argc, argv, params) == false) {
- whisper_print_usage(argc, argv, params);
- return 1;
- }
-
- // remove non-existent files
- for (auto it = params.fname_inp.begin(); it != params.fname_inp.end();) {
- const auto fname_inp = it->c_str();
-
- if (*it != "-" && !is_file_exist(fname_inp)) {
- fprintf(stderr, "error: input file not found '%s'\n", fname_inp);
- it = params.fname_inp.erase(it);
- continue;
- }
-
- it++;
- }
-
- if (params.fname_inp.empty()) {
- fprintf(stderr, "error: no input files specified\n");
- whisper_print_usage(argc, argv, params);
- return 2;
- }
-
- if (params.language != "auto" && whisper_lang_id(params.language.c_str()) == -1) {
- fprintf(stderr, "error: unknown language '%s'\n", params.language.c_str());
- whisper_print_usage(argc, argv, params);
- exit(0);
- }
-
- if (params.diarize && params.tinydiarize) {
- fprintf(stderr, "error: cannot use both --diarize and --tinydiarize\n");
- whisper_print_usage(argc, argv, params);
- exit(0);
- }
-
- if (params.no_prints) {
- whisper_log_set(cb_log_disable, NULL);
- }
-
- // whisper init
-
- struct whisper_context_params cparams = whisper_context_default_params();
-
- cparams.flash_attn = params.flash_attn;
-
- if (!params.dtw.empty()) {
- cparams.dtw_token_timestamps = true;
- cparams.dtw_aheads_preset = WHISPER_AHEADS_NONE;
-
- if (params.dtw == "tiny") cparams.dtw_aheads_preset = WHISPER_AHEADS_TINY;
- if (params.dtw == "tiny.en") cparams.dtw_aheads_preset = WHISPER_AHEADS_TINY_EN;
- if (params.dtw == "base") cparams.dtw_aheads_preset = WHISPER_AHEADS_BASE;
- if (params.dtw == "base.en") cparams.dtw_aheads_preset = WHISPER_AHEADS_BASE_EN;
- if (params.dtw == "small") cparams.dtw_aheads_preset = WHISPER_AHEADS_SMALL;
- if (params.dtw == "small.en") cparams.dtw_aheads_preset = WHISPER_AHEADS_SMALL_EN;
- if (params.dtw == "medium") cparams.dtw_aheads_preset = WHISPER_AHEADS_MEDIUM;
- if (params.dtw == "medium.en") cparams.dtw_aheads_preset = WHISPER_AHEADS_MEDIUM_EN;
- if (params.dtw == "large.v1") cparams.dtw_aheads_preset = WHISPER_AHEADS_LARGE_V1;
- if (params.dtw == "large.v2") cparams.dtw_aheads_preset = WHISPER_AHEADS_LARGE_V2;
- if (params.dtw == "large.v3") cparams.dtw_aheads_preset = WHISPER_AHEADS_LARGE_V3;
-
- if (cparams.dtw_aheads_preset == WHISPER_AHEADS_NONE) {
- fprintf(stderr, "error: unknown DTW preset '%s'\n", params.dtw.c_str());
- return 3;
- }
- }
-
- struct whisper_context * ctx = whisper_init_from_file_with_params(params.model.c_str(), cparams);
-
- if (ctx == nullptr) {
- fprintf(stderr, "error: failed to initialize whisper context\n");
- return 3;
- }
-
- // initialize openvino encoder. this has no effect on whisper.cpp builds that don't have OpenVINO configured
- whisper_ctx_init_openvino_encoder(ctx, nullptr, params.openvino_encode_device.c_str(), nullptr);
-
- if (!params.grammar.empty()) {
- auto & grammar = params.grammar_parsed;
- if (is_file_exist(params.grammar.c_str())) {
- // read grammar from file
- std::ifstream ifs(params.grammar.c_str());
- const std::string txt = std::string((std::istreambuf_iterator<char>(ifs)), std::istreambuf_iterator<char>());
- grammar = whisper_grammar_parser::parse(txt.c_str());
- } else {
- // read grammar from string
- grammar = whisper_grammar_parser::parse(params.grammar.c_str());
- }
-
- // will be empty (default) if there are parse errors
- if (grammar.rules.empty()) {
- fprintf(stderr, "error: failed to parse grammar \"%s\"\n", params.grammar.c_str());
- return 4;
- } else {
- fprintf(stderr, "%s: grammar:\n", __func__);
- whisper_grammar_parser::print_grammar(stderr, grammar);
- fprintf(stderr, "\n");
- }
- }
-
- for (int f = 0; f < (int) params.fname_inp.size(); ++f) {
- const auto fname_inp = params.fname_inp[f];
- const auto fname_out = f < (int) params.fname_out.size() && !params.fname_out[f].empty() ? params.fname_out[f] : params.fname_inp[f];
-
- std::vector<float> pcmf32; // mono-channel F32 PCM
- std::vector<std::vector<float>> pcmf32s; // stereo-channel F32 PCM
-
- if (!slurp_audio_file(fname_inp.c_str(), pcmf32, pcmf32s, params.diarize)) {
- fprintf(stderr, "error: failed to read audio file '%s'\n", fname_inp.c_str());
- continue;
- }
-
- if (!whisper_is_multilingual(ctx)) {
- if (params.language != "en" || params.translate) {
- params.language = "en";
- params.translate = false;
- fprintf(stderr, "%s: WARNING: model is not multilingual, ignoring language and translation options\n", __func__);
- }
- }
- if (params.detect_language) {
- params.language = "auto";
- }
-
- if (!params.no_prints) {
- // print system information
- fprintf(stderr, "\n");
- fprintf(stderr, "system_info: n_threads = %d / %d | %s\n",
- params.n_threads*params.n_processors, std::thread::hardware_concurrency(), whisper_print_system_info());
-
- // print some info about the processing
- fprintf(stderr, "\n");
- fprintf(stderr, "%s: processing '%s' (%d samples, %.1f sec), %d threads, %d processors, %d beams + best of %d, lang = %s, task = %s, %stimestamps = %d ...\n",
- __func__, fname_inp.c_str(), int(pcmf32.size()), float(pcmf32.size())/WHISPER_SAMPLE_RATE,
- params.n_threads, params.n_processors, params.beam_size, params.best_of,
- params.language.c_str(),
- params.translate ? "translate" : "transcribe",
- params.tinydiarize ? "tdrz = 1, " : "",
- params.no_timestamps ? 0 : 1);
-
- fprintf(stderr, "\n");
- }
-
- // run the inference
- {
- whisper_full_params wparams = whisper_full_default_params(WHISPER_SAMPLING_GREEDY);
-
- const bool use_grammar = (!params.grammar_parsed.rules.empty() && !params.grammar_rule.empty());
- wparams.strategy = (params.beam_size > 1 || use_grammar) ? WHISPER_SAMPLING_BEAM_SEARCH : WHISPER_SAMPLING_GREEDY;
-
- wparams.print_realtime = false;
- wparams.print_progress = params.print_progress;
- wparams.print_timestamps = !params.no_timestamps;
- wparams.print_special = params.print_special;
- wparams.translate = params.translate;
- wparams.language = params.language.c_str();
- wparams.detect_language = params.detect_language;
- wparams.n_threads = params.n_threads;
- wparams.n_max_text_ctx = params.max_context >= 0 ? params.max_context : wparams.n_max_text_ctx;
- wparams.offset_ms = params.offset_t_ms;
- wparams.duration_ms = params.duration_ms;
-
- wparams.token_timestamps = params.output_wts || params.output_jsn_full || params.max_len > 0;
- wparams.thold_pt = params.word_thold;
- wparams.max_len = params.output_wts && params.max_len == 0 ? 60 : params.max_len;
- wparams.split_on_word = params.split_on_word;
- wparams.audio_ctx = params.audio_ctx;
-
- wparams.debug_mode = params.debug_mode;
-
- wparams.tdrz_enable = params.tinydiarize; // [TDRZ]
-
- wparams.suppress_regex = params.suppress_regex.empty() ? nullptr : params.suppress_regex.c_str();
-
- wparams.initial_prompt = params.prompt.c_str();
-
- wparams.greedy.best_of = params.best_of;
- wparams.beam_search.beam_size = params.beam_size;
-
- wparams.temperature_inc = params.no_fallback ? 0.0f : params.temperature_inc;
- wparams.temperature = params.temperature;
-
- wparams.entropy_thold = params.entropy_thold;
- wparams.logprob_thold = params.logprob_thold;
-
- wparams.no_timestamps = params.no_timestamps;
-
- whisper_print_user_data user_data = { &params, &pcmf32s, 0 };
-
- const auto & grammar_parsed = params.grammar_parsed;
- auto grammar_rules = grammar_parsed.c_rules();
-
- if (use_grammar) {
- if (grammar_parsed.symbol_ids.find(params.grammar_rule) == grammar_parsed.symbol_ids.end()) {
- fprintf(stderr, "%s: warning: grammar rule '%s' not found - skipping grammar sampling\n", __func__, params.grammar_rule.c_str());
- } else {
- wparams.grammar_rules = grammar_rules.data();
- wparams.n_grammar_rules = grammar_rules.size();
- wparams.i_start_rule = grammar_parsed.symbol_ids.at(params.grammar_rule);
- wparams.grammar_penalty = params.grammar_penalty;
- }
- }
-
- // this callback is called on each new segment
- if (!wparams.print_realtime) {
- wparams.new_segment_callback = whisper_print_segment_callback;
- wparams.new_segment_callback_user_data = &user_data;
- }
-
- if (wparams.print_progress) {
- wparams.progress_callback = whisper_print_progress_callback;
- wparams.progress_callback_user_data = &user_data;
- }
-
- // examples for abort mechanism
- // in examples below, we do not abort the processing, but we could if the flag is set to true
-
- // the callback is called before every encoder run - if it returns false, the processing is aborted
- {
- static bool is_aborted = false; // NOTE: this should be atomic to avoid data race
-
- wparams.encoder_begin_callback = [](struct whisper_context * /*ctx*/, struct whisper_state * /*state*/, void * user_data) {
- bool is_aborted = *(bool*)user_data;
- return !is_aborted;
- };
- wparams.encoder_begin_callback_user_data = &is_aborted;
- }
-
- // the callback is called before every computation - if it returns true, the computation is aborted
- {
- static bool is_aborted = false; // NOTE: this should be atomic to avoid data race
-
- wparams.abort_callback = [](void * user_data) {
- bool is_aborted = *(bool*)user_data;
- return is_aborted;
- };
- wparams.abort_callback_user_data = &is_aborted;
- }
-
- if (whisper_full_parallel(ctx, wparams, pcmf32.data(), pcmf32.size(), params.n_processors) != 0) {
- fprintf(stderr, "%s: failed to process audio\n", argv[0]);
- return 10;
- }
- }
-
- // output stuff
- {
- printf("\n");
-
- // output to text file
- if (params.output_txt) {
- const auto fname_txt = fname_out + ".txt";
- output_txt(ctx, fname_txt.c_str(), params, pcmf32s);
- }
-
- // output to VTT file
- if (params.output_vtt) {
- const auto fname_vtt = fname_out + ".vtt";
- output_vtt(ctx, fname_vtt.c_str(), params, pcmf32s);
- }
-
- // output to SRT file
- if (params.output_srt) {
- const auto fname_srt = fname_out + ".srt";
- output_srt(ctx, fname_srt.c_str(), params, pcmf32s);
- }
-
- // output to WTS file
- if (params.output_wts) {
- const auto fname_wts = fname_out + ".wts";
- output_wts(ctx, fname_wts.c_str(), fname_inp.c_str(), params, float(pcmf32.size() + 1000)/WHISPER_SAMPLE_RATE, pcmf32s);
- }
-
- // output to CSV file
- if (params.output_csv) {
- const auto fname_csv = fname_out + ".csv";
- output_csv(ctx, fname_csv.c_str(), params, pcmf32s);
- }
-
- // output to JSON file
- if (params.output_jsn) {
- const auto fname_jsn = fname_out + ".json";
- output_json(ctx, fname_jsn.c_str(), params, pcmf32s, params.output_jsn_full);
- }
-
- // output to LRC file
- if (params.output_lrc) {
- const auto fname_lrc = fname_out + ".lrc";
- output_lrc(ctx, fname_lrc.c_str(), params, pcmf32s);
- }
-
- // output to score file
- if (params.log_score) {
- const auto fname_score = fname_out + ".score.txt";
- output_score(ctx, fname_score.c_str(), params, pcmf32s);
- }
- }
- }
-
- if (!params.no_prints) {
- whisper_print_timings(ctx);
- }
- whisper_free(ctx);
-
- return 0;
-}
diff --git a/whisper.cpp/server.cpp b/whisper.cpp/server.cpp
deleted file mode 100644
index a4f28dc1..00000000
--- a/whisper.cpp/server.cpp
+++ /dev/null
@@ -1,1039 +0,0 @@
-// -*- mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8 -*-
-// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
-#include "llamafile/debug.h"
-#include "common.h"
-#include "slurp.h"
-
-#include "whisper.h"
-#include "httplib.h"
-#include "llama.cpp/json.h"
-
-#include <cosmo.h>
-#include <cmath>
-#include <fstream>
-#include <cstdio>
-#include <string>
-#include <thread>
-#include <vector>
-#include <cstring>
-#include <sstream>
-#include <chrono>
-
-#if defined(_MSC_VER)
-#pragma warning(disable: 4244 4267) // possible loss of data
-#endif
-
-using namespace httplib;
-using json = nlohmann::ordered_json;
-
-namespace {
-
-// output formats
-const std::string json_format = "json";
-const std::string text_format = "text";
-const std::string srt_format = "srt";
-const std::string vjson_format = "verbose_json";
-const std::string vtt_format = "vtt";
-
-struct server_params
-{
- std::string hostname = "127.0.0.1";
- std::string public_path = "examples/server/public";
- std::string request_path = "";
- std::string inference_path = "/inference";
-
- int32_t port = 8080;
- int32_t read_timeout = 600;
- int32_t write_timeout = 600;
-};
-
-struct whisper_params {
- int32_t n_threads = std::min(4, (int32_t) std::thread::hardware_concurrency());
- int32_t n_processors = 1;
- int32_t offset_t_ms = 0;
- int32_t offset_n = 0;
- int32_t duration_ms = 0;
- int32_t progress_step = 5;
- int32_t max_context = -1;
- int32_t max_len = 0;
- int32_t best_of = 2;
- int32_t beam_size = -1;
- int32_t audio_ctx = 0;
-
- float word_thold = 0.01f;
- float entropy_thold = 2.40f;
- float logprob_thold = -1.00f;
- float temperature = 0.00f;
- float temperature_inc = 0.20f;
-
- bool debug_mode = false;
- bool translate = false;
- bool detect_language = false;
- bool diarize = false;
- bool tinydiarize = false;
- bool split_on_word = false;
- bool no_fallback = false;
- bool print_special = false;
- bool print_colors = false;
- bool print_realtime = false;
- bool print_progress = false;
- bool no_timestamps = false;
- bool flash_attn = false;
-
- std::string language = "en";
- std::string prompt = "";
- std::string font_path = "/System/Library/Fonts/Supplemental/Courier New Bold.ttf";
- std::string model = "models/ggml-base.en.bin";
-
- std::string response_format = json_format;
-
- // [TDRZ] speaker turn string
- std::string tdrz_speaker_turn = " [SPEAKER_TURN]"; // TODO: set from command line
-
- std::string openvino_encode_device = "CPU";
-
- std::string dtw = "";
-};
-
-void whisper_print_usage(int /*argc*/, char ** argv, const whisper_params & params, const server_params& sparams) {
- fprintf(stderr, "\n");
- fprintf(stderr, "usage: %s [options] \n", argv[0]);
- fprintf(stderr, "\n");
- fprintf(stderr, "options:\n");
- fprintf(stderr, " -h, --help [default] show this help message and exit\n");
- fprintf(stderr, " -t N, --threads N [%-7d] number of threads to use during computation\n", params.n_threads);
- fprintf(stderr, " -p N, --processors N [%-7d] number of processors to use during computation\n", params.n_processors);
- fprintf(stderr, " -ot N, --offset-t N [%-7d] time offset in milliseconds\n", params.offset_t_ms);
- fprintf(stderr, " -on N, --offset-n N [%-7d] segment index offset\n", params.offset_n);
- fprintf(stderr, " -d N, --duration N [%-7d] duration of audio to process in milliseconds\n", params.duration_ms);
- fprintf(stderr, " -mc N, --max-context N [%-7d] maximum number of text context tokens to store\n", params.max_context);
- fprintf(stderr, " -ml N, --max-len N [%-7d] maximum segment length in characters\n", params.max_len);
- fprintf(stderr, " -sow, --split-on-word [%-7s] split on word rather than on token\n", params.split_on_word ? "true" : "false");
- fprintf(stderr, " -bo N, --best-of N [%-7d] number of best candidates to keep\n", params.best_of);
- fprintf(stderr, " -bs N, --beam-size N [%-7d] beam size for beam search\n", params.beam_size);
- fprintf(stderr, " -ac N, --audio-ctx N [%-7d] audio context size (0 - all)\n", params.audio_ctx);
- fprintf(stderr, " -wt N, --word-thold N [%-7.2f] word timestamp probability threshold\n", params.word_thold);
- fprintf(stderr, " -et N, --entropy-thold N [%-7.2f] entropy threshold for decoder fail\n", params.entropy_thold);
- fprintf(stderr, " -lpt N, --logprob-thold N [%-7.2f] log probability threshold for decoder fail\n", params.logprob_thold);
- fprintf(stderr, " -debug, --debug-mode [%-7s] enable debug mode (eg. dump log_mel)\n", params.debug_mode ? "true" : "false");
- fprintf(stderr, " -tr, --translate [%-7s] translate from source language to english\n", params.translate ? "true" : "false");
- fprintf(stderr, " -di, --diarize [%-7s] stereo audio diarization\n", params.diarize ? "true" : "false");
- fprintf(stderr, " -tdrz, --tinydiarize [%-7s] enable tinydiarize (requires a tdrz model)\n", params.tinydiarize ? "true" : "false");
- fprintf(stderr, " -nf, --no-fallback [%-7s] do not use temperature fallback while decoding\n", params.no_fallback ? "true" : "false");
- fprintf(stderr, " -ps, --print-special [%-7s] print special tokens\n", params.print_special ? "true" : "false");
- fprintf(stderr, " -pc, --print-colors [%-7s] print colors\n", params.print_colors ? "true" : "false");
- fprintf(stderr, " -pr, --print-realtime [%-7s] print output in realtime\n", params.print_realtime ? "true" : "false");
- fprintf(stderr, " -pp, --print-progress [%-7s] print progress\n", params.print_progress ? "true" : "false");
- fprintf(stderr, " -nt, --no-timestamps [%-7s] do not print timestamps\n", params.no_timestamps ? "true" : "false");
- fprintf(stderr, " -l LANG, --language LANG [%-7s] spoken language ('auto' for auto-detect)\n", params.language.c_str());
- fprintf(stderr, " -dl, --detect-language [%-7s] exit after automatically detecting language\n", params.detect_language ? "true" : "false");
- fprintf(stderr, " --prompt PROMPT [%-7s] initial prompt\n", params.prompt.c_str());
- fprintf(stderr, " -m FNAME, --model FNAME [%-7s] model path\n", params.model.c_str());
- fprintf(stderr, " -oved D, --ov-e-device DNAME [%-7s] the OpenVINO device used for encode inference\n", params.openvino_encode_device.c_str());
- // server params
- fprintf(stderr, " -dtw MODEL --dtw MODEL [%-7s] compute token-level timestamps\n", params.dtw.c_str());
- fprintf(stderr, " --host HOST, [%-7s] Hostname/ip-adress for the server\n", sparams.hostname.c_str());
- fprintf(stderr, " --port PORT, [%-7d] Port number for the server\n", sparams.port);
- fprintf(stderr, " --public PATH, [%-7s] Path to the public folder\n", sparams.public_path.c_str());
- fprintf(stderr, " --request-path PATH, [%-7s] Request path for all requests\n", sparams.request_path.c_str());
- fprintf(stderr, " --inference-path PATH, [%-7s] Inference path for all requests\n", sparams.inference_path.c_str());
- fprintf(stderr, " --recompile [%-7s] Force GPU support to be recompiled at runtime if possible.\n", FLAG_recompile ? "true" : "false");
- fprintf(stderr, " --nocompile [%-7s] Never compile GPU support at runtime.", FLAG_nocompile ? "true" : "false");
- fprintf(stderr, "\n");
-}
-
-bool whisper_params_parse(int argc, char ** argv, whisper_params & params, server_params & sparams) {
- for (int i = 1; i < argc; i++) {
- std::string arg = argv[i];
-
- if (arg == "--log-disable") {
- FLAG_log_disable = true;
- } else if (arg == "--cli") {
- } else if (arg == "--server") {
- } else if (arg == "--fast") {
- FLAG_fast = true;
- } else if (arg == "--precise") {
- FLAG_precise = true;
- } else if (arg == "--trace") {
- FLAG_trace = true;
- } else if (arg == "--trap") {
- FLAG_trap = true;
- FLAG_unsecure = true; // for better backtraces
- llamafile_trapping_enabled(+1);
- } else if (arg == "--unsecure") {
- FLAG_unsecure = true;
- } else if (arg == "--nocompile") {
- FLAG_nocompile = true;
- } else if (arg == "--recompile") {
- FLAG_recompile = true;
- } else if (arg == "--tinyblas") {
- FLAG_tinyblas = true; // undocumented
- } else if (arg == "--gpu") {
- if (++i >= argc) {
- fprintf(stderr, "error: missing --gpu flag value\n");
- exit(1);
- }
- FLAG_gpu = llamafile_gpu_parse(argv[i]);
- if (FLAG_gpu == LLAMAFILE_GPU_ERROR) {
- fprintf(stderr, "error: invalid --gpu flag value: %s\n", argv[i]);
- exit(1);
- }
- } else
-
- if (arg == "-h" || arg == "--help") {
- whisper_print_usage(argc, argv, params, sparams);
- exit(0);
- }
- else if (arg == "-t" || arg == "--threads") { params.n_threads = std::stoi(argv[++i]); }
- else if (arg == "-p" || arg == "--processors") { params.n_processors = std::stoi(argv[++i]); }
- else if (arg == "-ot" || arg == "--offset-t") { params.offset_t_ms = std::stoi(argv[++i]); }
- else if (arg == "-on" || arg == "--offset-n") { params.offset_n = std::stoi(argv[++i]); }
- else if (arg == "-d" || arg == "--duration") { params.duration_ms = std::stoi(argv[++i]); }
- else if (arg == "-mc" || arg == "--max-context") { params.max_context = std::stoi(argv[++i]); }
- else if (arg == "-ml" || arg == "--max-len") { params.max_len = std::stoi(argv[++i]); }
- else if (arg == "-bo" || arg == "--best-of") { params.best_of = std::stoi(argv[++i]); }
- else if (arg == "-bs" || arg == "--beam-size") { params.beam_size = std::stoi(argv[++i]); }
- else if (arg == "-ac" || arg == "--audio-ctx") { params.audio_ctx = std::stoi(argv[++i]); }
- else if (arg == "-wt" || arg == "--word-thold") { params.word_thold = std::stof(argv[++i]); }
- else if (arg == "-et" || arg == "--entropy-thold") { params.entropy_thold = std::stof(argv[++i]); }
- else if (arg == "-lpt" || arg == "--logprob-thold") { params.logprob_thold = std::stof(argv[++i]); }
- else if (arg == "-debug"|| arg == "--debug-mode") { params.debug_mode = true; }
- else if (arg == "-tr" || arg == "--translate") { params.translate = true; }
- else if (arg == "-di" || arg == "--diarize") { params.diarize = true; }
- else if (arg == "-tdrz" || arg == "--tinydiarize") { params.tinydiarize = true; }
- else if (arg == "-sow" || arg == "--split-on-word") { params.split_on_word = true; }
- else if (arg == "-nf" || arg == "--no-fallback") { params.no_fallback = true; }
- else if (arg == "-fp" || arg == "--font-path") { params.font_path = argv[++i]; }
- else if (arg == "-ps" || arg == "--print-special") { params.print_special = true; }
- else if (arg == "-pc" || arg == "--print-colors") { params.print_colors = true; }
- else if (arg == "-pr" || arg == "--print-realtime") { params.print_realtime = true; }
- else if (arg == "-pp" || arg == "--print-progress") { params.print_progress = true; }
- else if (arg == "-nt" || arg == "--no-timestamps") { params.no_timestamps = true; }
- else if (arg == "-l" || arg == "--language") { params.language = argv[++i]; }
- else if (arg == "-dl" || arg == "--detect-language") { params.detect_language = true; }
- else if ( arg == "--prompt") { params.prompt = argv[++i]; }
- else if (arg == "-m" || arg == "--model") { params.model = argv[++i]; }
- else if (arg == "-oved" || arg == "--ov-e-device") { params.openvino_encode_device = argv[++i]; }
- else if (arg == "-dtw" || arg == "--dtw") { params.dtw = argv[++i]; }
- else if (arg == "-ng" || arg == "--no-gpu") { FLAG_gpu = LLAMAFILE_GPU_DISABLE; }
- else if (arg == "-fa" || arg == "--flash-attn") { params.flash_attn = true; }
- // server params
- else if ( arg == "--port") { sparams.port = std::stoi(argv[++i]); }
- else if ( arg == "--host") { sparams.hostname = argv[++i]; }
- else if ( arg == "--public") { sparams.public_path = argv[++i]; }
- else if ( arg == "--request-path") { sparams.request_path = argv[++i]; }
- else if ( arg == "--recompile") { FLAG_recompile = true; }
- else if ( arg == "--nocompile") { FLAG_nocompile = true; }
- else if ( arg == "--tinyblas") { FLAG_tinyblas = true; }
- else if ( arg == "--unsecure") { FLAG_unsecure = true; }
-
- else if (arg == "--gpu") {
- if (++i >= argc) {
- fprintf(stderr, "error: missing --gpu flag value\n");
- exit(1);
- }
- FLAG_gpu = llamafile_gpu_parse(argv[i]);
- if (FLAG_gpu == LLAMAFILE_GPU_ERROR) {
- fprintf(stderr, "error: invalid --gpu flag value: %s\n", argv[i]);
- exit(1);
- }
- return true;
- }
-
- else {
- fprintf(stderr, "error: unknown argument: %s\n", arg.c_str());
- // whisper_print_usage(argc, argv, params, sparams); // [jart]
- exit(0);
- }
- }
-
- FLAGS_READY = true;
-
- return true;
-}
-
-struct whisper_print_user_data {
- const whisper_params * params;
-
- const std::vector<std::vector<float>> * pcmf32s;
- int progress_prev;
-};
-
-std::string estimate_diarization_speaker(std::vector<std::vector<float>> pcmf32s, int64_t t0, int64_t t1, bool id_only = false) {
- std::string speaker = "";
- const int64_t n_samples = pcmf32s[0].size();
-
- const int64_t is0 = timestamp_to_sample(t0, n_samples, WHISPER_SAMPLE_RATE);
- const int64_t is1 = timestamp_to_sample(t1, n_samples, WHISPER_SAMPLE_RATE);
-
- double energy0 = 0.0f;
- double energy1 = 0.0f;
-
- for (int64_t j = is0; j < is1; j++) {
- energy0 += fabs(pcmf32s[0][j]);
- energy1 += fabs(pcmf32s[1][j]);
- }
-
- if (energy0 > 1.1*energy1) {
- speaker = "0";
- } else if (energy1 > 1.1*energy0) {
- speaker = "1";
- } else {
- speaker = "?";
- }
-
- //printf("is0 = %lld, is1 = %lld, energy0 = %f, energy1 = %f, speaker = %s\n", is0, is1, energy0, energy1, speaker.c_str());
-
- if (!id_only) {
- speaker.insert(0, "(speaker ");
- speaker.append(")");
- }
-
- return speaker;
-}
-
-void whisper_print_progress_callback(struct whisper_context * /*ctx*/, struct whisper_state * /*state*/, int progress, void * user_data) {
- int progress_step = ((whisper_print_user_data *) user_data)->params->progress_step;
- int * progress_prev = &(((whisper_print_user_data *) user_data)->progress_prev);
- if (progress >= *progress_prev + progress_step) {
- *progress_prev += progress_step;
- fprintf(stderr, "%s: progress = %3d%%\n", __func__, progress);
- }
-}
-
-void whisper_print_segment_callback(struct whisper_context * ctx, struct whisper_state * /*state*/, int n_new, void * user_data) {
- const auto & params = *((whisper_print_user_data *) user_data)->params;
- const auto & pcmf32s = *((whisper_print_user_data *) user_data)->pcmf32s;
-
- const int n_segments = whisper_full_n_segments(ctx);
-
- std::string speaker = "";
-
- int64_t t0 = 0;
- int64_t t1 = 0;
-
- // print the last n_new segments
- const int s0 = n_segments - n_new;
-
- if (s0 == 0) {
- printf("\n");
- }
-
- for (int i = s0; i < n_segments; i++) {
- if (!params.no_timestamps || params.diarize) {
- t0 = whisper_full_get_segment_t0(ctx, i);
- t1 = whisper_full_get_segment_t1(ctx, i);
- }
-
- if (!params.no_timestamps) {
- printf("[%s --> %s] ", to_timestamp(t0).c_str(), to_timestamp(t1).c_str());
- }
-
- if (params.diarize && pcmf32s.size() == 2) {
- speaker = estimate_diarization_speaker(pcmf32s, t0, t1);
- }
-
- if (params.print_colors) {
- for (int j = 0; j < whisper_full_n_tokens(ctx, i); ++j) {
- if (params.print_special == false) {
- const whisper_token id = whisper_full_get_token_id(ctx, i, j);
- if (id >= whisper_token_eot(ctx)) {
- continue;
- }
- }
-
- const char * text = whisper_full_get_token_text(ctx, i, j);
- const float p = whisper_full_get_token_p (ctx, i, j);
-
- const int col = std::max(0, std::min((int) k_colors.size() - 1, (int) (std::pow(p, 3)*float(k_colors.size()))));
-
- printf("%s%s%s%s", speaker.c_str(), k_colors[col].c_str(), text, "\033[0m");
- }
- } else {
- const char * text = whisper_full_get_segment_text(ctx, i);
-
- printf("%s%s", speaker.c_str(), text);
- }
-
- if (params.tinydiarize) {
- if (whisper_full_get_segment_speaker_turn_next(ctx, i)) {
- printf("%s", params.tdrz_speaker_turn.c_str());
- }
- }
-
- // with timestamps or speakers: each segment on new line
- if (!params.no_timestamps || params.diarize) {
- printf("\n");
- }
- fflush(stdout);
- }
-}
-
-std::string output_str(struct whisper_context * ctx, const whisper_params & params, std::vector<std::vector<float>> pcmf32s) {
- std::stringstream result;
- const int n_segments = whisper_full_n_segments(ctx);
- for (int i = 0; i < n_segments; ++i) {
- const char * text = whisper_full_get_segment_text(ctx, i);
- std::string speaker = "";
-
- if (params.diarize && pcmf32s.size() == 2)
- {
- const int64_t t0 = whisper_full_get_segment_t0(ctx, i);
- const int64_t t1 = whisper_full_get_segment_t1(ctx, i);
- speaker = estimate_diarization_speaker(pcmf32s, t0, t1);
- }
-
- result << speaker << text << "\n";
- }
- return result.str();
-}
-
-bool parse_str_to_bool(const std::string & s) {
- if (s == "true" || s == "1" || s == "yes" || s == "y") {
- return true;
- }
- return false;
-}
-
-void get_req_parameters(const Request & req, whisper_params & params)
-{
- if (req.has_file("offset_t"))
- {
- params.offset_t_ms = std::stoi(req.get_file_value("offset_t").content);
- }
- if (req.has_file("offset_n"))
- {
- params.offset_n = std::stoi(req.get_file_value("offset_n").content);
- }
- if (req.has_file("duration"))
- {
- params.duration_ms = std::stoi(req.get_file_value("duration").content);
- }
- if (req.has_file("max_context"))
- {
- params.max_context = std::stoi(req.get_file_value("max_context").content);
- }
- if (req.has_file("max_len"))
- {
- params.max_len = std::stoi(req.get_file_value("max_len").content);
- }
- if (req.has_file("best_of"))
- {
- params.best_of = std::stoi(req.get_file_value("best_of").content);
- }
- if (req.has_file("beam_size"))
- {
- params.beam_size = std::stoi(req.get_file_value("beam_size").content);
- }
- if (req.has_file("audio_ctx"))
- {
- params.audio_ctx = std::stof(req.get_file_value("audio_ctx").content);
- }
- if (req.has_file("word_thold"))
- {
- params.word_thold = std::stof(req.get_file_value("word_thold").content);
- }
- if (req.has_file("entropy_thold"))
- {
- params.entropy_thold = std::stof(req.get_file_value("entropy_thold").content);
- }
- if (req.has_file("logprob_thold"))
- {
- params.logprob_thold = std::stof(req.get_file_value("logprob_thold").content);
- }
- if (req.has_file("debug_mode"))
- {
- params.debug_mode = parse_str_to_bool(req.get_file_value("debug_mode").content);
- }
- if (req.has_file("translate"))
- {
- params.translate = parse_str_to_bool(req.get_file_value("translate").content);
- }
- if (req.has_file("diarize"))
- {
- params.diarize = parse_str_to_bool(req.get_file_value("diarize").content);
- }
- if (req.has_file("tinydiarize"))
- {
- params.tinydiarize = parse_str_to_bool(req.get_file_value("tinydiarize").content);
- }
- if (req.has_file("split_on_word"))
- {
- params.split_on_word = parse_str_to_bool(req.get_file_value("split_on_word").content);
- }
- if (req.has_file("no_timestamps"))
- {
- params.no_timestamps = parse_str_to_bool(req.get_file_value("no_timestamps").content);
- }
- if (req.has_file("language"))
- {
- params.language = req.get_file_value("language").content;
- }
- if (req.has_file("detect_language"))
- {
- params.detect_language = parse_str_to_bool(req.get_file_value("detect_language").content);
- }
- if (req.has_file("prompt"))
- {
- params.prompt = req.get_file_value("prompt").content;
- }
- if (req.has_file("response_format"))
- {
- params.response_format = req.get_file_value("response_format").content;
- }
- if (req.has_file("temperature"))
- {
- params.temperature = std::stof(req.get_file_value("temperature").content);
- }
- if (req.has_file("temperature_inc"))
- {
- params.temperature_inc = std::stof(req.get_file_value("temperature_inc").content);
- }
-}
-
-} // namespace
-
-int whisper_server_main(int argc, char ** argv) {
- whisper_params params;
- server_params sparams;
-
- std::mutex whisper_mutex;
-
- if (whisper_params_parse(argc, argv, params, sparams) == false) {
- whisper_print_usage(argc, argv, params, sparams);
- return 1;
- }
-
- if (params.language != "auto" && whisper_lang_id(params.language.c_str()) == -1) {
- fprintf(stderr, "error: unknown language '%s'\n", params.language.c_str());
- whisper_print_usage(argc, argv, params, sparams);
- exit(0);
- }
-
- if (params.diarize && params.tinydiarize) {
- fprintf(stderr, "error: cannot use both --diarize and --tinydiarize\n");
- whisper_print_usage(argc, argv, params, sparams);
- exit(0);
- }
-
- // whisper init
- struct whisper_context_params cparams = whisper_context_default_params();
-
- cparams.flash_attn = params.flash_attn;
-
- if (!params.dtw.empty()) {
- cparams.dtw_token_timestamps = true;
- cparams.dtw_aheads_preset = WHISPER_AHEADS_NONE;
-
- if (params.dtw == "tiny") {
- cparams.dtw_aheads_preset = WHISPER_AHEADS_TINY;
- }
- if (params.dtw == "tiny.en") {
- cparams.dtw_aheads_preset = WHISPER_AHEADS_TINY_EN;
- }
- if (params.dtw == "base") {
- cparams.dtw_aheads_preset = WHISPER_AHEADS_BASE;
- }
- if (params.dtw == "base.en") {
- cparams.dtw_aheads_preset = WHISPER_AHEADS_BASE_EN;
- }
- if (params.dtw == "small") {
- cparams.dtw_aheads_preset = WHISPER_AHEADS_SMALL;
- }
- if (params.dtw == "small.en") {
- cparams.dtw_aheads_preset = WHISPER_AHEADS_SMALL_EN;
- }
- if (params.dtw == "medium") {
- cparams.dtw_aheads_preset = WHISPER_AHEADS_MEDIUM;
- }
- if (params.dtw == "medium.en") {
- cparams.dtw_aheads_preset = WHISPER_AHEADS_MEDIUM_EN;
- }
- if (params.dtw == "large.v1") {
- cparams.dtw_aheads_preset = WHISPER_AHEADS_LARGE_V1;
- }
- if (params.dtw == "large.v2") {
- cparams.dtw_aheads_preset = WHISPER_AHEADS_LARGE_V2;
- }
- if (params.dtw == "large.v3") {
- cparams.dtw_aheads_preset = WHISPER_AHEADS_LARGE_V3;
- }
-
- if (cparams.dtw_aheads_preset == WHISPER_AHEADS_NONE) {
- fprintf(stderr, "error: unknown DTW preset '%s'\n", params.dtw.c_str());
- return 3;
- }
- }
-
- struct whisper_context * ctx = whisper_init_from_file_with_params(params.model.c_str(), cparams);
-
- if (ctx == nullptr) {
- fprintf(stderr, "error: failed to initialize whisper context\n");
- return 3;
- }
-
- // initialize openvino encoder. this has no effect on whisper.cpp builds that don't have OpenVINO configured
- whisper_ctx_init_openvino_encoder(ctx, nullptr, params.openvino_encode_device.c_str(), nullptr);
-
- Server svr;
- svr.set_default_headers({{"Server", "whisper.cpp"},
- {"Access-Control-Allow-Origin", "*"},
- {"Access-Control-Allow-Headers", "content-type, authorization"}});
-
- std::string const default_content = R"(
- <html>
- <head>
- <title>Whisper.cpp Server</title>
- <meta charset="utf-8">
- <meta name="viewport" content="width=device-width">
- <style>
- body {
- font-family: sans-serif;
- }
- form {
- display: flex;
- flex-direction: column;
- align-items: flex-start;
- }
- label {
- margin-bottom: 0.5rem;
- }
- input, select {
- margin-bottom: 1rem;
- }
- button {
- margin-top: 1rem;
- }
- </style>
- </head>
- <body>
- <h1>Whisper.cpp Server</h1>
-
- <h2>/inference</h2>
- <pre>
- curl 127.0.0.1:)" + std::to_string(sparams.port) + R"(/inference \
- -H "Content-Type: multipart/form-data" \
- -F file="@&lt;file-path&gt;" \
- -F temperature="0.0" \
- -F temperature_inc="0.2" \
- -F response_format="json"
- </pre>
-
- <h2>/load</h2>
- <pre>
- curl 127.0.0.1:)" + std::to_string(sparams.port) + R"(/load \
- -H "Content-Type: multipart/form-data" \
- -F model="&lt;path-to-model-file&gt;"
- </pre>
-
- <div>
- <h2>Try it out</h2>
- <form action="/inference" method="POST" enctype="multipart/form-data">
- <label for="file">Choose an audio file:</label>
- <input type="file" id="file" name="file" accept="audio/*" required><br>
-
- <label for="temperature">Temperature:</label>
- <input type="number" id="temperature" name="temperature" value="0.0" step="0.01" placeholder="e.g., 0.0"><br>
-
- <label for="response_format">Response Format:</label>
- <select id="response_format" name="response_format">
- <option value="verbose_json">Verbose JSON</option>
- <option value="json">JSON</option>
- <option value="text">Text</option>
- <option value="srt">SRT</option>
- <option value="vtt">VTT</option>
- </select><br>
-
- <button type="submit">Submit</button>
- </form>
- </div>
- </body>
- </html>
- )";
-
- // store default params so we can reset after each inference request
- whisper_params default_params = params;
-
- // this is only called if no index.html is found in the public --path
- svr.Get(sparams.request_path + "/", [&default_content](const Request &, Response &res){
- res.set_content(default_content, "text/html");
- return false;
- });
-
- svr.Options(sparams.request_path + sparams.inference_path, [&](const Request &, Response &){
- });
-
- svr.Post(sparams.request_path + sparams.inference_path, [&](const Request &req, Response &res){
- // acquire whisper model mutex lock
- std::lock_guard<std::mutex> lock(whisper_mutex);
-
- // first check user requested fields of the request
- if (!req.has_file("file"))
- {
- fprintf(stderr, "error: no 'file' field in the request\n");
- const std::string error_resp = "{\"error\":\"no 'file' field in the request\"}";
- res.set_content(error_resp, "application/json");
- return;
- }
- auto audio_file = req.get_file_value("file");
-
- // check non-required fields
- get_req_parameters(req, params);
-
- std::string filename{audio_file.filename};
- printf("Received request: %s\n", filename.c_str());
-
- // audio arrays
- std::vector<float> pcmf32; // mono-channel F32 PCM
- std::vector<std::vector<float>> pcmf32s; // stereo-channel F32 PCM
-
- // write incoming buffer to temporary file
- std::string temp_filename = __get_tmpdir();
- temp_filename += "/whisperfile.";
- temp_filename += std::to_string(_rand64());
-
- std::ofstream temp_file{temp_filename, std::ios::binary};
- temp_file << audio_file.content;
- temp_file.close();
-
- bool ok = slurp_audio_file(temp_filename.c_str(), pcmf32, pcmf32s, params.diarize);
- unlink(temp_filename.c_str());
- if (!ok) {
- fprintf(stderr, "error: failed to read audio file\n");
- const std::string error_resp = "{\"error\":\"failed to read audio file\"}";
- res.set_content(error_resp, "application/json");
- return;
- }
-
- printf("Successfully loaded %s\n", filename.c_str());
-
- // print system information
- {
- fprintf(stderr, "\n");
- fprintf(stderr, "system_info: n_threads = %d / %d | %s\n",
- params.n_threads*params.n_processors, std::thread::hardware_concurrency(), whisper_print_system_info());
- }
-
- // print some info about the processing
- {
- fprintf(stderr, "\n");
- if (!whisper_is_multilingual(ctx)) {
- if (params.language != "en" || params.translate) {
- params.language = "en";
- params.translate = false;
- fprintf(stderr, "%s: WARNING: model is not multilingual, ignoring language and translation options\n", __func__);
- }
- }
- if (params.detect_language) {
- params.language = "auto";
- }
- fprintf(stderr, "%s: processing '%s' (%d samples, %.1f sec), %d threads, %d processors, lang = %s, task = %s, %stimestamps = %d ...\n",
- __func__, filename.c_str(), int(pcmf32.size()), float(pcmf32.size())/WHISPER_SAMPLE_RATE,
- params.n_threads, params.n_processors,
- params.language.c_str(),
- params.translate ? "translate" : "transcribe",
- params.tinydiarize ? "tdrz = 1, " : "",
- params.no_timestamps ? 0 : 1);
-
- fprintf(stderr, "\n");
- }
-
- // run the inference
- float t_total;
- {
- printf("Running whisper.cpp inference on %s\n", filename.c_str());
- whisper_full_params wparams = whisper_full_default_params(WHISPER_SAMPLING_GREEDY);
-
- wparams.strategy = params.beam_size > 1 ? WHISPER_SAMPLING_BEAM_SEARCH : WHISPER_SAMPLING_GREEDY;
-
- wparams.print_realtime = false;
- wparams.print_progress = params.print_progress;
- wparams.print_timestamps = !params.no_timestamps;
- wparams.print_special = params.print_special;
- wparams.translate = params.translate;
- wparams.language = params.language.c_str();
- wparams.detect_language = params.detect_language;
- wparams.n_threads = params.n_threads;
- wparams.n_max_text_ctx = params.max_context >= 0 ? params.max_context : wparams.n_max_text_ctx;
- wparams.offset_ms = params.offset_t_ms;
- wparams.duration_ms = params.duration_ms;
-
- wparams.thold_pt = params.word_thold;
- wparams.max_len = params.max_len == 0 ? 60 : params.max_len;
- wparams.split_on_word = params.split_on_word;
- wparams.audio_ctx = params.audio_ctx;
-
- wparams.debug_mode = params.debug_mode;
-
- wparams.tdrz_enable = params.tinydiarize; // [TDRZ]
-
- wparams.initial_prompt = params.prompt.c_str();
-
- wparams.greedy.best_of = params.best_of;
- wparams.beam_search.beam_size = params.beam_size;
-
- wparams.temperature = params.temperature;
- wparams.temperature_inc = params.temperature_inc;
- wparams.entropy_thold = params.entropy_thold;
- wparams.logprob_thold = params.logprob_thold;
-
- wparams.no_timestamps = params.no_timestamps;
- wparams.token_timestamps = !params.no_timestamps && params.response_format == vjson_format;
-
- whisper_print_user_data user_data = { &params, &pcmf32s, 0 };
-
- // this callback is called on each new segment
- if (params.print_realtime) {
- wparams.new_segment_callback = whisper_print_segment_callback;
- wparams.new_segment_callback_user_data = &user_data;
- }
-
- if (wparams.print_progress) {
- wparams.progress_callback = whisper_print_progress_callback;
- wparams.progress_callback_user_data = &user_data;
- }
-
- // examples for abort mechanism
- // in examples below, we do not abort the processing, but we could if the flag is set to true
-
- // the callback is called before every encoder run - if it returns false, the processing is aborted
- {
- static bool is_aborted = false; // NOTE: this should be atomic to avoid data race
-
- wparams.encoder_begin_callback = [](struct whisper_context * /*ctx*/, struct whisper_state * /*state*/, void * user_data) {
- bool is_aborted = *(bool*)user_data;
- return !is_aborted;
- };
- wparams.encoder_begin_callback_user_data = &is_aborted;
- }
-
- // the callback is called before every computation - if it returns true, the computation is aborted
- {
- static bool is_aborted = false; // NOTE: this should be atomic to avoid data race
-
- wparams.abort_callback = [](void * user_data) {
- bool is_aborted = *(bool*)user_data;
- return is_aborted;
- };
- wparams.abort_callback_user_data = &is_aborted;
- }
-
- // time the processing
- auto t_start = std::chrono::high_resolution_clock::now();
- if (whisper_full_parallel(ctx, wparams, pcmf32.data(), pcmf32.size(), params.n_processors) != 0) {
- fprintf(stderr, "%s: failed to process audio\n", argv[0]);
- const std::string error_resp = "{\"error\":\"failed to process audio\"}";
- res.set_content(error_resp, "application/json");
- return;
- }
- t_total = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now() - t_start).count();
- }
-
- // return results to user
- if (params.response_format == text_format)
- {
- std::string results = output_str(ctx, params, pcmf32s);
- res.set_content(results.c_str(), "text/html; charset=utf-8");
- }
- else if (params.response_format == srt_format)
- {
- std::stringstream ss;
- const int n_segments = whisper_full_n_segments(ctx);
- for (int i = 0; i < n_segments; ++i) {
- const char * text = whisper_full_get_segment_text(ctx, i);
- const int64_t t0 = whisper_full_get_segment_t0(ctx, i);
- const int64_t t1 = whisper_full_get_segment_t1(ctx, i);
- std::string speaker = "";
-
- if (params.diarize && pcmf32s.size() == 2)
- {
- speaker = estimate_diarization_speaker(pcmf32s, t0, t1);
- }
-
- ss << i + 1 + params.offset_n << "\n";
- ss << to_timestamp(t0, true) << " --> " << to_timestamp(t1, true) << "\n";
- ss << speaker << text << "\n\n";
- }
- res.set_content(ss.str(), "application/x-subrip");
- } else if (params.response_format == vtt_format) {
- std::stringstream ss;
-
- ss << "WEBVTT\n\n";
-
- const int n_segments = whisper_full_n_segments(ctx);
- for (int i = 0; i < n_segments; ++i) {
- const char * text = whisper_full_get_segment_text(ctx, i);
- const int64_t t0 = whisper_full_get_segment_t0(ctx, i);
- const int64_t t1 = whisper_full_get_segment_t1(ctx, i);
- std::string speaker = "";
-
- if (params.diarize && pcmf32s.size() == 2)
- {
- speaker = estimate_diarization_speaker(pcmf32s, t0, t1, true);
- speaker.insert(0, "<v Speaker");
- speaker.append(">");
- }
-
- ss << to_timestamp(t0) << " --> " << to_timestamp(t1) << "\n";
- ss << speaker << text << "\n\n";
- }
- res.set_content(ss.str(), "text/vtt");
- } else if (params.response_format == vjson_format) {
- /* try to match openai/whisper's Python format */
- std::string results = output_str(ctx, params, pcmf32s);
- json jres = json{
- {"task", params.translate ? "translate" : "transcribe"},
- {"language", whisper_lang_str_full(whisper_full_lang_id(ctx))},
- {"duration", float(pcmf32.size())/WHISPER_SAMPLE_RATE},
- {"text", results},
- {"transcribe_time", t_total},
- {"segments", json::array()}
- };
- const int n_segments = whisper_full_n_segments(ctx);
- for (int i = 0; i < n_segments; ++i)
- {
- json segment = json{
- {"id", i},
- {"text", whisper_full_get_segment_text(ctx, i)},
- };
-
- if (!params.no_timestamps) {
- segment["start"] = whisper_full_get_segment_t0(ctx, i) * 0.01;
- segment["end"] = whisper_full_get_segment_t1(ctx, i) * 0.01;
- }
-
- float total_logprob = 0;
- const int n_tokens = whisper_full_n_tokens(ctx, i);
- for (int j = 0; j < n_tokens; ++j) {
- whisper_token_data token = whisper_full_get_token_data(ctx, i, j);
- if (token.id >= whisper_token_eot(ctx)) {
- continue;
- }
-
- segment["tokens"].push_back(token.id);
- json word = json{{"word", whisper_full_get_token_text(ctx, i, j)}};
- if (!params.no_timestamps) {
- word["start"] = token.t0 * 0.01;
- word["end"] = token.t1 * 0.01;
- word["t_dtw"] = token.t_dtw;
- }
- word["probability"] = token.p;
- total_logprob += token.plog;
- segment["words"].push_back(word);
- }
-
- segment["temperature"] = params.temperature;
- segment["avg_logprob"] = total_logprob / n_tokens;
-
- // TODO compression_ratio and no_speech_prob are not implemented yet
- // segment["compression_ratio"] = 0;
- // segment["no_speech_prob"] = 0;
-
- jres["segments"].push_back(segment);
- }
- res.set_content(jres.dump(-1, ' ', false, json::error_handler_t::replace),
- "application/json");
- }
- // TODO add more output formats
- else
- {
- std::string results = output_str(ctx, params, pcmf32s);
- json jres = json{
- {"text", results}
- };
- res.set_content(jres.dump(-1, ' ', false, json::error_handler_t::replace),
- "application/json");
- }
-
- // reset params to thier defaults
- params = default_params;
- });
- svr.Post(sparams.request_path + "/load", [&](const Request &req, Response &res){
- std::lock_guard<std::mutex> lock(whisper_mutex);
- if (!req.has_file("model"))
- {
- fprintf(stderr, "error: no 'model' field in the request\n");
- const std::string error_resp = "{\"error\":\"no 'model' field in the request\"}";
- res.set_content(error_resp, "application/json");
- return;
- }
- std::string model = req.get_file_value("model").content;
- if (!is_file_exist(model.c_str()))
- {
- fprintf(stderr, "error: 'model': %s not found!\n", model.c_str());
- const std::string error_resp = "{\"error\":\"model not found!\"}";
- res.set_content(error_resp, "application/json");
- return;
- }
-
- // clean up
- whisper_free(ctx);
-
- // whisper init
- ctx = whisper_init_from_file_with_params(model.c_str(), cparams);
-
- // TODO perhaps load prior model here instead of exit
- if (ctx == nullptr) {
- fprintf(stderr, "error: model init failed, no model loaded must exit\n");
- exit(1);
- }
-
- // initialize openvino encoder. this has no effect on whisper.cpp builds that don't have OpenVINO configured
- whisper_ctx_init_openvino_encoder(ctx, nullptr, params.openvino_encode_device.c_str(), nullptr);
-
- const std::string success = "Load was successful!";
- res.set_content(success, "application/text");
-
- // check if the model is in the file system
- });
-
- svr.set_exception_handler([](const Request &, Response &res, std::exception_ptr ep) {
- const char fmt[] = "500 Internal Server Error\n%s";
- char buf[BUFSIZ];
- try {
- std::rethrow_exception(std::move(ep));
- } catch (std::exception &e) {
- snprintf(buf, sizeof(buf), fmt, e.what());
- } catch (...) {
- snprintf(buf, sizeof(buf), fmt, "Unknown Exception");
- }
- res.set_content(buf, "text/plain");
- res.status = 500;
- });
-
- svr.set_error_handler([](const Request &req, Response &res) {
- if (res.status == 400) {
- res.set_content("Invalid request", "text/plain");
- } else if (res.status != 500) {
- res.set_content("File Not Found (" + req.path + ")", "text/plain");
- res.status = 404;
- }
- });
-
- // set timeouts and change hostname and port
- svr.set_read_timeout(sparams.read_timeout);
- svr.set_write_timeout(sparams.write_timeout);
-
- if (!svr.bind_to_port(sparams.hostname, sparams.port))
- {
- fprintf(stderr, "\ncouldn't bind to server socket: hostname=%s port=%d\n\n",
- sparams.hostname.c_str(), sparams.port);
- return 1;
- }
-
- // Set the base directory for serving static files
- svr.set_base_dir(sparams.public_path);
-
- // to make it ctrl+clickable:
- printf("\nwhisper server listening at http://%s:%d\n\n", sparams.hostname.c_str(), sparams.port);
-
- if (!svr.listen_after_bind())
- {
- return 1;
- }
-
- whisper_print_timings(ctx);
- whisper_free(ctx);
-
- return 0;
-}
diff --git a/whisper.cpp/stream.cpp b/whisper.cpp/stream.cpp
deleted file mode 100644
index 06c1d817..00000000
--- a/whisper.cpp/stream.cpp
+++ /dev/null
@@ -1,363 +0,0 @@
-#include "common.h"
-#include "whisper.h"
-
-#include <cassert>
-#include <cstdio>
-#include <string>
-#include <thread>
-#include <vector>
-#include <fstream>
-#include <cosmoaudio.h>
-
-// command-line parameters
-struct whisper_params {
- int32_t n_threads = std::min(8, (int32_t) std::thread::hardware_concurrency());
- int32_t step_ms = 3000;
- int32_t length_ms = 10000;
- int32_t keep_ms = 200;
- int32_t capture_id = -1;
- int32_t max_tokens = 32;
- int32_t audio_ctx = 0;
-
- float vad_thold = 0.6f;
- float freq_thold = 100.0f;
-
- bool translate = false;
- bool no_fallback = false;
- bool print_special = false;
- bool no_context = true;
- bool no_timestamps = false;
- bool tinydiarize = false;
- bool save_audio = false;
- bool use_gpu = true;
- bool flash_attn = false;
-
- std::string language = "en";
- std::string model = "models/ggml-base.en.bin";
- std::string fname_out;
-};
-
-void whisper_print_usage(int argc, char ** argv, const whisper_params & params);
-
-static bool whisper_params_parse(int argc, char ** argv, whisper_params & params) {
- for (int i = 1; i < argc; i++) {
- std::string arg = argv[i];
-
- if (arg == "-h" || arg == "--help") {
- whisper_print_usage(argc, argv, params);
- exit(0);
- }
- else if (arg == "-t" || arg == "--threads") { params.n_threads = std::stoi(argv[++i]); }
- else if ( arg == "--step") { params.step_ms = std::stoi(argv[++i]); }
- else if ( arg == "--length") { params.length_ms = std::stoi(argv[++i]); }
- else if ( arg == "--keep") { params.keep_ms = std::stoi(argv[++i]); }
- else if (arg == "-c" || arg == "--capture") { params.capture_id = std::stoi(argv[++i]); }
- else if (arg == "-mt" || arg == "--max-tokens") { params.max_tokens = std::stoi(argv[++i]); }
- else if (arg == "-ac" || arg == "--audio-ctx") { params.audio_ctx = std::stoi(argv[++i]); }
- else if (arg == "-vth" || arg == "--vad-thold") { params.vad_thold = std::stof(argv[++i]); }
- else if (arg == "-fth" || arg == "--freq-thold") { params.freq_thold = std::stof(argv[++i]); }
- else if (arg == "-tr" || arg == "--translate") { params.translate = true; }
- else if (arg == "-nf" || arg == "--no-fallback") { params.no_fallback = true; }
- else if (arg == "-ps" || arg == "--print-special") { params.print_special = true; }
- else if (arg == "-kc" || arg == "--keep-context") { params.no_context = false; }
- else if (arg == "-l" || arg == "--language") { params.language = argv[++i]; }
- else if (arg == "-m" || arg == "--model") { params.model = argv[++i]; }
- else if (arg == "-o" || arg == "--output-file") { params.fname_out = argv[++i]; }
- else if (arg == "-tdrz" || arg == "--tinydiarize") { params.tinydiarize = true; }
- else if (arg == "-sa" || arg == "--save-audio") { params.save_audio = true; }
- else if (arg == "-ng" || arg == "--no-gpu") { params.use_gpu = false; }
- else if (arg == "-fa" || arg == "--flash-attn") { params.flash_attn = true; }
-
- else {
- fprintf(stderr, "error: unknown argument: %s\n", arg.c_str());
- whisper_print_usage(argc, argv, params);
- exit(0);
- }
- }
-
- return true;
-}
-
-void whisper_print_usage(int /*argc*/, char ** argv, const whisper_params & params) {
- fprintf(stderr, "\n");
- fprintf(stderr, "usage: %s [options]\n", argv[0]);
- fprintf(stderr, "\n");
- fprintf(stderr, "options:\n");
- fprintf(stderr, " -h, --help [default] show this help message and exit\n");
- fprintf(stderr, " -t N, --threads N [%-7d] number of threads to use during computation\n", params.n_threads);
- fprintf(stderr, " --step N [%-7d] audio step size in milliseconds\n", params.step_ms);
- fprintf(stderr, " --length N [%-7d] audio length in milliseconds\n", params.length_ms);
- fprintf(stderr, " --keep N [%-7d] audio to keep from previous step in ms\n", params.keep_ms);
- fprintf(stderr, " -c ID, --capture ID [%-7d] capture device ID\n", params.capture_id);
- fprintf(stderr, " -mt N, --max-tokens N [%-7d] maximum number of tokens per audio chunk\n", params.max_tokens);
- fprintf(stderr, " -ac N, --audio-ctx N [%-7d] audio context size (0 - all)\n", params.audio_ctx);
- fprintf(stderr, " -vth N, --vad-thold N [%-7.2f] voice activity detection threshold\n", params.vad_thold);
- fprintf(stderr, " -fth N, --freq-thold N [%-7.2f] high-pass frequency cutoff\n", params.freq_thold);
- fprintf(stderr, " -tr, --translate [%-7s] translate from source language to english\n", params.translate ? "true" : "false");
- fprintf(stderr, " -nf, --no-fallback [%-7s] do not use temperature fallback while decoding\n", params.no_fallback ? "true" : "false");
- fprintf(stderr, " -ps, --print-special [%-7s] print special tokens\n", params.print_special ? "true" : "false");
- fprintf(stderr, " -kc, --keep-context [%-7s] keep context between audio chunks\n", params.no_context ? "false" : "true");
- fprintf(stderr, " -l LANG, --language LANG [%-7s] spoken language\n", params.language.c_str());
- fprintf(stderr, " -m FNAME, --model FNAME [%-7s] model path\n", params.model.c_str());
- fprintf(stderr, " -o FNAME, --file FNAME [%-7s] text output file name\n", params.fname_out.c_str());
- fprintf(stderr, " -tdrz, --tinydiarize [%-7s] enable tinydiarize (requires a tdrz model)\n", params.tinydiarize ? "true" : "false");
- fprintf(stderr, " -sa, --save-audio [%-7s] save the recorded audio to a file\n", params.save_audio ? "true" : "false");
- fprintf(stderr, " -ng, --no-gpu [%-7s] disable GPU inference\n", params.use_gpu ? "false" : "true");
- fprintf(stderr, " -fa, --flash-attn [%-7s] flash attention during inference\n", params.flash_attn ? "true" : "false");
- fprintf(stderr, "\n");
-}
-
-struct Transcriber {
- whisper_params params;
- bool use_vad;
- int n_samples_step;
- int n_samples_len;
- int n_samples_keep;
- int n_new_line;
- struct CosmoAudio *audio;
- struct whisper_context *ctx;
- std::vector<float> pcmf32;
- std::vector<float> pcmf32_old;
- std::vector<float> pcmf32_new;
- std::vector<whisper_token> prompt_tokens;
- int n_iter;
- std::ofstream fout;
- wav_writer wavWriter;
-
- int main(int argc, char *argv[]);
-
- void inference();
-};
-
-int Transcriber::main(int argc, char *argv[]) {
- if (whisper_params_parse(argc, argv, params) == false)
- return 1;
-
- params.keep_ms = std::min(params.keep_ms, params.step_ms);
- params.length_ms = std::max(params.length_ms, params.step_ms);
-
- n_samples_step = (1e-3*params.step_ms )*WHISPER_SAMPLE_RATE;
- n_samples_len = (1e-3*params.length_ms)*WHISPER_SAMPLE_RATE;
- n_samples_keep = (1e-3*params.keep_ms )*WHISPER_SAMPLE_RATE;
-
- use_vad = n_samples_step <= 0; // sliding window mode uses VAD
-
- n_new_line = !use_vad ? std::max(1, params.length_ms / params.step_ms - 1) : 1; // number of steps to print new line
-
- params.no_timestamps = !use_vad;
- params.no_context |= use_vad;
- params.max_tokens = 0;
-
- // init audio
- struct CosmoAudioOpenOptions cao = {};
- cao.sizeofThis = sizeof(struct CosmoAudioOpenOptions);
- cao.deviceType = kCosmoAudioDeviceTypeCapture;
- cao.sampleRate = WHISPER_SAMPLE_RATE;
- cao.bufferFrames = n_samples_len;
- cao.channels = 1;
- cao.debugLog = 1;
- if (cosmoaudio_open(&audio, &cao) != COSMOAUDIO_SUCCESS) {
- fprintf(stderr, "error: failed to open microphone\n");
- exit(1);
- }
-
- // whisper init
- if (params.language != "auto" && whisper_lang_id(params.language.c_str()) == -1){
- fprintf(stderr, "error: unknown language '%s'\n", params.language.c_str());
- whisper_print_usage(argc, argv, params);
- exit(0);
- }
-
- struct whisper_context_params cparams = whisper_context_default_params();
- // cparams.use_gpu = params.use_gpu;
- cparams.flash_attn = params.flash_attn;
-
- ctx = whisper_init_from_file_with_params(params.model.c_str(), cparams);
-
- n_iter = 0;
-
- if (params.fname_out.length() > 0) {
- fout.open(params.fname_out);
- if (!fout.is_open()) {
- fprintf(stderr, "%s: failed to open output file '%s'!\n", __func__, params.fname_out.c_str());
- return 1;
- }
- }
-
- // save wav file
- if (params.save_audio) {
- // Get current date/time for filename
- time_t now = time(0);
- char buffer[80];
- strftime(buffer, sizeof(buffer), "%Y%m%d%H%M%S", localtime(&now));
- std::string filename = std::string(buffer) + ".wav";
- wavWriter.open(filename, WHISPER_SAMPLE_RATE, 16, 1);
- }
-
- printf("[Start speaking]\n");
- fflush(stdout);
-
- auto t_last = std::chrono::high_resolution_clock::now();
- const auto t_start = t_last;
-
- // main audio loop
- for (;;) {
- if (params.save_audio)
- wavWriter.write(pcmf32_new.data(), pcmf32_new.size());
- inference();
- }
-
- cosmoaudio_close(audio);
- whisper_print_timings(ctx);
- whisper_free(ctx);
- return 0;
-}
-
-void Transcriber::inference() {
-
- pcmf32_new.clear();
- for (;;) {
- int rc;
- int avail = 2;
- if ((rc = cosmoaudio_poll(audio, &avail, 0)) != COSMOAUDIO_SUCCESS) {
- fprintf(stderr, "error: cosmoaudio_poll failed: %d\n", rc);
- exit(1);
- }
- --avail;
- int old_size = pcmf32_new.size();
- pcmf32_new.resize(old_size + avail);
- if ((rc = cosmoaudio_read(audio, &pcmf32_new[old_size], avail)) != avail) {
- fprintf(stderr, "error: cosmoaudio_poll failed: %d (want %d)\n", rc, avail);
- continue;
- }
- int new_size = pcmf32_new.size();
- if (new_size > 2*n_samples_step) {
- fprintf(stderr, "\n\n%s: WARNING: cannot process audio fast enough, dropping audio ...\n\n", __func__);
- pcmf32_new.clear();
- }
- if (new_size >= n_samples_step) {
- break;
- }
- }
-
- // get audio
- int n_samples_new = pcmf32_new.size();
- // take up to params.length_ms audio from previous iteration
- const int n_samples_take = std::min((int) pcmf32_old.size(), std::max(0, n_samples_keep + n_samples_len - n_samples_new));
- // printf("processing: take = %d, new = %d, old = %d\n", n_samples_take, n_samples_new, (int) pcmf32_old.size());
- pcmf32.resize(n_samples_new + n_samples_take);
- for (int i = 0; i < n_samples_take; i++)
- pcmf32[i] = pcmf32_old[pcmf32_old.size() - n_samples_take + i];
- memcpy(pcmf32.data() + n_samples_take, pcmf32_new.data(), n_samples_new*sizeof(float));
-
- pcmf32_old = pcmf32;
-
- // run the inference
- {
- whisper_full_params wparams = whisper_full_default_params(WHISPER_SAMPLING_BEAM_SEARCH);
- wparams.print_progress = false;
- wparams.print_special = params.print_special;
- wparams.print_realtime = false;
- wparams.print_timestamps = !params.no_timestamps;
- wparams.translate = params.translate;
- wparams.single_segment = !use_vad;
- wparams.max_tokens = params.max_tokens;
- wparams.language = params.language.c_str();
- wparams.n_threads = params.n_threads;
- wparams.audio_ctx = params.audio_ctx;
- wparams.tdrz_enable = params.tinydiarize; // [TDRZ]
- wparams.temperature_inc = params.no_fallback ? 0.0f : wparams.temperature_inc;
- wparams.prompt_tokens = params.no_context ? nullptr : prompt_tokens.data();
- wparams.prompt_n_tokens = params.no_context ? 0 : prompt_tokens.size();
-
- if (whisper_full(ctx, wparams, pcmf32.data(), pcmf32.size()) != 0) {
- fprintf(stderr, "error: failed to process audio\n");
- exit(6);
- }
-
- // print result;
- {
- if (!use_vad) {
- printf("\33[2K\r");
-
- // print long empty line to clear the previous line
- printf("%s", std::string(100, ' ').c_str());
-
- printf("\33[2K\r");
- }
-
- const int n_segments = whisper_full_n_segments(ctx);
- for (int i = 0; i < n_segments; ++i) {
- const char * text = whisper_full_get_segment_text(ctx, i);
-
- if (params.no_timestamps) {
- printf("%s", text);
- fflush(stdout);
-
- if (params.fname_out.length() > 0) {
- fout << text;
- }
- } else {
- const int64_t t0 = whisper_full_get_segment_t0(ctx, i);
- const int64_t t1 = whisper_full_get_segment_t1(ctx, i);
-
- std::string output = "[" + to_timestamp(t0, false) + " --> " + to_timestamp(t1, false) + "] " + text;
-
- if (whisper_full_get_segment_speaker_turn_next(ctx, i)) {
- output += " [SPEAKER_TURN]";
- }
-
- output += "\n";
-
- printf("%s", output.c_str());
- fflush(stdout);
-
- if (params.fname_out.length() > 0) {
- fout << output;
- }
- }
- }
-
- if (params.fname_out.length() > 0) {
- fout << std::endl;
- }
-
- if (use_vad) {
- printf("\n");
- printf("### Transcription %d END\n", n_iter);
- }
- }
-
- ++n_iter;
-
- if (!use_vad && (n_iter % n_new_line) == 0) {
- printf("\n");
-
- // keep part of the audio for next iteration to try to mitigate word boundary issues
- pcmf32_old = std::vector<float>(pcmf32.end() - n_samples_keep, pcmf32.end());
-
- // Add tokens of the last full length segment as the prompt
- if (!params.no_context) {
- prompt_tokens.clear();
-
- const int n_segments = whisper_full_n_segments(ctx);
- for (int i = 0; i < n_segments; ++i) {
- const int token_count = whisper_full_n_tokens(ctx, i);
- for (int j = 0; j < token_count; ++j) {
- prompt_tokens.push_back(whisper_full_get_token_id(ctx, i, j));
- }
- }
- }
- }
- fflush(stdout);
- }
-}
-
-int main(int argc, char *argv[]) {
- FLAG_gpu = LLAMAFILE_GPU_DISABLE;
- llamafile_check_cpu();
- ShowCrashReports();
-
- struct Transcriber ts;
- return ts.main(argc, argv);
-}
diff --git a/whisper.cpp/whisper-mel-cuda.cu b/whisper.cpp/whisper-mel-cuda.cu
deleted file mode 100644
index f1b5a319..00000000
--- a/whisper.cpp/whisper-mel-cuda.cu
+++ /dev/null
@@ -1,363 +0,0 @@
-#define CUB_IGNORE_DEPRECATED_CPP_DIALECT
-#include "whisper.cpp/whisper-mel-cuda.hpp"
-#include "whisper.h"
-
-#include <ggml-backend.h>
-
-#include <cuda.h>
-#include <cuda_runtime.h>
-#include <cufft.h>
-#include <cublas_v2.h>
-#include <cuComplex.h>
-#include <cub/device/device_reduce.cuh>
-#include <device_launch_parameters.h>
-
-#include <algorithm>
-
-#if defined(_MSC_VER)
-#pragma warning(disable: 4324) // added padding
-#endif
-
-namespace {
-
-static const char* cufftGetErrorString(cufftResult_t res) {
- switch (res) {
- case CUFFT_SUCCESS: return "The cuFFT operation was successful";
- case CUFFT_INVALID_PLAN: return "cuFFT was passed an invalid plan handle";
- case CUFFT_ALLOC_FAILED: return "cuFFT failed to allocate GPU or CPU memory";
- case CUFFT_INVALID_TYPE: return "No longer used";
- case CUFFT_INVALID_VALUE: return "User specified an invalid pointer or parameter";
- case CUFFT_INTERNAL_ERROR: return "Driver or internal cuFFT library error";
- case CUFFT_EXEC_FAILED: return "Failed to execute an FFT on the GPU";
- case CUFFT_SETUP_FAILED: return "The cuFFT library failed to initialize";
- case CUFFT_INVALID_SIZE: return "User specified an invalid transform size";
- case CUFFT_UNALIGNED_DATA: return "No longer used";
- case CUFFT_INCOMPLETE_PARAMETER_LIST: return "Missing parameters in call";
- case CUFFT_INVALID_DEVICE: return "Execution of a plan was on different GPU than plan creation";
- case CUFFT_PARSE_ERROR: return "Internal plan database error";
- case CUFFT_NO_WORKSPACE: return "No workspace has been provided prior to plan execution";
- case CUFFT_NOT_IMPLEMENTED: return "Function does not implement functionality for parameters given.";
- case CUFFT_LICENSE_ERROR: return "Used in previous versions.";
- case CUFFT_NOT_SUPPORTED: return "Operation is not supported for parameters given.";
- default: return "Unknown error";
- }
-}
-
-#define CUFFT_CHECK(err) CUDA_CHECK_GEN(err, CUFFT_SUCCESS, cufftGetErrorString)
-
-__global__ void k_fill_stft_input(
- const float * padded_samples,
- const int n_frames,
- const float * hann_window,
- float * stft_in
-) {
- auto y = blockIdx.y * blockDim.y + threadIdx.y;
- // if (y >= n_frames) return;
- auto x = blockIdx.x * blockDim.x + threadIdx.x;
- // if (x >= WHISPER_N_FFT) return;
-
- auto line = padded_samples + y * WHISPER_HOP_LENGTH;
- auto outLine = stft_in + y * WHISPER_N_FFT;
-
- outLine[x] = line[x] * hann_window[x];
-}
-
-__global__ void k_calc_magnitudes(
- const cuComplex * stft_out,
- const int n_frames,
- float * magnitudes
-) {
- auto y = blockIdx.y * blockDim.y + threadIdx.y;
- // if (y >= n_frames) return;
- auto x = blockIdx.x * blockDim.x + threadIdx.x;
- // if (x >= WHISPER_N_FFT_HALF) return;
-
- auto idx = y * WHISPER_N_FFT_HALF + x;
-
- auto r = stft_out[idx].x;
- auto i = stft_out[idx].y;
- magnitudes[idx] = r * r + i * i;
-}
-
-__global__ void k_calc_log_mel(
- const float * mel_data,
- const int n_mel,
- const float * max_val,
- float * log_mel
-) {
- auto x = blockIdx.x * blockDim.x + threadIdx.x;
- if (x >= n_mel) return;
-
- float val = mel_data[x];
-
- constexpr float e = 1e-10f;
- if (val < e) val = e;
-
- val = log10(val);
-
- const float max = log10(*max_val) - 8.f;
- if (val < max) val = max;
-
- log_mel[x] = (val + 4) / 4;
-}
-
-static void fill_stft_input(
- const float * padded_samples,
- int n_frames,
- const float * hann_window,
- float * stft_in,
- cudaStream_t stream
-) {
- dim3 block(WHISPER_N_FFT, 1);
- dim3 grid(1, n_frames);
-
- k_fill_stft_input<<<grid, block, 0, stream>>>(padded_samples, n_frames, hann_window, stft_in);
-}
-
-static void calc_magnitudes(
- const cuComplex * stft_out,
- int n_frames,
- float * magnitudes,
- cudaStream_t stream
-) {
- dim3 block(WHISPER_N_FFT_HALF, 1);
- dim3 grid(1, n_frames);
- k_calc_magnitudes<<<grid, block, 0, stream>>>(stft_out, n_frames, magnitudes);
-}
-
-constexpr auto LOG_MEL_PREFIX_SIZE = 256;
-
-static void calc_log_mel(
- const float * mel_data,
- int n_mel,
- void * tempStorage,
- int tempStorageSize,
- float * log_mel,
- cudaStream_t stream
-) {
- float * max_val = reinterpret_cast<float *>(tempStorage);
- void * maxTemp = reinterpret_cast<char*>(tempStorage) + LOG_MEL_PREFIX_SIZE;
-
- size_t nbytes = size_t(tempStorageSize - LOG_MEL_PREFIX_SIZE);
- cub::DeviceReduce::Max(maxTemp, nbytes, mel_data, max_val, n_mel, stream);
-
- int block = 256;
- int grid = (n_mel + block - 1) / block;
-
- k_calc_log_mel<<<grid, block, 0, stream>>>(mel_data, n_mel, max_val, log_mel);
-}
-
-class mel_calc_cuda : public whisper_mel_calc {
- const int m_n_mel;
-
- ggml_backend_t m_backend = nullptr;
- int m_device = -1;
-
- cudaStream_t m_stream = nullptr;
- cublasHandle_t m_cublas_handle = nullptr;
-
- float * m_hann_window = nullptr;
-
- float * m_filters = nullptr;
-
- // max samples for which we have allocated memory for the temp working areas below (cufft, log_mel)
- int m_n_max_samples = 0;
-
- size_t m_cufft_workspace_size = 0;
- void * m_cufft_workspace = nullptr;
-
- size_t m_log_mel_temp_storage_size = 0;
- void * m_log_mel_temp_storage = nullptr;
-public:
- mel_calc_cuda(ggml_backend_t backend, const whisper_filters & filters)
- : m_n_mel(filters.n_mel)
- , m_backend(backend)
- {
- ggml_backend_cuda_context* cuda_ctx = (ggml_backend_cuda_context*)m_backend->context;
- m_device = cuda_ctx->device;
-
- if (ggml_cuda_info().devices[m_device].cc < 600) {
- // we've only tesed on 6.0 and higher and we've had reports of crashes on 5.0:
- // https://github.com/ggerganov/whisper.cpp/issues/2230
- // to be safe forbid anything below 6.0
- throw std::runtime_error("CUDA compute capability 6.0 or higher is required");
- }
-
- ggml_cuda_set_device(m_device);
-
- if (filters.n_fft != WHISPER_N_FFT_HALF) {
- throw std::invalid_argument("MelFilters n_frames must be WHISPER_N_FFT_HALF");
- }
- assert(filters.data.size() == filters.n_mel * WHISPER_N_FFT_HALF);
-
- CUDA_CHECK(cudaStreamCreate(&m_stream));
- CUBLAS_CHECK(cublasCreate(&m_cublas_handle));
- CUBLAS_CHECK(cublasSetMathMode(m_cublas_handle, CUBLAS_TF32_TENSOR_OP_MATH));
- CUBLAS_CHECK(cublasSetStream(m_cublas_handle, m_stream));
-
- // create Hann window
- {
- auto hw = whisper_mel_calc::hann_window();
- CUDA_CHECK(cudaMallocAsync(&m_hann_window, hw.len * sizeof(float), m_stream));
- CUDA_CHECK(cudaMemcpyAsync(m_hann_window, hw.data, hw.len * sizeof(float), cudaMemcpyHostToDevice, m_stream));
- }
-
- // fill filters
- {
- auto& f = filters.data;
- CUDA_CHECK(cudaMallocAsync(&m_filters, f.size() * sizeof(float), m_stream));
- CUDA_CHECK(cudaMemcpyAsync(m_filters, f.data(), f.size() * sizeof(float), cudaMemcpyHostToDevice, m_stream));
- }
-
- // preallocate working areas enough for the most common cases (<= 30s)
- ensure_working_areas(WHISPER_N_SAMPLES);
- }
-
- ~mel_calc_cuda() {
- ggml_cuda_set_device(m_device);
- CUDA_CHECK(cudaStreamSynchronize(m_stream));
- CUDA_CHECK(cudaStreamDestroy(m_stream));
- CUDA_CHECK(cudaFree(m_hann_window));
- CUDA_CHECK(cudaFree(m_cufft_workspace));
- CUDA_CHECK(cudaFree(m_filters));
- CUDA_CHECK(cudaFree(m_log_mel_temp_storage));
- }
-
- void ensure_working_areas(int n_samples) {
- if (n_samples <= m_n_max_samples) {
- return;
- }
-
- const auto max_padded_samples = n_samples + WHISPER_N_SAMPLES + WHISPER_N_FFT;
- const auto max_frames = 1 + (max_padded_samples - WHISPER_N_FFT) / WHISPER_HOP_LENGTH;
-
- // cufft workspace
- {
- if (m_cufft_workspace) {
- CUDA_CHECK(cudaFree(m_cufft_workspace));
- m_cufft_workspace_size = 0;
- m_cufft_workspace = nullptr;
- }
- CUFFT_CHECK(cufftEstimate1d(WHISPER_N_FFT, CUFFT_R2C, max_frames, &m_cufft_workspace_size));
- CUDA_CHECK(cudaMallocAsync(&m_cufft_workspace, m_cufft_workspace_size, m_stream));
- }
-
- // device reduce working area
- {
- if (m_log_mel_temp_storage) {
- CUDA_CHECK(cudaFree(m_log_mel_temp_storage));
- m_log_mel_temp_storage_size = 0;
- m_log_mel_temp_storage = nullptr;
- }
-
- const auto max_mels = 160;
-
- size_t nbytes = 0;
- float* temp = nullptr;
- cub::DeviceReduce::Max(nullptr, nbytes, temp, temp, max_frames * max_mels);
- m_log_mel_temp_storage_size = nbytes + LOG_MEL_PREFIX_SIZE;
-
- CUDA_CHECK(cudaMallocAsync(&m_log_mel_temp_storage, m_log_mel_temp_storage_size, m_stream));
- }
-
- m_n_max_samples = n_samples;
- }
-
- virtual whisper_mel calculate(whisper_span<const float> samples, int /*n_threads*/) override {
- ggml_cuda_set_device(m_device);
- ensure_working_areas(samples.len);
-
- const size_t mirror_pad = WHISPER_N_FFT / 2;
- const size_t padded_size = samples.len + WHISPER_N_SAMPLES + WHISPER_N_FFT;
-
- // pad
- std::vector<float> padded_samples(padded_size);
- std::reverse_copy(samples.data + 1, samples.data + 1 + mirror_pad, padded_samples.begin()); // reflect
- std::copy(samples.data, samples.data + samples.len, padded_samples.begin() + mirror_pad); // copy
-
- // fill the rest of the data
- // it should canonically be mirrored at the end as well,
- // but we just assume the last MEL_FRAME_SIZE/2 samples are zeros
- std::fill(padded_samples.begin() + mirror_pad + samples.len, padded_samples.end(), 0.f);
-
- const auto n_frames = 1 + (padded_samples.size() - WHISPER_N_FFT) / WHISPER_HOP_LENGTH;
-
- float * cu_padded_samples = nullptr;
- CUDA_CHECK(cudaMallocAsync(&cu_padded_samples, padded_samples.size() * sizeof(float), m_stream));
- CUDA_CHECK(cudaMemcpyAsync(cu_padded_samples, padded_samples.data(), padded_samples.size() * sizeof(float), cudaMemcpyHostToDevice, m_stream));
-
- float * stft_in = nullptr; // contiguous buffer for stft input
- CUDA_CHECK(cudaMallocAsync(&stft_in, n_frames * WHISPER_N_FFT * sizeof(float), m_stream));
-
- fill_stft_input(cu_padded_samples, int(n_frames), m_hann_window, stft_in, m_stream);
-
- cufftComplex* stft_out;
- CUDA_CHECK(cudaMallocAsync(&stft_out, n_frames * WHISPER_N_FFT_HALF * sizeof(cufftComplex), m_stream));
-
- cufftHandle plan;
- CUFFT_CHECK(cufftCreate(&plan));
- CUFFT_CHECK(cufftSetAutoAllocation(plan, 0));
- {
- size_t waSize;
- CUFFT_CHECK(cufftMakePlan1d(plan, WHISPER_N_FFT, CUFFT_R2C, int(n_frames), &waSize));
- assert(waSize <= m_cufft_workspace_size);
- CUFFT_CHECK(cufftSetWorkArea(plan, m_cufft_workspace));
- CUFFT_CHECK(cufftSetStream(plan, m_stream));
- }
- CUFFT_CHECK(cufftExecR2C(plan, stft_in, stft_out));
-
- const auto n_mag_frames = n_frames - 1; // drop last frame
- float * magnitudes;
- CUDA_CHECK(cudaMallocAsync(&magnitudes, n_mag_frames * WHISPER_N_FFT_HALF * sizeof(float), m_stream));
- calc_magnitudes(stft_out, int(n_mag_frames), magnitudes, m_stream);
-
- float * mel_data = nullptr;
- CUDA_CHECK(cudaMallocAsync(&mel_data, m_n_mel * n_mag_frames * sizeof(float), m_stream));
-
- const float fone = 1.0f, fzero = 0.0f;
- CUBLAS_CHECK(cublasSgemm(m_cublas_handle, CUBLAS_OP_T, CUBLAS_OP_N,
- int(n_mag_frames), m_n_mel, WHISPER_N_FFT_HALF,
- &fone,
- magnitudes, WHISPER_N_FFT_HALF,
- m_filters, WHISPER_N_FFT_HALF,
- &fzero,
- mel_data, int(n_mag_frames)));
-
- whisper_mel ret;
- // Calculate semi-padded sample length to ensure compatibility
- int n_len_org = 1 + int(samples.len + mirror_pad - WHISPER_N_FFT) / WHISPER_HOP_LENGTH;
- whisper_mel_init(ret, m_backend, int(n_mag_frames), n_len_org, m_n_mel);
- assert(ggml_nbytes(ret.tensor) == m_n_mel * n_mag_frames * sizeof(float));
-
- float* log_mels = reinterpret_cast<float*>(ret.tensor->data);
-
- calc_log_mel(
- mel_data, int(m_n_mel * n_mag_frames),
- m_log_mel_temp_storage , int(m_log_mel_temp_storage_size),
- log_mels, m_stream);
-
- CUDA_CHECK(cudaStreamSynchronize(m_stream));
-
- // cleanup
- CUFFT_CHECK(cufftDestroy(plan));
- CUDA_CHECK(cudaFreeAsync(mel_data, m_stream));
- CUDA_CHECK(cudaFreeAsync(magnitudes, m_stream));
- CUDA_CHECK(cudaFreeAsync(stft_out, m_stream));
- CUDA_CHECK(cudaFreeAsync(stft_in, m_stream));
- CUDA_CHECK(cudaFreeAsync(cu_padded_samples, m_stream));
-
- return ret;
- }
-};
-
-}
-
-whisper_mel_calc * whisper_mel_calc_create_cuda(ggml_backend_t backend, const whisper_filters & filters) {
- try {
- return new mel_calc_cuda(backend, filters);
- }
- catch (...) {
- // TODO: log error (but for this we would have to expose the log state to be accessible here)
- return nullptr;
- }
-}
diff --git a/whisper.cpp/whisper.cpp b/whisper.cpp/whisper.cpp
deleted file mode 100644
index c6489311..00000000
--- a/whisper.cpp/whisper.cpp
+++ /dev/null
@@ -1,7447 +0,0 @@
-// -*- mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8 -*-
-// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
-#include "llama.cpp/ggml-vector.h"
-#include "llama.cpp/cores.h"
-#include "whisper.h"
-
-#define GGML_USE_CUDA
-#define GGML_USE_METAL
-
-#ifdef GGML_USE_METAL
-#include "llama.cpp/ggml-metal.h"
-#endif
-
-#ifdef GGML_USE_CUDA
-#include "llama.cpp/ggml-cuda.h"
-#include "whisper.cpp/whisper-mel-cuda.hpp"
-#endif
-
-#include "llama.cpp/ggml.h"
-#include "llama.cpp/ggml-alloc.h"
-#include "llama.cpp/ggml-backend.h"
-
-#include "llamafile/llamafile.h"
-
-#include "whisper-mel.hpp"
-
-#include <atomic>
-#include <algorithm>
-#include <cassert>
-#define _USE_MATH_DEFINES
-#include <cmath>
-#include <cstdio>
-#include <cstdarg>
-#include <cstring>
-#include <fstream>
-#include <map>
-#include <set>
-#include <string>
-#include <thread>
-#include <vector>
-#include <regex>
-#include <random>
-#include <functional>
-#include <codecvt>
-
-#if defined(_MSC_VER)
-#pragma warning(disable: 4244 4267) // possible loss of data
-#endif
-
-#if defined(GGML_BIG_ENDIAN)
-#include <bit>
-
-template<typename T>
-static T byteswap(T value) {
- return std::byteswap(value);
-}
-
-template<>
-float byteswap(float value) {
- return std::bit_cast<float>(byteswap(std::bit_cast<std::uint32_t>(value)));
-}
-
-template<typename T>
-static void byteswap_tensor_data(ggml_tensor * tensor) {
- T * datum = reinterpret_cast<T *>(tensor->data);
- for (int i = 0; i < ggml_nelements(tensor); i++) {
- datum[i] = byteswap(datum[i]);
- }
-}
-
-static void byteswap_tensor(ggml_tensor * tensor) {
- switch (tensor->type) {
- case GGML_TYPE_I16: {
- byteswap_tensor_data<int16_t>(tensor);
- break;
- }
- case GGML_TYPE_F16: {
- byteswap_tensor_data<ggml_fp16_t>(tensor);
- break;
- }
- case GGML_TYPE_I32: {
- byteswap_tensor_data<int32_t>(tensor);
- break;
- }
- case GGML_TYPE_F32: {
- byteswap_tensor_data<float>(tensor);
- break;
- }
- default: { // GML_TYPE_I8
- break;
- }
- }
-}
-
-#define BYTESWAP_VALUE(d) d = byteswap(d)
-#define BYTESWAP_FILTERS(f) \
- do { \
- for (auto & datum : f.data) { \
- datum = byteswap(datum); \
- } \
- } while (0)
-#define BYTESWAP_TENSOR(t) \
- do { \
- byteswap_tensor(t); \
- } while (0)
-#else
-#define BYTESWAP_VALUE(d) do {} while (0)
-#define BYTESWAP_FILTERS(f) do {} while (0)
-#define BYTESWAP_TENSOR(t) do {} while (0)
-#endif
-
-#ifdef __GNUC__
-#ifdef __MINGW32__
-#define WHISPER_ATTRIBUTE_FORMAT(...) __attribute__((format(gnu_printf, __VA_ARGS__)))
-#else
-#define WHISPER_ATTRIBUTE_FORMAT(...) __attribute__((format(printf, __VA_ARGS__)))
-#endif
-#else
-#define WHISPER_ATTRIBUTE_FORMAT(...)
-#endif
-
-//
-// logging
-//
-
-WHISPER_ATTRIBUTE_FORMAT(2, 3)
-static void whisper_log_internal (ggml_log_level level, const char * format, ...);
-static void whisper_log_callback_default(ggml_log_level level, const char * text, void * user_data);
-
-#define WHISPER_LOG_ERROR(...) whisper_log_internal(GGML_LOG_LEVEL_ERROR, __VA_ARGS__)
-#define WHISPER_LOG_WARN(...) whisper_log_internal(GGML_LOG_LEVEL_WARN , __VA_ARGS__)
-#define WHISPER_LOG_INFO(...) whisper_log_internal(GGML_LOG_LEVEL_INFO , __VA_ARGS__)
-
-// define this to enable verbose trace logging - useful for debugging purposes
-//#define WHISPER_DEBUG
-
-#if defined(WHISPER_DEBUG)
-#define WHISPER_LOG_DEBUG(...) whisper_log_internal(GGML_LOG_LEVEL_DEBUG, __VA_ARGS__)
-#else
-#define WHISPER_LOG_DEBUG(...)
-#endif
-
-#define WHISPER_ASSERT(x) \
- do { \
- if (!(x)) { \
- WHISPER_LOG_ERROR("WHISPER_ASSERT: %s:%d: %s\n", __FILE__, __LINE__, #x); \
- abort(); \
- } \
- } while (0)
-
-//#define WHISPER_USE_FLASH_FF
-#define WHISPER_MAX_DECODERS 8
-#define WHISPER_MAX_NODES 4096
-
-//
-// ggml helpers
-//
-
-static bool ggml_graph_compute_helper(
- struct ggml_cgraph * graph,
- std::vector<uint8_t> & buf,
- int n_threads,
- ggml_abort_callback abort_callback,
- void * abort_callback_data) {
- struct ggml_cplan plan = ggml_graph_plan(graph, n_threads);
-
- plan.abort_callback = abort_callback;
- plan.abort_callback_data = abort_callback_data;
-
- if (plan.work_size > 0) {
- buf.resize(plan.work_size);
- plan.work_data = buf.data();
- }
-
- return ggml_graph_compute(graph, &plan);
-}
-
-static bool ggml_graph_compute_helper(
- ggml_backend_sched_t sched,
- struct ggml_cgraph * graph,
- int n_threads) {
-
- for (int i = 0; i < ggml_backend_sched_get_n_backends(sched); ++i) {
- ggml_backend_t backend = ggml_backend_sched_get_backend(sched, i);
- if (ggml_backend_is_cpu(backend)) {
- ggml_backend_cpu_set_n_threads(backend, n_threads);
- }
-#ifdef GGML_USE_BLAS
- if (ggml_backend_is_blas(backend)) {
- ggml_backend_blas_set_n_threads(backend, n_threads);
- }
-#endif
-#ifdef GGML_USE_METAL
- if (ggml_backend_is_metal(backend)) {
- ggml_backend_metal_set_n_cb(backend, n_threads);
- }
-#endif
- }
-
- bool t = ggml_backend_sched_graph_compute(sched, graph) == GGML_STATUS_SUCCESS;
- ggml_backend_sched_reset(sched);
- return t;
-}
-
-// faster matrix multiplications for tensors that do not have dimension 0 divisible by "pad"
-// the idea is to represent the original matrix multiplication:
-//
-// Z = X @ Y
-//
-// with the sum of two matrix multiplications:
-//
-// Z = (X_0 @ Y_0) + (X_1 @ Y_1)
-//
-// here X_0 and Y_0 are views of X and Y that have dimension 0 divisible by "pad"
-// and X_1 and Y_1 are the remaining views. X_1 and Y_1 end up being small matrices that can be processed with more
-// general-purpose kernels
-//
-static struct ggml_tensor * ggml_mul_mat_pad(struct ggml_context * ctx, struct ggml_tensor * x, struct ggml_tensor * y) {
- int pad = 32;
- // use padding only if dimension 0 is at least 8 times larger than the padding
- // else we won't get much benefit from the optimization
- const int n_pad_req = 8;
-
- if (x->ne[0] % pad == 0 || x->ne[0] / pad < n_pad_req) {
- return ggml_mul_mat(ctx, x, y);
- }
-
- struct ggml_tensor * x_0 = ggml_view_3d(ctx, x, (x->ne[0]/pad)*pad, x->ne[1], x->ne[2], x->nb[1], x->nb[2], 0);
- struct ggml_tensor * x_1 = ggml_view_3d(ctx, x, x->ne[0]%pad, x->ne[1], x->ne[2], x->nb[1], x->nb[2], x_0->ne[0]*x_0->nb[0]);
-
- struct ggml_tensor * y_0 = ggml_view_3d(ctx, y, (y->ne[0]/pad)*pad, y->ne[1], y->ne[2], y->nb[1], y->nb[2], 0);
- struct ggml_tensor * y_1 = ggml_view_3d(ctx, y, y->ne[0]%pad, y->ne[1], y->ne[2], y->nb[1], y->nb[2], y_0->ne[0]*y_0->nb[0]);
-
- return ggml_add(ctx,
- ggml_mul_mat(ctx, x_0, y_0),
- ggml_mul_mat(ctx, x_1, y_1));
-}
-
-// TODO: check if other platforms can benefit from this optimization
-// TODO: CUDA is currently broken - seems ggml_mul_mat does not handle views correctly
-#if defined(GGML_USE_METAL)
-#define ggml_mul_mat (llamafile_has_metal() ? ggml_mul_mat_pad : ggml_mul_mat)
-#endif
-
-// available whisper models
-enum e_model {
- MODEL_UNKNOWN,
- MODEL_TINY,
- MODEL_BASE,
- MODEL_SMALL,
- MODEL_MEDIUM,
- MODEL_LARGE,
-};
-
-static const std::map<e_model, std::string> g_model_name = {
- { MODEL_UNKNOWN, "unknown" },
- { MODEL_TINY, "tiny" },
- { MODEL_BASE, "base" },
- { MODEL_SMALL, "small" },
- { MODEL_MEDIUM, "medium" },
- { MODEL_LARGE, "large" },
-};
-
-static const std::map<std::string, std::pair<int, std::string>> g_lang = {
- { "en", { 0, "english", } },
- { "zh", { 1, "chinese", } },
- { "de", { 2, "german", } },
- { "es", { 3, "spanish", } },
- { "ru", { 4, "russian", } },
- { "ko", { 5, "korean", } },
- { "fr", { 6, "french", } },
- { "ja", { 7, "japanese", } },
- { "pt", { 8, "portuguese", } },
- { "tr", { 9, "turkish", } },
- { "pl", { 10, "polish", } },
- { "ca", { 11, "catalan", } },
- { "nl", { 12, "dutch", } },
- { "ar", { 13, "arabic", } },
- { "sv", { 14, "swedish", } },
- { "it", { 15, "italian", } },
- { "id", { 16, "indonesian", } },
- { "hi", { 17, "hindi", } },
- { "fi", { 18, "finnish", } },
- { "vi", { 19, "vietnamese", } },
- { "he", { 20, "hebrew", } },
- { "uk", { 21, "ukrainian", } },
- { "el", { 22, "greek", } },
- { "ms", { 23, "malay", } },
- { "cs", { 24, "czech", } },
- { "ro", { 25, "romanian", } },
- { "da", { 26, "danish", } },
- { "hu", { 27, "hungarian", } },
- { "ta", { 28, "tamil", } },
- { "no", { 29, "norwegian", } },
- { "th", { 30, "thai", } },
- { "ur", { 31, "urdu", } },
- { "hr", { 32, "croatian", } },
- { "bg", { 33, "bulgarian", } },
- { "lt", { 34, "lithuanian", } },
- { "la", { 35, "latin", } },
- { "mi", { 36, "maori", } },
- { "ml", { 37, "malayalam", } },
- { "cy", { 38, "welsh", } },
- { "sk", { 39, "slovak", } },
- { "te", { 40, "telugu", } },
- { "fa", { 41, "persian", } },
- { "lv", { 42, "latvian", } },
- { "bn", { 43, "bengali", } },
- { "sr", { 44, "serbian", } },
- { "az", { 45, "azerbaijani", } },
- { "sl", { 46, "slovenian", } },
- { "kn", { 47, "kannada", } },
- { "et", { 48, "estonian", } },
- { "mk", { 49, "macedonian", } },
- { "br", { 50, "breton", } },
- { "eu", { 51, "basque", } },
- { "is", { 52, "icelandic", } },
- { "hy", { 53, "armenian", } },
- { "ne", { 54, "nepali", } },
- { "mn", { 55, "mongolian", } },
- { "bs", { 56, "bosnian", } },
- { "kk", { 57, "kazakh", } },
- { "sq", { 58, "albanian", } },
- { "sw", { 59, "swahili", } },
- { "gl", { 60, "galician", } },
- { "mr", { 61, "marathi", } },
- { "pa", { 62, "punjabi", } },
- { "si", { 63, "sinhala", } },
- { "km", { 64, "khmer", } },
- { "sn", { 65, "shona", } },
- { "yo", { 66, "yoruba", } },
- { "so", { 67, "somali", } },
- { "af", { 68, "afrikaans", } },
- { "oc", { 69, "occitan", } },
- { "ka", { 70, "georgian", } },
- { "be", { 71, "belarusian", } },
- { "tg", { 72, "tajik", } },
- { "sd", { 73, "sindhi", } },
- { "gu", { 74, "gujarati", } },
- { "am", { 75, "amharic", } },
- { "yi", { 76, "yiddish", } },
- { "lo", { 77, "lao", } },
- { "uz", { 78, "uzbek", } },
- { "fo", { 79, "faroese", } },
- { "ht", { 80, "haitian creole", } },
- { "ps", { 81, "pashto", } },
- { "tk", { 82, "turkmen", } },
- { "nn", { 83, "nynorsk", } },
- { "mt", { 84, "maltese", } },
- { "sa", { 85, "sanskrit", } },
- { "lb", { 86, "luxembourgish", } },
- { "my", { 87, "myanmar", } },
- { "bo", { 88, "tibetan", } },
- { "tl", { 89, "tagalog", } },
- { "mg", { 90, "malagasy", } },
- { "as", { 91, "assamese", } },
- { "tt", { 92, "tatar", } },
- { "haw", { 93, "hawaiian", } },
- { "ln", { 94, "lingala", } },
- { "ha", { 95, "hausa", } },
- { "ba", { 96, "bashkir", } },
- { "jw", { 97, "javanese", } },
- { "su", { 98, "sundanese", } },
- { "yue", { 99, "cantonese", } },
-};
-
-// [EXPERIMENTAL] Token-level timestamps with DTW
-static const whisper_ahead g_aheads_tiny_en[] = { {1, 0}, {2, 0}, {2, 5}, {3, 0}, {3, 1}, {3, 2}, {3, 3}, {3, 4} };
-static const whisper_ahead g_aheads_tiny[] = { {2, 2}, {3, 0}, {3, 2}, {3, 3}, {3, 4}, {3, 5} };
-static const whisper_ahead g_aheads_base_en[] = { {3, 3}, {4, 7}, {5, 1}, {5, 5}, {5, 7} };
-static const whisper_ahead g_aheads_base[] = { {3, 1}, {4, 2}, {4, 3}, {4, 7}, {5, 1}, {5, 2}, {5, 4}, {5, 6} };
-static const whisper_ahead g_aheads_small_en[] = { {6, 6}, {7, 0}, {7, 3}, {7, 8}, {8, 2}, {8, 5}, {8, 7}, {9, 0}, {9, 4}, {9, 8}, {9, 10}, {10, 0}, {10, 1}, {10, 2}, {10, 3}, {10, 6}, {10, 11}, {11, 2}, {11, 4} };
-static const whisper_ahead g_aheads_small[] = { {5, 3}, {5, 9}, {8, 0}, {8, 4}, {8, 7}, {8, 8}, {9, 0}, {9, 7}, {9, 9}, {10, 5} };
-static const whisper_ahead g_aheads_medium_en[] = { {11, 4}, {14, 1}, {14, 12}, {14, 14}, {15, 4}, {16, 0}, {16, 4}, {16, 9}, {17, 12}, {17, 14}, {18, 7}, {18, 10}, {18, 15}, {20, 0}, {20, 3}, {20, 9}, {20, 14}, {21, 12} };
-static const whisper_ahead g_aheads_medium[] = { {13, 15}, {15, 4}, {15, 15}, {16, 1}, {20, 0}, {23, 4} };
-static const whisper_ahead g_aheads_large_v1[] = { {9, 19}, {11, 2}, {11, 4}, {11, 17}, {22, 7}, {22, 11}, {22, 17}, {23, 2}, {23, 15} };
-static const whisper_ahead g_aheads_large_v2[] = { {10, 12}, {13, 17}, {16, 11}, {16, 12}, {16, 13}, {17, 15}, {17, 16}, {18, 4}, {18, 11}, {18, 19}, {19, 11}, {21, 2}, {21, 3}, {22, 3}, {22, 9}, {22, 12}, {23, 5}, {23, 7}, {23, 13}, {25, 5}, {26, 1}, {26, 12}, {27, 15} };
-static const whisper_ahead g_aheads_large_v3[] = { {7, 0}, {10, 17}, {12, 18}, {13, 12}, {16, 1}, {17, 14}, {19, 11}, {21, 4}, {24, 1}, {25, 6} };
-
-static const std::map<whisper_alignment_heads_preset, whisper_aheads> g_aheads {
- { WHISPER_AHEADS_TINY_EN, { 8, g_aheads_tiny_en } },
- { WHISPER_AHEADS_TINY, { 6, g_aheads_tiny } },
- { WHISPER_AHEADS_BASE_EN, { 5, g_aheads_base_en } },
- { WHISPER_AHEADS_BASE, { 8, g_aheads_base } },
- { WHISPER_AHEADS_SMALL_EN, { 19, g_aheads_small_en } },
- { WHISPER_AHEADS_SMALL, { 10, g_aheads_small } },
- { WHISPER_AHEADS_MEDIUM_EN, { 18, g_aheads_medium_en } },
- { WHISPER_AHEADS_MEDIUM, { 6, g_aheads_medium } },
- { WHISPER_AHEADS_LARGE_V1, { 9, g_aheads_large_v1 } },
- { WHISPER_AHEADS_LARGE_V2, { 23, g_aheads_large_v2 } },
- { WHISPER_AHEADS_LARGE_V3, { 10, g_aheads_large_v3 } },
-};
-
-static std::vector<uint32_t> get_alignment_heads_by_layer(const whisper_context_params & cparams, int il, int32_t n_text_layer, int32_t n_head);
-
-struct whisper_vocab {
- using id = int32_t;
- using token = std::string;
-
- int n_vocab = 51864;
-
- std::map<token, id> token_to_id;
- std::map<id, token> id_to_token;
-
- // reference: https://github.com/openai/whisper/blob/248b6cb124225dd263bb9bd32d060b6517e067f8/whisper/tokenizer.py#L334-L349
- id token_eot = 50256;
- id token_sot = 50257;
- // task tokens (used only for multilingual models)
- id token_translate = 50357;
- id token_transcribe = 50358;
- // other special tokens
- id token_solm = 50359; // [TDRZ] used by tinydiarize models to indicate speaker turn
- id token_prev = 50360;
- id token_nosp = 50361;
- id token_not = 50362; // no timestamps
- id token_beg = 50363; // begin timestamps
-
- bool is_multilingual() const {
- return n_vocab >= 51865;
- }
-
- int num_languages() const {
- return n_vocab - 51765 - (is_multilingual() ? 1 : 0);
- }
-};
-
-struct whisper_segment {
- int64_t t0;
- int64_t t1;
-
- std::string text;
-
- std::vector<whisper_token_data> tokens;
-
- bool speaker_turn_next;
-};
-
-struct whisper_batch {
- int32_t n_tokens;
-
- whisper_token * token;
- whisper_pos * pos;
- int32_t * n_seq_id; // always 1, here for consistency with llama.cpp
- whisper_seq_id ** seq_id; // null terminated
- int8_t * logits;
-};
-
-static struct whisper_batch whisper_batch_init(int32_t n_tokens, int32_t n_seq_max) {
- whisper_batch batch = { 0, nullptr, nullptr, nullptr, nullptr, nullptr, };
-
- batch.token = (whisper_token * ) malloc(sizeof(whisper_token) * (n_tokens));
- batch.pos = (whisper_pos *) malloc(sizeof(whisper_pos) * (n_tokens));
- batch.n_seq_id = (int32_t *) malloc(sizeof(int32_t) * (n_tokens));
- batch.seq_id = (whisper_seq_id **) malloc(sizeof(whisper_seq_id *) * (n_tokens + 1));
- for (int i = 0; i < n_tokens; ++i) {
- batch.seq_id[i] = (whisper_seq_id *) malloc(sizeof(whisper_seq_id) * n_seq_max);
- }
- batch.seq_id[n_tokens] = nullptr;
- batch.logits = (int8_t *) malloc(sizeof(int8_t) * n_tokens);
-
- return batch;
-}
-
-static void whisper_batch_free(struct whisper_batch batch) {
- if (batch.token) free(batch.token);
- if (batch.pos) free(batch.pos);
- if (batch.n_seq_id) free(batch.n_seq_id);
- if (batch.seq_id) {
- for (int i = 0; batch.seq_id[i]; ++i) {
- free(batch.seq_id[i]);
- }
- free(batch.seq_id);
- }
- if (batch.logits) free(batch.logits);
-}
-
-static void whisper_batch_prep_legacy(whisper_batch & batch, const whisper_token * tokens, int n_tokens, int n_past, int seq_id) {
- batch.n_tokens = n_tokens;
- for (int i = 0; i < n_tokens; ++i) {
- if (tokens) {
- batch.token[i] = tokens[i];
- }
- batch.pos [i] = n_past + i;
- batch.n_seq_id[i] = 1;
- batch.seq_id [i][0] = seq_id;
- batch.logits [i] = 0;
- }
- batch.logits[n_tokens - 1] = 1;
-}
-
-// replace std::pair by using customized pair struct (reason: std::pair is very slow)
-template<typename A, typename B>
-struct whisper_pair {
- A first;
- B second;
-
- // Define a constructor that takes two arguments.
- whisper_pair(const A& a, const B& b) : first(a), second(b) {}
- // Define a constructor that takes no argument.
- whisper_pair() : first(A()), second(B()) {}
-};
-
-// ggml_backend_sched wrapper for whisper usage
-struct whisper_sched {
- ggml_backend_sched_t sched = nullptr;
-
- std::vector<uint8_t> meta;
-};
-
-static size_t whisper_sched_size(struct whisper_sched & allocr) {
- size_t size = allocr.meta.size();
- for (int i = 0; i < ggml_backend_sched_get_n_backends(allocr.sched); ++i) {
- ggml_backend_t backend = ggml_backend_sched_get_backend(allocr.sched, i);
- size += ggml_backend_sched_get_buffer_size(allocr.sched, backend);
- }
- return size;
-}
-
-// measure the memory usage of a graph and prepare the allocr's internal data buffer
-static bool whisper_sched_graph_init(struct whisper_sched & allocr, std::vector<ggml_backend_t> backends, std::function<struct ggml_cgraph *()> && get_graph) {
- auto & sched = allocr.sched;
- auto & meta = allocr.meta;
-
- sched = ggml_backend_sched_new(backends.data(), nullptr, backends.size(), WHISPER_MAX_NODES, false);
-
- meta.resize(ggml_tensor_overhead()*WHISPER_MAX_NODES + ggml_graph_overhead());
-
- // since there are dependencies between the different graphs,
- // we need to allocate them instead of only reserving to get the correct compute buffer size
- if (!ggml_backend_sched_alloc_graph(sched, get_graph())) {
- // failed to allocate the compute buffer
- WHISPER_LOG_ERROR("%s: failed to allocate the compute buffer\n", __func__);
- return false;
- }
-
- ggml_backend_sched_reset(sched);
-
- return true;
-}
-
-// medium
-// hparams: {
-// 'n_mels': 80,
-// 'n_vocab': 51864,
-// 'n_audio_ctx': 1500,
-// 'n_audio_state': 1024,
-// 'n_audio_head': 16,
-// 'n_audio_layer': 24,
-// 'n_text_ctx': 448,
-// 'n_text_state': 1024,
-// 'n_text_head': 16,
-// 'n_text_layer': 24
-// }
-//
-// default hparams (Whisper tiny)
-struct whisper_hparams {
- int32_t n_vocab = 51864;
- int32_t n_audio_ctx = 1500;
- int32_t n_audio_state = 384;
- int32_t n_audio_head = 6;
- int32_t n_audio_layer = 4;
- int32_t n_text_ctx = 448;
- int32_t n_text_state = 384;
- int32_t n_text_head = 6;
- int32_t n_text_layer = 4;
- int32_t n_mels = 80;
- int32_t ftype = 1;
- float eps = 1e-5f;
-};
-
-// audio encoding layer
-struct whisper_layer_encoder {
- // encoder.blocks.*.attn_ln
- struct ggml_tensor * attn_ln_0_w;
- struct ggml_tensor * attn_ln_0_b;
-
- // encoder.blocks.*.attn.out
- struct ggml_tensor * attn_ln_1_w;
- struct ggml_tensor * attn_ln_1_b;
-
- // encoder.blocks.*.attn.query
- struct ggml_tensor * attn_q_w;
- struct ggml_tensor * attn_q_b;
-
- // encoder.blocks.*.attn.key
- struct ggml_tensor * attn_k_w;
-
- // encoder.blocks.*.attn.value
- struct ggml_tensor * attn_v_w;
- struct ggml_tensor * attn_v_b;
-
- // encoder.blocks.*.mlp_ln
- struct ggml_tensor * mlp_ln_w;
- struct ggml_tensor * mlp_ln_b;
-
- // encoder.blocks.*.mlp.0
- struct ggml_tensor * mlp_0_w;
- struct ggml_tensor * mlp_0_b;
-
- // encoder.blocks.*.mlp.2
- struct ggml_tensor * mlp_1_w;
- struct ggml_tensor * mlp_1_b;
-};
-
-// token decoding layer
-struct whisper_layer_decoder {
- // decoder.blocks.*.attn_ln
- struct ggml_tensor * attn_ln_0_w;
- struct ggml_tensor * attn_ln_0_b;
-
- // decoder.blocks.*.attn.out
- struct ggml_tensor * attn_ln_1_w;
- struct ggml_tensor * attn_ln_1_b;
-
- // decoder.blocks.*.attn.query
- struct ggml_tensor * attn_q_w;
- struct ggml_tensor * attn_q_b;
-
- // decoder.blocks.*.attn.key
- struct ggml_tensor * attn_k_w;
-
- // decoder.blocks.*.attn.value
- struct ggml_tensor * attn_v_w;
- struct ggml_tensor * attn_v_b;
-
- // decoder.blocks.*.cross_attn_ln
- struct ggml_tensor * cross_attn_ln_0_w;
- struct ggml_tensor * cross_attn_ln_0_b;
-
- // decoder.blocks.*.cross_attn.out
- struct ggml_tensor * cross_attn_ln_1_w;
- struct ggml_tensor * cross_attn_ln_1_b;
-
- // decoder.blocks.*.cross_attn.query
- struct ggml_tensor * cross_attn_q_w;
- struct ggml_tensor * cross_attn_q_b;
-
- // decoder.blocks.*.cross_attn.key
- struct ggml_tensor * cross_attn_k_w;
-
- // decoder.blocks.*.cross_attn.value
- struct ggml_tensor * cross_attn_v_w;
- struct ggml_tensor * cross_attn_v_b;
-
- // decoder.blocks.*.mlp_ln
- struct ggml_tensor * mlp_ln_w;
- struct ggml_tensor * mlp_ln_b;
-
- // decoder.blocks.*.mlp.0
- struct ggml_tensor * mlp_0_w;
- struct ggml_tensor * mlp_0_b;
-
- // decoder.blocks.*.mlp.2
- struct ggml_tensor * mlp_1_w;
- struct ggml_tensor * mlp_1_b;
-};
-
-struct whisper_kv_cell {
- whisper_pos pos = -1;
-
- std::set<whisper_seq_id> seq_id;
-
- bool has_seq_id(const whisper_seq_id & id) const {
- return seq_id.find(id) != seq_id.end();
- }
-};
-
-struct whisper_kv_cache {
- uint32_t head = 0;
- uint32_t size = 0;
-
- // computed before each graph build
- uint32_t n = 0;
-
- std::vector<whisper_kv_cell> cells;
-
- struct ggml_tensor * k;
- struct ggml_tensor * v;
-
- struct ggml_context * ctx = nullptr;
-
- ggml_backend_buffer_t buffer = nullptr;
-};
-
-struct whisper_model {
- e_model type = MODEL_UNKNOWN;
-
- whisper_hparams hparams;
- whisper_filters filters;
-
- // encoder.positional_embedding
- struct ggml_tensor * e_pe;
-
- // encoder.conv1
- struct ggml_tensor * e_conv_1_w;
- struct ggml_tensor * e_conv_1_b;
-
- // encoder.conv2
- struct ggml_tensor * e_conv_2_w;
- struct ggml_tensor * e_conv_2_b;
-
- // encoder.ln_post
- struct ggml_tensor * e_ln_w;
- struct ggml_tensor * e_ln_b;
-
- // decoder.positional_embedding
- struct ggml_tensor * d_pe;
-
- // decoder.token_embedding
- struct ggml_tensor * d_te;
-
- // decoder.ln
- struct ggml_tensor * d_ln_w;
- struct ggml_tensor * d_ln_b;
-
- std::vector<whisper_layer_encoder> layers_encoder;
- std::vector<whisper_layer_decoder> layers_decoder;
-
- // ggml context that contains all the meta information about the model tensors
- struct ggml_context * ctx = nullptr;
-
- // the model backend data is read-only and can be shared between processors
- ggml_backend_buffer_t buffer = nullptr;
-
- // tensors
- int n_loaded;
- std::map<std::string, struct ggml_tensor *> tensors;
-};
-
-struct whisper_partial_utf8 {
- uint32_t value; // bit value so far (unshifted)
- int n_remain; // num bytes remaining; -1 indicates invalid sequence
-};
-
-struct whisper_grammar {
- /*const*/ std::vector<std::vector<whisper_grammar_element>> rules;
- std::vector<std::vector<const whisper_grammar_element *>> stacks;
-
- // buffer for partially generated UTF-8 sequence from accepted tokens
- whisper_partial_utf8 partial_utf8;
-};
-
-struct whisper_grammar_candidate {
- whisper_token id;
- const uint32_t * code_points;
- whisper_partial_utf8 partial_utf8;
-};
-
-struct whisper_sequence {
- std::vector<whisper_token_data> tokens;
-
- // the accumulated transcription in the current iteration (used to truncate the tokens array)
- int result_len;
-
- double sum_logprobs_all; // the sum of the log probabilities of the tokens
- double sum_logprobs; // the sum of the log probabilities of the tokens (first result_len tokens)
- double avg_logprobs; // the average log probability of the tokens
- double entropy; // the entropy of the tokens
- double score; // likelihood rank score
-};
-
-// TAGS: WHISPER_DECODER_INIT
-struct whisper_decoder {
- // the currently generated sequence of tokens
- whisper_sequence sequence;
-
- // grammar parse state of generated sequence of tokens
- whisper_grammar grammar;
-
- int i_batch; // the index of the token in the current batch
- int seek_delta; // the window shift found so far based on the decoded timestamp tokens
-
- bool failed; // has the current segment failed to decode?
- bool completed; // has the decoder completed the current segment?
- bool has_ts; // have we already sampled a non-beg timestamp token for the current segment?
-
- // new token probs, logits and logprobs after the last whisper_decode (1-dimensional array: [n_vocab])
- std::vector<float> probs;
- std::vector<float> logits;
- std::vector<float> logprobs;
-
- // work container used to avoid memory allocations
- std::vector<whisper_pair<double, whisper_vocab::id>> logits_id;
-
- mutable std::mt19937 rng; // used for sampling at t > 0.0
-};
-
-// [EXPERIMENTAL] Token-level timestamps with DTW
-struct whisper_aheads_masks {
- std::vector<struct ggml_tensor *> m; // One mask per text layer.
- struct ggml_context * ctx = nullptr;
- ggml_backend_buffer_t buffer = nullptr;
-};
-
-struct whisper_state {
- int64_t t_sample_us = 0;
- int64_t t_encode_us = 0;
- int64_t t_decode_us = 0;
- int64_t t_batchd_us = 0;
- int64_t t_prompt_us = 0;
- int64_t t_mel_us = 0;
-
- int32_t n_sample = 0; // number of tokens sampled
- int32_t n_encode = 0; // number of encoder calls
- int32_t n_decode = 0; // number of decoder calls with n_tokens == 1 (text-generation)
- int32_t n_batchd = 0; // number of decoder calls with n_tokens < 16 (batch decoding)
- int32_t n_prompt = 0; // number of decoder calls with n_tokens > 1 (prompt encoding)
- int32_t n_fail_p = 0; // number of logprob threshold failures
- int32_t n_fail_h = 0; // number of entropy threshold failures
-
- // unified self-attention KV cache for all decoders
- whisper_kv_cache kv_self;
-
- // cross-attention KV cache for the decoders
- // shared between all decoders
- whisper_kv_cache kv_cross;
-
- // padded buffer for flash-attention
- whisper_kv_cache kv_pad;
-
- whisper_mel mel;
- whisper_mel_calc * mel_calc = nullptr;
- whisper_mel_calc * mel_calc_fallback = nullptr;
-
- whisper_batch batch;
-
- whisper_decoder decoders[WHISPER_MAX_DECODERS];
-
- std::vector<ggml_backend_t> backends;
-
- // - stores meta info about the intermediate tensors into the `meta` buffers
- whisper_sched sched_conv;
- whisper_sched sched_encode;
- whisper_sched sched_cross;
- whisper_sched sched_decode;
-
- // result of the encoder
- struct ggml_tensor * embd_conv = nullptr;
- struct ggml_tensor * embd_enc = nullptr;
-
- // helpers for GPU offloading
- std::vector<float> inp_mask;
-
- // decode output (2-dimensional array: [n_tokens][n_vocab])
- std::vector<float> logits;
-
- std::vector<whisper_segment> result_all;
- std::vector<whisper_token> prompt_past;
-
- int lang_id = 0; // english by default
-
- std::string path_model; // populated by whisper_init_from_file_with_params()
-
-#ifdef WHISPER_USE_COREML
- whisper_coreml_context * ctx_coreml = nullptr;
-#endif
-
-#ifdef WHISPER_USE_OPENVINO
- whisper_openvino_context * ctx_openvino = nullptr;
-#endif
-
- // [EXPERIMENTAL] token-level timestamps data
- int64_t t_beg = 0;
- int64_t t_last = 0;
-
- whisper_token tid_last;
-
- std::vector<float> energy; // PCM signal energy
-
- // [EXPERIMENTAL] Token-level timestamps with DTW
- whisper_aheads_masks aheads_masks;
- ggml_tensor * aheads_cross_QKs = nullptr;
- std::vector<float> aheads_cross_QKs_data;
-
- // [EXPERIMENTAL] speed-up techniques
- int32_t exp_n_audio_ctx = 0; // 0 - use default
-};
-
-struct whisper_context {
- int64_t t_load_us = 0;
- int64_t t_start_us = 0;
-
- ggml_type wtype = ggml_type::GGML_TYPE_F16; // weight type (FP32 / FP16 / QX)
- ggml_type itype = ggml_type::GGML_TYPE_F16; // intermediate type (FP32 or FP16)
-
- whisper_context_params params;
-
- whisper_model model;
- whisper_vocab vocab;
-
- whisper_state * state = nullptr;
-
- std::string path_model; // populated by whisper_init_from_file_with_params()
-};
-
-struct whisper_global {
- // We save the log callback globally
- ggml_log_callback log_callback = whisper_log_callback_default;
- void * log_callback_user_data = nullptr;
-};
-
-static whisper_global g_state;
-
-template<typename T>
-static void read_safe(whisper_model_loader * loader, T & dest) {
- loader->read(loader->context, &dest, sizeof(T));
- BYTESWAP_VALUE(dest);
-}
-
-static bool whisper_kv_cache_init(
- struct whisper_kv_cache & cache,
- ggml_backend_t backend,
- ggml_type wtype,
- int64_t n_text_state,
- int64_t n_text_layer,
- int n_ctx) {
- const int64_t n_mem = n_text_layer*n_ctx;
- const int64_t n_elements = n_text_state*n_mem;
-
- struct ggml_init_params params = {
- /*.mem_size =*/ 2*ggml_tensor_overhead(),
- /*.mem_buffer =*/ nullptr,
- /*.no_alloc =*/ true,
- };
-
- cache.head = 0;
- cache.size = n_ctx;
-
- cache.cells.clear();
- cache.cells.resize(n_ctx);
-
- cache.ctx = ggml_init(params);
-
- if (!cache.ctx) {
- WHISPER_LOG_ERROR("%s: failed to allocate memory for the kv cache context\n", __func__);
- return false;
- }
-
- cache.k = ggml_new_tensor_1d(cache.ctx, wtype, n_elements);
- cache.v = ggml_new_tensor_1d(cache.ctx, wtype, n_elements);
-
- cache.buffer = ggml_backend_alloc_ctx_tensors(cache.ctx, backend);
- if (!cache.buffer) {
- WHISPER_LOG_ERROR("%s: failed to allocate memory for the kv cache\n", __func__);
- return false;
- }
-
- ggml_backend_buffer_clear(cache.buffer, 0);
-
- return true;
-}
-
-static void whisper_kv_cache_free(struct whisper_kv_cache & cache) {
- ggml_free(cache.ctx);
- ggml_backend_buffer_free(cache.buffer);
- cache.ctx = nullptr;
-}
-
-static bool whisper_kv_cache_find_slot(
- struct whisper_kv_cache & cache,
- const struct whisper_batch & batch) {
- const uint32_t n_ctx = cache.size;
- const uint32_t n_tokens = batch.n_tokens;
-
- if (n_tokens > n_ctx) {
- WHISPER_LOG_ERROR("%s: n_tokens=%d > n_ctx=%d\n", __func__, n_tokens, n_ctx);
- return false;
- }
-
- uint32_t n_tested = 0;
-
- while (true) {
- if (cache.head + n_tokens > n_ctx) {
- n_tested += n_ctx - cache.head;
- cache.head = 0;
- continue;
- }
-
- bool found = true;
- for (uint32_t i = 0; i < n_tokens; i++) {
- if (cache.cells[cache.head + i].pos >= 0) {
- found = false;
- cache.head += i + 1;
- n_tested += i + 1;
- break;
- }
- }
-
- if (found) {
- break;
- }
-
- if (n_tested >= n_ctx) {
- //WHISPER_LOG_ERROR("%s: failed to find a slot for %d tokens\n", __func__, n_tokens);
- return false;
- }
- }
-
- for (uint32_t i = 0; i < n_tokens; i++) {
- cache.cells[cache.head + i].pos = batch.pos[i];
-
- for (int32_t j = 0; j < batch.n_seq_id[i]; j++) {
- cache.cells[cache.head + i].seq_id.insert(batch.seq_id[i][j]);
- }
- }
-
- return true;
-}
-
-// find how many cells are currently in use
-static int32_t whisper_kv_cache_cell_max(const struct whisper_kv_cache & cache) {
- for (uint32_t i = cache.size - 1; i > 0; --i) {
- if (cache.cells[i].pos >= 0 && !cache.cells[i].seq_id.empty()) {
- return i + 1;
- }
- }
-
- return 1;
-}
-
-static void whisper_kv_cache_clear(struct whisper_kv_cache & cache) {
- for (int32_t i = 0; i < (int32_t) cache.size; ++i) {
- cache.cells[i].pos = -1;
- cache.cells[i].seq_id.clear();
- }
- cache.head = 0;
-}
-
-static void whisper_kv_cache_seq_rm(
- struct whisper_kv_cache & cache,
- whisper_seq_id seq_id,
- whisper_pos p0,
- whisper_pos p1) {
- uint32_t new_head = cache.size;
-
- if (p0 < 0) p0 = 0;
- if (p1 < 0) p1 = std::numeric_limits<whisper_pos>::max();
-
- for (uint32_t i = 0; i < cache.size; ++i) {
- if (cache.cells[i].pos >= p0 && cache.cells[i].pos < p1) {
- if (seq_id < 0) {
- cache.cells[i].seq_id.clear();
- } else if (cache.cells[i].has_seq_id(seq_id)) {
- cache.cells[i].seq_id.erase(seq_id);
- } else {
- continue;
- }
- if (cache.cells[i].seq_id.empty()) {
- cache.cells[i].pos = -1;
- if (new_head == cache.size) new_head = i;
- }
- }
- }
-
- // If we freed up a slot, set head to it so searching can start there.
- if (new_head != cache.size) cache.head = new_head;
-}
-
-static void whisper_kv_cache_seq_cp(
- struct whisper_kv_cache & cache,
- whisper_seq_id seq_id_src,
- whisper_seq_id seq_id_dst,
- whisper_pos p0,
- whisper_pos p1) {
- if (p0 < 0) p0 = 0;
- if (p1 < 0) p1 = std::numeric_limits<whisper_pos>::max();
-
- cache.head = 0;
-
- for (uint32_t i = 0; i < cache.size; ++i) {
- if (cache.cells[i].has_seq_id(seq_id_src) && cache.cells[i].pos >= p0 && cache.cells[i].pos < p1) {
- cache.cells[i].seq_id.insert(seq_id_dst);
- }
- }
-}
-
-static uint32_t whisper_kv_cache_get_padding(const struct whisper_context & wctx) {
- if (!wctx.params.flash_attn) {
- return 1u;
- }
-
-#ifdef GGML_USE_METAL
- if (llamafile_has_metal()) {
- return 32u;
- }
-#endif
-
-#ifdef GGML_USE_CUDA
- if (llamafile_has_cuda()) {
- return 256u;
- }
-#endif
-
- return 1u;
-}
-
-// [EXPERIMENTAL] Token-level timestamps with DTW
-static bool aheads_masks_init(
- const whisper_context_params & cparams,
- const whisper_hparams & hparams,
- struct whisper_aheads_masks & aheads_masks,
- ggml_backend_t backend) {
-
- const int32_t n_text_layer = hparams.n_text_layer;
- const int32_t n_head = hparams.n_text_head;
-
- // Sanity checks
- if (cparams.dtw_aheads_preset == WHISPER_AHEADS_NONE) {
- WHISPER_LOG_ERROR("%s: dtw_aheads_preset should be != DTW_AHEADS_NONE\n", __func__);
- return false;
- } else if (cparams.dtw_aheads_preset == WHISPER_AHEADS_N_TOP_MOST) {
- if (cparams.dtw_n_top > n_text_layer || cparams.dtw_n_top <= 0) {
- WHISPER_LOG_ERROR("%s: dtw_n_top must be between %d and %d for this model.", __func__, 1, n_text_layer);
- return false;
- }
- } else {
- const auto aheads = cparams.dtw_aheads_preset == WHISPER_AHEADS_CUSTOM ? cparams.dtw_aheads : g_aheads.at(cparams.dtw_aheads_preset);
- if (cparams.dtw_aheads_preset == WHISPER_AHEADS_CUSTOM) {
- if (aheads.n_heads == 0) {
- WHISPER_LOG_ERROR("%s: dtw_aheads.n_heads should be > 0", __func__);
- return false;
- }
- if (aheads.heads == NULL) {
- WHISPER_LOG_ERROR("%s: dtw_aheads.heads unset", __func__);
- return false;
- }
- }
- for (size_t i = 0; i < aheads.n_heads; ++i) {
- if (aheads.heads[i].n_text_layer >= n_text_layer) {
- WHISPER_LOG_ERROR("%s: tried to set alignment head on text layer %d, but model only has %d text layers", __func__, aheads.heads[i].n_text_layer + 1, n_text_layer);
- return false;
- }
- if (aheads.heads[i].n_text_layer < 0) {
- WHISPER_LOG_ERROR("%s: tried to set alignment head on text layer < 0", __func__);
- return false;
- }
- if (aheads.heads[i].n_head >= n_head) {
- WHISPER_LOG_ERROR("%s: tried to set alignment head on head %d, but model only has %d heads", __func__, aheads.heads[i].n_head + 1, n_head);
- return false;
- }
- if (aheads.heads[i].n_head < 0) {
- WHISPER_LOG_ERROR("%s: tried to set alignment head on head < 0", __func__);
- return false;
- }
- }
- }
-
- struct ggml_init_params params = {
- /*.mem_size =*/ (size_t) static_cast<size_t>(n_text_layer)*ggml_tensor_overhead(),
- /*.mem_buffer =*/ nullptr,
- /*.no_alloc =*/ true,
- };
-
- aheads_masks.ctx = ggml_init(params);
-
- if (!aheads_masks.ctx) {
- WHISPER_LOG_ERROR("%s: failed to allocate memory for the aheads_masks context\n", __func__);
- return false;
- }
-
- for (int64_t il = 0; il < n_text_layer; ++il) {
- auto aheads = get_alignment_heads_by_layer(cparams, il, n_text_layer, n_head);
- if (!aheads.empty()) {
- aheads_masks.m.push_back(ggml_new_tensor_2d(aheads_masks.ctx, GGML_TYPE_F32, n_head, aheads.size()));
- } else {
- aheads_masks.m.push_back(nullptr);
- }
- }
-
- aheads_masks.buffer = ggml_backend_alloc_ctx_tensors(aheads_masks.ctx, backend);
- if (!aheads_masks.buffer) {
- WHISPER_LOG_ERROR("%s: failed to allocate memory for aheads_masks\n", __func__);
- return false;
- }
-
- // Set data on mask tensors
- // Since this must be backend agnostic, we write our desired values on mask_data,
- // and send it to backend with ggml_backend_tensor_set.
- // Each mask in N_HEADS*N_ALIGNMENT_HEADS, one per text layer containing alignment
- // heads. Each row of the mask "marks" one alignment head. E.g. if some text layer
- // has a total of 10 heads and of those, heads 0,5,6 are alignment heads, the mask
- // should read:
- // 1 0 0 0 0 0 0 0 0 0
- // 0 0 0 0 0 1 0 0 0 0
- // 0 0 0 0 0 0 1 0 0 0
- std::vector<float> mask_data;
- for (int64_t il = 0; il < n_text_layer; ++il) {
- if (aheads_masks.m[il] != nullptr) {
- auto aheads = get_alignment_heads_by_layer(cparams, il, n_text_layer, n_head);
-
- size_t data_size = aheads_masks.m[il]->ne[0] * aheads_masks.m[il]->ne[1];
- size_t data_size_bytes = data_size * sizeof(float);
- mask_data.resize(data_size);
-
- std::fill(mask_data.begin(), mask_data.end(), 0);
- for (size_t ih = 0; ih < aheads.size(); ++ih) {
- size_t pos = (aheads[ih] + (ih * aheads_masks.m[il]->ne[0]));
- mask_data[pos] = 1.0f;
- }
-
- ggml_backend_tensor_set(aheads_masks.m[il], mask_data.data(), 0, data_size_bytes);
- }
- }
-
- if (aheads_masks.m.empty()) {
- WHISPER_LOG_ERROR("%s: \n", __func__);
- return false;
- }
-
- return true;
-}
-
-static void aheads_masks_free(struct whisper_aheads_masks & aheads_masks) {
- ggml_free(aheads_masks.ctx);
- ggml_backend_buffer_free(aheads_masks.buffer);
- aheads_masks.ctx = nullptr;
-}
-
-static size_t aheads_masks_nbytes(struct whisper_aheads_masks & aheads_masks) {
- size_t size = 0;
- for (size_t i = 0; i < aheads_masks.m.size(); ++i) {
- if (aheads_masks.m[i] != nullptr)
- size += ggml_nbytes(aheads_masks.m[i]);
- }
- return size;
-}
-
-static ggml_backend_t whisper_backend_init_gpu(const whisper_context_params & params) {
- ggml_backend_t result = NULL;
-
-#ifdef GGML_USE_CUDA
- if (llamafile_has_cuda()) {
- WHISPER_LOG_INFO("%s: using CUDA backend\n", __func__);
- result = ggml_backend_cuda_init(params.gpu_device);
- if (!result) {
- WHISPER_LOG_ERROR("%s: ggml_backend_cuda_init() failed\n", __func__);
- }
- }
-#endif
-
-#ifdef GGML_USE_METAL
- if (!result && llamafile_has_metal()) {
- WHISPER_LOG_INFO("%s: using Metal backend\n", __func__);
- ggml_backend_metal_log_set_callback(g_state.log_callback, g_state.log_callback_user_data);
- result = ggml_backend_metal_init();
- if (!result) {
- WHISPER_LOG_ERROR("%s: ggml_backend_metal_init() failed\n", __func__);
- } else if (!ggml_backend_metal_supports_family(result, 7)) {
- WHISPER_LOG_ERROR("%s: Metal GPU does not support family 7 - falling back to CPU\n", __func__);
- ggml_backend_free(result);
- result = NULL;
- }
- }
-#endif
-
-#ifdef GGML_USE_SYCL
- if (params.use_gpu) {
- WHISPER_LOG_INFO("%s: using SYCL backend\n", __func__);
- result = ggml_backend_sycl_init(params.gpu_device);
- if (!result) {
- WHISPER_LOG_ERROR("%s: ggml_backend_sycl_init() failed\n", __func__);
- }
- }
-#endif
-
-#ifdef GGML_USE_VULKAN
- if (params.use_gpu) {
- WHISPER_LOG_INFO("%s: using Vulkan backend\n", __func__);
- result = ggml_backend_vk_init(params.gpu_device);
- if (!result) {
- WHISPER_LOG_ERROR("%s: ggml_backend_vk_init() failed\n", __func__);
- }
- }
-#endif
-
- return result;
-}
-
-static std::vector<ggml_backend_t> whisper_backend_init(const whisper_context_params & params) {
- std::vector<ggml_backend_t> result;
-
- ggml_backend_t backend_gpu = whisper_backend_init_gpu(params);
-
- if (backend_gpu) {
- result.push_back(backend_gpu);
- }
-
-#ifdef GGML_USE_BLAS
- {
- WHISPER_LOG_INFO("%s: using BLAS backend\n", __func__);
- ggml_backend_t backend_blas = ggml_backend_blas_init();
- if (!backend_blas) {
- WHISPER_LOG_ERROR("%s: ggml_backend_blas_init() failed\n", __func__);
- } else {
- result.push_back(backend_blas);
- }
- }
-#endif
-
- GGML_UNUSED(params);
-
- result.push_back(ggml_backend_cpu_init());
-
- return result;
-}
-
-static ggml_backend_buffer_type_t whisper_default_buffer_type(const whisper_context_params & params) {
- ggml_backend_buffer_type_t result = nullptr;
-
-#ifdef GGML_USE_CUDA
- if (!result && llamafile_has_cuda())
- result = ggml_backend_cuda_buffer_type(params.gpu_device);
-#endif
-
-#ifdef GGML_USE_METAL
- if (!result && llamafile_has_metal())
- result = ggml_backend_metal_buffer_type();
-#endif
-
-#ifdef GGML_USE_SYCL
- result || (result = ggml_backend_sycl_buffer_type(params.gpu_device));
-#endif
-
-#ifdef GGML_USE_VULKAN
- result || (result = ggml_backend_vk_buffer_type(params.gpu_device));
-#endif
-
- if (!result)
- result = ggml_backend_cpu_buffer_type();
-
- return result;
-}
-
-// load the model from a ggml file
-//
-// file format:
-//
-// - hparams
-// - pre-computed mel filters
-// - vocab
-// - weights
-//
-// see the convert-pt-to-ggml.py script for details
-//
-static bool whisper_model_load(struct whisper_model_loader * loader, whisper_context & wctx) {
- WHISPER_LOG_INFO("%s: loading model\n", __func__);
-
- const int64_t t_start_us = ggml_time_us();
-
- wctx.t_start_us = t_start_us;
-
- auto & model = wctx.model;
- auto & vocab = wctx.vocab;
-
- // verify magic
- {
- uint32_t magic;
- read_safe(loader, magic);
- if (magic != GGML_FILE_MAGIC) {
- WHISPER_LOG_ERROR("%s: invalid model data (bad magic)\n", __func__);
- return false;
- }
- }
-
- //load hparams
- {
- auto & hparams = model.hparams;
-
- read_safe(loader, hparams.n_vocab);
- read_safe(loader, hparams.n_audio_ctx);
- read_safe(loader, hparams.n_audio_state);
- read_safe(loader, hparams.n_audio_head);
- read_safe(loader, hparams.n_audio_layer);
- read_safe(loader, hparams.n_text_ctx);
- read_safe(loader, hparams.n_text_state);
- read_safe(loader, hparams.n_text_head);
- read_safe(loader, hparams.n_text_layer);
- read_safe(loader, hparams.n_mels);
- read_safe(loader, hparams.ftype);
-
- assert(hparams.n_text_state == hparams.n_audio_state);
-
- std::string mver = "";
-
- if (hparams.n_audio_layer == 4) {
- model.type = e_model::MODEL_TINY;
- }
-
- if (hparams.n_audio_layer == 6) {
- model.type = e_model::MODEL_BASE;
- }
-
- if (hparams.n_audio_layer == 12) {
- model.type = e_model::MODEL_SMALL;
- }
-
- if (hparams.n_audio_layer == 24) {
- model.type = e_model::MODEL_MEDIUM;
- }
-
- if (hparams.n_audio_layer == 32) {
- model.type = e_model::MODEL_LARGE;
-
- if (hparams.n_vocab == 51866) {
- mver = " v3";
- }
- }
-
- const int32_t qntvr = hparams.ftype / GGML_QNT_VERSION_FACTOR;
-
- hparams.ftype %= GGML_QNT_VERSION_FACTOR;
-
- // for the big tensors, we have the option to store the data in 16-bit floats or quantized
- // in order to save memory and also to speed up the computation
- wctx.wtype = ggml_ftype_to_ggml_type((ggml_ftype) (model.hparams.ftype));
- if (wctx.wtype == GGML_TYPE_COUNT) {
- WHISPER_LOG_ERROR("%s: invalid model (bad ftype value %d)\n", __func__, model.hparams.ftype);
- return false;
- }
-
- WHISPER_LOG_INFO("%s: n_vocab = %d\n", __func__, hparams.n_vocab);
- WHISPER_LOG_INFO("%s: n_audio_ctx = %d\n", __func__, hparams.n_audio_ctx);
- WHISPER_LOG_INFO("%s: n_audio_state = %d\n", __func__, hparams.n_audio_state);
- WHISPER_LOG_INFO("%s: n_audio_head = %d\n", __func__, hparams.n_audio_head);
- WHISPER_LOG_INFO("%s: n_audio_layer = %d\n", __func__, hparams.n_audio_layer);
- WHISPER_LOG_INFO("%s: n_text_ctx = %d\n", __func__, hparams.n_text_ctx);
- WHISPER_LOG_INFO("%s: n_text_state = %d\n", __func__, hparams.n_text_state);
- WHISPER_LOG_INFO("%s: n_text_head = %d\n", __func__, hparams.n_text_head);
- WHISPER_LOG_INFO("%s: n_text_layer = %d\n", __func__, hparams.n_text_layer);
- WHISPER_LOG_INFO("%s: n_mels = %d\n", __func__, hparams.n_mels);
- WHISPER_LOG_INFO("%s: ftype = %d\n", __func__, model.hparams.ftype);
- WHISPER_LOG_INFO("%s: qntvr = %d\n", __func__, qntvr);
- WHISPER_LOG_INFO("%s: type = %d (%s%s)\n", __func__, model.type, g_model_name.at(model.type).c_str(), mver.c_str());
- }
-
- // load mel filters
- {
- auto & filters = wctx.model.filters;
-
- read_safe(loader, filters.n_mel);
- read_safe(loader, filters.n_fft);
-
- filters.data.resize(filters.n_mel * filters.n_fft);
- loader->read(loader->context, filters.data.data(), filters.data.size() * sizeof(float));
- BYTESWAP_FILTERS(filters);
- }
-
- // load vocab
- {
- int32_t n_vocab = 0;
- read_safe(loader, n_vocab);
-
- //if (n_vocab != model.hparams.n_vocab) {
- // WHISPER_LOG_ERROR("%s: invalid model file '%s' (bad vocab size %d != %d)\n",
- // __func__, fname.c_str(), n_vocab, model.hparams.n_vocab);
- // return false;
- //}
-
- std::string word;
- std::vector<char> tmp;
-
- tmp.reserve(128);
-
- for (int i = 0; i < n_vocab; i++) {
- uint32_t len;
- read_safe(loader, len);
-
- if (len > 0) {
- tmp.resize(len);
- loader->read(loader->context, &tmp[0], tmp.size()); // read to buffer
- word.assign(&tmp[0], tmp.size());
- } else {
- // seems like we have an empty-string token in multi-language models (i = 50256)
- //WHISPER_LOG_WARN("%s: warning: empty-string token in vocab, i = %d\n", __func__, i);
- word = "";
- }
-
- vocab.token_to_id[word] = i;
- vocab.id_to_token[i] = word;
-
- //printf("%s: vocab[%d] = '%s'\n", __func__, i, word.c_str());
- }
-
- vocab.n_vocab = model.hparams.n_vocab;
- if (vocab.is_multilingual()) {
- vocab.token_eot++;
- vocab.token_sot++;
-
- // account for variable number of language tokens
- const int dt = vocab.num_languages() - 98;
-
- vocab.token_translate += dt;
- vocab.token_transcribe += dt;
- vocab.token_solm += dt;
- vocab.token_prev += dt;
- vocab.token_nosp += dt;
- vocab.token_not += dt;
- vocab.token_beg += dt;
- }
-
- if (n_vocab < model.hparams.n_vocab) {
- WHISPER_LOG_INFO("%s: adding %d extra tokens\n", __func__, model.hparams.n_vocab - n_vocab);
- for (int i = n_vocab; i < model.hparams.n_vocab; i++) {
- if (i > vocab.token_beg) {
- word = "[_TT_" + std::to_string(i - vocab.token_beg) + "]";
- } else if (i == vocab.token_eot) {
- word = "[_EOT_]";
- } else if (i == vocab.token_sot) {
- word = "[_SOT_]";
- } else if (i == vocab.token_translate) {
- word = "[_TRANSLATE_]";
- } else if (i == vocab.token_transcribe) {
- word = "[_TRANSCRIBE_]";
- } else if (i == vocab.token_solm) {
- word = "[_SOLM_]";
- } else if (i == vocab.token_prev) {
- word = "[_PREV_]";
- } else if (i == vocab.token_nosp) {
- word = "[_NOSP_]";
- } else if (i == vocab.token_not) {
- word = "[_NOT_]";
- } else if (i == vocab.token_beg) {
- word = "[_BEG_]";
- } else if (i > vocab.token_sot && i <= vocab.token_sot + vocab.num_languages()) {
- word = "[_LANG_" + std::string(whisper_lang_str(i - vocab.token_sot - 1)) + "]";
- } else {
- word = "[_extra_token_" + std::to_string(i) + "]";
- }
- vocab.token_to_id[word] = i;
- vocab.id_to_token[i] = word;
- }
- }
-
- WHISPER_LOG_INFO("%s: n_langs = %d\n", __func__, vocab.num_languages());
- }
-
- const ggml_type wtype = wctx.wtype;
- const ggml_type vtype = wctx.wtype == GGML_TYPE_F32 ? GGML_TYPE_F32 : GGML_TYPE_F16; // conv type
-
- // create the ggml context
- {
- const auto & hparams = model.hparams;
-
- const int n_audio_layer = hparams.n_audio_layer;
- const int n_text_layer = hparams.n_text_layer;
-
- const size_t n_tensors = 10 /* input */ + 15 + 15*n_audio_layer + 24*n_text_layer;
-
- struct ggml_init_params params = {
- /*.mem_size =*/ n_tensors*ggml_tensor_overhead(),
- /*.mem_buffer =*/ nullptr,
- /*.no_alloc =*/ true,
- };
-
- model.ctx = ggml_init(params);
- if (!model.ctx) {
- WHISPER_LOG_ERROR("%s: ggml_init() failed\n", __func__);
- return false;
- }
- }
-
- // prepare tensors for the weights
- {
- auto & ctx = model.ctx;
-
- const auto & hparams = model.hparams;
-
- const int n_vocab = hparams.n_vocab;
-
- const int n_audio_ctx = hparams.n_audio_ctx;
- const int n_audio_state = hparams.n_audio_state;
- const int n_audio_layer = hparams.n_audio_layer;
-
- const int n_text_ctx = hparams.n_text_ctx;
- const int n_text_state = hparams.n_text_state;
- const int n_text_layer = hparams.n_text_layer;
-
- const int n_mels = hparams.n_mels;
-
- model.layers_encoder.resize(n_audio_layer);
- model.layers_decoder.resize(n_text_layer);
-
- // encoder
- {
- model.e_pe = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, n_audio_state, n_audio_ctx);
-
- model.e_conv_1_w = ggml_new_tensor_3d(ctx, vtype, 3, n_mels, n_audio_state);
- model.e_conv_1_b = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, 1, n_audio_state);
-
- model.e_conv_2_w = ggml_new_tensor_3d(ctx, vtype, 3, n_audio_state, n_audio_state);
- model.e_conv_2_b = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, 1, n_audio_state);
-
- model.e_ln_w = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, n_audio_state);
- model.e_ln_b = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, n_audio_state);
-
- // map by name
- model.tensors["encoder.positional_embedding"] = model.e_pe;
-
- model.tensors["encoder.conv1.weight"] = model.e_conv_1_w;
- model.tensors["encoder.conv1.bias"] = model.e_conv_1_b;
-
- model.tensors["encoder.conv2.weight"] = model.e_conv_2_w;
- model.tensors["encoder.conv2.bias"] = model.e_conv_2_b;
-
- model.tensors["encoder.ln_post.weight"] = model.e_ln_w;
- model.tensors["encoder.ln_post.bias"] = model.e_ln_b;
-
- for (int i = 0; i < n_audio_layer; ++i) {
- auto & layer = model.layers_encoder[i];
-
- layer.mlp_ln_w = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, n_audio_state);
- layer.mlp_ln_b = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, n_audio_state);
-
- layer.mlp_0_w = ggml_new_tensor_2d(ctx, wtype, n_audio_state, 4*n_audio_state);
- layer.mlp_0_b = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, 4*n_audio_state);
-
- layer.mlp_1_w = ggml_new_tensor_2d(ctx, wtype, 4*n_audio_state, n_audio_state);
- layer.mlp_1_b = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, n_audio_state);
-
- layer.attn_ln_0_w = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, n_audio_state);
- layer.attn_ln_0_b = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, n_audio_state);
-
- layer.attn_q_w = ggml_new_tensor_2d(ctx, wtype, n_audio_state, n_audio_state);
- layer.attn_q_b = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, n_audio_state);
-
- layer.attn_k_w = ggml_new_tensor_2d(ctx, wtype, n_audio_state, n_audio_state);
-
- layer.attn_v_w = ggml_new_tensor_2d(ctx, wtype, n_audio_state, n_audio_state);
- layer.attn_v_b = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, n_audio_state);
-
- layer.attn_ln_1_w = ggml_new_tensor_2d(ctx, wtype, n_audio_state, n_audio_state);
- layer.attn_ln_1_b = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, n_audio_state);
-
- // map by name
- model.tensors["encoder.blocks." + std::to_string(i) + ".mlp_ln.weight"] = layer.mlp_ln_w;
- model.tensors["encoder.blocks." + std::to_string(i) + ".mlp_ln.bias"] = layer.mlp_ln_b;
-
- model.tensors["encoder.blocks." + std::to_string(i) + ".mlp.0.weight"] = layer.mlp_0_w;
- model.tensors["encoder.blocks." + std::to_string(i) + ".mlp.0.bias"] = layer.mlp_0_b;
-
- model.tensors["encoder.blocks." + std::to_string(i) + ".mlp.2.weight"] = layer.mlp_1_w;
- model.tensors["encoder.blocks." + std::to_string(i) + ".mlp.2.bias"] = layer.mlp_1_b;
-
- model.tensors["encoder.blocks." + std::to_string(i) + ".attn_ln.weight"] = layer.attn_ln_0_w;
- model.tensors["encoder.blocks." + std::to_string(i) + ".attn_ln.bias"] = layer.attn_ln_0_b;
-
- model.tensors["encoder.blocks." + std::to_string(i) + ".attn.query.weight"] = layer.attn_q_w;
- model.tensors["encoder.blocks." + std::to_string(i) + ".attn.query.bias"] = layer.attn_q_b;
-
- model.tensors["encoder.blocks." + std::to_string(i) + ".attn.key.weight"] = layer.attn_k_w;
-
- model.tensors["encoder.blocks." + std::to_string(i) + ".attn.value.weight"] = layer.attn_v_w;
- model.tensors["encoder.blocks." + std::to_string(i) + ".attn.value.bias"] = layer.attn_v_b;
-
- model.tensors["encoder.blocks." + std::to_string(i) + ".attn.out.weight"] = layer.attn_ln_1_w;
- model.tensors["encoder.blocks." + std::to_string(i) + ".attn.out.bias"] = layer.attn_ln_1_b;
- }
- }
-
- // decoder
- {
- model.d_pe = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, n_text_state, n_text_ctx);
-
- model.d_te = ggml_new_tensor_2d(ctx, wtype, n_text_state, n_vocab);
-
- model.d_ln_w = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, n_text_state);
- model.d_ln_b = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, n_text_state);
-
- // map by name
- model.tensors["decoder.positional_embedding"] = model.d_pe;
-
- model.tensors["decoder.token_embedding.weight"] = model.d_te;
-
- model.tensors["decoder.ln.weight"] = model.d_ln_w;
- model.tensors["decoder.ln.bias"] = model.d_ln_b;
-
- for (int i = 0; i < n_text_layer; ++i) {
- auto & layer = model.layers_decoder[i];
-
- layer.mlp_ln_w = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, n_text_state);
- layer.mlp_ln_b = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, n_text_state);
-
- layer.mlp_0_w = ggml_new_tensor_2d(ctx, wtype, n_text_state, 4*n_text_state);
- layer.mlp_0_b = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, 4*n_text_state);
-
- layer.mlp_1_w = ggml_new_tensor_2d(ctx, wtype, 4*n_text_state, n_text_state);
- layer.mlp_1_b = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, n_text_state);
-
- layer.attn_ln_0_w = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, n_text_state);
- layer.attn_ln_0_b = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, n_text_state);
-
- layer.attn_q_w = ggml_new_tensor_2d(ctx, wtype, n_text_state, n_text_state);
- layer.attn_q_b = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, n_text_state);
-
- layer.attn_k_w = ggml_new_tensor_2d(ctx, wtype, n_text_state, n_text_state);
-
- layer.attn_v_w = ggml_new_tensor_2d(ctx, wtype, n_text_state, n_text_state);
- layer.attn_v_b = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, n_text_state);
-
- layer.attn_ln_1_w = ggml_new_tensor_2d(ctx, wtype, n_text_state, n_text_state);
- layer.attn_ln_1_b = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, n_text_state);
-
- layer.cross_attn_ln_0_w = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, n_text_state);
- layer.cross_attn_ln_0_b = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, n_text_state);
-
- layer.cross_attn_q_w = ggml_new_tensor_2d(ctx, wtype, n_text_state, n_text_state);
- layer.cross_attn_q_b = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, n_text_state);
-
- layer.cross_attn_k_w = ggml_new_tensor_2d(ctx, wtype, n_text_state, n_text_state);
-
- layer.cross_attn_v_w = ggml_new_tensor_2d(ctx, wtype, n_text_state, n_text_state);
- layer.cross_attn_v_b = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, n_text_state);
-
- layer.cross_attn_ln_1_w = ggml_new_tensor_2d(ctx, wtype, n_text_state, n_text_state);
- layer.cross_attn_ln_1_b = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, n_text_state);
-
- // map by name
- model.tensors["decoder.blocks." + std::to_string(i) + ".mlp_ln.weight"] = layer.mlp_ln_w;
- model.tensors["decoder.blocks." + std::to_string(i) + ".mlp_ln.bias"] = layer.mlp_ln_b;
-
- model.tensors["decoder.blocks." + std::to_string(i) + ".mlp.0.weight"] = layer.mlp_0_w;
- model.tensors["decoder.blocks." + std::to_string(i) + ".mlp.0.bias"] = layer.mlp_0_b;
-
- model.tensors["decoder.blocks." + std::to_string(i) + ".mlp.2.weight"] = layer.mlp_1_w;
- model.tensors["decoder.blocks." + std::to_string(i) + ".mlp.2.bias"] = layer.mlp_1_b;
-
- model.tensors["decoder.blocks." + std::to_string(i) + ".attn_ln.weight"] = layer.attn_ln_0_w;
- model.tensors["decoder.blocks." + std::to_string(i) + ".attn_ln.bias"] = layer.attn_ln_0_b;
-
- model.tensors["decoder.blocks." + std::to_string(i) + ".attn.query.weight"] = layer.attn_q_w;
- model.tensors["decoder.blocks." + std::to_string(i) + ".attn.query.bias"] = layer.attn_q_b;
-
- model.tensors["decoder.blocks." + std::to_string(i) + ".attn.key.weight"] = layer.attn_k_w;
-
- model.tensors["decoder.blocks." + std::to_string(i) + ".attn.value.weight"] = layer.attn_v_w;
- model.tensors["decoder.blocks." + std::to_string(i) + ".attn.value.bias"] = layer.attn_v_b;
-
- model.tensors["decoder.blocks." + std::to_string(i) + ".attn.out.weight"] = layer.attn_ln_1_w;
- model.tensors["decoder.blocks." + std::to_string(i) + ".attn.out.bias"] = layer.attn_ln_1_b;
-
- model.tensors["decoder.blocks." + std::to_string(i) + ".cross_attn_ln.weight"] = layer.cross_attn_ln_0_w;
- model.tensors["decoder.blocks." + std::to_string(i) + ".cross_attn_ln.bias"] = layer.cross_attn_ln_0_b;
-
- model.tensors["decoder.blocks." + std::to_string(i) + ".cross_attn.query.weight"] = layer.cross_attn_q_w;
- model.tensors["decoder.blocks." + std::to_string(i) + ".cross_attn.query.bias"] = layer.cross_attn_q_b;
-
- model.tensors["decoder.blocks." + std::to_string(i) + ".cross_attn.key.weight"] = layer.cross_attn_k_w;
-
- model.tensors["decoder.blocks." + std::to_string(i) + ".cross_attn.value.weight"] = layer.cross_attn_v_w;
- model.tensors["decoder.blocks." + std::to_string(i) + ".cross_attn.value.bias"] = layer.cross_attn_v_b;
-
- model.tensors["decoder.blocks." + std::to_string(i) + ".cross_attn.out.weight"] = layer.cross_attn_ln_1_w;
- model.tensors["decoder.blocks." + std::to_string(i) + ".cross_attn.out.bias"] = layer.cross_attn_ln_1_b;
- }
- }
- }
-
- // allocate tensors in the backend buffers
- model.buffer = ggml_backend_alloc_ctx_tensors_from_buft(model.ctx, whisper_default_buffer_type(wctx.params));
- if (!model.buffer) {
- WHISPER_LOG_ERROR("%s: failed to allocate memory for the model\n", __func__);
- return false;
- }
-
- size_t size_main = ggml_backend_buffer_get_size(model.buffer);
- WHISPER_LOG_INFO("%s: %8s total size = %8.2f MB\n", __func__, ggml_backend_buffer_name(model.buffer), size_main / 1e6);
-
- // load weights
- {
- size_t total_size = 0;
-
- model.n_loaded = 0;
-
- std::vector<char> read_buf;
-
- while (true) {
- int32_t n_dims;
- int32_t length;
- int32_t ttype;
-
- read_safe(loader, n_dims);
- read_safe(loader, length);
- read_safe(loader, ttype);
-
- if (loader->eof(loader->context)) {
- break;
- }
-
- int32_t nelements = 1;
- int32_t ne[4] = { 1, 1, 1, 1 };
- for (int i = 0; i < n_dims; ++i) {
- read_safe(loader, ne[i]);
- nelements *= ne[i];
- }
-
- std::string name;
- std::vector<char> tmp(length); // create a buffer
- loader->read(loader->context, &tmp[0], tmp.size()); // read to buffer
- name.assign(&tmp[0], tmp.size());
-
- if (model.tensors.find(name) == model.tensors.end()) {
- WHISPER_LOG_ERROR("%s: unknown tensor '%s' in model file\n", __func__, name.data());
- return false;
- }
-
- auto tensor = model.tensors[name.data()];
-
- if (ggml_nelements(tensor) != nelements) {
- WHISPER_LOG_ERROR("%s: tensor '%s' has wrong size in model file\n", __func__, name.data());
- WHISPER_LOG_ERROR("%s: shape: [%d, %d, %d], expected: [%d, %d, %d]\n",
- __func__, ne[0], ne[1], ne[2], (int) tensor->ne[0], (int) tensor->ne[1], (int) tensor->ne[2]);
- return false;
- }
-
- if (tensor->ne[0] != ne[0] || tensor->ne[1] != ne[1] || tensor->ne[2] != ne[2]) {
- WHISPER_LOG_ERROR("%s: tensor '%s' has wrong shape in model file: got [%d, %d, %d], expected [%d, %d, %d]\n",
- __func__, name.data(), (int) tensor->ne[0], (int) tensor->ne[1], (int) tensor->ne[2], ne[0], ne[1], ne[2]);
- return false;
- }
-
- const size_t bpe = ggml_type_size(ggml_type(ttype));
-
- if ((nelements*bpe)/ggml_blck_size(tensor->type) != ggml_nbytes(tensor)) {
- WHISPER_LOG_ERROR("%s: tensor '%s' has wrong size in model file: got %zu, expected %zu\n",
- __func__, name.data(), ggml_nbytes(tensor), nelements*bpe);
- return false;
- }
-
- //ggml_backend_t backend = wctx.backend;
-
- //printf("%s: [%5.5s] %s\n", __func__, ggml_backend_name(backend), name.c_str());
-
- if (ggml_backend_buffer_is_host(model.buffer)) {
- // for the CPU and Metal backend, we can read directly into the tensor
- loader->read(loader->context, tensor->data, ggml_nbytes(tensor));
- BYTESWAP_TENSOR(tensor);
- } else {
- // read into a temporary buffer first, then copy to device memory
- read_buf.resize(ggml_nbytes(tensor));
-
- loader->read(loader->context, read_buf.data(), read_buf.size());
-
- ggml_backend_tensor_set(tensor, read_buf.data(), 0, ggml_nbytes(tensor));
- }
-
- //printf("%48s - [%5d, %5d, %5d], type = %6s, %6.2f MB\n", name.data(), ne[0], ne[1], ne[2], ggml_type_name((ggml_type) ttype), ggml_nbytes(tensor)/1e6);
- total_size += ggml_nbytes(tensor);
- model.n_loaded++;
- }
-
- WHISPER_LOG_INFO("%s: model size = %7.2f MB\n", __func__, total_size/1e6);
-
- if (model.n_loaded == 0) {
- WHISPER_LOG_WARN("%s: WARN no tensors loaded from model file - assuming empty model for testing\n", __func__);
- } else if (model.n_loaded != (int) model.tensors.size()) {
- WHISPER_LOG_ERROR("%s: ERROR not all tensors loaded from model file - expected %zu, got %d\n", __func__, model.tensors.size(), model.n_loaded);
- return false;
- }
- }
-
- ggml_backend_buffer_set_usage(model.buffer, GGML_BACKEND_BUFFER_USAGE_WEIGHTS);
-
- wctx.t_load_us = ggml_time_us() - t_start_us;
-
- return true;
-}
-
-static bool whisper_encode_external(const whisper_state & wstate) {
- GGML_UNUSED(wstate);
-
-#ifndef WHISPER_USE_COREML
- const bool use_coreml = false;
-#else
- const bool use_coreml = wstate.ctx_coreml != nullptr;
-#endif
-
-#ifndef WHISPER_USE_OPENVINO
- const bool use_openvino = false;
-#else
- const bool use_openvino = wstate.ctx_openvino != nullptr;
-#endif
-
- return use_coreml || use_openvino;
-}
-
-static struct ggml_cgraph * whisper_build_graph_conv(
- whisper_context & wctx,
- whisper_state & wstate,
- const int mel_offset) {
- const auto & model = wctx.model;
- const auto & hparams = model.hparams;
-
- const int n_ctx = wstate.exp_n_audio_ctx > 0 ? wstate.exp_n_audio_ctx : hparams.n_audio_ctx;
- const int n_state = hparams.n_audio_state; GGML_UNUSED(n_state);
-
- const int n_mels = hparams.n_mels;
-
- struct ggml_init_params params = {
- /*.mem_size =*/ wstate.sched_conv.meta.size(),
- /*.mem_buffer =*/ wstate.sched_conv.meta.data(),
- /*.no_alloc =*/ true,
- };
-
- struct ggml_context * ctx0 = ggml_init(params);
-
- ggml_cgraph * gf = ggml_new_graph(ctx0);
-
- GGML_ASSERT(wstate.mel.tensor);
-
- ggml_tensor * mel_inp = wstate.mel.tensor;
- ggml_set_input(mel_inp);
-
- ggml_tensor * mel;
- if (ggml_nelements(mel_inp) > 0) {
- const int n_len = int(mel_inp->ne[0]);
- const int out_s = 2 * n_ctx;
- const int i0 = std::min(mel_offset, n_len);
- const int i1 = std::min(mel_offset + out_s, n_len);
- const int mel_s = i1 - i0;
-
- assert(mel_inp->type == GGML_TYPE_F32);
- assert(mel_inp->ne[1] == n_mels);
-
- ggml_tensor * cur = ggml_view_2d(ctx0, mel_inp, out_s, n_mels, mel_inp->nb[1], ggml_row_size(mel_inp->type, i0));
-
- if (mel_s < out_s) {
- mel = ggml_pad(ctx0, cur, out_s - mel_s, 0, 0, 0);
- } else {
- mel = ggml_cont(ctx0, cur);
- }
- } else {
- // empty mel - just create a dummy tensor with the correct size
- mel = ggml_new_tensor_2d(ctx0, GGML_TYPE_F32, 2*n_ctx, n_mels);
- }
-
- ggml_set_name(mel, "mel");
-
- struct ggml_tensor * cur = nullptr;
-
- if (!whisper_encode_external(wstate)) {
- // convolution + gelu
- {
- cur = ggml_conv_1d_ph(ctx0, model.e_conv_1_w, mel, 1, 1);
- cur = ggml_add(ctx0, cur, model.e_conv_1_b);
-
- cur = ggml_gelu(ctx0, cur);
-
- cur = ggml_conv_1d_ph(ctx0, model.e_conv_2_w, cur, 2, 1);
- cur = ggml_add(ctx0, cur, model.e_conv_2_b);
-
- cur = ggml_gelu(ctx0, cur);
- }
-
- ggml_set_name(cur, "embd_conv");
- wstate.embd_conv = cur;
- } else {
- ggml_build_forward_expand(gf, mel);
-
- cur = ggml_new_tensor_2d(ctx0, GGML_TYPE_F32, n_state, n_ctx);
- ggml_set_input(cur); // the external encoder will write into this tensor
-
- ggml_set_name(cur, "embd_enc");
- wstate.embd_enc = cur;
- }
-
- ggml_set_output(cur);
-
- ggml_build_forward_expand(gf, cur);
-
- ggml_free(ctx0);
-
- return gf;
-}
-
-static struct ggml_cgraph * whisper_build_graph_encoder(
- whisper_context & wctx,
- whisper_state & wstate) {
- const auto & model = wctx.model;
- const auto & hparams = model.hparams;
-
- const int n_ctx = wstate.exp_n_audio_ctx > 0 ? wstate.exp_n_audio_ctx : hparams.n_audio_ctx;
- const int n_state = hparams.n_audio_state;
- const int n_head = hparams.n_audio_head;
- const int n_layer = hparams.n_audio_layer;
-
- const int n_state_head = n_state/n_head;
-
- auto & kv_pad = wstate.kv_pad;
-
- WHISPER_ASSERT(!!kv_pad.ctx);
-
- const int n_ctx_pad = GGML_PAD(n_ctx, 256);
-
- struct ggml_init_params params = {
- /*.mem_size =*/ wstate.sched_encode.meta.size(),
- /*.mem_buffer =*/ wstate.sched_encode.meta.data(),
- /*.no_alloc =*/ true,
- };
-
- struct ggml_context * ctx0 = ggml_init(params);
-
- ggml_cgraph * gf = ggml_new_graph_custom(ctx0, WHISPER_MAX_NODES, false);
-
- struct ggml_tensor * cur = ggml_view_tensor(ctx0, wstate.embd_conv);
-
- const float KQscale = 1.0f/sqrtf(float(n_state_head));
-
- // ===================================================================
- // NOTE: experimenting with partial evaluation of the encoder (ignore)
- //static int iter = -1;
- //const int n_iter = 1500/n_ctx;
-
- //iter = (iter + 1) % n_iter;
-
- //if (iter == 0) {
- // memset(model.memory_cross_k->data, 0, ggml_nbytes(model.memory_cross_k));
- // memset(model.memory_cross_v->data, 0, ggml_nbytes(model.memory_cross_v));
- //}
-
- static int iter = 0;
-
- const size_t e_pe_stride = model.e_pe->ne[0]*ggml_element_size(model.e_pe);
- const size_t e_pe_offset = model.e_pe->ne[0]*ggml_element_size(model.e_pe)*n_ctx*iter;
-
- struct ggml_tensor * e_pe = ggml_view_2d(ctx0, model.e_pe, model.e_pe->ne[0], n_ctx, e_pe_stride, e_pe_offset);
- cur = ggml_add(ctx0, e_pe, ggml_cont(ctx0, ggml_transpose(ctx0, cur)));
-
- // ===================================================================
-
- // original:
- //cur = ggml_add(ctx0, model.e_pe, ggml_transpose(ctx0, cur));
-
- struct ggml_tensor * inpL = cur;
-
- for (int il = 0; il < n_layer; ++il) {
- const auto & layer = model.layers_encoder[il];
-
- // norm
- {
- cur = ggml_norm(ctx0, inpL, hparams.eps);
-
- // cur = ln_0_w*cur + ln_0_b
- cur = ggml_add(ctx0,
- ggml_mul(ctx0, cur, layer.attn_ln_0_w),
- layer.attn_ln_0_b);
- }
-
- // self-attention
- {
- struct ggml_tensor * Qcur = ggml_mul_mat(ctx0,
- layer.attn_q_w,
- cur);
-
- Qcur = ggml_add(ctx0, Qcur, layer.attn_q_b);
-
- //Qcur = ggml_scale(ctx0, Qcur, pow(float(n_state_head), -0.25));
-
- // note: no bias for Key
- struct ggml_tensor * Kcur = ggml_mul_mat(ctx0,
- layer.attn_k_w,
- cur);
-
- //Kcur = ggml_scale(ctx0, Kcur, pow(float(n_state_head), -0.25));
-
- struct ggml_tensor * Vcur = ggml_mul_mat(ctx0,
- layer.attn_v_w,
- cur);
-
- Vcur = ggml_add(ctx0, Vcur, layer.attn_v_b);
-
- // ------
-
- struct ggml_tensor * Q =
- ggml_permute(ctx0,
- ggml_cpy(ctx0,
- Qcur,
- ggml_new_tensor_3d(ctx0, GGML_TYPE_F32, n_state_head, n_head, n_ctx)),
- 0, 2, 1, 3);
-
- if (wctx.params.flash_attn) {
- ggml_build_forward_expand(gf, ggml_cpy(ctx0, Kcur, ggml_view_1d(ctx0, kv_pad.k, n_ctx*n_state, 0)));
- ggml_build_forward_expand(gf, ggml_cpy(ctx0, Vcur, ggml_view_1d(ctx0, kv_pad.v, n_ctx*n_state, 0)));
-
- struct ggml_tensor * K =
- ggml_view_3d(ctx0, kv_pad.k,
- n_state_head, n_ctx_pad, n_head,
- ggml_element_size(kv_pad.k)*n_state,
- ggml_element_size(kv_pad.k)*n_state_head,
- 0);
-
- struct ggml_tensor * V =
- ggml_view_3d(ctx0, kv_pad.v,
- n_state_head, n_ctx_pad, n_head,
- ggml_element_size(kv_pad.v)*n_state,
- ggml_element_size(kv_pad.v)*n_state_head,
- 0);
-
- cur = ggml_flash_attn_ext(ctx0, Q, K, V, nullptr, KQscale, 0.0f);
-
- cur = ggml_reshape_2d(ctx0, cur, n_state, n_ctx);
- } else {
- struct ggml_tensor * K =
- ggml_permute(ctx0,
- ggml_cpy(ctx0,
- Kcur,
- ggml_new_tensor_3d(ctx0, wctx.itype, n_state_head, n_head, n_ctx)),
- 0, 2, 1, 3);
-
- // K * Q
- struct ggml_tensor * KQ = ggml_mul_mat(ctx0, K, Q);
-
- struct ggml_tensor * KQ_soft_max = ggml_soft_max_ext(ctx0, KQ, nullptr, KQscale, 0.0f);
-
- struct ggml_tensor * V =
- ggml_cpy(ctx0,
- ggml_permute(ctx0,
- ggml_reshape_3d(ctx0,
- Vcur,
- n_state_head, n_head, n_ctx),
- 1, 2, 0, 3),
- ggml_new_tensor_3d(ctx0, wctx.itype, n_ctx, n_state_head, n_head)
- );
-
- struct ggml_tensor * KQV = ggml_mul_mat(ctx0, V, KQ_soft_max);
-
- struct ggml_tensor * KQV_merged = ggml_permute(ctx0, KQV, 0, 2, 1, 3);
-
- cur = ggml_cpy(ctx0,
- KQV_merged,
- ggml_new_tensor_2d(ctx0, GGML_TYPE_F32, n_state, n_ctx));
- }
- }
-
- // projection
- {
- cur = ggml_mul_mat(ctx0,
- layer.attn_ln_1_w,
- cur);
-
- cur = ggml_add(ctx0, cur, layer.attn_ln_1_b);
- }
-
- // add the input
- cur = ggml_add(ctx0, cur, inpL);
-
- struct ggml_tensor * inpFF = cur;
-
- // feed-forward network
- {
- // norm
- {
- cur = ggml_norm(ctx0, inpFF, hparams.eps);
-
- // cur = mlp_ln_w*cur + mlp_ln_b
- cur = ggml_add(ctx0,
- ggml_mul(ctx0, cur, layer.mlp_ln_w),
- layer.mlp_ln_b);
- }
-
-#ifdef WHISPER_USE_FLASH_FF
- cur = ggml_flash_ff(ctx0,
- ggml_cpy(ctx0, cur, ggml_new_tensor_2d(ctx0, wstate.itype, n_state, n_ctx)),
- layer.mlp_0_w, layer.mlp_0_b, layer.mlp_1_w, layer.mlp_1_b);
-#else
- // fully connected
- cur = ggml_mul_mat(ctx0,
- layer.mlp_0_w,
- cur);
-
- cur = ggml_add(ctx0, cur, layer.mlp_0_b);
-
- // GELU activation
- cur = ggml_gelu(ctx0, cur);
-
- // projection
- cur = ggml_mul_mat(ctx0,
- layer.mlp_1_w,
- cur);
-
- cur = ggml_add(ctx0, cur, layer.mlp_1_b);
-#endif
- }
-
- inpL = ggml_add(ctx0, cur, inpFF);
- }
-
- cur = inpL;
-
- // norm
- {
- cur = ggml_norm(ctx0, cur, hparams.eps);
-
- // cur = ln_f_g*cur + ln_f_b
- cur = ggml_add(ctx0,
- ggml_mul(ctx0, cur, model.e_ln_w),
- model.e_ln_b);
- }
-
- ggml_build_forward_expand(gf, cur);
-
- wstate.embd_enc = cur;
-
- //ggml_graph_print(gf);
-
- ////////////////////////////////////////////////////////////////////////////
-
- //printf("%s: used_mem = %f MB, %f MB, %f MB %f MB %f MB\n", __func__,
- // ggml_used_mem(ctx0)/1e6,
- // wstate.get_buf_max_mem(0)/1e6,
- // wstate.get_buf_max_mem(1)/1e6,
- // wstate.get_buf_max_mem(2)/1e6,
- // wstate.get_buf_max_mem(3)/1e6);
-
- ggml_free(ctx0);
-
- return gf;
-}
-
-// pre-compute cross-attention memory
-static struct ggml_cgraph * whisper_build_graph_cross(
- whisper_context & wctx,
- whisper_state & wstate) {
- const auto & model = wctx.model;
- const auto & hparams = model.hparams;
-
- const int n_ctx = wstate.exp_n_audio_ctx > 0 ? wstate.exp_n_audio_ctx : hparams.n_audio_ctx;
- const int n_state = hparams.n_audio_state;
- const int n_head = hparams.n_audio_head;
-
- const int n_state_head = n_state/n_head;
-
- const int n_ctx_pad = GGML_PAD(n_ctx, 256);
-
- struct ggml_init_params params = {
- /*.mem_size =*/ wstate.sched_cross.meta.size(),
- /*.mem_buffer =*/ wstate.sched_cross.meta.data(),
- /*.no_alloc =*/ true,
- };
-
- struct ggml_context * ctx0 = ggml_init(params);
-
- ggml_cgraph * gf = ggml_new_graph(ctx0);
-
- struct ggml_tensor * cur = ggml_view_tensor(ctx0, wstate.embd_enc);
-
- const float Kscale = pow(float(n_state_head), -0.25);
-
- for (int il = 0; il < model.hparams.n_text_layer; ++il) {
- auto & layer = model.layers_decoder[il];
-
- struct ggml_tensor * Kcross = ggml_mul_mat(ctx0,
- layer.cross_attn_k_w,
- cur);
-
- Kcross = ggml_scale(ctx0, Kcross, Kscale);
-
- struct ggml_tensor * Vcross = ggml_mul_mat(ctx0,
- layer.cross_attn_v_w,
- cur);
-
- Vcross = ggml_add(ctx0,
- Vcross,
- layer.cross_attn_v_b);
-
- struct ggml_tensor * k;
- struct ggml_tensor * v;
-
- if (wctx.params.flash_attn) {
- k = ggml_view_1d(ctx0, wstate.kv_cross.k, n_state*n_ctx,
- (ggml_element_size(wstate.kv_cross.k)*n_state)*(il*n_ctx_pad));
-
- v = ggml_view_1d(ctx0, wstate.kv_cross.v, n_state*n_ctx,
- (ggml_element_size(wstate.kv_cross.v)*n_state)*(il*n_ctx_pad));
- } else {
- Vcross = ggml_transpose(ctx0, ggml_reshape_2d(ctx0, Vcross, n_state, n_ctx));
-
- k = ggml_view_1d(ctx0, wstate.kv_cross.k, n_state*n_ctx,
- (ggml_element_size(wstate.kv_cross.k)*n_state)*(il*n_ctx));
-
- v = ggml_view_2d(ctx0, wstate.kv_cross.v, n_ctx, n_state,
- ( n_ctx)*ggml_element_size(wstate.kv_cross.v),
- (il*n_ctx)*ggml_element_size(wstate.kv_cross.v)*n_state);
- }
-
- ggml_build_forward_expand(gf, ggml_cpy(ctx0, Kcross, k));
- ggml_build_forward_expand(gf, ggml_cpy(ctx0, Vcross, v));
- }
-
- //ggml_graph_print(gf);
-
- ggml_free(ctx0);
-
- return gf;
-}
-
-// evaluate the encoder with the given state
-//
-// given audio recording (more specifically, its log mel spectrogram), runs forward pass of the encoder
-// part of the transformer model and returns the encoded features
-//
-// - wctx: the model
-// - wstate: the state of the encoder
-// - n_threads: number of threads to use
-// - mel_offset: offset in the mel spectrogram (i.e. audio offset)
-//
-static bool whisper_encode_internal(
- whisper_context & wctx,
- whisper_state & wstate,
- const int mel_offset,
- const int n_threads,
- ggml_abort_callback abort_callback,
- void * abort_callback_data) {
- const int64_t t_start_us = ggml_time_us();
-
- // conv
- {
- auto & sched = wstate.sched_conv.sched;
-
- ggml_cgraph * gf = whisper_build_graph_conv(wctx, wstate, mel_offset);
-
- if (!ggml_backend_sched_alloc_graph(sched, gf)) {
- // should never happen as we pre-allocate the memory
- return false;
- }
-
- if (!ggml_graph_compute_helper(sched, gf, n_threads)) {
- return false;
- }
-
- if (whisper_encode_external(wstate)) {
- ggml_tensor * mel = ggml_graph_get_tensor(gf, "mel");
- assert(mel->ne[1] == wctx.model.hparams.n_mels);
- GGML_UNUSED(mel);
-#if defined(WHISPER_USE_COREML)
- whisper_coreml_encode(wstate.ctx_coreml, mel->ne[0], mel->ne[1], (float *) mel->data, (float *) wstate.embd_enc->data);
-#elif defined(WHISPER_USE_OPENVINO)
- whisper_openvino_encode(wstate.ctx_openvino, mel, wstate.embd_enc);
-#endif
- }
- }
-
- // encoder
- if (!whisper_encode_external(wstate)) {
- auto & sched = wstate.sched_encode.sched;
-
- ggml_cgraph * gf = whisper_build_graph_encoder(wctx, wstate);
-
- if (!ggml_backend_sched_alloc_graph(sched, gf)) {
- // should never happen as we pre-allocate the memory
- return false;
- }
-
- if (!ggml_graph_compute_helper(sched, gf, n_threads)) {
- return false;
- }
- }
-
- // cross
- {
- auto & sched = wstate.sched_cross.sched;
-
- ggml_cgraph * gf = whisper_build_graph_cross(wctx, wstate);
-
- if (!ggml_backend_sched_alloc_graph(sched, gf)) {
- // should never happen as we pre-allocate the memory
- return false;
- }
-
- if (!ggml_graph_compute_helper(sched, gf, n_threads)) {
- return false;
- }
- }
-
- wstate.t_encode_us += ggml_time_us() - t_start_us;
- wstate.n_encode++;
-
- return !(abort_callback && abort_callback(abort_callback_data));
-}
-
-static struct ggml_cgraph * whisper_build_graph_decoder(
- whisper_context & wctx,
- whisper_state & wstate,
- const whisper_batch & batch,
- bool save_alignment_heads_QKs,
- bool worst_case) {
- const auto & model = wctx.model;
- const auto & hparams = model.hparams;
-
- auto & kv_self = wstate.kv_self;
-
- WHISPER_ASSERT(!!kv_self.ctx);
-
- const int n_ctx = kv_self.size;
- const int n_state = hparams.n_text_state;
- const int n_head = hparams.n_text_head;
- const int n_layer = hparams.n_text_layer;
-
- const int n_state_head = n_state/n_head;
-
- const int n_tokens = batch.n_tokens;
- const int n_audio_ctx = wstate.exp_n_audio_ctx > 0 ? wstate.exp_n_audio_ctx : hparams.n_audio_ctx;
-
- const int n_audio_ctx_pad = GGML_PAD(n_audio_ctx, 256);
-
- const int32_t n_kv = worst_case ? n_ctx : kv_self.n;
- const int32_t kv_head = worst_case ? n_ctx - n_tokens : kv_self.head;
-
- //WHISPER_LOG_DEBUG("%s: n_past = %d, n_tokens = %d, n_audio_ctx = %d, n_ctx = %d\n", __func__, n_past, n_tokens, n_audio_ctx, n_ctx);
-
- struct ggml_init_params params = {
- /*.mem_size =*/ wstate.sched_decode.meta.size(),
- /*.mem_buffer =*/ wstate.sched_decode.meta.data(),
- /*.no_alloc =*/ true,
- };
-
- struct ggml_context * ctx0 = ggml_init(params);
-
- ggml_cgraph * gf = ggml_new_graph_custom(ctx0, WHISPER_MAX_NODES, false);
-
- struct ggml_tensor * embd = ggml_new_tensor_1d(ctx0, GGML_TYPE_I32, n_tokens);
- ggml_set_name(embd, "embd");
- ggml_set_input(embd);
-
- struct ggml_tensor * position = ggml_new_tensor_1d(ctx0, GGML_TYPE_I32, n_tokens);
- ggml_set_name(position, "position");
- ggml_set_input(position);
-
- const float KQscale = pow(float(n_state_head), -0.25);
-
- struct ggml_tensor * KQ_mask = ggml_new_tensor_3d(ctx0, GGML_TYPE_F32, n_kv, GGML_PAD(n_tokens, GGML_KQ_MASK_PAD), 1);
- ggml_set_name(KQ_mask, "KQ_mask");
- ggml_set_input(KQ_mask);
-
- struct ggml_tensor * KQ_mask_f16 = ggml_cast(ctx0, KQ_mask, GGML_TYPE_F16);
-
- // token encoding + position encoding
- struct ggml_tensor * cur =
- ggml_add(ctx0,
- ggml_get_rows(ctx0, model.d_te, embd),
- ggml_get_rows(ctx0, model.d_pe, position));
-
- struct ggml_tensor * inpL = cur;
-
- // [EXPERIMENTAL] Token-level timestamps with DTW
- struct ggml_tensor * aheads_cross_QKs = nullptr;
-
- for (int il = 0; il < n_layer; ++il) {
- const auto & layer = model.layers_decoder[il];
-
- // norm
- {
- cur = ggml_norm(ctx0, inpL, hparams.eps);
-
- // cur = ln_0_w*cur + ln_0_b
- cur = ggml_add(ctx0,
- ggml_mul(ctx0,
- cur,
- layer.attn_ln_0_w),
- layer.attn_ln_0_b);
- }
-
- // self-attention
- {
- struct ggml_tensor * Qcur = ggml_mul_mat(ctx0,
- layer.attn_q_w,
- cur);
-
- Qcur = ggml_add(ctx0,
- Qcur,
- layer.attn_q_b);
-
- Qcur = ggml_scale(ctx0, Qcur, KQscale);
-
- // note: no bias for Key
- struct ggml_tensor * Kcur = ggml_mul_mat(ctx0,
- layer.attn_k_w,
- cur);
-
- Kcur = ggml_scale(ctx0, Kcur, KQscale);
-
- // store key and value to memory
- {
- struct ggml_tensor * Vcur = ggml_mul_mat(ctx0,
- layer.attn_v_w,
- cur);
-
- Vcur = ggml_add(ctx0,
- Vcur,
- layer.attn_v_b);
-
- struct ggml_tensor * k;
- struct ggml_tensor * v;
-
- if (wctx.params.flash_attn) {
- k = ggml_view_1d(ctx0, kv_self.k, n_tokens*n_state,
- (ggml_element_size(kv_self.k)*n_state)*(il*n_ctx + kv_head));
-
- v = ggml_view_1d(ctx0, kv_self.v, n_tokens*n_state,
- (ggml_element_size(kv_self.v)*n_state)*(il*n_ctx + kv_head));
- } else {
- Vcur = ggml_transpose(ctx0, ggml_reshape_2d(ctx0, Vcur, n_state, n_tokens));
-
- k = ggml_view_1d(ctx0, kv_self.k, n_tokens*n_state,
- (ggml_element_size(kv_self.k)*n_state)*(il*n_ctx + kv_head));
-
- v = ggml_view_2d(ctx0, kv_self.v, n_tokens, n_state,
- ( n_ctx)*ggml_element_size(kv_self.v),
- (il*n_ctx)*ggml_element_size(kv_self.v)*n_state + kv_head*ggml_element_size(kv_self.v));
- }
-
- ggml_build_forward_expand(gf, ggml_cpy(ctx0, Kcur, k));
- ggml_build_forward_expand(gf, ggml_cpy(ctx0, Vcur, v));
- }
-
- // ------
-
- struct ggml_tensor * Q =
- ggml_permute(ctx0,
- ggml_reshape_3d(ctx0, Qcur, n_state_head, n_head, n_tokens),
- 0, 2, 1, 3);
-
- struct ggml_tensor * K =
- ggml_view_3d(ctx0, kv_self.k,
- n_state_head, n_kv, n_head,
- ggml_element_size(kv_self.k)*n_state,
- ggml_element_size(kv_self.k)*n_state_head,
- ggml_element_size(kv_self.k)*n_state*n_ctx*il);
-
- if (wctx.params.flash_attn) {
- struct ggml_tensor * V =
- ggml_view_3d(ctx0, kv_self.v,
- n_state_head, n_kv, n_head,
- ggml_element_size(kv_self.v)*n_state,
- ggml_element_size(kv_self.v)*n_state_head,
- ggml_element_size(kv_self.v)*n_state*n_ctx*il);
-
- cur = ggml_flash_attn_ext(ctx0, Q, K, V, KQ_mask_f16, 1.0f, 0.0f);
-
- cur = ggml_reshape_2d(ctx0, cur, n_state, n_tokens);
- } else {
- // K * Q
- struct ggml_tensor * KQ = ggml_mul_mat(ctx0, K, Q);
-
- struct ggml_tensor * KQ_soft_max = ggml_soft_max_ext(ctx0, KQ, KQ_mask, 1.0f, 0.0f);
-
- struct ggml_tensor * V =
- ggml_view_3d(ctx0, kv_self.v,
- n_kv, n_state_head, n_head,
- n_ctx*ggml_element_size(kv_self.v),
- n_ctx*ggml_element_size(kv_self.v)*n_state_head,
- n_ctx*ggml_element_size(kv_self.v)*n_state*il);
-
- struct ggml_tensor * KQV = ggml_mul_mat(ctx0, V, KQ_soft_max);
-
- struct ggml_tensor * KQV_merged = ggml_permute(ctx0, KQV, 0, 2, 1, 3);
-
- cur = ggml_cpy(ctx0,
- KQV_merged,
- ggml_new_tensor_2d(ctx0, GGML_TYPE_F32, n_state, n_tokens));
- }
- }
-
- // projection
- {
- cur = ggml_mul_mat(ctx0,
- layer.attn_ln_1_w,
- cur);
-
- cur = ggml_add(ctx0,
- cur,
- layer.attn_ln_1_b);
- }
-
- // add the input
- struct ggml_tensor * inpCA = ggml_add(ctx0, cur, inpL);
-
- // norm
- {
- cur = ggml_norm(ctx0, inpCA, hparams.eps); // note: we use inpCA here
-
- // cur = ln_0_w*cur + ln_0_b
- cur = ggml_add(ctx0,
- ggml_mul(ctx0,
- cur,
- layer.cross_attn_ln_0_w),
- layer.cross_attn_ln_0_b);
- }
-
- // cross-attention
- {
- struct ggml_tensor * Qcur = ggml_mul_mat(ctx0,
- layer.cross_attn_q_w,
- cur);
-
- Qcur = ggml_add(ctx0,
- Qcur,
- layer.cross_attn_q_b);
-
- struct ggml_tensor * Q =
- ggml_permute(ctx0,
- ggml_reshape_3d(ctx0, Qcur, n_state_head, n_head, n_tokens),
- 0, 2, 1, 3);
-
- if (wctx.params.flash_attn) {
- struct ggml_tensor * Kcross =
- ggml_view_3d(ctx0, wstate.kv_cross.k,
- n_state_head, n_audio_ctx_pad, n_head,
- ggml_element_size(wstate.kv_cross.k)*n_state,
- ggml_element_size(wstate.kv_cross.k)*n_state_head,
- ggml_element_size(wstate.kv_cross.k)*n_state*n_audio_ctx_pad*il);
-
- struct ggml_tensor * Vcross =
- ggml_view_3d(ctx0, wstate.kv_cross.v,
- n_state_head, n_audio_ctx_pad, n_head,
- ggml_element_size(wstate.kv_cross.v)*n_state,
- ggml_element_size(wstate.kv_cross.v)*n_state_head,
- ggml_element_size(wstate.kv_cross.v)*n_state*n_audio_ctx_pad*il);
-
- cur = ggml_flash_attn_ext(ctx0, Q, Kcross, Vcross, nullptr, KQscale, 0.0f);
-
- cur = ggml_reshape_2d(ctx0, cur, n_state, n_tokens);
- } else {
- struct ggml_tensor * Kcross =
- ggml_view_3d(ctx0, wstate.kv_cross.k,
- n_state_head, n_audio_ctx, n_head,
- ggml_element_size(wstate.kv_cross.k)*n_state,
- ggml_element_size(wstate.kv_cross.k)*n_state_head,
- ggml_element_size(wstate.kv_cross.k)*n_state*n_audio_ctx*il);
-
- struct ggml_tensor * Vcross =
- ggml_view_3d(ctx0, wstate.kv_cross.v,
- n_audio_ctx, n_state_head, n_head,
- n_audio_ctx*ggml_element_size(wstate.kv_cross.v),
- n_audio_ctx*ggml_element_size(wstate.kv_cross.v)*n_state_head,
- n_audio_ctx*ggml_element_size(wstate.kv_cross.v)*n_state*il);
-
- // ------
-
- // K * Q
- struct ggml_tensor * KQ = ggml_mul_mat(ctx0, Kcross, Q);
-
- struct ggml_tensor * KQ_soft_max = ggml_soft_max_ext(ctx0, KQ, nullptr, KQscale, 0.0f);
-
- // [EXPERIMENTAL] Token-level timestamps with DTW
- if (wctx.params.dtw_token_timestamps) {
- if (wstate.aheads_masks.m[il] != nullptr) {
- struct ggml_tensor * aheads_KQs = ggml_reshape_2d(ctx0, KQ_soft_max, KQ_soft_max->ne[0] * KQ_soft_max->ne[1], KQ_soft_max->ne[2]);
- aheads_KQs = ggml_transpose(ctx0, aheads_KQs);
- aheads_KQs = ggml_cont(ctx0, aheads_KQs);
- aheads_KQs = ggml_mul_mat(ctx0, wstate.aheads_masks.m[il], aheads_KQs);
- aheads_KQs = ggml_transpose(ctx0, aheads_KQs);
- aheads_KQs = ggml_cont(ctx0, aheads_KQs);
- aheads_KQs = ggml_reshape_3d(ctx0, aheads_KQs, KQ_soft_max->ne[0], KQ_soft_max->ne[1], wstate.aheads_masks.m[il]->ne[1]);
- if (aheads_cross_QKs == NULL) {
- aheads_cross_QKs = aheads_KQs;
- } else {
- aheads_cross_QKs = ggml_concat(ctx0, aheads_cross_QKs, aheads_KQs, 2);
- }
- }
- }
-
- struct ggml_tensor * KQV = ggml_mul_mat(ctx0, Vcross, KQ_soft_max);
-
- struct ggml_tensor * KQV_merged = ggml_permute(ctx0, KQV, 0, 2, 1, 3);
-
- cur = ggml_cpy(ctx0,
- KQV_merged,
- ggml_new_tensor_2d(ctx0, GGML_TYPE_F32, n_state, n_tokens));
- }
- }
-
- // projection
- {
- cur = ggml_mul_mat(ctx0,
- layer.cross_attn_ln_1_w,
- cur);
-
- cur = ggml_add(ctx0,
- cur,
- layer.cross_attn_ln_1_b);
- }
-
- // add the input
- cur = ggml_add(ctx0, cur, inpCA);
-
- struct ggml_tensor * inpFF = cur;
-
- // feed-forward network
- {
- // norm
- {
- cur = ggml_norm(ctx0, inpFF, hparams.eps);
-
- // cur = mlp_ln_w*cur + mlp_ln_b
- cur = ggml_add(ctx0,
- ggml_mul(ctx0,
- cur,
- layer.mlp_ln_w),
- layer.mlp_ln_b);
- }
-
- // fully connected
- cur = ggml_mul_mat(ctx0,
- layer.mlp_0_w,
- cur);
-
- cur = ggml_add(ctx0,
- cur,
- layer.mlp_0_b);
-
- // GELU activation
- cur = ggml_gelu(ctx0, cur);
-
- // projection
- cur = ggml_mul_mat(ctx0,
- layer.mlp_1_w,
- cur);
-
- cur = ggml_add(ctx0,
- cur,
- layer.mlp_1_b);
- }
-
- inpL = ggml_add(ctx0, cur, inpFF);
- }
-
- cur = inpL;
-
- // norm
- {
- cur = ggml_norm(ctx0, cur, hparams.eps);
-
- cur = ggml_add(ctx0,
- ggml_mul(ctx0,
- cur,
- model.d_ln_w),
- model.d_ln_b);
- }
-
- // compute logits only for the last token
- // comment this line to compute logits for all n_tokens
- // might be useful in the future
- //cur = ggml_view_2d(ctx0, cur, cur->ne[0], 1, cur->nb[1], (cur->ne[1] - 1)*cur->nb[1]);
-
- struct ggml_tensor * logits = ggml_mul_mat(ctx0, model.d_te, cur);
-
- // [EXPERIMENTAL] Token-level timestamps with DTW
- if (wctx.params.dtw_token_timestamps && aheads_cross_QKs != nullptr) {
- aheads_cross_QKs = ggml_transpose(ctx0, aheads_cross_QKs);
- aheads_cross_QKs = ggml_cont(ctx0, aheads_cross_QKs);
- if (save_alignment_heads_QKs) {
- ggml_build_forward_expand(gf, aheads_cross_QKs);
- wstate.aheads_cross_QKs = aheads_cross_QKs;
- }
- }
-
- ggml_build_forward_expand(gf, logits);
-
- ggml_free(ctx0);
-
- return gf;
-}
-
-// evaluate the decoder
-//
-// given text prompt + audio features -> computes the logits for the next token
-//
-// - model: the model
-// - n_threads: number of threads to use
-// - tokens: text prompt
-// - n_tokens: number of tokens in the prompt
-// - n_past: number of past tokens to prefix the prompt with
-//
-static bool whisper_decode_internal(
- whisper_context & wctx,
- whisper_state & wstate,
- const whisper_batch & batch,
- int n_threads,
- bool save_alignment_heads_QKs,
- ggml_abort_callback abort_callback,
- void * abort_callback_data) {
- const int64_t t_start_us = ggml_time_us();
-
- const auto & model = wctx.model;
- const auto & hparams = model.hparams;
-
- const int n_vocab = hparams.n_vocab;
- const int n_tokens = batch.n_tokens;
-
- auto & logits_out = wstate.logits;
-
- struct ggml_tensor * logits;
-
- // find KV slot for the batch
- {
- auto & kv_self = wstate.kv_self;
-
- if (!whisper_kv_cache_find_slot(kv_self, batch)) {
- return false;
- }
-
- const uint32_t pad = whisper_kv_cache_get_padding(wctx);
- kv_self.n = std::min(kv_self.size, std::max(pad, GGML_PAD(whisper_kv_cache_cell_max(kv_self), pad)));
-
- //kv_self.n = std::min((int32_t) hparams.n_text_ctx, std::max(32, whisper_kv_cache_cell_max(kv_self)));
- //printf("n_tokens = %5d, kv_self.head = %5d, kv_self.n = %5d, seq_id = %5d\n", batch.n_tokens, kv_self.head, kv_self.n, batch.seq_id[0][0]);
- }
-
- // decoder
- {
- auto & sched = wstate.sched_decode.sched;
-
- ggml_cgraph * gf = whisper_build_graph_decoder(wctx, wstate, batch, save_alignment_heads_QKs, false);
-
- if (!ggml_backend_sched_alloc_graph(sched, gf)) {
- // should never happen as we pre-allocate the memory
- return false;
- }
-
- // set the inputs
- {
- struct ggml_tensor * embd = ggml_graph_get_tensor(gf, "embd");
- ggml_backend_tensor_set(embd, batch.token, 0, n_tokens*ggml_element_size(embd));
- }
-
- {
- struct ggml_tensor * position = ggml_graph_get_tensor(gf, "position");
- for (int i = 0; i < n_tokens; ++i) {
- const int32_t val = batch.pos[i];
- ggml_backend_tensor_set(position, &val, i*sizeof(int32_t), sizeof(int32_t));
- }
- }
-
- {
- struct ggml_tensor * KQ_mask = ggml_graph_get_tensor(gf, "KQ_mask");
-
- auto & kv_self = wstate.kv_self;
-
- const int32_t n_kv = kv_self.n;
-
- wstate.inp_mask.resize(ggml_nelements(KQ_mask));
-
- float * data = wstate.inp_mask.data();
- memset(data, 0, ggml_nbytes(KQ_mask));
-
- for (int h = 0; h < 1; ++h) {
- for (int j = 0; j < n_tokens; ++j) {
- const whisper_pos pos = batch.pos[j];
- const whisper_seq_id seq_id = batch.seq_id[j][0];
-
- for (int i = 0; i < n_kv; ++i) {
- if (!kv_self.cells[i].has_seq_id(seq_id) || kv_self.cells[i].pos > pos) {
- data[h*(n_kv*n_tokens) + j*n_kv + i] = -INFINITY;
- }
- }
- }
-
- for (int i = n_tokens; i < GGML_PAD(n_tokens, GGML_KQ_MASK_PAD); ++i) {
- for (int j = 0; j < n_kv; ++j) {
- data[h*(n_kv*n_tokens) + i*n_kv + j] = -INFINITY;
- }
- }
- }
-
- ggml_backend_tensor_set(KQ_mask, wstate.inp_mask.data(), 0, ggml_nelements(KQ_mask)*sizeof(float));
- }
-
- logits = gf->nodes[gf->n_nodes - 1];
-
- if (batch.n_tokens < 16) {
- if (n_threads > 23)
- n_threads = 23;
- }
-
- if (!ggml_graph_compute_helper(sched, gf, n_threads)) {
- return false;
- }
- }
-
- logits_out.resize(n_tokens*n_vocab);
- for (int i = 0; i < n_tokens; i++) {
- if (batch.logits[i] == 0) {
- continue;
- }
- ggml_backend_tensor_get(logits, logits_out.data() + (n_vocab*i), sizeof(float)*(n_vocab*i), sizeof(float)*n_vocab);
- }
-
- if (batch.n_tokens > 1) {
- //printf("%s: used_mem = %f MB, %f MB, %f MB %f MB %f MB\n", __func__,
- // ggml_used_mem(ctx0)/1e6,
- // wstate.get_buf_max_mem(0)/1e6,
- // wstate.get_buf_max_mem(1)/1e6,
- // wstate.get_buf_max_mem(2)/1e6,
- // wstate.get_buf_max_mem(3)/1e6);
- }
-
- if (batch.n_tokens == 1) {
- wstate.t_decode_us += ggml_time_us() - t_start_us;
- wstate.n_decode++;
- } else if (batch.n_tokens < 16) {
- wstate.t_batchd_us += ggml_time_us() - t_start_us;
- wstate.n_batchd += n_tokens;
- } else {
- wstate.t_prompt_us += ggml_time_us() - t_start_us;
- wstate.n_prompt += n_tokens;
- }
-
- return !(abort_callback && abort_callback(abort_callback_data));
-}
-
-// 500 -> 00:05.000
-// 6000 -> 01:00.000
-static std::string to_timestamp(int64_t t, bool comma = false) {
- int64_t msec = t * 10;
- int64_t hr = msec / (1000 * 60 * 60);
- msec = msec - hr * (1000 * 60 * 60);
- int64_t min = msec / (1000 * 60);
- msec = msec - min * (1000 * 60);
- int64_t sec = msec / 1000;
- msec = msec - sec * 1000;
-
- char buf[32];
- snprintf(buf, sizeof(buf), "%02d:%02d:%02d%s%03d", (int) hr, (int) min, (int) sec, comma ? "," : ".", (int) msec);
-
- return std::string(buf);
-}
-
-#define SIN_COS_N_COUNT WHISPER_N_FFT
-namespace {
-struct whisper_global_cache {
- // In FFT, we frequently use sine and cosine operations with the same values.
- // We can use precalculated values to speed up the process.
- float sin_vals[SIN_COS_N_COUNT];
- float cos_vals[SIN_COS_N_COUNT];
-
- // Hann window (Use cosf to eliminate difference)
- // ref: https://pytorch.org/docs/stable/generated/torch.hann_window.html
- // ref: https://github.com/openai/whisper/blob/main/whisper/audio.py#L147
- float hann_window[WHISPER_N_FFT];
-
- whisper_global_cache() {
- fill_sin_cos_table();
- fill_hann_window(sizeof(hann_window)/sizeof(hann_window[0]), true, hann_window);
- }
-
- void fill_sin_cos_table() {
- for (int i = 0; i < SIN_COS_N_COUNT; i++) {
- double theta = (2 * M_PI * i) / SIN_COS_N_COUNT;
- sin_vals[i] = sinf(theta);
- cos_vals[i] = cosf(theta);
- }
- }
-
- void fill_hann_window(int length, bool periodic, float * output) {
- int offset = -1;
- if (periodic) {
- offset = 0;
- }
- for (int i = 0; i < length; i++) {
- output[i] = 0.5 * (1.0 - cosf((2.0 * M_PI * i) / (length + offset)));
- }
- }
-} global_cache;
-}
-
-// Mel spectrogram
-
-void whisper_mel_init(whisper_mel & mel, ggml_backend_t backend, int n_len, int n_len_org, int n_mel) {
- //WHISPER_LOG_INFO("%s: n_len = %d, n_len_org = %d, n_mel = %d\n", __func__, n_len, n_len_org, n_mel);
- mel.n_len_org = n_len_org;
- assert(!mel.ctx);
- mel.ctx = ggml_init({ggml_tensor_overhead(), nullptr, true});
- mel.tensor = ggml_new_tensor_2d(mel.ctx, GGML_TYPE_F32, n_len, n_mel);
- mel.buffer = ggml_backend_alloc_buffer(backend, ggml_nbytes(mel.tensor) + ggml_backend_get_alignment(backend));
- auto alloc = ggml_tallocr_new(mel.buffer);
- ggml_tallocr_alloc(&alloc, mel.tensor);
-}
-
-void whisper_mel_free(whisper_mel & mel) {
- ggml_free(mel.ctx);
- ggml_backend_buffer_free(mel.buffer);
-
- mel.n_len_org = 0;
- mel.ctx = nullptr;
- mel.tensor = nullptr;
- mel.buffer = nullptr;
-}
-
-whisper_mel_calc::~whisper_mel_calc() = default; // export vtable
-
-whisper_span<const float> whisper_mel_calc::hann_window() {
- return {global_cache.hann_window, WHISPER_N_FFT};
-}
-
-// naive Discrete Fourier Transform
-// input is real-valued
-// output is complex-valued
-static void dft(const float* in, int N, float* out) {
- const int sin_cos_step = SIN_COS_N_COUNT / N;
-
- for (int k = 0; k < N; k++) {
- float re = 0;
- float im = 0;
-
- for (int n = 0; n < N; n++) {
- int idx = (k * n * sin_cos_step) % (SIN_COS_N_COUNT); // t = 2*M_PI*k*n/N
- re += in[n]*global_cache.cos_vals[idx]; // cos(t)
- im -= in[n]*global_cache.sin_vals[idx]; // sin(t)
- }
-
- out[k*2 + 0] = re;
- out[k*2 + 1] = im;
- }
-}
-
-// Cooley-Tukey FFT
-// poor man's implementation - use something better
-// input is real-valued
-// output is complex-valued
-static void fft(float* in, int N, float* out) {
- if (N == 1) {
- out[0] = in[0];
- out[1] = 0;
- return;
- }
-
- const int half_N = N / 2;
- if (N - half_N*2 == 1) {
- dft(in, N, out);
- return;
- }
-
- float* even = in + N;
- for (int i = 0; i < half_N; ++i) {
- even[i]= in[2*i];
- }
- float* even_fft = out + 2 * N;
- fft(even, half_N, even_fft);
-
- float* odd = even;
- for (int i = 0; i < half_N; ++i) {
- odd[i] = in[2*i + 1];
- }
- float* odd_fft = even_fft + N;
- fft(odd, half_N, odd_fft);
-
- const int sin_cos_step = SIN_COS_N_COUNT / N;
- for (int k = 0; k < half_N; k++) {
- int idx = k * sin_cos_step; // t = 2*M_PI*k/N
- float re = global_cache.cos_vals[idx]; // cos(t)
- float im = -global_cache.sin_vals[idx]; // sin(t)
-
- float re_odd = odd_fft[2*k + 0];
- float im_odd = odd_fft[2*k + 1];
-
- out[2*k + 0] = even_fft[2*k + 0] + re*re_odd - im*im_odd;
- out[2*k + 1] = even_fft[2*k + 1] + re*im_odd + im*re_odd;
-
- out[2*(k + half_N) + 0] = even_fft[2*k + 0] - re*re_odd + im*im_odd;
- out[2*(k + half_N) + 1] = even_fft[2*k + 1] - re*im_odd - im*re_odd;
- }
-}
-
-namespace {
-
-struct whisper_mel_data {
- int n_len;
- int n_len_org;
- int n_mel;
- float * data;
-};
-
-void log_mel_spectrogram_worker_thread(int ith, const float * hann, const std::vector<float> & samples,
- int n_samples, int n_threads,
- const whisper_filters & filters, whisper_mel_data & mel) {
- const auto frame_size = WHISPER_N_FFT;
- const auto frame_step = WHISPER_HOP_LENGTH;
- std::vector<float> fft_in(frame_size * 2, 0.0);
- std::vector<float> fft_out(frame_size * 2 * 2 * 2);
- int n_fft = filters.n_fft;
- int i = ith;
-
- // make sure n_fft == 1 + (WHISPER_N_FFT / 2), bin_0 to bin_nyquist
- assert(n_fft == 1 + (frame_size / 2));
-
- // calculate FFT only when fft_in are not all zero
- for (; i < std::min(n_samples / frame_step + 1, mel.n_len); i += n_threads) {
- const int offset = i * frame_step;
-
- // apply Hann window (~10% faster)
- for (int j = 0; j < std::min(frame_size, n_samples - offset); j++) {
- fft_in[j] = hann[j] * samples[offset + j];
- }
- // fill the rest with zeros
- if (n_samples - offset < frame_size) {
- std::fill(fft_in.begin() + (n_samples - offset), fft_in.end(), 0.0);
- }
-
- // FFT
- fft(fft_in.data(), frame_size, fft_out.data());
-
- // Calculate modulus^2 of complex numbers
- // Use pow(fft_out[2 * j + 0], 2) + pow(fft_out[2 * j + 1], 2) causes inference quality problem? Interesting.
- for (int j = 0; j < n_fft; j++) {
- fft_out[j] = (fft_out[2 * j + 0] * fft_out[2 * j + 0] + fft_out[2 * j + 1] * fft_out[2 * j + 1]);
- }
-
- // mel spectrogram
- for (int j = 0; j < mel.n_mel; j++) {
- double sum = 0.0;
-
- // unroll loop (suggested by GH user @lunixbochs)
- int k = 0;
- for (k = 0; k < n_fft - 3; k += 4) {
- sum +=
- fft_out[k + 0] * filters.data[j * n_fft + k + 0] +
- fft_out[k + 1] * filters.data[j * n_fft + k + 1] +
- fft_out[k + 2] * filters.data[j * n_fft + k + 2] +
- fft_out[k + 3] * filters.data[j * n_fft + k + 3];
- }
-
- // handle n_fft remainder
- for (; k < n_fft; k++) {
- sum += fft_out[k] * filters.data[j * n_fft + k];
- }
-
- sum = log10(std::max(sum, 1e-10));
-
- mel.data[j * mel.n_len + i] = sum;
- }
- }
-
- // Otherwise fft_out are all zero
- double sum = log10(1e-10);
- for (; i < mel.n_len; i += n_threads) {
- for (int j = 0; j < mel.n_mel; j++) {
- mel.data[j * mel.n_len + i] = sum;
- }
- }
-}
-
-struct mel_calc_cpu : public whisper_mel_calc {
- ggml_backend_t m_backend;
- const whisper_filters & m_filters;
- mel_calc_cpu(ggml_backend_t backend, const whisper_filters & filters) : m_backend(backend), m_filters(filters) {}
-
- // ref: https://github.com/openai/whisper/blob/main/whisper/audio.py#L110-L157
- whisper_mel calculate(whisper_span<const float> ssamples, int n_threads) override {
- // Hann window
- const float * hann = global_cache.hann_window;
-
- // Calculate the length of padding
- int64_t stage_1_pad = WHISPER_SAMPLE_RATE * 30;
- int64_t stage_2_pad = WHISPER_N_FFT / 2;
-
- const int n_samples = int(ssamples.len);
- const float * samples = ssamples.data;
-
- // Initialize a vector and copy data from C array to it.
- std::vector<float> samples_padded;
- samples_padded.resize(n_samples + stage_1_pad + stage_2_pad * 2);
- std::copy(samples, samples + n_samples, samples_padded.begin() + stage_2_pad);
-
- // pad 30 seconds of zeros at the end of audio (480,000 samples) + reflective pad 200 samples at the end of audio
- std::fill(samples_padded.begin() + n_samples + stage_2_pad, samples_padded.begin() + n_samples + stage_1_pad + 2 * stage_2_pad, 0);
-
- // reflective pad 200 samples at the beginning of audio
- std::reverse_copy(samples + 1, samples + 1 + stage_2_pad, samples_padded.begin());
-
- whisper_mel_data mel;
- mel.n_mel = m_filters.n_mel;
- // https://github.com/pytorch/pytorch/blob/main/aten/src/ATen/native/SpectralOps.cpp#L936
- // Calculate number of frames + remove the last frame
- mel.n_len = (samples_padded.size() - WHISPER_N_FFT) / WHISPER_HOP_LENGTH;
- // Calculate semi-padded sample length to ensure compatibility
- mel.n_len_org = 1 + (n_samples + stage_2_pad - WHISPER_N_FFT) / WHISPER_HOP_LENGTH;
-
- std::vector<float> host_mel_data;
-
- whisper_mel ret;
- whisper_mel_init(ret, m_backend, mel.n_len, mel.n_len_org, mel.n_mel);
- if (ggml_backend_buffer_is_host(ret.buffer)) {
- mel.data = reinterpret_cast<float*>(ret.tensor->data);
- } else {
- host_mel_data.resize(mel.n_len * mel.n_mel);
- mel.data = host_mel_data.data();
- }
-
- {
- std::vector<std::thread> workers(n_threads - 1);
- for (int iw = 0; iw < n_threads - 1; ++iw) {
- workers[iw] = std::thread(
- log_mel_spectrogram_worker_thread, iw + 1, hann, samples_padded,
- n_samples + stage_2_pad, n_threads,
- std::cref(m_filters), std::ref(mel));
- }
-
- // main thread
- log_mel_spectrogram_worker_thread(0, hann, samples_padded, n_samples + stage_2_pad, n_threads, m_filters, mel);
-
- for (int iw = 0; iw < n_threads - 1; ++iw) {
- workers[iw].join();
- }
- }
-
- // clamping and normalization
- double mmax = -1e20;
- for (int i = 0; i < mel.n_mel*mel.n_len; i++) {
- if (mel.data[i] > mmax) {
- mmax = mel.data[i];
- }
- }
-
- mmax -= 8.0;
-
- for (int i = 0; i < mel.n_mel*mel.n_len; i++) {
- if (mel.data[i] < mmax) {
- mel.data[i] = mmax;
- }
-
- mel.data[i] = (mel.data[i] + 4.0)/4.0;
- }
-
- if (!host_mel_data.empty()) {
- // the ret buffer is not host-accessible so we used this temporary buffer and now we need to upload it
- ggml_backend_tensor_set(ret.tensor, host_mel_data.data(), 0, ggml_nbytes(ret.tensor));
- }
-
- return ret;
- }
-};
-}
-
-static whisper_mel_calc * whisper_mel_calc_create(ggml_backend_t backend, const whisper_filters & filters) {
-// TODO: disabled because it relies on ggml internals that are no longer accessible (ggml-backend-impl.h, ggml-cuda/common.cuh, ..)
-//#if defined(GGML_USE_CUDA) && !defined(GGML_USE_HIPBLAS)
-#if 0
- if (ggml_backend_is_cuda(backend)) {
- auto ret = whisper_mel_calc_create_cuda(backend, filters);
- if (ret) {
- // run a warmup to avoid the first kernel launch overhead (thus we get the best perf even on the first run)
- const float warmup[256] = { 0 };
- ret->calculate({ warmup, 256 }, 1);
- return ret;
- }
- }
-#endif
-
- // a specialized mel_calc could not be created
- // fall back to CPU
- return new mel_calc_cpu(backend, filters);
-}
-
-// split text into tokens
-//
-// ref: https://github.com/openai/gpt-2/blob/a74da5d99abaaba920de8131d64da2862a8f213b/src/encoder.py#L53
-//
-// Regex (Python):
-// r"""'s|'t|'re|'ve|'m|'ll|'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+"""
-//
-// Regex (C++):
-// R"('s|'t|'re|'ve|'m|'ll|'d| ?[[:alpha:]]+| ?[[:digit:]]+| ?[^\s[:alpha:][:digit:]]+|\s+(?!\S)|\s+)"
-//
-static std::vector<whisper_vocab::id> tokenize(const whisper_vocab & vocab, const std::string & text) {
- std::vector<std::string> words;
-
- // first split the text into words
- {
- std::string str = text;
- std::string pat = R"('s|'t|'re|'ve|'m|'ll|'d| ?[[:alpha:]]+| ?[[:digit:]]+| ?[^\s[:alpha:][:digit:]]+|\s+(?!\S)|\s+)";
-
- std::regex re(pat);
- std::smatch m;
-
- while (std::regex_search(str, m, re)) {
- for (auto x : m) {
- words.push_back(x);
- }
- str = m.suffix();
- }
- }
-
- // find the longest tokens that form the words:
- std::vector<whisper_vocab::id> tokens;
- for (const auto & word : words) {
- if (word.empty()) continue;
-
- int i = 0;
- int n = word.size();
- while (i < n) {
- int j = n;
- bool found = false;
- while (j > i) {
- auto sub = word.substr(i, j-i);
- auto it = vocab.token_to_id.find(sub);
- if (it != vocab.token_to_id.end()) {
- tokens.push_back(it->second);
- i = j;
- found = true;
- break;
- }
- --j;
- }
- if (!found) {
- WHISPER_LOG_ERROR("unknown token\n");
- ++i;
- }
- }
- }
-
- return tokens;
-}
-
-//
-// interface implementation
-//
-
-#ifdef WHISPER_USE_COREML
-// replace .bin with -encoder.mlmodelc
-static std::string whisper_get_coreml_path_encoder(std::string path_bin) {
- auto pos = path_bin.rfind('.');
- if (pos != std::string::npos) {
- path_bin = path_bin.substr(0, pos);
- }
-
- // match "-qx_x"
- pos = path_bin.rfind('-');
- if (pos != std::string::npos) {
- auto sub = path_bin.substr(pos);
- if (sub.size() == 5 && sub[1] == 'q' && sub[3] == '_') {
- path_bin = path_bin.substr(0, pos);
- }
- }
-
- path_bin += "-encoder.mlmodelc";
-
- return path_bin;
-}
-#endif
-
-#ifdef WHISPER_USE_OPENVINO
-// replace .bin with-encoder-openvino.xml
-static std::string whisper_openvino_get_path_encoder(std::string path_bin) {
- auto pos = path_bin.rfind('.');
- if (pos != std::string::npos) {
- path_bin = path_bin.substr(0, pos);
- }
-
- path_bin += "-encoder-openvino.xml";
-
- return path_bin;
-}
-
-static std::string whisper_openvino_get_path_cache(std::string path_bin) {
- auto pos = path_bin.rfind('.');
- if (pos != std::string::npos) {
- path_bin = path_bin.substr(0, pos);
- }
-
- path_bin += "-encoder-openvino-cache";
-
- return path_bin;
-}
-#endif
-
-struct whisper_state * whisper_init_state(whisper_context * ctx) {
- whisper_state * state = new whisper_state;
-
- state->backends = whisper_backend_init(ctx->params);
- if (state->backends.empty()) {
- WHISPER_LOG_ERROR("%s: whisper_backend_init() failed\n", __func__);
- whisper_free_state(state);
- return nullptr;
- }
-
- state->mel_calc = whisper_mel_calc_create(state->backends[0], ctx->model.filters);
-
- // init 60s of random mel data
- {
- const int n_len = 2*100*WHISPER_CHUNK_SIZE;
- const int n_mel = ctx->model.filters.n_mel;
-
- whisper_mel_free(state->mel);
- whisper_mel_init(state->mel, state->backends[0], n_len, n_len, n_mel);
- }
-
- // at this point, we don't know yet how many decoders will be used, so we overallocate 3x ctx
- // in theory, there can be a case where this is not enough, but in practice it should always be enough
- const int factor = 3;
-
- if (!whisper_kv_cache_init(state->kv_self, state->backends[0], ctx->itype,
- ctx->model.hparams.n_text_state,
- ctx->model.hparams.n_text_layer,
- GGML_PAD(ctx->model.hparams.n_text_ctx, 256)*factor)) {
- WHISPER_LOG_ERROR("%s: whisper_kv_cache_init() failed for self-attention cache\n", __func__);
- whisper_free_state(state);
- return nullptr;
- }
-
- {
- const size_t memory_size = ggml_nbytes(state->kv_self.k) + ggml_nbytes(state->kv_self.v);
- WHISPER_LOG_INFO("%s: kv self size = %7.2f MB\n", __func__, memory_size / 1e6);
- }
-
- if (!whisper_kv_cache_init(state->kv_cross, state->backends[0], ctx->itype,
- ctx->model.hparams.n_text_state,
- ctx->model.hparams.n_text_layer,
- GGML_PAD(ctx->model.hparams.n_audio_ctx, 256))) {
- WHISPER_LOG_ERROR("%s: whisper_kv_cache_init() failed for cross-attention cache\n", __func__);
- whisper_free_state(state);
- return nullptr;
- }
-
- {
- const size_t memory_size = ggml_nbytes(state->kv_cross.k) + ggml_nbytes(state->kv_cross.v);
- WHISPER_LOG_INFO("%s: kv cross size = %7.2f MB\n", __func__, memory_size / 1e6);
- }
-
- if (!whisper_kv_cache_init(state->kv_pad, state->backends[0], ctx->itype,
- ctx->model.hparams.n_audio_state,
- 1,
- GGML_PAD(ctx->model.hparams.n_audio_ctx, 256))) {
- WHISPER_LOG_ERROR("%s: whisper_kv_cache_init() failed for self-attention cache\n", __func__);
- whisper_free_state(state);
- return nullptr;
- }
-
- {
- const size_t memory_size = ggml_nbytes(state->kv_pad.k) + ggml_nbytes(state->kv_pad.v);
- WHISPER_LOG_INFO("%s: kv pad size = %7.2f MB\n", __func__, memory_size / 1e6);
- }
-
- // [EXPERIMENTAL] Token-level timestamps with DTW
- if (ctx->params.dtw_token_timestamps) {
- if (!aheads_masks_init(ctx->params, ctx->model.hparams, state->aheads_masks, state->backends[0])) {
- WHISPER_LOG_ERROR("%s: aheads_masks_init() failed for alignment heads masks\n", __func__);
- whisper_free_state(state);
- return nullptr;
- }
- const size_t memory_size = aheads_masks_nbytes(state->aheads_masks);
- WHISPER_LOG_INFO("%s: alignment heads masks size = %ld B\n", __func__, memory_size);
- }
-
-#ifdef WHISPER_USE_COREML
- const auto path_coreml = whisper_get_coreml_path_encoder(ctx->path_model);
-
- WHISPER_LOG_INFO("%s: loading Core ML model from '%s'\n", __func__, path_coreml.c_str());
- WHISPER_LOG_INFO("%s: first run on a device may take a while ...\n", __func__);
-
- state->ctx_coreml = whisper_coreml_init(path_coreml.c_str());
- if (!state->ctx_coreml) {
- WHISPER_LOG_ERROR("%s: failed to load Core ML model from '%s'\n", __func__, path_coreml.c_str());
-#ifndef WHISPER_COREML_ALLOW_FALLBACK
- whisper_free_state(state);
- return nullptr;
-#endif
- } else {
- WHISPER_LOG_INFO("%s: Core ML model loaded\n", __func__);
- }
-#endif
-
- state->logits.reserve(ctx->vocab.n_vocab * ctx->model.hparams.n_text_ctx);
-
- state->batch = whisper_batch_init(ctx->model.hparams.n_text_ctx, WHISPER_MAX_DECODERS);
-
- // TAGS: WHISPER_DECODER_INIT
- state->decoders[0].sequence.tokens.reserve(ctx->model.hparams.n_text_ctx);
-
- state->decoders[0].probs.reserve (ctx->vocab.n_vocab);
- state->decoders[0].logits.reserve (ctx->vocab.n_vocab);
- state->decoders[0].logprobs.reserve (ctx->vocab.n_vocab);
- state->decoders[0].logits_id.reserve(ctx->model.hparams.n_vocab);
-
- state->decoders[0].rng = std::mt19937(0);
-
- // conv allocator
- {
- bool ok = whisper_sched_graph_init(state->sched_conv, state->backends,
- [&]() {
- return whisper_build_graph_conv(*ctx, *state, 0);
- });
-
- if (!ok) {
- WHISPER_LOG_ERROR("%s: failed to init conv allocator\n", __func__);
- whisper_free_state(state);
- return nullptr;
- }
-
- WHISPER_LOG_INFO("%s: compute buffer (conv) = %7.2f MB\n", __func__, whisper_sched_size(state->sched_conv) / 1e6);
- }
-
- // encoder allocator
- if (!whisper_encode_external(*state)) {
- bool ok = whisper_sched_graph_init(state->sched_encode, state->backends,
- [&]() {
- return whisper_build_graph_encoder(*ctx, *state);
- });
-
- if (!ok) {
- WHISPER_LOG_ERROR("%s: failed to init encoder allocator\n", __func__);
- whisper_free_state(state);
- return nullptr;
- }
-
- WHISPER_LOG_INFO("%s: compute buffer (encode) = %7.2f MB\n", __func__, whisper_sched_size(state->sched_encode) / 1e6);
- }
-
- // cross allocator
- {
- bool ok = whisper_sched_graph_init(state->sched_cross, state->backends,
- [&]() {
- return whisper_build_graph_cross(*ctx, *state);
- });
-
- if (!ok) {
- WHISPER_LOG_ERROR("%s: failed to init cross allocator\n", __func__);
- whisper_free_state(state);
- return nullptr;
- }
-
- WHISPER_LOG_INFO("%s: compute buffer (cross) = %7.2f MB\n", __func__, whisper_sched_size(state->sched_cross) / 1e6);
- }
-
- // decoder allocator
- {
- bool ok = whisper_sched_graph_init(state->sched_decode, state->backends,
- [&]() {
- const auto & hparams = ctx->model.hparams;
-
- // TODO: make sure this is the worst-case scenario
- const int n_tokens = hparams.n_text_ctx;
- const int n_past = 0;
-
- whisper_batch_prep_legacy(state->batch, nullptr, n_tokens, n_past, 0);
-
- return whisper_build_graph_decoder(*ctx, *state, state->batch, ctx->params.dtw_token_timestamps, true);
- });
-
- if (!ok) {
- WHISPER_LOG_ERROR("%s: failed to init decoder allocator\n", __func__);
- whisper_free_state(state);
- return nullptr;
- }
-
- WHISPER_LOG_INFO("%s: compute buffer (decode) = %7.2f MB\n", __func__, whisper_sched_size(state->sched_decode) / 1e6);
- }
-
- return state;
-}
-
-int whisper_ctx_init_openvino_encoder(
- struct whisper_context * ctx,
- const char * model_path,
- const char * device,
- const char * cache_dir) {
-#ifndef WHISPER_USE_OPENVINO
- (void)(ctx);
- (void)(model_path);
- (void)(device);
- (void)(cache_dir);
-
- return 1;
-#else
- if (!model_path && ctx->path_model.empty()) {
- WHISPER_LOG_ERROR("%s: model_path is nullptr, and ctx has no model_path set.\n", __func__);
- return 1;
- }
-
- std::string path_encoder;
- if (!model_path) {
- //if model_path is not set, attempt to find it in the same directory as ggml-<model>.bin model
- path_encoder = whisper_openvino_get_path_encoder(ctx->path_model);
- } else {
- path_encoder = model_path;
- }
-
- std::string path_cache;
- if (!cache_dir) {
- //if cache_dir is not set, set it as a dir residing next to ggml-<model>.bin
- path_cache = whisper_openvino_get_path_cache(ctx->path_model);
- } else {
- path_cache = cache_dir;
- }
-
- WHISPER_LOG_INFO("%s: loading OpenVINO model from '%s'\n", __func__, path_encoder.c_str());
- WHISPER_LOG_INFO("%s: first run on a device may take a while ...\n", __func__);
-
- ctx->state->ctx_openvino = whisper_openvino_init(path_encoder.c_str(), device, path_cache.c_str());
- if (!ctx->state->ctx_openvino) {
- WHISPER_LOG_ERROR("%s: failed to init OpenVINO encoder from '%s'\n", __func__, path_encoder.c_str());
- return 1;
- } else {
- WHISPER_LOG_INFO("%s: OpenVINO model loaded\n", __func__);
- }
-
- return 0;
-#endif
-}
-
-struct whisper_context_params whisper_context_default_params() {
- struct whisper_context_params result = {
- /*.flash_attn =*/ false,
- /*.gpu_device =*/ 0,
-
- /*.dtw_token_timestamps =*/ false,
- /*.dtw_aheads_preset =*/ WHISPER_AHEADS_NONE,
- /*.dtw_n_top =*/ -1,
- /*.dtw_aheads =*/ {
- /*.n_heads =*/ 0,
- /*.heads =*/ NULL,
- },
- /*.dtw_mem_size =*/ 1024*1024*128,
- };
- return result;
-}
-
-struct whisper_context * whisper_init_from_file_with_params_no_state(const char * path_model, struct whisper_context_params params) {
- WHISPER_LOG_INFO("%s: loading model from '%s'\n", __func__, path_model);
-#ifdef _MSC_VER
- // Convert UTF-8 path to wide string (UTF-16) for Windows, resolving character encoding issues.
- std::wstring_convert<std::codecvt_utf8<wchar_t>> converter;
- std::wstring path_model_wide = converter.from_bytes(path_model);
- auto fin = std::ifstream(path_model_wide, std::ios::binary);
-#else
- auto fin = std::ifstream(path_model, std::ios::binary);
-#endif
- if (!fin) {
- WHISPER_LOG_ERROR("%s: failed to open '%s'\n", __func__, path_model);
- return nullptr;
- }
-
- whisper_model_loader loader = {};
-
- loader.context = &fin;
-
- loader.read = [](void * ctx, void * output, size_t read_size) {
- std::ifstream * fin = (std::ifstream*)ctx;
- fin->read((char *)output, read_size);
- return read_size;
- };
-
- loader.eof = [](void * ctx) {
- std::ifstream * fin = (std::ifstream*)ctx;
- return fin->eof();
- };
-
- loader.close = [](void * ctx) {
- std::ifstream * fin = (std::ifstream*)ctx;
- fin->close();
- };
-
- auto ctx = whisper_init_with_params_no_state(&loader, params);
-
- if (ctx) {
- ctx->path_model = path_model;
- }
-
- return ctx;
-}
-
-struct whisper_context * whisper_init_from_buffer_with_params_no_state(void * buffer, size_t buffer_size, struct whisper_context_params params) {
- struct buf_context {
- uint8_t* buffer;
- size_t size;
- size_t current_offset;
- };
-
- buf_context ctx = { reinterpret_cast<uint8_t*>(buffer), buffer_size, 0 };
-
- WHISPER_LOG_INFO("%s: loading model from buffer\n", __func__);
-
- whisper_model_loader loader = {};
-
- loader.context = &ctx;
-
- loader.read = [](void * ctx, void * output, size_t read_size) {
- buf_context * buf = reinterpret_cast<buf_context *>(ctx);
-
- size_t size_to_copy = buf->current_offset + read_size < buf->size ? read_size : buf->size - buf->current_offset;
-
- memcpy(output, buf->buffer + buf->current_offset, size_to_copy);
- buf->current_offset += size_to_copy;
-
- return size_to_copy;
- };
-
- loader.eof = [](void * ctx) {
- buf_context * buf = reinterpret_cast<buf_context *>(ctx);
-
- return buf->current_offset >= buf->size;
- };
-
- loader.close = [](void * /*ctx*/) { };
-
- return whisper_init_with_params_no_state(&loader, params);
-}
-
-struct whisper_context * whisper_init_with_params_no_state(struct whisper_model_loader * loader, struct whisper_context_params params) {
- ggml_time_init();
-
- if (params.flash_attn && params.dtw_token_timestamps) {
- WHISPER_LOG_WARN("%s: dtw_token_timestamps is not supported with flash_attn - disabling\n", __func__);
- params.dtw_token_timestamps = false;
- }
-
- WHISPER_LOG_INFO("%s: cuda gpu = %d\n", __func__, llamafile_has_cuda());
- WHISPER_LOG_INFO("%s: metal gpu = %d\n", __func__, llamafile_has_metal());
- WHISPER_LOG_INFO("%s: flash attn = %d\n", __func__, params.flash_attn);
- WHISPER_LOG_INFO("%s: gpu_device = %d\n", __func__, params.gpu_device);
- WHISPER_LOG_INFO("%s: dtw = %d\n", __func__, params.dtw_token_timestamps);
-
- whisper_context * ctx = new whisper_context;
- ctx->params = params;
-
- if (!whisper_model_load(loader, *ctx)) {
- loader->close(loader->context);
- WHISPER_LOG_ERROR("%s: failed to load model\n", __func__);
- delete ctx;
- return nullptr;
- }
-
- loader->close(loader->context);
-
- return ctx;
-}
-
-struct whisper_context * whisper_init_from_file_with_params(const char * path_model, struct whisper_context_params params) {
- whisper_context * ctx = whisper_init_from_file_with_params_no_state(path_model, params);
- if (!ctx) {
- return nullptr;
- }
-
- ctx->state = whisper_init_state(ctx);
- if (!ctx->state) {
- whisper_free(ctx);
- return nullptr;
- }
-
- return ctx;
-}
-
-struct whisper_context * whisper_init_from_buffer_with_params(void * buffer, size_t buffer_size, struct whisper_context_params params) {
- whisper_context * ctx = whisper_init_from_buffer_with_params_no_state(buffer, buffer_size, params);
- if (!ctx) {
- return nullptr;
- }
-
- ctx->state = whisper_init_state(ctx);
- if (!ctx->state) {
- whisper_free(ctx);
- return nullptr;
- }
-
- return ctx;
-}
-
-struct whisper_context * whisper_init_with_params(struct whisper_model_loader * loader, struct whisper_context_params params) {
- whisper_context * ctx = whisper_init_with_params_no_state(loader, params);
- if (!ctx) {
- return nullptr;
- }
-
- ctx->state = whisper_init_state(ctx);
- if (!ctx->state) {
- whisper_free(ctx);
- return nullptr;
- }
-
- return ctx;
-}
-
-struct whisper_context * whisper_init_from_file(const char * path_model) {
- return whisper_init_from_file_with_params(path_model, whisper_context_default_params());
-}
-
-struct whisper_context * whisper_init_from_buffer(void * buffer, size_t buffer_size) {
- return whisper_init_from_buffer_with_params(buffer, buffer_size, whisper_context_default_params());
-}
-
-struct whisper_context * whisper_init(struct whisper_model_loader * loader) {
- return whisper_init_with_params(loader, whisper_context_default_params());
-}
-
-struct whisper_context * whisper_init_from_file_no_state(const char * path_model) {
- return whisper_init_from_file_with_params_no_state(path_model, whisper_context_default_params());
-}
-
-struct whisper_context * whisper_init_from_buffer_no_state(void * buffer, size_t buffer_size) {
- return whisper_init_from_buffer_with_params_no_state(buffer, buffer_size, whisper_context_default_params());
-}
-
-struct whisper_context * whisper_init_no_state(struct whisper_model_loader * loader) {
- return whisper_init_with_params_no_state(loader, whisper_context_default_params());
-}
-
-void whisper_free_state(struct whisper_state * state) {
- if (state) {
- whisper_kv_cache_free(state->kv_self);
- whisper_kv_cache_free(state->kv_cross);
- whisper_kv_cache_free(state->kv_pad);
-
- whisper_mel_free(state->mel);
-
- delete state->mel_calc;
- state->mel_calc = nullptr;
- delete state->mel_calc_fallback;
- state->mel_calc_fallback = nullptr;
-
-#ifdef WHISPER_USE_COREML
- if (state->ctx_coreml != nullptr) {
- whisper_coreml_free(state->ctx_coreml);
- state->ctx_coreml = nullptr;
- }
-#endif
-
-#ifdef WHISPER_USE_OPENVINO
- if (state->ctx_openvino != nullptr) {
- whisper_openvino_free(state->ctx_openvino);
- state->ctx_openvino = nullptr;
- }
-#endif
-
- whisper_batch_free(state->batch);
-
- ggml_backend_sched_free(state->sched_conv.sched);
- ggml_backend_sched_free(state->sched_encode.sched);
- ggml_backend_sched_free(state->sched_cross.sched);
- ggml_backend_sched_free(state->sched_decode.sched);
-
- for (auto & backend : state->backends) {
- ggml_backend_free(backend);
- }
-
- // [EXPERIMENTAL] Token-level timestamps with DTW
- aheads_masks_free(state->aheads_masks);
-
- delete state;
- }
-}
-
-void whisper_free(struct whisper_context * ctx) {
- if (ctx) {
- ggml_free(ctx->model.ctx);
-
- ggml_backend_buffer_free(ctx->model.buffer);
-
- whisper_free_state(ctx->state);
-
- delete ctx;
- }
-}
-
-void whisper_free_context_params(struct whisper_context_params * params) {
- if (params) {
- delete params;
- }
-}
-
-void whisper_free_params(struct whisper_full_params * params) {
- if (params) {
- delete params;
- }
-}
-
-int whisper_pcm_to_mel_with_state(struct whisper_context * ctx, struct whisper_state * state, const float * samples, int n_samples, int n_threads) {
- const int64_t t_start_us = ggml_time_us();
-
- whisper_mel_free(state->mel);
- if (n_samples <= 5 * 60 * WHISPER_SAMPLE_RATE) {
- // calculate mel spectrogram for lengths up to 5 minutes on the most optimal mel calculator
- state->mel = state->mel_calc->calculate({samples, n_samples}, n_threads);
- } else {
- // calcuate mel spectrogram for longer audios on the CPU
- // 1. gpu calculations may use hundreds of megabytes of memory for longer audios so we're being conservative
- // with our gpu demands
- // 2. the time to transcribe audios this long will be dominated by the decoding time, so the mel calculation
- // taking longer is not a major concern
- if (!state->mel_calc_fallback) {
- state->mel_calc_fallback = new mel_calc_cpu(state->backends[0], ctx->model.filters);
- }
- state->mel = state->mel_calc_fallback->calculate({samples, n_samples}, n_threads);
- }
-
- state->t_mel_us += ggml_time_us() - t_start_us;
-
- // Dump log_mel_spectrogram
- //{
- // auto& mel = state->mel;
- // std::ofstream outFile("log_mel_spectrogram.json");
- // outFile << "[";
- // for (uint64_t i = 0; i < mel.data.size() - 1; i++) {
- // outFile << mel.data[i] << ", ";
- // }
- // outFile << mel.data[mel.data.size() - 1] << "]";
- // outFile.close();
- //}
- return 0;
-}
-
-int whisper_pcm_to_mel(struct whisper_context * ctx, const float * samples, int n_samples, int n_threads) {
- return whisper_pcm_to_mel_with_state(ctx, ctx->state, samples, n_samples, n_threads);
-}
-
-int whisper_set_mel_with_state(
- struct whisper_context * ctx,
- struct whisper_state * state,
- const float * data,
- int n_len,
- int n_mel) {
- if (n_mel != ctx->model.filters.n_mel) {
- WHISPER_LOG_ERROR("%s: invalid number of mel bands: %d (expected %d)\n", __func__, n_mel, ctx->model.filters.n_mel);
- return -1;
- }
-
- whisper_mel_free(state->mel);
- whisper_mel_init(state->mel, state->backends[0], n_len, n_len, n_mel);
-
- ggml_backend_tensor_set(state->mel.tensor, data, 0, ggml_nbytes(state->mel.tensor));
-
- return 0;
-}
-
-int whisper_set_mel(
- struct whisper_context * ctx,
- const float * data,
- int n_len,
- int n_mel) {
- return whisper_set_mel_with_state(ctx, ctx->state, data, n_len, n_mel);
-}
-
-int whisper_encode_with_state(struct whisper_context * ctx, struct whisper_state * state, int offset, int n_threads) {
- if (!whisper_encode_internal(*ctx, *state, offset, n_threads, nullptr, nullptr)) {
- WHISPER_LOG_ERROR("%s: failed to eval\n", __func__);
- return -1;
- }
-
- return 0;
-}
-
-int whisper_encode(struct whisper_context * ctx, int offset, int n_threads) {
- if (!whisper_encode_internal(*ctx, *ctx->state, offset, n_threads, nullptr, nullptr)) {
- WHISPER_LOG_ERROR("%s: failed to eval\n", __func__);
- return -1;
- }
-
- return 0;
-}
-
-int whisper_decode_with_state(struct whisper_context * ctx, struct whisper_state * state, const whisper_token * tokens, int n_tokens, int n_past, int n_threads) {
- whisper_batch_prep_legacy(state->batch, tokens, n_tokens, n_past, 0);
-
- whisper_kv_cache_seq_rm(state->kv_self, 0, n_past, -1);
-
- if (!whisper_decode_internal(*ctx, *state, state->batch, n_threads, false, nullptr, nullptr)) {
- WHISPER_LOG_ERROR("%s: failed to eval\n", __func__);
- return 1;
- }
-
- return 0;
-}
-
-int whisper_decode(struct whisper_context * ctx, const whisper_token * tokens, int n_tokens, int n_past, int n_threads) {
- if (ctx->state == nullptr) {
- WHISPER_LOG_ERROR("%s: ERROR state was not loaded.\n", __func__);
- return -1;
- }
-
- return whisper_decode_with_state(ctx, ctx->state, tokens, n_tokens, n_past, n_threads);
-}
-
-int whisper_tokenize(struct whisper_context * ctx, const char * text, whisper_token * tokens, int n_max_tokens) {
- const auto res = tokenize(ctx->vocab, text);
-
- if (n_max_tokens < (int) res.size()) {
- WHISPER_LOG_ERROR("%s: too many resulting tokens: %d (max %d)\n", __func__, (int) res.size(), n_max_tokens);
- return -(int) res.size();
- }
-
- for (int i = 0; i < (int) res.size(); i++) {
- tokens[i] = res[i];
- }
-
- return res.size();
-}
-
-int whisper_token_count(struct whisper_context * ctx, const char * text) {
- return -whisper_tokenize(ctx, text, NULL, 0);
-}
-
-int whisper_lang_max_id(void) {
- auto max_id = 0;
- for (const auto & kv : g_lang) {
- max_id = std::max(max_id, kv.second.first);
- }
-
- return max_id;
-}
-
-int whisper_lang_id(const char * lang) {
- if (!g_lang.count(lang)) {
- for (const auto & kv : g_lang) {
- if (kv.second.second == lang) {
- return kv.second.first;
- }
- }
-
- WHISPER_LOG_ERROR("%s: unknown language '%s'\n", __func__, lang);
- return -1;
- }
- return g_lang.at(lang).first;
-}
-
-const char * whisper_lang_str(int id) {
- for (const auto & kv : g_lang) {
- if (kv.second.first == id) {
- return kv.first.c_str();
- }
- }
-
- WHISPER_LOG_ERROR("%s: unknown language id %d\n", __func__, id);
- return nullptr;
-}
-
-const char * whisper_lang_str_full(int id) {
- for (const auto & kv : g_lang) {
- if (kv.second.first == id) {
- return kv.second.second.c_str();
- }
- }
-
- WHISPER_LOG_ERROR("%s: unknown language id %d\n", __func__, id);
- return nullptr;
-}
-
-int whisper_lang_auto_detect_with_state(
- struct whisper_context * ctx,
- struct whisper_state * state,
- int offset_ms,
- int n_threads,
- float * lang_probs) {
- const int seek = offset_ms/10;
-
- if (seek < 0) {
- WHISPER_LOG_ERROR("%s: offset %dms is before the start of the audio\n", __func__, offset_ms);
- return -1;
- }
-
- if (seek >= state->mel.n_len_org) {
- WHISPER_LOG_ERROR("%s: offset %dms is past the end of the audio (%dms)\n", __func__, offset_ms, state->mel.n_len_org*10);
- return -2;
- }
-
- // run the encoder
- if (whisper_encode_with_state(ctx, state, seek, n_threads) != 0) {
- WHISPER_LOG_ERROR("%s: failed to encode\n", __func__);
- return -6;
- }
-
- const std::vector<whisper_token> prompt = { whisper_token_sot(ctx) };
-
- if (whisper_decode_with_state(ctx, state, prompt.data(), prompt.size(), 0, n_threads) != 0) {
- WHISPER_LOG_ERROR("%s: failed to decode\n", __func__);
- return -7;
- }
-
- auto & logits_id = state->decoders[0].logits_id;
- logits_id.clear();
-
- for (const auto & kv : g_lang) {
- const auto token_lang = whisper_token_lang(ctx, kv.second.first);
- logits_id.emplace_back(state->logits[token_lang], kv.second.first);
- }
-
- // sort descending
- {
- using pair_type = std::remove_reference<decltype(logits_id)>::type::value_type;
- std::sort(logits_id.begin(), logits_id.end(), [](const pair_type & a, const pair_type & b) {
- return a.first > b.first;
- });
- }
-
- // softmax
- {
- const auto max = logits_id[0].first;
-
- double sum = 0.0f;
- for (auto & kv : logits_id) {
- kv.first = exp(kv.first - max);
- sum += kv.first;
- }
-
- for (auto & kv : logits_id) {
- kv.first /= sum;
- }
- }
-
- {
- for (const auto & prob : logits_id) {
- if (lang_probs) {
- lang_probs[prob.second] = prob.first;
- }
-
- //printf("%s: lang %2d (%3s): %f\n", __func__, prob.second, whisper_lang_str(prob.second), prob.first);
- }
- }
-
- return logits_id[0].second;
-}
-
-int whisper_lang_auto_detect(
- struct whisper_context * ctx,
- int offset_ms,
- int n_threads,
- float * lang_probs) {
- return whisper_lang_auto_detect_with_state(ctx, ctx->state, offset_ms, n_threads, lang_probs);
-}
-
-int whisper_model_n_vocab(struct whisper_context * ctx) {
- return ctx->model.hparams.n_vocab;
-}
-
-int whisper_model_n_audio_ctx(struct whisper_context * ctx) {
- return ctx->model.hparams.n_audio_ctx;
-}
-
-int whisper_model_n_audio_state(struct whisper_context * ctx) {
- return ctx->model.hparams.n_audio_state;
-}
-
-int whisper_model_n_audio_head(struct whisper_context * ctx) {
- return ctx->model.hparams.n_audio_head;
-}
-
-int whisper_model_n_audio_layer(struct whisper_context * ctx) {
- return ctx->model.hparams.n_audio_layer;
-}
-
-int whisper_model_n_text_ctx(struct whisper_context * ctx) {
- return ctx->model.hparams.n_text_ctx;
-}
-
-int whisper_model_n_text_state(struct whisper_context * ctx) {
- return ctx->model.hparams.n_text_state;
-}
-
-int whisper_model_n_text_head(struct whisper_context * ctx) {
- return ctx->model.hparams.n_text_head;
-}
-
-int whisper_model_n_text_layer(struct whisper_context * ctx) {
- return ctx->model.hparams.n_text_layer;
-}
-
-int whisper_model_n_mels(struct whisper_context * ctx) {
- return ctx->model.hparams.n_mels;
-}
-
-int whisper_model_ftype(struct whisper_context * ctx) {
- return ctx->model.hparams.ftype;
-}
-
-int whisper_model_type(struct whisper_context * ctx) {
- return ctx->model.type;
-}
-
-const char *whisper_model_type_readable(struct whisper_context * ctx) {
- switch (ctx->model.type) {
- case e_model::MODEL_TINY:
- return "tiny";
- case e_model::MODEL_BASE:
- return "base";
- case e_model::MODEL_SMALL:
- return "small";
- case e_model::MODEL_MEDIUM:
- return "medium";
- case e_model::MODEL_LARGE:
- return "large";
- default:
- return "unknown";
- }
-}
-
-int whisper_n_len_from_state(struct whisper_state * state) {
- return state->mel.n_len_org;
-}
-
-int whisper_n_len(struct whisper_context * ctx) {
- return ctx->state->mel.n_len_org;
-}
-
-int whisper_n_vocab(struct whisper_context * ctx) {
- return ctx->vocab.n_vocab;
-}
-
-int whisper_n_text_ctx(struct whisper_context * ctx) {
- return ctx->model.hparams.n_text_ctx;
-}
-
-int whisper_n_audio_ctx(struct whisper_context * ctx) {
- return ctx->model.hparams.n_audio_ctx;
-}
-
-int whisper_is_multilingual(struct whisper_context * ctx) {
- return ctx->vocab.is_multilingual() ? 1 : 0;
-}
-
-float * whisper_get_logits(struct whisper_context * ctx) {
- return ctx->state->logits.data();
-}
-
-float * whisper_get_logits_from_state(struct whisper_state * state) {
- return state->logits.data();
-}
-
-const char * whisper_token_to_str(struct whisper_context * ctx, whisper_token token) {
- return ctx->vocab.id_to_token.at(token).c_str();
-}
-
-whisper_token whisper_token_eot(struct whisper_context * ctx) {
- return ctx->vocab.token_eot;
-}
-
-whisper_token whisper_token_sot(struct whisper_context * ctx) {
- return ctx->vocab.token_sot;
-}
-
-whisper_token whisper_token_solm(struct whisper_context * ctx) {
- return ctx->vocab.token_solm;
-}
-
-whisper_token whisper_token_prev(struct whisper_context * ctx) {
- return ctx->vocab.token_prev;
-}
-
-whisper_token whisper_token_nosp(struct whisper_context * ctx) {
- return ctx->vocab.token_nosp;
-}
-
-whisper_token whisper_token_not(struct whisper_context * ctx) {
- return ctx->vocab.token_not;
-}
-
-whisper_token whisper_token_beg(struct whisper_context * ctx) {
- return ctx->vocab.token_beg;
-}
-
-whisper_token whisper_token_lang(struct whisper_context * ctx, int lang_id) {
- return whisper_token_sot(ctx) + 1 + lang_id;
-}
-
-whisper_token whisper_token_translate(struct whisper_context * ctx) {
- return ctx->vocab.token_translate;
-}
-
-whisper_token whisper_token_transcribe(struct whisper_context * ctx) {
- return ctx->vocab.token_transcribe;
-}
-
-void whisper_print_timings(struct whisper_context * ctx) {
- const int64_t t_end_us = ggml_time_us();
-
- WHISPER_LOG_INFO("\n");
- WHISPER_LOG_INFO("%s: load time = %8.2f ms\n", __func__, ctx->t_load_us / 1000.0f);
- if (ctx->state != nullptr) {
-
- const int32_t n_sample = std::max(1, ctx->state->n_sample);
- const int32_t n_encode = std::max(1, ctx->state->n_encode);
- const int32_t n_decode = std::max(1, ctx->state->n_decode);
- const int32_t n_batchd = std::max(1, ctx->state->n_batchd);
- const int32_t n_prompt = std::max(1, ctx->state->n_prompt);
-
- WHISPER_LOG_INFO("%s: fallbacks = %3d p / %3d h\n", __func__, ctx->state->n_fail_p, ctx->state->n_fail_h);
- WHISPER_LOG_INFO("%s: mel time = %8.2f ms\n", __func__, ctx->state->t_mel_us / 1000.0f);
- WHISPER_LOG_INFO("%s: sample time = %8.2f ms / %5d runs (%8.2f ms per run)\n", __func__, 1e-3f * ctx->state->t_sample_us, n_sample, 1e-3f * ctx->state->t_sample_us / n_sample);
- WHISPER_LOG_INFO("%s: encode time = %8.2f ms / %5d runs (%8.2f ms per run)\n", __func__, 1e-3f * ctx->state->t_encode_us, n_encode, 1e-3f * ctx->state->t_encode_us / n_encode);
- WHISPER_LOG_INFO("%s: decode time = %8.2f ms / %5d runs (%8.2f ms per run)\n", __func__, 1e-3f * ctx->state->t_decode_us, n_decode, 1e-3f * ctx->state->t_decode_us / n_decode);
- WHISPER_LOG_INFO("%s: batchd time = %8.2f ms / %5d runs (%8.2f ms per run)\n", __func__, 1e-3f * ctx->state->t_batchd_us, n_batchd, 1e-3f * ctx->state->t_batchd_us / n_batchd);
- WHISPER_LOG_INFO("%s: prompt time = %8.2f ms / %5d runs (%8.2f ms per run)\n", __func__, 1e-3f * ctx->state->t_prompt_us, n_prompt, 1e-3f * ctx->state->t_prompt_us / n_prompt);
- }
- WHISPER_LOG_INFO("%s: total time = %8.2f ms\n", __func__, (t_end_us - ctx->t_start_us)/1000.0f);
-}
-
-void whisper_reset_timings(struct whisper_context * ctx) {
- ctx->t_start_us = ggml_time_us();
- if (ctx->state != nullptr) {
- ctx->state->t_mel_us = 0;
- ctx->state->t_sample_us = 0;
- ctx->state->t_encode_us = 0;
- ctx->state->t_decode_us = 0;
- ctx->state->t_batchd_us = 0;
- ctx->state->t_prompt_us = 0;
- ctx->state->n_sample = 0;
- ctx->state->n_encode = 0;
- ctx->state->n_decode = 0;
- ctx->state->n_batchd = 0;
- ctx->state->n_prompt = 0;
- }
-}
-
-static int whisper_has_coreml(void) {
-#ifdef WHISPER_USE_COREML
- return 1;
-#else
- return 0;
-#endif
-}
-
-static int whisper_has_openvino(void) {
-#ifdef WHISPER_USE_OPENVINO
- return 1;
-#else
- return 0;
-#endif
-}
-
-const char * whisper_print_system_info(void) {
- static std::string s;
-
- s = "";
- s += "AVX = " + std::to_string(ggml_cpu_has_avx()) + " | ";
- s += "AVX2 = " + std::to_string(ggml_cpu_has_avx2()) + " | ";
- s += "AVX512 = " + std::to_string(ggml_cpu_has_avx512()) + " | ";
- s += "FMA = " + std::to_string(ggml_cpu_has_fma()) + " | ";
- s += "NEON = " + std::to_string(ggml_cpu_has_neon()) + " | ";
- s += "ARM_FMA = " + std::to_string(ggml_cpu_has_arm_fma()) + " | ";
- s += "METAL = " + std::to_string(ggml_cpu_has_metal()) + " | ";
- s += "F16C = " + std::to_string(ggml_cpu_has_f16c()) + " | ";
- s += "FP16_VA = " + std::to_string(ggml_cpu_has_fp16_va()) + " | ";
- s += "WASM_SIMD = " + std::to_string(ggml_cpu_has_wasm_simd()) + " | ";
- s += "BLAS = " + std::to_string(ggml_cpu_has_blas()) + " | ";
- s += "SSE3 = " + std::to_string(ggml_cpu_has_sse3()) + " | ";
- s += "SSSE3 = " + std::to_string(ggml_cpu_has_ssse3()) + " | ";
- s += "VSX = " + std::to_string(ggml_cpu_has_vsx()) + " | ";
- s += "CUDA = " + std::to_string(ggml_cpu_has_cuda()) + " | ";
- s += "COREML = " + std::to_string(whisper_has_coreml()) + " | ";
- s += "OPENVINO = " + std::to_string(whisper_has_openvino()) ;
-
- return s.c_str();
-}
-
-//////////////////////////////////
-// Grammar - ported from llama.cpp
-//////////////////////////////////
-
-// Decodes a UTF-8 string which may end in an incomplete sequence. Adds a terminating 0 for use as
-// pointer. If an invalid sequence is encountered, returns `whisper_partial_utf8.n_remain == -1`.
-static std::pair<std::vector<uint32_t>, whisper_partial_utf8> decode_utf8(
- const char * src,
- whisper_partial_utf8 partial_start) {
- static const int lookup[] = { 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 2, 2, 3, 4 };
- const char * pos = src;
- std::vector<uint32_t> code_points;
- uint32_t value = partial_start.value;
- int n_remain = partial_start.n_remain;
-
- // continue previous decode, if applicable
- while (*pos != 0 && n_remain > 0) {
- uint8_t next_byte = static_cast<uint8_t>(*pos);
- if ((next_byte >> 6) != 2) {
- // invalid sequence, abort
- code_points.push_back(0);
- return std::make_pair(std::move(code_points), whisper_partial_utf8{ 0, -1 });
- }
- value = (value << 6) + (next_byte & 0x3F);
- ++pos;
- --n_remain;
- }
-
- if (partial_start.n_remain > 0 && n_remain == 0) {
- code_points.push_back(value);
- }
-
- // decode any subsequent utf-8 sequences, which may end in an incomplete one
- while (*pos != 0) {
- uint8_t first_byte = static_cast<uint8_t>(*pos);
- uint8_t highbits = first_byte >> 4;
- n_remain = lookup[highbits] - 1;
-
- if (n_remain < 0) {
- // invalid sequence, abort
- code_points.clear();
- code_points.push_back(0);
- return std::make_pair(std::move(code_points), whisper_partial_utf8{ 0, n_remain });
- }
-
- uint8_t mask = (1 << (7 - n_remain)) - 1;
- value = first_byte & mask;
- ++pos;
- while (*pos != 0 && n_remain > 0) {
- value = (value << 6) + (static_cast<uint8_t>(*pos) & 0x3F);
- ++pos;
- --n_remain;
- }
- if (n_remain == 0) {
- code_points.push_back(value);
- }
- }
- code_points.push_back(0);
-
- return std::make_pair(std::move(code_points), whisper_partial_utf8{ value, n_remain });
-}
-
-// returns true iff pos points to the end of one of the definitions of a rule
-static bool whisper_grammar_is_end_of_sequence(const whisper_grammar_element * pos) {
- switch (pos->type) {
- case WHISPER_GRETYPE_END: return true; // NOLINT
- case WHISPER_GRETYPE_ALT: return true; // NOLINT
- default: return false;
- }
-}
-
-// returns true iff chr satisfies the char range at pos (regular or inverse range)
-// asserts that pos is pointing to a char range element
-static std::pair<bool, const whisper_grammar_element *> whisper_grammar_match_char(
- const whisper_grammar_element * pos,
- const uint32_t chr) {
-
- bool found = false;
- bool is_positive_char = pos->type == WHISPER_GRETYPE_CHAR;
-
- WHISPER_ASSERT(is_positive_char || pos->type == WHISPER_GRETYPE_CHAR_NOT); // NOLINT
-
- do {
- if (pos[1].type == WHISPER_GRETYPE_CHAR_RNG_UPPER) {
- // inclusive range, e.g. [a-z]
- found = found || (pos->value <= chr && chr <= pos[1].value);
- pos += 2;
- } else {
- // exact char match, e.g. [a] or "a"
- found = found || pos->value == chr;
- pos += 1;
- }
- } while (pos->type == WHISPER_GRETYPE_CHAR_ALT);
-
- return std::make_pair(found == is_positive_char, pos);
-}
-
-// returns true iff some continuation of the given partial UTF-8 sequence could satisfy the char
-// range at pos (regular or inverse range)
-// asserts that pos is pointing to a char range element
-static bool whisper_grammar_match_partial_char(
- const whisper_grammar_element * pos,
- const whisper_partial_utf8 partial_utf8) {
-
- bool is_positive_char = pos->type == WHISPER_GRETYPE_CHAR;
- WHISPER_ASSERT(is_positive_char || pos->type == WHISPER_GRETYPE_CHAR_NOT);
-
- uint32_t partial_value = partial_utf8.value;
- int n_remain = partial_utf8.n_remain;
-
- // invalid sequence or 7-bit char split across 2 bytes (overlong)
- if (n_remain < 0 || (n_remain == 1 && partial_value < 2)) {
- return false;
- }
-
- // range of possible code points this partial UTF-8 sequence could complete to
- uint32_t low = partial_value << (n_remain * 6);
- uint32_t high = low | ((1 << (n_remain * 6)) - 1);
-
- if (low == 0) {
- if (n_remain == 2) {
- low = 1 << 11;
- } else if (n_remain == 3) {
- low = 1 << 16;
- }
- }
-
- do {
- if (pos[1].type == WHISPER_GRETYPE_CHAR_RNG_UPPER) {
- // inclusive range, e.g. [a-z]
- if (pos->value <= high && low <= pos[1].value) {
- return is_positive_char;
- }
- pos += 2;
- } else {
- // exact char match, e.g. [a] or "a"
- if (low <= pos->value && pos->value <= high) {
- return is_positive_char;
- }
- pos += 1;
- }
- } while (pos->type == WHISPER_GRETYPE_CHAR_ALT);
-
- return !is_positive_char;
-}
-
-
-// transforms a grammar pushdown stack into N possible stacks, all ending
-// at a character range (terminal element)
-static void whisper_grammar_advance_stack(
- const std::vector<std::vector<whisper_grammar_element>> & rules,
- const std::vector<const whisper_grammar_element *> & stack,
- std::vector<std::vector<const whisper_grammar_element *>> & new_stacks) {
-
- if (stack.empty()) {
- new_stacks.push_back(stack);
- return;
- }
-
- const whisper_grammar_element * pos = stack.back();
-
- switch (pos->type) {
- case WHISPER_GRETYPE_RULE_REF: {
- const size_t rule_id = static_cast<size_t>(pos->value);
- const whisper_grammar_element * subpos = rules[rule_id].data();
- do {
- // init new stack without the top (pos)
- std::vector<const whisper_grammar_element *> new_stack(stack.begin(), stack.end() - 1);
- if (!whisper_grammar_is_end_of_sequence(pos + 1)) {
- // if this rule ref is followed by another element, add that to stack
- new_stack.push_back(pos + 1);
- }
- if (!whisper_grammar_is_end_of_sequence(subpos)) {
- // if alternate is nonempty, add to stack
- new_stack.push_back(subpos);
- }
- whisper_grammar_advance_stack(rules, new_stack, new_stacks);
- while (!whisper_grammar_is_end_of_sequence(subpos)) {
- // scan to end of alternate def
- subpos++;
- }
- if (subpos->type == WHISPER_GRETYPE_ALT) {
- // there's another alternate def of this rule to process
- subpos++;
- } else {
- break;
- }
- } while (true);
- break;
- }
- case WHISPER_GRETYPE_CHAR:
- case WHISPER_GRETYPE_CHAR_NOT:
- new_stacks.push_back(stack);
- break;
- default:
- // end of alternate (WHISPER_GRETYPE_END, WHISPER_GRETYPE_ALT) or middle of char range
- // (WHISPER_GRETYPE_CHAR_ALT, WHISPER_GRETYPE_CHAR_RNG_UPPER); stack should never be left on
- // those
- WHISPER_ASSERT(false);
- }
-}
-
-// takes a set of possible pushdown stacks on a grammar, which are required to
-// be positioned at a character range (see `whisper_grammar_advance_stack`), and
-// produces the N possible stacks if the given char is accepted at those
-// positions
-static std::vector<std::vector<const whisper_grammar_element *>> whisper_grammar_accept(
- const std::vector<std::vector<whisper_grammar_element>> & rules,
- const std::vector<std::vector<const whisper_grammar_element *>> & stacks,
- const uint32_t chr) {
-
- std::vector<std::vector<const whisper_grammar_element *>> new_stacks;
-
- for (const auto & stack : stacks) {
- if (stack.empty()) {
- continue;
- }
-
- auto match = whisper_grammar_match_char(stack.back(), chr);
- if (match.first) {
- const whisper_grammar_element * pos = match.second;
-
- // update top of stack to next element, if any
- std::vector<const whisper_grammar_element *> new_stack(stack.begin(), stack.end() - 1);
- if (!whisper_grammar_is_end_of_sequence(pos)) {
- new_stack.push_back(pos);
- }
- whisper_grammar_advance_stack(rules, new_stack, new_stacks);
- }
- }
-
- return new_stacks;
-}
-
-static std::vector<whisper_grammar_candidate> whisper_grammar_reject_candidates(
- const std::vector<std::vector<whisper_grammar_element>> & rules,
- const std::vector<std::vector<const whisper_grammar_element *>> & stacks,
- const std::vector<whisper_grammar_candidate> & candidates);
-
-static std::vector<whisper_grammar_candidate> whisper_grammar_reject_candidates_for_stack(
- const std::vector<std::vector<whisper_grammar_element>> & rules,
- const std::vector<const whisper_grammar_element *> & stack,
- const std::vector<whisper_grammar_candidate> & candidates) {
-
- std::vector<whisper_grammar_candidate> rejects;
-
- if (stack.empty()) {
- for (auto tok : candidates) {
- if (*tok.code_points != 0 || tok.partial_utf8.n_remain != 0) {
- rejects.push_back(tok);
- }
- }
- return rejects;
- }
-
- const whisper_grammar_element * stack_pos = stack.back();
-
- std::vector<whisper_grammar_candidate> next_candidates;
- for (auto tok : candidates) {
- if (*tok.code_points == 0) {
- // reached end of full codepoints in token, reject iff it ended in a partial sequence
- // that cannot satisfy this position in grammar
- if (tok.partial_utf8.n_remain != 0 && !whisper_grammar_match_partial_char(stack_pos, tok.partial_utf8)) {
- rejects.push_back(tok);
- }
- } else if (whisper_grammar_match_char(stack_pos, *tok.code_points).first) {
- next_candidates.push_back({ tok.id, tok.code_points + 1, tok.partial_utf8 });
- } else {
- rejects.push_back(tok);
- }
- }
-
- const auto * stack_pos_after = whisper_grammar_match_char(stack_pos, 0).second;
-
- // update top of stack to next element, if any
- std::vector<const whisper_grammar_element *> stack_after(stack.begin(), stack.end() - 1);
- if (!whisper_grammar_is_end_of_sequence(stack_pos_after)) {
- stack_after.push_back(stack_pos_after);
- }
- std::vector<std::vector<const whisper_grammar_element *>> next_stacks;
- whisper_grammar_advance_stack(rules, stack_after, next_stacks);
-
- auto next_rejects = whisper_grammar_reject_candidates(rules, next_stacks, next_candidates);
- for (auto tok : next_rejects) {
- rejects.push_back({ tok.id, tok.code_points - 1, tok.partial_utf8 });
- }
-
- return rejects;
-}
-
-static std::vector<whisper_grammar_candidate> whisper_grammar_reject_candidates(
- const std::vector<std::vector<whisper_grammar_element>> & rules,
- const std::vector<std::vector<const whisper_grammar_element *>> & stacks,
- const std::vector<whisper_grammar_candidate> & candidates) {
- if (candidates.empty() || stacks.empty()) {
- return std::vector<whisper_grammar_candidate>();
- }
-
- auto rejects = whisper_grammar_reject_candidates_for_stack(rules, stacks.front(), candidates);
-
- for (size_t i = 1, size = stacks.size(); i < size; ++i) {
- rejects = whisper_grammar_reject_candidates_for_stack(rules, stacks[i], rejects);
- }
- return rejects;
-}
-
-static struct whisper_grammar whisper_grammar_init(
- const whisper_grammar_element ** rules,
- size_t n_rules,
- size_t i_start_rule) {
- const whisper_grammar_element * pos;
-
- // copy rule definitions into vectors
- std::vector<std::vector<whisper_grammar_element>> vec_rules(n_rules);
- for (size_t i = 0; i < n_rules; i++) {
- for (pos = rules[i]; pos->type != WHISPER_GRETYPE_END; pos++) {
- vec_rules[i].push_back(*pos);
- }
- vec_rules[i].push_back({WHISPER_GRETYPE_END, 0});
- }
-
- // loop over alternates of start rule to build initial stacks
- std::vector<std::vector<const whisper_grammar_element *>> stacks;
- pos = rules[i_start_rule];
- do {
- std::vector<const whisper_grammar_element *> stack;
- if (!whisper_grammar_is_end_of_sequence(pos)) {
- // if alternate is nonempty, add to stack
- stack.push_back(pos);
- }
- whisper_grammar_advance_stack(vec_rules, stack, stacks);
- while (!whisper_grammar_is_end_of_sequence(pos)) {
- // scan to end of alternate def
- pos++;
- }
- if (pos->type == WHISPER_GRETYPE_ALT) {
- // there's another alternate def of this rule to process
- pos++;
- } else {
- break;
- }
- } while (true);
-
- return { std::move(vec_rules), std::move(stacks), {} };
-}
-
-static void whisper_suppress_invalid_grammar(
- whisper_context & ctx,
- const whisper_full_params & params,
- std::vector<float> & logits,
- const whisper_grammar & grammar) {
-
- if (grammar.rules.empty() || grammar.stacks.empty()) {
- return;
- }
-
- //bool allow_eot = false;
- //for (const auto & stack : grammar.stacks) {
- // if (stack.empty()) {
- // allow_eot = true;
- // break;
- // }
- //}
-
- const whisper_token eot = whisper_token_eot(&ctx);
-
- std::vector<std::pair<std::vector<uint32_t>, whisper_partial_utf8>> candidates_decoded;
- std::vector<whisper_grammar_candidate> candidates_grammar;
-
- for (whisper_token id = 0; id < eot; ++id) {
- const std::string & text = ctx.vocab.id_to_token[id];
- if (!text.empty()) {
- candidates_decoded.push_back(decode_utf8(text.c_str(), grammar.partial_utf8));
- candidates_grammar.push_back({ id, candidates_decoded.back().first.data(), candidates_decoded.back().second });
- }
- }
-
- const auto rejects = whisper_grammar_reject_candidates(grammar.rules, grammar.stacks, candidates_grammar);
-
- for (const auto & reject : rejects) {
- logits[reject.id] -= params.grammar_penalty;
- }
-
- // when the grammar allows a continuation, we penalize the end-of-text token
- //if (!allow_eot) {
- // logits[eot] -= params.grammar_penalty;
- //}
- //fprintf(stderr, "Allowed: (%zu tokens)\n", size - rejects.size());
-}
-
-static void whisper_grammar_accept_token(whisper_context & ctx, whisper_grammar & grammar, whisper_token token) {
- if (grammar.rules.empty() || grammar.stacks.empty()) {
- return;
- }
-
- //fprintf(stderr, "Accept: '%s'\n", ctx.vocab.id_to_token[token].c_str());
-
- const std::string & text = ctx.vocab.id_to_token[token];
-
- if (text.rfind("[_", 0) == 0) {
- // fprintf(stderr, " (skipped)\n");
- return;
- }
- // fprintf(stderr, "\n");
-
- // Note terminating 0 in decoded string
- const auto decoded = decode_utf8(text.c_str(), grammar.partial_utf8);
- const auto & code_points = decoded.first;
- for (auto it = code_points.begin(), end = code_points.end() - 1; it != end; ++it) {
- grammar.stacks = whisper_grammar_accept(grammar.rules, grammar.stacks, *it);
- }
- grammar.partial_utf8 = decoded.second;
-}
-
-//////////////
-// END grammar
-//////////////
-
-////////////////////////////////////////////////////////////////////////////
-
-struct whisper_context_params * whisper_context_default_params_by_ref(void) {
- struct whisper_context_params params = whisper_context_default_params();
-
- struct whisper_context_params* result = new whisper_context_params();
- *result = params;
- return result;
-}
-
-struct whisper_full_params * whisper_full_default_params_by_ref(enum whisper_sampling_strategy strategy) {
- struct whisper_full_params params = whisper_full_default_params(strategy);
-
- struct whisper_full_params* result = new whisper_full_params();
- *result = params;
- return result;
-}
-
-struct whisper_full_params whisper_full_default_params(enum whisper_sampling_strategy strategy) {
- struct whisper_full_params result = {
- /*.strategy =*/ strategy,
-
- /*.n_threads =*/ std::min(8, (int32_t) cpu_get_num_math()),
- /*.n_max_text_ctx =*/ 16384,
- /*.offset_ms =*/ 0,
- /*.duration_ms =*/ 0,
-
- /*.translate =*/ false,
- /*.no_context =*/ true,
- /*.no_timestamps =*/ false,
- /*.single_segment =*/ false,
- /*.print_special =*/ false,
- /*.print_progress =*/ true,
- /*.print_realtime =*/ false,
- /*.print_timestamps =*/ true,
-
- /*.token_timestamps =*/ false,
- /*.thold_pt =*/ 0.01f,
- /*.thold_ptsum =*/ 0.01f,
- /*.max_len =*/ 0,
- /*.split_on_word =*/ false,
- /*.max_tokens =*/ 0,
-
- /*.debug_mode =*/ false,
- /*.audio_ctx =*/ 0,
-
- /*.tdrz_enable =*/ false,
-
- /* suppress_regex =*/ nullptr,
-
- /*.initial_prompt =*/ nullptr,
- /*.prompt_tokens =*/ nullptr,
- /*.prompt_n_tokens =*/ 0,
-
- /*.language =*/ "en",
- /*.detect_language =*/ false,
-
- /*.suppress_blank =*/ true,
- /*.suppress_non_speech_tokens =*/ false,
-
- /*.temperature =*/ 0.0f,
- /*.max_initial_ts =*/ 1.0f,
- /*.length_penalty =*/ -1.0f,
-
- /*.temperature_inc =*/ 0.2f,
- /*.entropy_thold =*/ 2.4f,
- /*.logprob_thold =*/ -1.0f,
- /*.no_speech_thold =*/ 0.6f,
-
- /*.greedy =*/ {
- /*.best_of =*/ -1,
- },
-
- /*.beam_search =*/ {
- /*.beam_size =*/ -1,
-
- /*.patience =*/ -1.0f,
- },
-
- /*.new_segment_callback =*/ nullptr,
- /*.new_segment_callback_user_data =*/ nullptr,
-
- /*.progress_callback =*/ nullptr,
- /*.progress_callback_user_data =*/ nullptr,
-
- /*.encoder_begin_callback =*/ nullptr,
- /*.encoder_begin_callback_user_data =*/ nullptr,
-
- /*.abort_callback =*/ nullptr,
- /*.abort_callback_user_data =*/ nullptr,
-
- /*.logits_filter_callback =*/ nullptr,
- /*.logits_filter_callback_user_data =*/ nullptr,
-
- /*.grammar_rules =*/ nullptr,
- /*.n_grammar_rules =*/ 0,
- /*.i_start_rule =*/ 0,
- /*.grammar_penalty =*/ 100.0f,
- };
-
- switch (strategy) {
- case WHISPER_SAMPLING_GREEDY:
- {
- result.greedy = {
- /*.best_of =*/ 5,
- };
- } break;
- case WHISPER_SAMPLING_BEAM_SEARCH:
- {
- result.beam_search = {
- /*.beam_size =*/ 5,
-
- /*.patience =*/ -1.0f,
- };
- } break;
- }
-
- return result;
-}
-
-// forward declarations
-static std::vector<float> get_signal_energy(const float * signal, int n_samples, int n_samples_per_half_window);
-static void whisper_exp_compute_token_level_timestamps(
- struct whisper_context & ctx,
- struct whisper_state & state,
- int i_segment,
- float thold_pt,
- float thold_ptsum);
-
-static inline bool should_split_on_word(const char * txt, bool split_on_word) {
- if (!split_on_word) return true;
-
- return txt[0] == ' ';
-}
-
-static void whisper_exp_compute_token_level_timestamps_dtw(
- struct whisper_context * ctx,
- struct whisper_state * state,
- struct whisper_full_params params,
- int i_segment,
- size_t n_segments,
- int seek,
- int n_frames,
- int medfilt_width,
- int n_threads);
-
-// wrap the last segment to max_len characters
-// returns the number of new segments
-static int whisper_wrap_segment(struct whisper_context & ctx, struct whisper_state & state, int max_len, bool split_on_word) {
- auto segment = state.result_all.back();
-
- int res = 1;
- int acc = 0;
-
- std::string text;
-
- for (int i = 0; i < (int) segment.tokens.size(); i++) {
- const auto & token = segment.tokens[i];
- if (token.id >= whisper_token_eot(&ctx)) {
- continue;
- }
-
- const auto txt = whisper_token_to_str(&ctx, token.id);
- const int cur = strlen(txt);
-
- if (acc + cur > max_len && i > 0 && should_split_on_word(txt, split_on_word)) {
- state.result_all.back().text = std::move(text);
- state.result_all.back().t1 = token.t0;
- state.result_all.back().tokens.resize(i);
- state.result_all.back().speaker_turn_next = false;
-
- state.result_all.push_back({});
- state.result_all.back().t0 = token.t0;
- state.result_all.back().t1 = segment.t1;
-
- // add tokens [i, end] to the new segment
- state.result_all.back().tokens.insert(
- state.result_all.back().tokens.end(),
- segment.tokens.begin() + i,
- segment.tokens.end());
-
- state.result_all.back().speaker_turn_next = segment.speaker_turn_next;
-
- acc = 0;
- text = "";
-
- segment = state.result_all.back();
- i = -1;
-
- res++;
- } else {
- acc += cur;
- text += txt;
- }
- }
-
- state.result_all.back().text = std::move(text);
-
- return res;
-}
-
-static const std::vector<std::string> non_speech_tokens = {
- "\"", "#", "(", ")", "*", "+", "/", ":", ";", "<", "=", ">", "@", "[", "\\", "]", "^",
- "_", "`", "{", "|", "}", "~", "「", "」", "『", "』", "<<", ">>", "<<<", ">>>", "--",
- "---", "-(", "-[", "('", "(\"", "((", "))", "(((", ")))", "[[", "]]", "{{", "}}", "♪♪",
- "♪♪♪","♩", "♪", "♫", "♬", "♭", "♮", "♯"
-};
-
-// process the logits for the selected decoder
-// - applies logit filters
-// - computes logprobs and probs
-// TODO: optimize
-static void whisper_process_logits(
- struct whisper_context & ctx,
- struct whisper_state & state,
- struct whisper_decoder & decoder,
- const struct whisper_full_params params,
- float temperature) {
- const auto & vocab = ctx.vocab;
- const auto & tokens_cur = decoder.sequence.tokens;
-
- const bool is_initial = tokens_cur.size() == 0;
- const int n_logits = vocab.id_to_token.size();
-
- WHISPER_ASSERT(n_logits == ctx.vocab.n_vocab);
-
- // extract the logits for the last token
- // we will be mutating, and therefore we don't want to use the ctx.logits buffer directly
- auto & probs = decoder.probs;
- auto & logits = decoder.logits;
- auto & logprobs = decoder.logprobs;
- {
- logits.resize(n_logits);
- memcpy(logits.data(), state.logits.data() + decoder.i_batch*n_logits, n_logits*sizeof(float));
-
- if (temperature > 0.0f) {
- for (int i = 0; i < n_logits; i++) {
- logits[i] /= temperature;
- }
- }
-
- // will be populated a bit later
- probs.resize(n_logits);
- logprobs.resize(n_logits);
- }
-
- // apply logit filters here
- // ref: https://github.com/openai/whisper/blob/0b1ba3d46ebf7fe6f953acfd8cad62a4f851b49f/whisper/decoding.py#L480-L493
- {
- // suppress blank
- // https://github.com/openai/whisper/blob/0b1ba3d46ebf7fe6f953acfd8cad62a4f851b49f/whisper/decoding.py#L388-L390
- if (params.suppress_blank) {
- if (is_initial) {
- logits[vocab.token_eot] = -INFINITY;
- logits[vocab.token_to_id.at(" ")] = -INFINITY;
- }
- }
-
- // suppress <|notimestamps|> token
- // ref: https://github.com/openai/whisper/blob/0b1ba3d46ebf7fe6f953acfd8cad62a4f851b49f/whisper/decoding.py#L410-L412
- logits[vocab.token_not] = -INFINITY;
- if (params.no_timestamps) {
- for (int i = vocab.token_beg; i < n_logits; ++i) {
- logits[i] = -INFINITY;
- }
- }
-
- // suppress sot and nosp tokens
- logits[vocab.token_sot] = -INFINITY;
- logits[vocab.token_nosp] = -INFINITY; // TODO: ignore this token for now
-
- // [TDRZ] when tinydiarize is disabled, suppress solm token
- if (params.tdrz_enable == false) {
- logits[vocab.token_solm] = -INFINITY;
- }
-
- // suppress task tokens
- logits[vocab.token_translate] = -INFINITY;
- logits[vocab.token_transcribe] = -INFINITY;
- logits[vocab.token_prev] = -INFINITY;
-
- // suppress lang tokens
- for (size_t i = 0; i < g_lang.size(); ++i) {
- logits[whisper_token_lang(&ctx, i)] = -INFINITY;
- }
-
- // suppress prev token
- logits[vocab.token_prev] = -INFINITY;
-
- if (params.logits_filter_callback) {
- params.logits_filter_callback(&ctx, &state, tokens_cur.data(), tokens_cur.size(), logits.data(), params.logits_filter_callback_user_data);
- }
-
- // suppress any tokens matching a regular expression
- // ref: https://github.com/openai/whisper/discussions/1041
- if (params.suppress_regex != nullptr) {
- std::regex re(params.suppress_regex);
- for (std::pair<whisper_vocab::token, whisper_vocab::id> token_id : vocab.token_to_id) {
- if (std::regex_match(token_id.first, re)) {
- logits[token_id.second] = -INFINITY;
- }
- }
- }
-
- // suppress non-speech tokens
- // ref: https://github.com/openai/whisper/blob/7858aa9c08d98f75575035ecd6481f462d66ca27/whisper/tokenizer.py#L224-L253
- if (params.suppress_non_speech_tokens) {
- for (const std::string & token : non_speech_tokens) {
- const std::string suppress_tokens[] = {token, " " + token};
- for (const std::string & suppress_token : suppress_tokens) {
- if (vocab.token_to_id.find(suppress_token) != vocab.token_to_id.end()) {
- logits[vocab.token_to_id.at(suppress_token)] = -INFINITY;
- }
- }
- }
-
- // allow hyphens "-" and single quotes "'" between words, but not at the beginning of a word
- if (vocab.token_to_id.find(" -") != vocab.token_to_id.end()) {
- logits[vocab.token_to_id.at(" -")] = -INFINITY;
- }
- if (vocab.token_to_id.find(" '") != vocab.token_to_id.end()) {
- logits[vocab.token_to_id.at(" '")] = -INFINITY;
- }
- }
-
- // timestamps have to appear in pairs, except directly before EOT; mask logits accordingly
- // https://github.com/openai/whisper/blob/0b1ba3d46ebf7fe6f953acfd8cad62a4f851b49f/whisper/decoding.py#L414-L424
- {
- const bool last_was_timestamp = tokens_cur.size() > 0 && tokens_cur.back().id >= vocab.token_beg;
- const bool penultimate_was_timestamp = tokens_cur.size() < 2 || tokens_cur[tokens_cur.size() - 2].id >= vocab.token_beg;
-
- //WHISPER_LOG_INFO("last_was_timestamp=%d penultimate_was_timestamp=%d\n", last_was_timestamp, penultimate_was_timestamp);
-
- if (last_was_timestamp) {
- if (penultimate_was_timestamp) {
- for (int i = vocab.token_beg; i < n_logits; ++i) {
- logits[i] = -INFINITY;
- }
- } else {
- for (int i = 0; i < vocab.token_eot; ++i) {
- logits[i] = -INFINITY;
- }
- }
- }
- }
-
- // the initial timestamp cannot be larger than max_initial_ts
- // ref: https://github.com/openai/whisper/blob/0b1ba3d46ebf7fe6f953acfd8cad62a4f851b49f/whisper/decoding.py#L426-L429
- if (is_initial && params.max_initial_ts > 0.0f) {
- const float precision = float(WHISPER_CHUNK_SIZE)/ctx.model.hparams.n_audio_ctx;
- const int tid0 = std::round(params.max_initial_ts/precision);
-
- for (int i = vocab.token_beg + tid0 + 1; i < n_logits; ++i) {
- logits[i] = -INFINITY;
- }
- }
-
- // condition timestamp tokens to be increasing
- // ref: https://github.com/openai/whisper/pull/831#issuecomment-1385910556
- if (decoder.has_ts) {
- const int tid0 = decoder.seek_delta/2;
-
- for (int i = vocab.token_beg; i < vocab.token_beg + tid0; ++i) {
- logits[i] = -INFINITY;
- }
- }
-
- // populate the logprobs array (log_softmax)
- {
- const float logit_max = *std::max_element(logits.begin(), logits.end());
- float logsumexp = ggml_vec_soft_max_f32(n_logits, 0, logits.data(), logit_max); // [jart]
- logsumexp = logf(logsumexp) + logit_max;
-
- for (int i = 0; i < n_logits; ++i) {
- if (logits[i] > -INFINITY) {
- logprobs[i] = logits[i] - logsumexp;
- } else {
- logprobs[i] = -INFINITY;
- }
- }
- }
-
- // if sum of probability over timestamps is above any other token, sample timestamp
- // ref: https://github.com/openai/whisper/blob/0b1ba3d46ebf7fe6f953acfd8cad62a4f851b49f/whisper/decoding.py#L431-L437
- {
- // logsumexp over timestamps
- float timestamp_logprob = -INFINITY;
- {
- float logsumexp = 0.0f;
- const float logprob_max = *std::max_element(logprobs.begin() + vocab.token_beg, logprobs.end());
- if (logprob_max > -INFINITY) {
- float logsumexp = ggml_vec_soft_max_f32(n_logits - vocab.token_beg, 0,
- &logprobs[vocab.token_beg],
- logprob_max); // [jart]
- if (logsumexp > 0.0f) {
- timestamp_logprob = logf(logsumexp) + logprob_max;
- }
- }
- }
-
- const float max_text_token_logprob = *std::max_element(logprobs.begin(), logprobs.begin() + vocab.token_beg);
-
- //WHISPER_LOG_INFO("timestamp_logprob=%f max_text_token_logprob=%f\n", timestamp_logprob, max_text_token_logprob);
-
- if (timestamp_logprob > max_text_token_logprob) {
- for (int i = 0; i < vocab.token_beg; ++i) {
- logits[i] = -INFINITY;
- logprobs[i] = -INFINITY;
- }
- } else {
- if (params.n_grammar_rules > 0) {
- whisper_suppress_invalid_grammar(ctx, params, logits, decoder.grammar);
-
- // populate the logprobs array (log_softmax)
- {
- const float logit_max = *std::max_element(logits.begin(), logits.end());
- float logsumexp = ggml_vec_soft_max_f32(n_logits, 0, logits.data(), logit_max); // [jart]
- logsumexp = logf(logsumexp) + logit_max;
-
- for (int i = 0; i < n_logits; ++i) {
- if (logits[i] > -INFINITY) {
- logprobs[i] = logits[i] - logsumexp;
- } else {
- logprobs[i] = -INFINITY;
- }
- }
- }
- }
- }
- }
- }
-
- // compute probs
- ggml_vec_soft_max_f32(n_logits, &probs[0], logprobs.data(), 0); // [jart]
-
-#if 0
- // print first 100 logits - token string : logit
- //for (int i = 0; i < 10; i++) {
- // const auto token = vocab.id_to_token.at(i);
- // const auto prob = probs[i];
- // const auto logit = logits[i];
- // const auto logprob = logprobs[i];
- // printf("%16s : prob=%9.5f logit=%9.5f logprob=%9.5f\n", token.c_str(), prob, logit, logprob);
- //}
-
- // print sorted
- {
- std::vector<std::pair<float, int>> pairs;
-
- for (int i = 0; i < n_logits; ++i) {
- pairs.push_back(std::make_pair(probs[i], i));
- }
-
- std::sort(pairs.begin(), pairs.end(), [](const std::pair<float, int>& a, const std::pair<float, int>& b) {
- return a.first > b.first;
- });
-
- for (int i = 0; i < 10; i++) {
- const auto token = vocab.id_to_token.at(pairs[i].second);
- const auto prob = pairs[i].first;
- const auto logit = logits[pairs[i].second];
- const auto logprob = logprobs[pairs[i].second];
- printf("%16s : id=%6d prob=%9.5f logit=%9.5f logprob=%9.5f '%s'\n", token.c_str(), pairs[i].second, prob, logit, logprob, token.c_str());
- }
-
- printf("----------------\n");
- }
-
- // "And", "and", " And", " and"
- //printf("logits[\"and\"] = %f\n", logits[vocab.token_to_id.at("and")]);
- //printf("logits[\"And\"] = %f\n", logits[vocab.token_to_id.at("And")]);
- //printf("logits[\" and\"] = %f\n", logits[vocab.token_to_id.at(" and")]);
- //printf("logits[\" And\"] = %f\n", logits[vocab.token_to_id.at(" And")]);
- //printf("logits[\" so\"] = %f\n", logits[vocab.token_to_id.at(" so")]);
-
- //printf("logprobs[\"and\"] = %f\n", logprobs[vocab.token_to_id.at("and")]);
- //printf("logprobs[\"And\"] = %f\n", logprobs[vocab.token_to_id.at("And")]);
- //printf("logprobs[\" and\"] = %f\n", logprobs[vocab.token_to_id.at(" and")]);
- //printf("logprobs[\" And\"] = %f\n", logprobs[vocab.token_to_id.at(" And")]);
- //printf("logprobs[\" so\"] = %f\n", logprobs[vocab.token_to_id.at(" so")]);
-
- //printf("probs[\"and\"] = %f\n", probs[vocab.token_to_id.at("and")]);
- //printf("probs[\"And\"] = %f\n", probs[vocab.token_to_id.at("And")]);
- //printf("probs[\" and\"] = %f\n", probs[vocab.token_to_id.at(" and")]);
- //printf("probs[\" And\"] = %f\n", probs[vocab.token_to_id.at(" And")]);
- //printf("probs[\" so\"] = %f\n", probs[vocab.token_to_id.at(" so")]);
-#endif
-}
-
-static bool whisper_sequence_tokens_equal(const whisper_sequence & a, const whisper_sequence & b) {
- if (a.tokens.size() != b.tokens.size()) {
- return false;
- }
- // sequences are more likely to diverge at the end
- for (int i = a.tokens.size() - 1; i >= 0; i--) {
- if (a.tokens[i].id != b.tokens[i].id) {
- return false;
- }
- }
- return true;
-}
-
-static whisper_token_data whisper_sample_token(
- whisper_context & ctx,
- const whisper_decoder & decoder,
- bool best) {
- whisper_token_data result = {
- 0, 0, 0.0f, 0.0f, 0.0f, 0.0f, -1, -1, -1, 0.0f,
- };
-
- const auto & vocab = ctx.vocab;
-
- const auto & probs = decoder.probs;
- const auto & logprobs = decoder.logprobs;
-
- const int n_logits = vocab.n_vocab;
-
- {
- double sum_ts = 0.0;
- double max_ts = 0.0;
-
- for (int i = vocab.token_beg; i < n_logits; i++) {
- if (probs[i] == -INFINITY) {
- continue;
- }
-
- sum_ts += probs[i];
- if (max_ts < probs[i]) {
- max_ts = probs[i];
- result.tid = i;
- }
- }
-
- result.pt = max_ts/(sum_ts + 1e-10);
- result.ptsum = sum_ts;
- }
-
- if (best) {
- for (int i = 0; i < n_logits; ++i) {
- if (result.p < probs[i]) {
- result.id = i;
- result.p = probs[i];
- result.plog = logprobs[i];
- }
- }
- } else {
- std::discrete_distribution<> dist(probs.begin(), probs.end());
-
- result.id = dist(decoder.rng);
- result.p = probs[result.id];
- result.plog = logprobs[result.id];
- }
-
- if (result.id >= vocab.token_beg) {
- result.tid = result.id;
- result.pt = result.p;
- }
-
- return result;
-}
-
-static std::vector<whisper_token_data> whisper_sample_token_topk(
- whisper_context & ctx,
- whisper_decoder & decoder,
- int k) {
- const auto & vocab = ctx.vocab;
-
- const auto & probs = decoder.probs;
- const auto & logits = decoder.logits;
- const auto & logprobs = decoder.logprobs;
-
- const int n_logits = vocab.n_vocab;
-
- auto & logits_id = decoder.logits_id;
-
- logits_id.resize(n_logits);
- for (int i = 0; i < n_logits; ++i) {
- logits_id[i].first = logits[i];
- logits_id[i].second = i;
- }
-
- {
- using pair_type = std::remove_reference<decltype(logits_id)>::type::value_type;
- std::partial_sort(
- logits_id.begin(),
- logits_id.begin() + k, logits_id.end(),
- [](const pair_type & a, const pair_type & b) {
- return a.first > b.first;
- });
- }
-
- std::vector<whisper_token_data> result;
- result.reserve(k);
-
- whisper_token tid = vocab.token_beg;
-
- float pt = 0.0;
- float ptsum = 0.0;
-
- {
- double sum_ts = 0.0;
- double max_ts = 0.0;
-
- for (int i = vocab.token_beg; i < n_logits; i++) {
- if (probs[i] == -INFINITY) {
- continue;
- }
-
- sum_ts += probs[i];
- if (max_ts < probs[i]) {
- max_ts = probs[i];
- tid = i;
- }
- }
-
- pt = max_ts/(sum_ts + 1e-10);
- ptsum = sum_ts;
- }
-
- std::discrete_distribution<> dist(probs.begin(), probs.end());
-
- for (int i = 0; i < k; ++i) {
- const auto id = dist(decoder.rng);
- //printf("XXX %d %d %f %f %f %f\n", id, tid, probs[id], logprobs[id], pt, ptsum);
-
- result.push_back({ id, tid, probs[id], logprobs[id], pt, ptsum, -1, -1, -1, 0.0f, });
-
- if (result[i].id >= vocab.token_beg) {
- result[i].tid = result[i].id;
- result[i].pt = result[i].p;
- }
- }
-
- return result;
-}
-
-// ref: https://github.com/openai/whisper/blob/0b1ba3d46ebf7fe6f953acfd8cad62a4f851b49f/whisper/decoding.py#L178-L192
-static void whisper_sequence_score(
- const struct whisper_full_params & params,
- whisper_sequence & sequence) {
- if (sequence.result_len == 0) {
- return;
- }
-
- double result = 0.0f;
-
- for (int i = 0; i < sequence.result_len; ++i) {
- result += sequence.tokens[i].plog;
- }
-
- sequence.sum_logprobs = result;
- sequence.avg_logprobs = result/sequence.result_len;
-
- double penalty = sequence.result_len;
-
- if (params.length_penalty > 0.0f) {
- penalty = pow((5.0 + penalty)/6.0, params.length_penalty);
- }
-
- sequence.score = result/penalty;
-
- // compute the entropy of the sequence of the last 32 tokens
- {
- const int n = 32;
-
- int cnt = 0;
- double entropy = 0.0f;
-
- std::map<whisper_token, int> token_counts;
- for (int i = std::max(0, sequence.result_len - n); i < sequence.result_len; ++i) {
- token_counts[sequence.tokens[i].id]++;
- cnt++;
- }
-
- for (const auto & kv : token_counts) {
- const auto p = kv.second/(double)cnt;
- entropy -= p*log(p);
-
- //WHISPER_LOG_DEBUG("entropy: %d %f %f, count %d\n", kv.first, p, log(p), kv.second);
- }
-
- sequence.entropy = entropy;
- }
-}
-
-int whisper_full_with_state(
- struct whisper_context * ctx,
- struct whisper_state * state,
- struct whisper_full_params params,
- const float * samples,
- int n_samples) {
- // clear old results
- auto & result_all = state->result_all;
-
- result_all.clear();
-
- if (n_samples > 0) {
- // compute log mel spectrogram
- if (whisper_pcm_to_mel_with_state(ctx, state, samples, n_samples, params.n_threads) != 0) {
- WHISPER_LOG_ERROR("%s: failed to compute log mel spectrogram\n", __func__);
- return -2;
- }
- }
-
- // auto-detect language if not specified
- if (params.language == nullptr || strlen(params.language) == 0 || strcmp(params.language, "auto") == 0 || params.detect_language) {
- std::vector<float> probs(whisper_lang_max_id() + 1, 0.0f);
-
- const auto lang_id = whisper_lang_auto_detect_with_state(ctx, state, 0, params.n_threads, probs.data());
- if (lang_id < 0) {
- WHISPER_LOG_ERROR("%s: failed to auto-detect language\n", __func__);
- return -3;
- }
- state->lang_id = lang_id;
- params.language = whisper_lang_str(lang_id);
-
- WHISPER_LOG_INFO("%s: auto-detected language: %s (p = %f)\n", __func__, params.language, probs[whisper_lang_id(params.language)]);
- if (params.detect_language) {
- return 0;
- }
- }
-
- if (params.token_timestamps) {
- state->t_beg = 0;
- state->t_last = 0;
- state->tid_last = 0;
- if (n_samples > 0) {
- state->energy = get_signal_energy(samples, n_samples, 32);
- }
- }
-
- const int seek_start = params.offset_ms/10;
- const int seek_end = params.duration_ms == 0 ? whisper_n_len_from_state(state) : seek_start + params.duration_ms/10;
-
- // if length of spectrogram is less than 1.0s (100 frames), then return
- // basically don't process anything that is less than 1.0s
- // see issue #39: https://github.com/ggerganov/whisper.cpp/issues/39
- if (seek_end < seek_start + 100) {
- WHISPER_LOG_WARN("%s: input is too short - %d ms < 1000 ms. consider padding the input audio with silence\n", __func__, (seek_end - seek_start)*10);
- return 0;
- }
-
- // a set of temperatures to use
- // [ t0, t0 + delta, t0 + 2*delta, ..., < 1.0f + 1e-6f ]
- std::vector<float> temperatures;
- if (params.temperature_inc > 0.0f) {
- for (float t = params.temperature; t < 1.0f + 1e-6f; t += params.temperature_inc) {
- temperatures.push_back(t);
- }
- } else {
- temperatures.push_back(params.temperature);
- }
-
- // initialize the decoders
- int n_decoders = 1;
-
- switch (params.strategy) {
- case WHISPER_SAMPLING_GREEDY:
- {
- n_decoders = params.greedy.best_of;
- } break;
- case WHISPER_SAMPLING_BEAM_SEARCH:
- {
- n_decoders = std::max(params.greedy.best_of, params.beam_search.beam_size);
- } break;
- };
-
- n_decoders = std::max(1, n_decoders);
-
- if (n_decoders > WHISPER_MAX_DECODERS) {
- WHISPER_LOG_ERROR("%s: too many decoders requested (%d), max = %d\n", __func__, n_decoders, WHISPER_MAX_DECODERS);
- return -4;
- }
-
- // TAGS: WHISPER_DECODER_INIT
- for (int j = 1; j < n_decoders; j++) {
- auto & decoder = state->decoders[j];
-
- decoder.sequence.tokens.reserve(state->decoders[0].sequence.tokens.capacity());
-
- decoder.probs.resize (ctx->vocab.n_vocab);
- decoder.logits.resize (ctx->vocab.n_vocab);
- decoder.logprobs.resize(ctx->vocab.n_vocab);
- decoder.logits_id.reserve(ctx->model.hparams.n_vocab);
-
- decoder.rng = std::mt19937(0);
- }
-
- // the accumulated text context so far
- auto & prompt_past = state->prompt_past;
- if (params.no_context) {
- prompt_past.clear();
- }
-
- // prepare prompt
- {
- std::vector<whisper_token> prompt_tokens;
-
- // initial prompt
- if (!params.prompt_tokens && params.initial_prompt) {
- prompt_tokens.resize(1024);
- int n_needed = whisper_tokenize(ctx, params.initial_prompt, prompt_tokens.data(), prompt_tokens.size());
- if (n_needed < 0) {
- prompt_tokens.resize(-n_needed);
- n_needed = whisper_tokenize(ctx, params.initial_prompt, prompt_tokens.data(), prompt_tokens.size());
- }
- prompt_tokens.resize(n_needed);
- params.prompt_tokens = prompt_tokens.data();
- params.prompt_n_tokens = prompt_tokens.size();
- }
-
- // prepend the prompt tokens to the prompt_past
- if (params.prompt_tokens && params.prompt_n_tokens > 0) {
- // parse tokens from the pointer
- for (int i = 0; i < params.prompt_n_tokens; i++) {
- prompt_past.push_back(params.prompt_tokens[i]);
- }
- std::rotate(prompt_past.begin(), prompt_past.end() - params.prompt_n_tokens, prompt_past.end());
- }
- }
-
- // overwrite audio_ctx, max allowed is hparams.n_audio_ctx
- if (params.audio_ctx > whisper_n_audio_ctx(ctx)) {
- WHISPER_LOG_ERROR("%s: audio_ctx is larger than the maximum allowed (%d > %d)\n", __func__, params.audio_ctx, whisper_n_audio_ctx(ctx));
- return -5;
- }
- state->exp_n_audio_ctx = params.audio_ctx;
-
- // these tokens determine the task that will be performed
- std::vector<whisper_token> prompt_init = { whisper_token_sot(ctx), };
-
- if (whisper_is_multilingual(ctx)) {
- const int lang_id = whisper_lang_id(params.language);
- state->lang_id = lang_id;
- prompt_init.push_back(whisper_token_lang(ctx, lang_id));
- if (params.translate) {
- prompt_init.push_back(whisper_token_translate(ctx));
- } else {
- prompt_init.push_back(whisper_token_transcribe(ctx));
- }
- }
-
- // first release distilled models require the "no_timestamps" token
- {
- const bool is_distil = ctx->model.hparams.n_text_layer == 2 && ctx->model.hparams.n_vocab != 51866;
- if (is_distil && !params.no_timestamps) {
- WHISPER_LOG_WARN("%s: using first release distilled models - forcing no_timestamps\n", __func__);
- params.no_timestamps = true;
- }
- }
-
- if (params.no_timestamps) {
- prompt_init.push_back(whisper_token_not(ctx));
- }
-
- int seek = seek_start;
-
- std::vector<whisper_token> prompt;
- prompt.reserve(whisper_n_text_ctx(ctx));
-
- struct beam_candidate {
- int decoder_idx;
- int seek_delta;
-
- bool has_ts;
-
- whisper_sequence sequence;
- whisper_grammar grammar;
- };
-
- std::vector<std::vector<beam_candidate>> bc_per_dec(n_decoders);
- std::vector<beam_candidate> beam_candidates;
-
- // main loop
- while (true) {
- if (params.progress_callback) {
- const int progress_cur = (100*(seek - seek_start))/(seek_end - seek_start);
-
- params.progress_callback(
- ctx, state, progress_cur, params.progress_callback_user_data);
- }
-
- // if only 1 second left, then stop
- if (seek + 100 >= seek_end) {
- break;
- }
-
- if (params.encoder_begin_callback) {
- if (params.encoder_begin_callback(ctx, state, params.encoder_begin_callback_user_data) == false) {
- WHISPER_LOG_ERROR("%s: encoder_begin_callback returned false - aborting\n", __func__);
- break;
- }
- }
-
- // encode audio features starting at offset seek
- if (!whisper_encode_internal(*ctx, *state, seek, params.n_threads, params.abort_callback, params.abort_callback_user_data)) {
- WHISPER_LOG_ERROR("%s: failed to encode\n", __func__);
- return -6;
- }
-
- // if there is a very short audio segment left to process, we remove any past prompt since it tends
- // to confuse the decoder and often make it repeat or hallucinate stuff
- if (seek > seek_start && seek + 500 >= seek_end) {
- prompt_past.clear();
- }
-
- int best_decoder_id = 0;
-
- for (int it = 0; it < (int) temperatures.size(); ++it) {
- const float t_cur = temperatures[it];
-
- int n_decoders_cur = 1;
-
- switch (params.strategy) {
- case whisper_sampling_strategy::WHISPER_SAMPLING_GREEDY:
- {
- if (t_cur > 0.0f) {
- n_decoders_cur = params.greedy.best_of;
- }
- } break;
- case whisper_sampling_strategy::WHISPER_SAMPLING_BEAM_SEARCH:
- {
- if (t_cur > 0.0f) {
- n_decoders_cur = params.greedy.best_of;
- } else {
- n_decoders_cur = params.beam_search.beam_size;
- }
- } break;
- };
-
- n_decoders_cur = std::max(1, n_decoders_cur);
-
- WHISPER_LOG_DEBUG("\n%s: strategy = %d, decoding with %d decoders, temperature = %.2f\n", __func__, params.strategy, n_decoders_cur, t_cur);
-
- // TAGS: WHISPER_DECODER_INIT
- for (int j = 0; j < n_decoders_cur; ++j) {
- auto & decoder = state->decoders[j];
-
- decoder.sequence.tokens.clear();
- decoder.sequence.result_len = 0;
- decoder.sequence.sum_logprobs_all = 0.0;
- decoder.sequence.sum_logprobs = -INFINITY;
- decoder.sequence.avg_logprobs = -INFINITY;
- decoder.sequence.entropy = 0.0;
- decoder.sequence.score = -INFINITY;
-
- decoder.seek_delta = 100*WHISPER_CHUNK_SIZE;
-
- decoder.failed = false;
- decoder.completed = false;
- decoder.has_ts = false;
-
- if (params.grammar_rules != nullptr) {
- decoder.grammar = whisper_grammar_init(params.grammar_rules, params.n_grammar_rules, params.i_start_rule);
- } else {
- decoder.grammar = {};
- }
- }
-
- // init prompt and kv cache for the current iteration
- // TODO: do not recompute the prompt if it is the same as previous time
- {
- prompt.clear();
-
- // if we have already generated some text, use it as a prompt to condition the next generation
- if (!prompt_past.empty() && t_cur < 0.5f && params.n_max_text_ctx > 0) {
- int n_take = std::min(std::min(params.n_max_text_ctx, whisper_n_text_ctx(ctx)/2), int(prompt_past.size()));
-
- prompt = { whisper_token_prev(ctx) };
- prompt.insert(prompt.begin() + 1, prompt_past.end() - n_take, prompt_past.end());
- }
-
- // init new transcription with sot, language (opt) and task tokens
- prompt.insert(prompt.end(), prompt_init.begin(), prompt_init.end());
-
- // print the prompt
- WHISPER_LOG_DEBUG("\n\n");
- for (int i = 0; i < (int) prompt.size(); i++) {
- WHISPER_LOG_DEBUG("%s: prompt[%d] = %s\n", __func__, i, ctx->vocab.id_to_token.at(prompt[i]).c_str());
- }
- WHISPER_LOG_DEBUG("\n\n");
-
- whisper_kv_cache_clear(state->kv_self);
-
- whisper_batch_prep_legacy(state->batch, prompt.data(), prompt.size(), 0, 0);
-
- if (!whisper_decode_internal(*ctx, *state, state->batch, params.n_threads, false, params.abort_callback, params.abort_callback_user_data)) {
- WHISPER_LOG_ERROR("%s: failed to decode\n", __func__);
- return -7;
- }
-
- {
- const int64_t t_start_sample_us = ggml_time_us();
-
- state->decoders[0].i_batch = prompt.size() - 1;
-
- whisper_process_logits(*ctx, *state, state->decoders[0], params, t_cur);
-
- for (int j = 1; j < n_decoders_cur; ++j) {
- auto & decoder = state->decoders[j];
-
- whisper_kv_cache_seq_cp(state->kv_self, 0, j, -1, -1);
-
- memcpy(decoder.probs.data(), state->decoders[0].probs.data(), decoder.probs.size()*sizeof(decoder.probs[0]));
- memcpy(decoder.logits.data(), state->decoders[0].logits.data(), decoder.logits.size()*sizeof(decoder.logits[0]));
- memcpy(decoder.logprobs.data(), state->decoders[0].logprobs.data(), decoder.logprobs.size()*sizeof(decoder.logprobs[0]));
- }
-
- state->t_sample_us += ggml_time_us() - t_start_sample_us;
- }
- }
-
- for (int i = 0, n_max = whisper_n_text_ctx(ctx)/2 - 4; i < n_max; ++i) {
- const int64_t t_start_sample_us = ggml_time_us();
-
- if (params.strategy == whisper_sampling_strategy::WHISPER_SAMPLING_BEAM_SEARCH) {
- for (auto & bc : bc_per_dec) {
- bc.clear();
- }
- }
-
- // sampling
- // TODO: avoid memory allocations, optimize, avoid threads?
- {
- std::atomic<int> j_cur(0);
-
- auto process = [&]() {
- while (true) {
- const int j = j_cur.fetch_add(1);
-
- if (j >= n_decoders_cur) {
- break;
- }
-
- auto & decoder = state->decoders[j];
-
- if (decoder.completed || decoder.failed) {
- continue;
- }
-
- switch (params.strategy) {
- case whisper_sampling_strategy::WHISPER_SAMPLING_GREEDY:
- {
- if (t_cur < 1e-6f) {
- decoder.sequence.tokens.push_back(whisper_sample_token(*ctx, decoder, true));
- } else {
- decoder.sequence.tokens.push_back(whisper_sample_token(*ctx, decoder, false));
- }
-
- decoder.sequence.sum_logprobs_all += decoder.sequence.tokens.back().plog;
- } break;
- case whisper_sampling_strategy::WHISPER_SAMPLING_BEAM_SEARCH:
- {
- const auto tokens_new = whisper_sample_token_topk(*ctx, decoder, params.beam_search.beam_size);
-
- for (const auto & token : tokens_new) {
- bc_per_dec[j].push_back({ j, decoder.seek_delta, decoder.has_ts, decoder.sequence, decoder.grammar, });
- bc_per_dec[j].back().sequence.tokens.push_back(token);
- bc_per_dec[j].back().sequence.sum_logprobs_all += token.plog;
- }
- } break;
- };
- }
- };
-
- const int n_threads = std::min(params.n_threads, n_decoders_cur);
-
- if (n_threads == 1) {
- process();
- } else {
- std::vector<std::thread> threads(n_threads - 1);
-
- for (int t = 0; t < n_threads - 1; ++t) {
- threads[t] = std::thread(process);
- }
-
- process();
-
- for (int t = 0; t < n_threads - 1; ++t) {
- threads[t].join();
- }
- }
- }
-
- beam_candidates.clear();
- for (const auto & bc : bc_per_dec) {
- beam_candidates.insert(beam_candidates.end(), bc.begin(), bc.end());
-
- if (!bc.empty()) {
- state->n_sample += 1;
- }
- }
-
- // for beam-search, choose the top candidates and update the KV caches
- if (params.strategy == whisper_sampling_strategy::WHISPER_SAMPLING_BEAM_SEARCH) {
- std::sort(
- beam_candidates.begin(),
- beam_candidates.end(),
- [](const beam_candidate & a, const beam_candidate & b) {
- if (a.sequence.sum_logprobs_all != b.sequence.sum_logprobs_all) {
- return a.sequence.sum_logprobs_all > b.sequence.sum_logprobs_all;
- }
- return a.decoder_idx < b.decoder_idx;
- });
-
- uint32_t cur_c = 0;
-
- for (int j = 0; j < n_decoders_cur; ++j) {
- auto & decoder = state->decoders[j];
-
- if (decoder.completed || decoder.failed) {
- continue;
- }
-
- if (cur_c >= beam_candidates.size()) {
- cur_c = 0;
- }
-
- auto & cur = beam_candidates[cur_c++];
-
- while (beam_candidates.size() > cur_c && whisper_sequence_tokens_equal(beam_candidates[cur_c].sequence, cur.sequence) && i > 0) {
- ++cur_c;
- }
-
- decoder.seek_delta = cur.seek_delta;
- decoder.has_ts = cur.has_ts;
- decoder.sequence = cur.sequence;
- decoder.grammar = cur.grammar;
-
- whisper_kv_cache_seq_cp(state->kv_self, cur.decoder_idx, WHISPER_MAX_DECODERS + j, -1, -1);
-
- WHISPER_LOG_DEBUG("%s: beam search: decoder %d: from decoder %d: token = %10s, plog = %8.5f, sum_logprobs = %8.5f\n",
- __func__, j, cur.decoder_idx, ctx->vocab.id_to_token.at(decoder.sequence.tokens.back().id).c_str(), decoder.sequence.tokens.back().plog, decoder.sequence.sum_logprobs_all);
- }
-
- for (int j = 0; j < n_decoders_cur; ++j) {
- auto & decoder = state->decoders[j];
-
- if (decoder.completed || decoder.failed) {
- continue;
- }
-
- whisper_kv_cache_seq_rm(state->kv_self, j, -1, -1);
- whisper_kv_cache_seq_cp(state->kv_self, WHISPER_MAX_DECODERS + j, j, -1, -1);
- whisper_kv_cache_seq_rm(state->kv_self, WHISPER_MAX_DECODERS + j, -1, -1);
- }
- }
-
- // update the decoder state
- // - check if the sequence is completed
- // - check if the sequence is failed
- // - update sliding window based on timestamp tokens
- for (int j = 0; j < n_decoders_cur; ++j) {
- auto & decoder = state->decoders[j];
-
- if (decoder.completed || decoder.failed) {
- continue;
- }
-
- auto & has_ts = decoder.has_ts;
- auto & failed = decoder.failed;
- auto & completed = decoder.completed;
- auto & seek_delta = decoder.seek_delta;
- auto & result_len = decoder.sequence.result_len;
-
- {
- const auto & token = decoder.sequence.tokens.back();
-
- // timestamp token - update sliding window
- if (token.id > whisper_token_beg(ctx)) {
- const int seek_delta_new = 2*(token.id - whisper_token_beg(ctx));
-
- // do not allow to go back in time
- if (has_ts && seek_delta > seek_delta_new && result_len < i) {
- WHISPER_LOG_DEBUG("%s: decoder %d: failed due to seek_delta (%d > %d)\n", __func__, j, seek_delta, seek_delta_new);
- failed = true; // TODO: maybe this is not a failure ?
- continue;
- }
-
- seek_delta = seek_delta_new;
- result_len = i + 1;
- has_ts = true;
- }
-
- whisper_grammar_accept_token(*ctx, decoder.grammar, token.id);
-
-#ifdef WHISPER_DEBUG
- {
- const auto tt = token.pt > 0.10 ? ctx->vocab.id_to_token.at(token.tid) : "[?]";
- WHISPER_LOG_DEBUG("%s: id = %3d, decoder = %d, token = %6d, p = %6.3f, ts = %10s, %6.3f, result_len = %4d '%s'\n",
- __func__, i, j, token.id, token.p, tt.c_str(), token.pt, result_len, ctx->vocab.id_to_token.at(token.id).c_str());
- }
-#endif
-
- // end of segment
- if (token.id == whisper_token_eot(ctx) || // end of text token
- (params.max_tokens > 0 && i >= params.max_tokens) || // max tokens per segment reached
- (has_ts && seek + seek_delta + 100 >= seek_end) // end of audio reached
- ) {
- if (result_len == 0 && !params.no_timestamps) {
- if (seek + seek_delta + 100 >= seek_end) {
- result_len = i + 1;
- } else {
- WHISPER_LOG_DEBUG("%s: decoder %d failed (result_len = 0)\n", __func__, j);
- failed = true;
- continue;
- }
- }
-
- if (params.single_segment || params.no_timestamps) {
- result_len = i + 1;
- seek_delta = 100*WHISPER_CHUNK_SIZE;
- }
-
- WHISPER_LOG_DEBUG("%s: decoder %d completed\n", __func__, j);
- completed = true;
- continue;
- }
-
- // TESTS: if no tensors are loaded, it means we are running tests
- if (ctx->model.n_loaded == 0) {
- seek_delta = 100*WHISPER_CHUNK_SIZE;
- completed = true;
- continue;
- }
- }
-
- // sometimes, the decoding can get stuck in a repetition loop
- // this is an attempt to mitigate such cases - we flag the decoding as failed and use a fallback strategy
- if (i == n_max - 1 && (result_len == 0 || seek_delta < 100*WHISPER_CHUNK_SIZE/2)) {
- WHISPER_LOG_DEBUG("%s: decoder %d: failed due to repetition loop\n", __func__, j);
- failed = true;
- continue;
- }
- }
-
- // check if all decoders have finished (i.e. completed or failed)
- {
- bool completed_all = true;
-
- for (int j = 0; j < n_decoders_cur; ++j) {
- auto & decoder = state->decoders[j];
-
- if (decoder.completed || decoder.failed) {
- continue;
- }
-
- completed_all = false;
- }
-
- if (completed_all) {
- break;
- }
- }
-
- state->t_sample_us += ggml_time_us() - t_start_sample_us;
-
- // obtain logits for the next token
- {
- auto & batch = state->batch;
-
- batch.n_tokens = 0;
-
- const int n_past = prompt.size() + i;
-
- for (int j = 0; j < n_decoders_cur; ++j) {
- auto & decoder = state->decoders[j];
-
- if (decoder.failed || decoder.completed) {
- continue;
- }
-
- //WHISPER_LOG_DEBUG("%s: decoder %d: token %d, seek_delta %d\n", __func__, j, decoder.sequence.tokens.back().id, decoder.seek_delta);
-
- decoder.i_batch = batch.n_tokens;
-
- batch.token [batch.n_tokens] = decoder.sequence.tokens.back().id;
- batch.pos [batch.n_tokens] = n_past;
- batch.n_seq_id[batch.n_tokens] = 1;
- batch.seq_id [batch.n_tokens][0] = j;
- batch.logits [batch.n_tokens] = 1;
- batch.n_tokens++;
- }
-
- assert(batch.n_tokens > 0);
-
- if (!whisper_decode_internal(*ctx, *state, state->batch, params.n_threads, false, params.abort_callback, params.abort_callback_user_data)) {
- WHISPER_LOG_ERROR("%s: failed to decode\n", __func__);
- return -8;
- }
-
- const int64_t t_start_sample_us = ggml_time_us();
-
- // TODO: avoid memory allocations, optimize, avoid threads?
- {
- std::atomic<int> j_cur(0);
-
- auto process = [&]() {
- while (true) {
- const int j = j_cur.fetch_add(1);
-
- if (j >= n_decoders_cur) {
- break;
- }
-
- auto & decoder = state->decoders[j];
-
- if (decoder.failed || decoder.completed) {
- continue;
- }
-
- whisper_process_logits(*ctx, *state, decoder, params, t_cur);
- }
- };
-
- const int n_threads = std::min(params.n_threads, n_decoders_cur);
-
- if (n_threads == 1) {
- process();
- } else {
- std::vector<std::thread> threads(n_threads - 1);
-
- for (int t = 0; t < n_threads - 1; ++t) {
- threads[t] = std::thread(process);
- }
-
- process();
-
- for (int t = 0; t < n_threads - 1; ++t) {
- threads[t].join();
- }
- }
- }
-
- state->t_sample_us += ggml_time_us() - t_start_sample_us;
- }
- }
-
- // rank the resulting sequences and select the best one
- {
- double best_score = -INFINITY;
-
- for (int j = 0; j < n_decoders_cur; ++j) {
- auto & decoder = state->decoders[j];
-
- if (decoder.failed) {
- continue;
- }
-
- decoder.sequence.tokens.resize(decoder.sequence.result_len);
- whisper_sequence_score(params, decoder.sequence);
-
- WHISPER_LOG_DEBUG("%s: decoder %2d: score = %8.5f, result_len = %3d, avg_logprobs = %8.5f, entropy = %8.5f\n",
- __func__, j, decoder.sequence.score, decoder.sequence.result_len, decoder.sequence.avg_logprobs, decoder.sequence.entropy);
-
- if (decoder.sequence.result_len > 32 && decoder.sequence.entropy < params.entropy_thold) {
- WHISPER_LOG_DEBUG("%s: decoder %2d: failed due to entropy %8.5f < %8.5f\n",
- __func__, j, decoder.sequence.entropy, params.entropy_thold);
-
- decoder.failed = true;
- state->n_fail_h++;
-
- continue;
- }
-
- if (best_score < decoder.sequence.score) {
- best_score = decoder.sequence.score;
- best_decoder_id = j;
- }
- }
-
- WHISPER_LOG_DEBUG("%s: best decoder = %d\n", __func__, best_decoder_id);
- }
-
- bool success = true;
-
- // was the decoding successful for the current temperature?
- // do fallback only if:
- // - we are not at the last temperature
- if (it != (int) temperatures.size() - 1) {
- const auto & decoder = state->decoders[best_decoder_id];
-
- if (decoder.failed || decoder.sequence.avg_logprobs < params.logprob_thold) {
- WHISPER_LOG_DEBUG("%s: failed due to avg_logprobs %8.5f < %8.5f\n", __func__, decoder.sequence.avg_logprobs, params.logprob_thold);
- success = false;
- state->n_fail_p++;
- }
- }
-
- if (success) {
- //for (auto & token : ctx->decoders[best_decoder_id].sequence.tokens) {
- // WHISPER_LOG_DEBUG("%s: token = %d, p = %6.3f, pt = %6.3f, ts = %s, str = %s\n", __func__, token.id, token.p, token.pt, ctx->vocab.id_to_token.at(token.tid).c_str(), ctx->vocab.id_to_token.at(token.id).c_str());
- //}
-
- break;
- }
-
- WHISPER_LOG_DEBUG("\n%s: failed to decode with temperature = %.2f\n", __func__, t_cur);
- }
-
- // output results through a user-provided callback
- {
- const auto & best_decoder = state->decoders[best_decoder_id];
-
- const auto seek_delta = best_decoder.seek_delta;
- const auto result_len = best_decoder.sequence.result_len;
-
- const auto & tokens_cur = best_decoder.sequence.tokens;
-
- // [EXPERIMENTAL] Token-level timestamps with DTW
- const auto n_segments_before = state->result_all.size();
-
- //WHISPER_LOG_DEBUG("prompt_init.size() = %d, prompt.size() = %d, result_len = %d, seek_delta = %d\n", prompt_init.size(), prompt.size(), result_len, seek_delta);
-
- // update prompt_past
- prompt_past.clear();
- if (prompt.front() == whisper_token_prev(ctx)) {
- prompt_past.insert(prompt_past.end(), prompt.begin() + 1, prompt.end() - prompt_init.size());
- }
-
- for (int i = 0; i < result_len; ++i) {
- prompt_past.push_back(tokens_cur[i].id);
- }
-
- if (!tokens_cur.empty() && ctx->model.n_loaded > 0) {
- int i0 = 0;
- auto t0 = seek + 2*(tokens_cur.front().tid - whisper_token_beg(ctx));
-
- std::string text;
- bool speaker_turn_next = false;
-
- for (int i = 0; i < (int) tokens_cur.size(); i++) {
- //printf("%s: %18s %6.3f %18s %6.3f\n", __func__,
- // ctx->vocab.id_to_token[tokens_cur[i].id].c_str(), tokens_cur[i].p,
- // ctx->vocab.id_to_token[tokens_cur[i].tid].c_str(), tokens_cur[i].pt);
-
- if (params.print_special || tokens_cur[i].id < whisper_token_eot(ctx)) {
- text += whisper_token_to_str(ctx, tokens_cur[i].id);
- }
-
- // [TDRZ] record if speaker turn was predicted after current segment
- if (params.tdrz_enable && tokens_cur[i].id == whisper_token_solm(ctx)) {
- speaker_turn_next = true;
- }
-
- if (tokens_cur[i].id > whisper_token_beg(ctx) && !params.single_segment) {
- const auto t1 = seek + 2*(tokens_cur[i].tid - whisper_token_beg(ctx));
-
- if (!text.empty()) {
- const auto tt0 = t0;
- const auto tt1 = t1;
-
- if (params.print_realtime) {
- if (params.print_timestamps) {
- printf("[%s --> %s] %s\n", to_timestamp(tt0).c_str(), to_timestamp(tt1).c_str(), text.c_str());
- } else {
- printf("%s", text.c_str());
- fflush(stdout);
- }
- }
-
- //printf("tt0 = %d, tt1 = %d, text = %s, token = %s, token_id = %d, tid = %d\n", tt0, tt1, text.c_str(), ctx->vocab.id_to_token[tokens_cur[i].id].c_str(), tokens_cur[i].id, tokens_cur[i].tid);
-
- result_all.push_back({ tt0, tt1, text, {}, speaker_turn_next });
- for (int j = i0; j <= i; j++) {
- result_all.back().tokens.push_back(tokens_cur[j]);
- }
-
- int n_new = 1;
-
- if (params.token_timestamps) {
- whisper_exp_compute_token_level_timestamps(
- *ctx, *state, result_all.size() - 1, params.thold_pt, params.thold_ptsum);
-
- if (params.max_len > 0) {
- n_new = whisper_wrap_segment(*ctx, *state, params.max_len, params.split_on_word);
- }
- }
- if (params.new_segment_callback) {
- params.new_segment_callback(ctx, state, n_new, params.new_segment_callback_user_data);
- }
- }
- text = "";
- while (i < (int) tokens_cur.size() && tokens_cur[i].id > whisper_token_beg(ctx)) {
- i++;
- }
- i--;
- t0 = t1;
- i0 = i + 1;
- speaker_turn_next = false;
- }
- }
-
- if (!text.empty()) {
- const auto t1 = seek + seek_delta;
-
- const auto tt0 = t0;
- const auto tt1 = t1;
-
- if (params.print_realtime) {
- if (params.print_timestamps) {
- printf("[%s --> %s] %s\n", to_timestamp(tt0).c_str(), to_timestamp(tt1).c_str(), text.c_str());
- } else {
- printf("%s", text.c_str());
- fflush(stdout);
- }
- }
-
- result_all.push_back({ tt0, tt1, text, {} , speaker_turn_next });
- for (int j = i0; j < (int) tokens_cur.size(); j++) {
- result_all.back().tokens.push_back(tokens_cur[j]);
- }
-
- int n_new = 1;
-
- if (params.token_timestamps) {
- whisper_exp_compute_token_level_timestamps(
- *ctx, *state, result_all.size() - 1, params.thold_pt, params.thold_ptsum);
-
- if (params.max_len > 0) {
- n_new = whisper_wrap_segment(*ctx, *state, params.max_len, params.split_on_word);
- }
- }
- if (params.new_segment_callback) {
- params.new_segment_callback(ctx, state, n_new, params.new_segment_callback_user_data);
- }
- }
- }
-
- // FIXME: will timestamp offsets be correct?
- // [EXPERIMENTAL] Token-level timestamps with DTW
- {
- const auto n_segments = state->result_all.size() - n_segments_before;
- if (ctx->params.dtw_token_timestamps && n_segments) {
- const int n_frames = std::min(std::min(WHISPER_CHUNK_SIZE * 100, seek_delta), seek_end - seek);
- whisper_exp_compute_token_level_timestamps_dtw(
- ctx, state, params, result_all.size() - n_segments, n_segments, seek, n_frames, 7, params.n_threads);
- }
- }
-
- // update audio window
- seek += seek_delta;
-
- WHISPER_LOG_DEBUG("seek = %d, seek_delta = %d\n", seek, seek_delta);
- }
- }
-
- return 0;
-}
-
-int whisper_full(
- struct whisper_context * ctx,
- struct whisper_full_params params,
- const float * samples,
- int n_samples) {
- return whisper_full_with_state(ctx, ctx->state, params, samples, n_samples);
-}
-
-int whisper_full_parallel(
- struct whisper_context * ctx,
- struct whisper_full_params params,
- const float * samples,
- int n_samples,
- int n_processors) {
- if (n_processors == 1) {
- return whisper_full(ctx, params, samples, n_samples);
- }
- int ret = 0;
-
- // prepare separate states for each thread
- std::vector<whisper_state*> states;
-
- const int offset_samples = (WHISPER_SAMPLE_RATE*params.offset_ms)/1000;
- const int n_samples_per_processor = (n_samples - offset_samples)/n_processors;
-
- // the calling thread will process the first chunk
- // while the other threads will process the remaining chunks
-
- std::vector<std::thread> workers(n_processors - 1);
- for (int i = 0; i < n_processors - 1; ++i) {
- // create a new state for each thread
- states.push_back(whisper_init_state(ctx));
-
- const int start_samples = offset_samples + (i + 1)*n_samples_per_processor;
- const int n_samples_cur = (i == n_processors - 2) ? n_samples - start_samples : n_samples_per_processor;
-
- auto params_cur = params;
-
- params_cur.offset_ms = 0;
- params_cur.print_progress = false;
- params_cur.print_realtime = false;
-
- params_cur.new_segment_callback = nullptr;
- params_cur.new_segment_callback_user_data = nullptr;
-
- params_cur.progress_callback = nullptr;
- params_cur.progress_callback_user_data = nullptr;
-
- workers[i] = std::thread(whisper_full_with_state, ctx, states[i], std::move(params_cur), samples + start_samples, n_samples_cur);
- }
-
- {
- auto params_cur = params;
-
- // We need to disable the print real-time for this one as well, otherwise it will show only for the first chunk.
- params_cur.print_realtime = false;
-
- // Run the first transformation using default state but only for the first chunk.
- ret = whisper_full_with_state(ctx, ctx->state, std::move(params_cur), samples, offset_samples + n_samples_per_processor);
- }
-
- for (int i = 0; i < n_processors - 1; ++i) {
- workers[i].join();
- }
-
- const int64_t offset_t = (int64_t) params.offset_ms/10.0;
-
- // combine results into result_state->result_all from all other states
- for (int i = 0; i < n_processors - 1; ++i) {
- auto& results_i = states[i]->result_all;
-
- for (auto& result : results_i) {
- // correct the segment timestamp taking into account the offset
- result.t0 += 100 * ((i + 1) * n_samples_per_processor) / WHISPER_SAMPLE_RATE + offset_t;
- result.t1 += 100 * ((i + 1) * n_samples_per_processor) / WHISPER_SAMPLE_RATE + offset_t;
-
- // make sure that segments are not overlapping
- if (!ctx->state->result_all.empty()) {
- result.t0 = std::max(result.t0, ctx->state->result_all.back().t1);
- }
-
- ctx->state->result_all.push_back(std::move(result));
-
- // call the new_segment_callback for each segment
- if (params.new_segment_callback) {
- params.new_segment_callback(ctx, ctx->state, 1, params.new_segment_callback_user_data);
- }
- }
-
- ctx->state->t_mel_us += states[i]->t_mel_us;
-
- ctx->state->t_sample_us += states[i]->t_sample_us;
- ctx->state->t_encode_us += states[i]->t_encode_us;
- ctx->state->t_decode_us += states[i]->t_decode_us;
- ctx->state->t_batchd_us += states[i]->t_batchd_us;
- ctx->state->t_prompt_us += states[i]->t_prompt_us;
-
- ctx->state->n_sample += states[i]->n_sample;
- ctx->state->n_encode += states[i]->n_encode;
- ctx->state->n_decode += states[i]->n_decode;
- ctx->state->n_batchd += states[i]->n_batchd;
- ctx->state->n_prompt += states[i]->n_prompt;
-
- whisper_free_state(states[i]);
- }
-
- // average the timings
- ctx->state->t_mel_us /= n_processors;
- ctx->state->t_sample_us /= n_processors;
- ctx->state->t_encode_us /= n_processors;
- ctx->state->t_decode_us /= n_processors;
-
- // print information about the audio boundaries
- WHISPER_LOG_WARN("\n");
- WHISPER_LOG_WARN("%s: the audio has been split into %d chunks at the following times:\n", __func__, n_processors);
- for (int i = 0; i < n_processors - 1; ++i) {
- WHISPER_LOG_WARN("%s: split %d - %s\n", __func__, (i + 1), to_timestamp(100*((i + 1)*n_samples_per_processor)/WHISPER_SAMPLE_RATE + offset_t).c_str());
- }
- WHISPER_LOG_WARN("%s: the transcription quality may be degraded near these boundaries\n", __func__);
-
- return ret;
-}
-
-int whisper_full_n_segments_from_state(struct whisper_state * state) {
- return state->result_all.size();
-}
-
-int whisper_full_n_segments(struct whisper_context * ctx) {
- return ctx->state->result_all.size();
-}
-
-int whisper_full_lang_id_from_state(struct whisper_state * state) {
- return state->lang_id;
-}
-
-int whisper_full_lang_id(struct whisper_context * ctx) {
- return ctx->state->lang_id;
-}
-
-int64_t whisper_full_get_segment_t0_from_state(struct whisper_state * state, int i_segment) {
- return state->result_all[i_segment].t0;
-}
-
-int64_t whisper_full_get_segment_t0(struct whisper_context * ctx, int i_segment) {
- return ctx->state->result_all[i_segment].t0;
-}
-
-int64_t whisper_full_get_segment_t1_from_state(struct whisper_state * state, int i_segment) {
- return state->result_all[i_segment].t1;
-}
-
-int64_t whisper_full_get_segment_t1(struct whisper_context * ctx, int i_segment) {
- return ctx->state->result_all[i_segment].t1;
-}
-
-bool whisper_full_get_segment_speaker_turn_next_from_state(struct whisper_state * state, int i_segment) {
- return state->result_all[i_segment].speaker_turn_next;
-}
-
-bool whisper_full_get_segment_speaker_turn_next(struct whisper_context * ctx, int i_segment) {
- return ctx->state->result_all[i_segment].speaker_turn_next;
-}
-
-const char * whisper_full_get_segment_text_from_state(struct whisper_state * state, int i_segment) {
- return state->result_all[i_segment].text.c_str();
-}
-
-const char * whisper_full_get_segment_text(struct whisper_context * ctx, int i_segment) {
- return ctx->state->result_all[i_segment].text.c_str();
-}
-
-int whisper_full_n_tokens_from_state(struct whisper_state * state, int i_segment) {
- return state->result_all[i_segment].tokens.size();
-}
-
-int whisper_full_n_tokens(struct whisper_context * ctx, int i_segment) {
- return ctx->state->result_all[i_segment].tokens.size();
-}
-
-const char * whisper_full_get_token_text_from_state(struct whisper_context * ctx, struct whisper_state * state, int i_segment, int i_token) {
- return ctx->vocab.id_to_token[state->result_all[i_segment].tokens[i_token].id].c_str();
-}
-
-const char* whisper_full_get_token_text(struct whisper_context * ctx, int i_segment, int i_token) {
- return ctx->vocab.id_to_token[ctx->state->result_all[i_segment].tokens[i_token].id].c_str();
-}
-
-whisper_token whisper_full_get_token_id_from_state(struct whisper_state * state, int i_segment, int i_token) {
- return state->result_all[i_segment].tokens[i_token].id;
-}
-
-whisper_token whisper_full_get_token_id(struct whisper_context * ctx, int i_segment, int i_token) {
- return ctx->state->result_all[i_segment].tokens[i_token].id;
-}
-
-struct whisper_token_data whisper_full_get_token_data_from_state(struct whisper_state * state, int i_segment, int i_token) {
- return state->result_all[i_segment].tokens[i_token];
-}
-
-struct whisper_token_data whisper_full_get_token_data(struct whisper_context * ctx, int i_segment, int i_token) {
- return ctx->state->result_all[i_segment].tokens[i_token];
-}
-
-float whisper_full_get_token_p_from_state(struct whisper_state * state, int i_segment, int i_token) {
- return state->result_all[i_segment].tokens[i_token].p;
-}
-
-float whisper_full_get_token_p(struct whisper_context * ctx, int i_segment, int i_token) {
- return ctx->state->result_all[i_segment].tokens[i_token].p;
-}
-
-// =================================================================================================
-
-//
-// Temporary interface needed for exposing ggml interface
-// Will be removed in the future when ggml becomes a separate library
-//
-
-WHISPER_API int whisper_bench_memcpy(int n_threads) {
- fputs(whisper_bench_memcpy_str(n_threads), stderr);
- return 0;
-}
-
-WHISPER_API const char * whisper_bench_memcpy_str(int n_threads) {
- static std::string s;
- s = "";
- char strbuf[256];
-
- ggml_time_init();
-
- size_t n = 20;
- size_t arr = n_threads > 0 ? 1024llu : n_threads; // trick to avoid compiler optimizations
-
- // 1GB array
- const size_t size = arr*1e6;
-
- double sum = 0.0;
-
- // heat-up
- {
- char * src = (char *) malloc(size);
- char * dst = (char *) malloc(size);
-
- for (size_t i = 0; i < size; i++) src[i] = i;
-
- memcpy(dst, src, size); // heat-up
-
- double tsum = 0.0;
-
- for (size_t i = 0; i < n; i++) {
- const int64_t t0 = ggml_time_us();
-
- memcpy(dst, src, size);
-
- const int64_t t1 = ggml_time_us();
-
- tsum += (t1 - t0)*1e-6;
-
- src[rand() % size] = rand() % 256;
- }
-
- snprintf(strbuf, sizeof(strbuf), "memcpy: %7.2f GB/s (heat-up)\n", (double) (n*size)/(tsum*1e9));
- s += strbuf;
-
- // needed to prevent the compiler from optimizing the memcpy away
- {
- for (size_t i = 0; i < size; i++) sum += dst[i];
- }
-
- free(src);
- free(dst);
- }
-
- // single-thread
- {
- char * src = (char *) malloc(size);
- char * dst = (char *) malloc(size);
-
- for (size_t i = 0; i < size; i++) src[i] = i;
-
- memcpy(dst, src, size); // heat-up
-
- double tsum = 0.0;
-
- for (size_t i = 0; i < n; i++) {
- const int64_t t0 = ggml_time_us();
-
- memcpy(dst, src, size);
-
- const int64_t t1 = ggml_time_us();
-
- tsum += (t1 - t0)*1e-6;
-
- src[rand() % size] = rand() % 256;
- }
-
- snprintf(strbuf, sizeof(strbuf), "memcpy: %7.2f GB/s ( 1 thread)\n", (double) (n*size)/(tsum*1e9));
- s += strbuf;
-
- // needed to prevent the compiler from optimizing the memcpy away
- {
- for (size_t i = 0; i < size; i++) sum += dst[i];
- }
-
- free(src);
- free(dst);
- }
-
- // multi-thread
-
- for (int32_t k = 1; k <= n_threads; k++) {
- char * src = (char *) malloc(size);
- char * dst = (char *) malloc(size);
-
- for (size_t i = 0; i < size; i++) src[i] = i;
-
- memcpy(dst, src, size); // heat-up
-
- double tsum = 0.0;
-
- auto helper = [&](int th) {
- const int64_t i0 = (th + 0)*size/k;
- const int64_t i1 = (th + 1)*size/k;
-
- for (size_t i = 0; i < n; i++) {
- memcpy(dst + i0, src + i0, i1 - i0);
-
- src[i0 + rand() % (i1 - i0)] = rand() % 256;
- };
- };
-
- const int64_t t0 = ggml_time_us();
-
- std::vector<std::thread> threads(k - 1);
- for (int32_t th = 0; th < k - 1; ++th) {
- threads[th] = std::thread(helper, th);
- }
-
- helper(k - 1);
-
- for (int32_t th = 0; th < k - 1; ++th) {
- threads[th].join();
- }
-
- const int64_t t1 = ggml_time_us();
-
- tsum += (t1 - t0)*1e-6;
-
- snprintf(strbuf, sizeof(strbuf), "memcpy: %7.2f GB/s (%2d thread)\n", (double) (n*size)/(tsum*1e9), k);
- s += strbuf;
-
- // needed to prevent the compiler from optimizing the memcpy away
- {
- for (size_t i = 0; i < size; i++) sum += dst[i];
- }
-
- free(src);
- free(dst);
- }
-
- snprintf(strbuf, sizeof(strbuf), "sum: %f\n", sum);
- s += strbuf;
-
- return s.c_str();
-}
-
-WHISPER_API int whisper_bench_ggml_mul_mat(int n_threads) {
- fputs(whisper_bench_ggml_mul_mat_str(n_threads), stderr);
- return 0;
-}
-
-WHISPER_API const char * whisper_bench_ggml_mul_mat_str(int n_threads) {
- static std::string s;
- s = "";
- char strbuf[256];
-
- ggml_time_init();
-
- const int n_max = 128;
-
- const std::vector<size_t> sizes = {
- 64, 128, 256, 512, 1024, 2048, 4096,
- };
-
- const size_t N_max = sizes.back();
-
- // a: N*N*sizeof(float)
- // b: N*N*sizeof(float)
- // c: N*N*sizeof(float)
- // when F16 is used, there is an extra work buffer of size N*N*sizeof(float)
- std::vector<uint8_t> buf(3llu*N_max*N_max*sizeof(float) + 3*ggml_tensor_overhead() + ggml_graph_overhead());
- std::vector<uint8_t> work;
-
- // put a bunch of random data in the buffer
- for (size_t i = 0; i < buf.size(); i++) buf[i] = i;
-
- for (int j = 0; j < (int) sizes.size(); j++) {
- int n_q4_0 = 0;
- int n_q4_1 = 0;
- int n_q5_0 = 0;
- int n_q5_1 = 0;
- int n_q8_0 = 0;
- int n_fp16 = 0;
- int n_fp32 = 0;
-
- // GFLOPS/s
- double s_q4_0 = 0.0;
- double s_q4_1 = 0.0;
- double s_q5_0 = 0.0;
- double s_q5_1 = 0.0;
- double s_q8_0 = 0.0;
- double s_fp16 = 0.0;
- double s_fp32 = 0.0;
-
- const size_t N = sizes[j];
-
- for (int k = 0; k < 7; ++k) {
- const ggml_type wtype =
- k == 0 ? GGML_TYPE_Q4_0 :
- k == 1 ? GGML_TYPE_Q4_1 :
- k == 2 ? GGML_TYPE_Q5_0 :
- k == 3 ? GGML_TYPE_Q5_1 :
- k == 4 ? GGML_TYPE_Q8_0 :
- k == 5 ? GGML_TYPE_F16 : GGML_TYPE_F32;
-
- double & s = k == 0 ? s_q4_0 : k == 1 ? s_q4_1 : k == 2 ? s_q5_0 : k == 3 ? s_q5_1 : k == 4 ? s_q8_0 : k == 5 ? s_fp16 : /*k == 6*/ s_fp32;
- int & n = k == 0 ? n_q4_0 : k == 1 ? n_q4_1 : k == 2 ? n_q5_0 : k == 3 ? n_q5_1 : k == 4 ? n_q8_0 : k == 5 ? n_fp16 : /*k == 6*/ n_fp32;
-
- struct ggml_init_params gparams = {
- /*.mem_size =*/ buf.size(),
- /*.mem_buffer =*/ buf.data(),
- /*.no_alloc =*/ false,
- };
-
- struct ggml_context * ctx0 = ggml_init(gparams);
-
- struct ggml_tensor * a = ggml_new_tensor_2d(ctx0, wtype, N, N);
- struct ggml_tensor * b = ggml_new_tensor_2d(ctx0, GGML_TYPE_F32, N, N);
-
- struct ggml_tensor * c = ggml_mul_mat(ctx0, a, b);
-
- struct ggml_cgraph * gf = ggml_new_graph(ctx0);
-
- ggml_build_forward_expand(gf, c);
-
- double tsum = 0.0;
-
- // heat-up
- ggml_graph_compute_helper(gf, work, n_threads, nullptr, nullptr);
-
- for (int i = 0; i < n_max; ++i) {
- const int64_t t0 = ggml_time_us();
-
- ggml_graph_compute_helper(gf, work, n_threads, nullptr, nullptr);
-
- const int64_t t1 = ggml_time_us();
-
- tsum += (t1 - t0)*1e-6;
- n++;
-
- if (tsum > 1.0 && n >= 3) {
- break;
- }
- }
-
- ggml_free(ctx0);
-
- s = ((2.0*N*N*N*n)/tsum)*1e-9;
- }
-
- // Q4_0 | Q4_1
- snprintf(strbuf, sizeof(strbuf), "%4zu x %4zu: Q4_0 %7.1f GFLOPS (%3d runs) | Q4_1 %7.1f GFLOPS (%3d runs)\n",
- N, N, s_q4_0, n_q4_0, s_q4_1, n_q4_1);
- s += strbuf;
-
- // Q5_0 | Q5_1 | Q8_0
- snprintf(strbuf, sizeof(strbuf), "%4zu x %4zu: Q5_0 %7.1f GFLOPS (%3d runs) | Q5_1 %7.1f GFLOPS (%3d runs) | Q8_0 %7.1f GFLOPS (%3d runs)\n",
- N, N, s_q5_0, n_q5_0, s_q5_1, n_q5_1, s_q8_0, n_q8_0);
- s += strbuf;
-
- // F16 | F32
- snprintf(strbuf, sizeof(strbuf), "%4zu x %4zu: F16 %7.1f GFLOPS (%3d runs) | F32 %7.1f GFLOPS (%3d runs)\n",
- N, N, s_fp16, n_fp16, s_fp32, n_fp32);
- s += strbuf;
- }
-
- return s.c_str();
-}
-
-// =================================================================================================
-
-// =================================================================================================
-
-//
-// Experimental stuff below
-//
-// Not sure if these should be part of the library at all, because the quality of the results is not
-// guaranteed. Might get removed at some point unless a robust algorithm implementation is found
-//
-
-// =================================================================================================
-
-//
-// token-level timestamps
-//
-
-static int timestamp_to_sample(int64_t t, int n_samples) {
- return std::max(0, std::min((int) n_samples - 1, (int) ((t*WHISPER_SAMPLE_RATE)/100)));
-}
-
-static int64_t sample_to_timestamp(int i_sample) {
- return (100ll*i_sample)/WHISPER_SAMPLE_RATE;
-}
-
-// a cost-function / heuristic that is high for text that takes longer to pronounce
-// obviously, can be improved
-static float voice_length(const std::string & text) {
- float res = 0.0f;
-
- for (char c : text) {
- if (c == ' ') {
- res += 0.01f;
- } else if (c == ',') {
- res += 2.00f;
- } else if (c == '.') {
- res += 3.00f;
- } else if (c == '!') {
- res += 3.00f;
- } else if (c == '?') {
- res += 3.00f;
- } else if (c >= '0' && c <= '9') {
- res += 3.00f;
- } else {
- res += 1.00f;
- }
- }
-
- return res;
-}
-
-// average the fabs of the signal
-static std::vector<float> get_signal_energy(const float * signal, int n_samples, int n_samples_per_half_window) {
- const int hw = n_samples_per_half_window;
-
- std::vector<float> result(n_samples);
-
- for (int i = 0; i < n_samples; i++) {
- float sum = 0;
- for (int j = -hw; j <= hw; j++) {
- if (i + j >= 0 && i + j < n_samples) {
- sum += fabs(signal[i + j]);
- }
- }
- result[i] = sum/(2*hw + 1);
- }
-
- return result;
-}
-
-static void whisper_exp_compute_token_level_timestamps(
- struct whisper_context & ctx,
- struct whisper_state & state,
- int i_segment,
- float thold_pt,
- float thold_ptsum) {
- auto & segment = state.result_all[i_segment];
- auto & tokens = segment.tokens;
-
- const int n_samples = state.energy.size();
-
- if (n_samples == 0) {
- WHISPER_LOG_ERROR("%s: no signal data available\n", __func__);
- return;
- }
-
- const int64_t t0 = segment.t0;
- const int64_t t1 = segment.t1;
-
- const int n = tokens.size();
-
- if (n == 0) {
- return;
- }
-
- if (n == 1) {
- tokens[0].t0 = t0;
- tokens[0].t1 = t1;
-
- return;
- }
-
- auto & t_beg = state.t_beg;
- auto & t_last = state.t_last;
- auto & tid_last = state.tid_last;
-
- for (int j = 0; j < n; ++j) {
- auto & token = tokens[j];
-
- if (j == 0) {
- if (token.id == whisper_token_beg(&ctx)) {
- tokens[j ].t0 = t0;
- tokens[j ].t1 = t0;
- tokens[j + 1].t0 = t0;
-
- t_beg = t0;
- t_last = t0;
- tid_last = whisper_token_beg(&ctx);
- } else {
- tokens[j ].t0 = t_last;
- }
- }
-
- const int64_t tt = t_beg + 2*(token.tid - whisper_token_beg(&ctx));
-
- tokens[j].id = token.id;
- tokens[j].tid = token.tid;
- tokens[j].p = token.p;
- tokens[j].pt = token.pt;
- tokens[j].ptsum = token.ptsum;
-
- tokens[j].vlen = voice_length(whisper_token_to_str(&ctx, token.id));
-
- if (token.pt > thold_pt && token.ptsum > thold_ptsum && token.tid > tid_last && tt <= t1) {
- if (j > 0) {
- tokens[j - 1].t1 = tt;
- }
- tokens[j].t0 = tt;
- tid_last = token.tid;
- }
- }
-
- tokens[n - 2].t1 = t1;
- tokens[n - 1].t0 = t1;
- tokens[n - 1].t1 = t1;
-
- t_last = t1;
-
- // find intervals of tokens with unknown timestamps
- // fill the timestamps by proportionally splitting the interval based on the token voice lengths
- {
- int p0 = 0;
- int p1 = 0;
-
- while (true) {
- while (p1 < n && tokens[p1].t1 < 0) {
- p1++;
- }
-
- if (p1 >= n) {
- p1--;
- }
-
- //printf("p0=%d p1=%d t0=%lld t1=%lld\n", p0, p1, tokens[p0].t0, tokens[p1].t1);
-
- if (p1 > p0) {
- double psum = 0.0;
- for (int j = p0; j <= p1; j++) {
- psum += tokens[j].vlen;
- }
-
- //printf("analyzing %d - %d, psum = %f\n", p0, p1, psum);
-
- const double dt = tokens[p1].t1 - tokens[p0].t0;
-
- // split the time proportionally to the voice length
- for (int j = p0 + 1; j <= p1; j++) {
- const double ct = tokens[j - 1].t0 + dt*tokens[j - 1].vlen/psum;
-
- tokens[j - 1].t1 = ct;
- tokens[j ].t0 = ct;
- }
- }
-
- p1++;
- p0 = p1;
- if (p1 >= n) {
- break;
- }
- }
- }
-
- // fix up (just in case)
- for (int j = 0; j < n - 1; j++) {
- if (tokens[j].t1 < 0) {
- tokens[j + 1].t0 = tokens[j].t1;
- }
-
- if (j > 0) {
- if (tokens[j - 1].t1 > tokens[j].t0) {
- tokens[j].t0 = tokens[j - 1].t1;
- tokens[j].t1 = std::max(tokens[j].t0, tokens[j].t1);
- }
- }
- }
-
- // VAD
- // expand or contract tokens based on voice activity
- {
- const int hw = WHISPER_SAMPLE_RATE/8;
-
- for (int j = 0; j < n; j++) {
- if (tokens[j].id >= whisper_token_eot(&ctx)) {
- continue;
- }
-
- int s0 = timestamp_to_sample(tokens[j].t0, n_samples);
- int s1 = timestamp_to_sample(tokens[j].t1, n_samples);
-
- const int ss0 = std::max(s0 - hw, 0);
- const int ss1 = std::min(s1 + hw, n_samples);
-
- const int ns = ss1 - ss0;
-
- float sum = 0.0f;
-
- for (int k = ss0; k < ss1; k++) {
- sum += state.energy[k];
- }
-
- const float thold = 0.5*sum/ns;
-
- {
- int k = s0;
- if (state.energy[k] > thold && j > 0) {
- while (k > 0 && state.energy[k] > thold) {
- k--;
- }
- tokens[j].t0 = sample_to_timestamp(k);
- if (tokens[j].t0 < tokens[j - 1].t1) {
- tokens[j].t0 = tokens[j - 1].t1;
- } else {
- s0 = k;
- }
- } else {
- while (state.energy[k] < thold && k < s1) {
- k++;
- }
- s0 = k;
- tokens[j].t0 = sample_to_timestamp(k);
- }
- }
-
- {
- int k = s1;
- if (state.energy[k] > thold) {
- while (k < n_samples - 1 && state.energy[k] > thold) {
- k++;
- }
- tokens[j].t1 = sample_to_timestamp(k);
- if (j < ns - 1 && tokens[j].t1 > tokens[j + 1].t0) {
- tokens[j].t1 = tokens[j + 1].t0;
- } else {
- s1 = k;
- }
- } else {
- while (state.energy[k] < thold && k > s0) {
- k--;
- }
- s1 = k;
- tokens[j].t1 = sample_to_timestamp(k);
- }
- }
- }
- }
-
- // fixed token expand (optional)
- //{
- // const int t_expand = 0;
-
- // for (int j = 0; j < n; j++) {
- // if (j > 0) {
- // tokens[j].t0 = std::max(0, (int) (tokens[j].t0 - t_expand));
- // }
- // if (j < n - 1) {
- // tokens[j].t1 = tokens[j].t1 + t_expand;
- // }
- // }
- //}
-
- // debug info
- //for (int j = 0; j < n; ++j) {
- // const auto & token = tokens[j];
- // const auto tt = token.pt > thold_pt && token.ptsum > 0.01 ? whisper_token_to_str(&ctx, token.tid) : "[?]";
- // printf("%s: %10s %6.3f %6.3f %6.3f %6.3f %5d %5d '%s'\n", __func__,
- // tt, token.p, token.pt, token.ptsum, token.vlen, (int) token.t0, (int) token.t1, whisper_token_to_str(&ctx, token.id));
-
- // if (tokens[j].id >= whisper_token_eot(&ctx)) {
- // continue;
- // }
- //}
-}
-
-//
-// token level timestamps - dtw version
-//
-
-// n_text_layer -> total text layers on model
-// n_head -> total heads per text layer on model
-static std::vector<uint32_t> get_alignment_heads_by_layer(const whisper_context_params & cparams, int il, int n_text_layer, int n_head) {
- std::vector<uint32_t> ret;
- if (cparams.dtw_aheads_preset == WHISPER_AHEADS_NONE) {
- return ret;
- } else if (cparams.dtw_aheads_preset == WHISPER_AHEADS_N_TOP_MOST) {
- if (il >= n_text_layer - cparams.dtw_n_top) {
- for (int32_t i = 0; i < n_head; ++i) {
- ret.push_back(i);
- }
- }
- } else {
- const auto aheads = cparams.dtw_aheads_preset == WHISPER_AHEADS_CUSTOM ? cparams.dtw_aheads : g_aheads.at(cparams.dtw_aheads_preset);
- for (size_t i = 0; i < aheads.n_heads; ++i) {
- if (aheads.heads[i].n_text_layer == il) {
- ret.push_back(aheads.heads[i].n_head);
- }
- }
- }
- return ret;
-}
-
-// dtw + backtrace to return found path
-// based on
-// https://github.com/openai/whisper/blob/main/whisper/timing.py#L83
-static ggml_tensor * dtw_and_backtrace(ggml_context * ctx, ggml_tensor * x) {
- WHISPER_ASSERT(ggml_n_dims(x) == 2);
-
- int64_t N = x->ne[0];
- int64_t M = x->ne[1];
- struct ggml_tensor * cost = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, N + 1, M + 1);
- struct ggml_tensor * trace = ggml_new_tensor_2d(ctx, GGML_TYPE_I32, N + 1, M + 1);
-
- cost = ggml_set_f32(cost, INFINITY);
- trace = ggml_set_f32(trace, -1);
- ggml_set_f32_nd(cost, 0, 0, 0, 0, 0.0);
-
- // dtw
- // supposedly can be optmized by computing diagonals in parallel ?
- // Not sure it is worth it since x will be GENERATED_TOKENS*1500 size at most.
- for (int64_t j = 1; j < M + 1; ++j) {
- for (int64_t i = 1; i < N + 1; ++i) {
- float c0 = ggml_get_f32_nd(cost, i - 1, j - 1, 0, 0);
- float c1 = ggml_get_f32_nd(cost, i - 1, j, 0, 0);
- float c2 = ggml_get_f32_nd(cost, i, j - 1, 0, 0);
-
- float c;
- int32_t t;
- if (c0 < c1 && c0 < c2) {
- c = c0;
- t = 0;
- } else if (c1 < c0 && c1 < c2) {
- c = c1;
- t = 1;
- } else {
- c = c2;
- t = 2;
- }
-
- c = ggml_get_f32_nd(x, i - 1, j - 1, 0, 0) + c;
- ggml_set_f32_nd(cost, i, j, 0, 0, c);
- ggml_set_i32_nd(trace, i, j, 0, 0, t);
- }
- }
-
- // Backtrace
- const int64_t BT_MAX_ROWS = N + M - 1;
- struct ggml_tensor * bt = ggml_new_tensor_2d(ctx, GGML_TYPE_I32, BT_MAX_ROWS, 2);
- // trace[0, :] = 2;
- for (int64_t i = 0; i < M + 1; ++i)
- ggml_set_i32_nd(trace, 0, i, 0, 0, 2);
- //trace[:, 0] = 1;
- for (int64_t i = 0; i < N + 1; ++i)
- ggml_set_i32_nd(trace, i, 0, 0, 0, 1);
- int bt_row_idx = BT_MAX_ROWS - 1;
- int64_t i = N;
- int64_t j = M;
- while (i > 0 || j > 0) {
- ggml_set_i32_nd(bt, bt_row_idx, 0, 0, 0, i - 1);
- ggml_set_i32_nd(bt, bt_row_idx, 1, 0, 0, j - 1);
- --bt_row_idx;
-
- int32_t t = ggml_get_i32_nd(trace, i, j, 0, 0);
- if (t == 0) {
- --i;
- --j;
- } else if (t == 1) {
- --i;
- } else if (t == 2) {
- --j;
- } else {
- WHISPER_ASSERT(0);
- }
- }
-
- // FIXME: manual clip/transpose might not be the most efficient way? (e.g. use ggml funcs)
- // Clip + transpose
- // This might not be entirely necessary for our case, but leaving it for now so output matrix
- // is identical to dtw on openAI timing.py
- const int64_t result_n_cols = BT_MAX_ROWS-bt_row_idx-1;
- ggml_tensor * r = ggml_new_tensor_2d(ctx, GGML_TYPE_I32, 2, result_n_cols);
- for (int64_t i = 0; i < 2; ++i) {
- for (int64_t j = 0; j < result_n_cols; ++j) {
- int32_t v = ggml_get_i32_nd(bt, j+bt_row_idx+1, i, 0, 0);
- ggml_set_i32_nd(r, i, j, 0, 0, v);
- }
- }
-
- return r;
-}
-
-struct median_filter_user_data {
- int filter_width;
-};
-
-static void median_filter(struct ggml_tensor * dst , const struct ggml_tensor * a, int ith, int nth, void * userdata) {
- if (ith != 0) {
- return;
- }
- int filter_width = ((median_filter_user_data *) userdata)->filter_width;
- WHISPER_ASSERT(filter_width < a->ne[2]);
- WHISPER_ASSERT(filter_width % 2);
- WHISPER_ASSERT(ggml_n_dims(a) == 3);
- WHISPER_ASSERT(a->type == GGML_TYPE_F32);
-
- std::vector<float> filter;
- filter.reserve(filter_width);
- for (int64_t i = 0; i < a->ne[0]; ++i) {
- for (int64_t j = 0; j < a->ne[1]; ++j) {
- for (int64_t k = 0; k < a->ne[2]; ++k) {
- for (int64_t off = -filter_width/2; off <= filter_width/2; ++off) {
- // "reflect" padding
- int64_t idx = k + off;
- if (idx < 0) {
- idx = -idx;
- } else if (idx >= a->ne[2]) {
- idx = 2*(a->ne[2] - 1) - idx;
- }
-
- filter.push_back(ggml_get_f32_nd(a, i, j, idx, 0));
- }
- std::sort(filter.begin(), filter.end());
- const float v = filter[filter.size()/2];
- ggml_set_f32_nd(dst, i, j, k, 0, v);
- filter.clear();
- }
- }
- }
-}
-
-static void whisper_exp_compute_token_level_timestamps_dtw(
- struct whisper_context * ctx,
- struct whisper_state * state,
- struct whisper_full_params params,
- int i_segment,
- size_t n_segments,
- int seek,
- int n_frames,
- int medfilt_width,
- int n_threads)
-{
- const int n_audio_ctx = state->exp_n_audio_ctx > 0 ? state->exp_n_audio_ctx : ctx->model.hparams.n_audio_ctx;
- WHISPER_ASSERT(medfilt_width % 2);
- WHISPER_ASSERT(n_frames <= n_audio_ctx * 2);
- WHISPER_ASSERT(ctx->params.dtw_aheads_preset != WHISPER_AHEADS_NONE);
-
- // FIXME: Allocating mem everytime we call this func
- // Our ggml buffer should be pre-allocated somewhere during init and reused
- // when we call this function
- struct ggml_init_params gparams = {
- /*.mem_size =*/ ctx->params.dtw_mem_size,
- /*.mem_buffer =*/ NULL,
- /*.no_alloc =*/ false,
- };
- struct ggml_context * gctx = ggml_init(gparams);
-
- // Build token sequence that will be passed to decoder
- // sot + [lang] + text result + eot
- std::vector<whisper_token> tokens = { whisper_token_sot(ctx), };
- if (whisper_is_multilingual(ctx)) {
- const int lang_id = whisper_lang_id(params.language);
- state->lang_id = lang_id;
- tokens.push_back(whisper_token_lang(ctx, lang_id));
- }
- const size_t sot_sequence_length = tokens.size();
- tokens.push_back(whisper_token_not(ctx));
- for (size_t i = i_segment; i < i_segment + n_segments; ++i) {
- auto & segment = state->result_all[i];
- for (auto &t: segment.tokens) {
- // Only text tokens
- if (t.id < whisper_token_eot(ctx)) {
- tokens.push_back(t.id);
- }
- }
- }
- tokens.push_back(whisper_token_eot(ctx));
-
- // Get result tokens, pass then along to decoder to get cross attention QKs
- // used in timestamping
- // Decoder already returns only alignment head QKs, already concatenated in
- // one tensor.
- whisper_kv_cache_clear(state->kv_self);
- whisper_batch_prep_legacy(state->batch, tokens.data(), tokens.size(), 0, 0);
- whisper_kv_cache_seq_rm(state->kv_self, 0, 0, -1);
- if (!whisper_decode_internal(*ctx, *state, state->batch, n_threads, true, nullptr, nullptr)) {
- WHISPER_LOG_INFO("DECODER FAILED\n");
- WHISPER_ASSERT(0);
- }
- WHISPER_ASSERT(state->aheads_cross_QKs != nullptr);
-
- const auto n_audio_tokens = n_frames/2;
- WHISPER_ASSERT(state->aheads_cross_QKs != NULL);
- WHISPER_ASSERT(n_audio_tokens <= state->aheads_cross_QKs->ne[1]);
- const auto n_tokens = state->aheads_cross_QKs->ne[0];
- const auto n_heads = state->aheads_cross_QKs->ne[2];
-
- // Copy data from decoder buffer to a local CPU tensor, discarding unused audio
- // tokens (i.e. discarding rows at the end of tensor)
- // IN: Tensor with N_TOKENS*audio_ctx*N_ALIGNMENT_HEADS dims
- // OUT: Tensor with N_TOKENS*N_AUDIO_TOKENS*N_ALIGNMENT_HEADS dims
- WHISPER_ASSERT(state->aheads_cross_QKs->type == GGML_TYPE_F32);
- WHISPER_ASSERT(ggml_is_contiguous(state->aheads_cross_QKs));
- ggml_tensor * w = ggml_new_tensor_3d(gctx, GGML_TYPE_F32, n_tokens, n_audio_tokens, n_heads);
- auto & data = state->aheads_cross_QKs_data;
- data.resize(n_tokens * n_audio_ctx * n_heads);
- ggml_backend_tensor_get(state->aheads_cross_QKs, data.data(), 0, sizeof(float) * n_tokens * n_audio_ctx * n_heads);
- for (int k = 0; k < n_heads; ++k) {
- for (int j = 0; j < n_audio_tokens; ++j) {
- memcpy(
- (char *) w->data + j * w->nb[1] + k * w->nb[2],
- data.data() + j * n_tokens + k * n_tokens * n_audio_ctx,
- n_tokens * sizeof(float)
- );
- }
- }
-
- // Normalize - in original OpenAI code, this is done over dim=-2. In this case,
- // we already permuted N_TOKENS dimension to columns on last loop, becase ggml_norm
- // operates over columns. Afterwards, permute to a shape that facilitates mean
- // operation (after median filter)
- // IN: Tensor with N_TOKENS*N_AUDIO_TOKENS*N_ALIGNMENT_HEADS dims
- // OUT: Tensor with N_ALIGNMENT_HEADS*N_TOKENS*N_AUDIO_TOKENS dims
- w = ggml_norm(gctx, w, 1e-9f);
- w = ggml_permute(gctx, ggml_permute(gctx, w, 2, 1, 0 ,3), 0, 2, 1, 3);
-
- // Pass median filter - this is done over AUDIO_TOKENS dimension.
- // IN: Tensor with N_ALIGNMENT_HEADS*N_TOKENS*N_AUDIO_TOKENS dims
- // OUT: Same dims
- median_filter_user_data mf_user_data = {medfilt_width};
- w = ggml_map_custom1(gctx, w, median_filter, 1, &mf_user_data);
-
- // Take mean over columns, scale by -1, reshape to 2D tensor, remove SOT sequence and EOT
- // IN: Tensor with N_ALIGNMENT_HEADS*N_TOKENS*N_AUDIO_TOKENS dims
- // OUT: Tensor with N_TOKENS*N_AUDIO_TOKENS dims
- w = ggml_mean(gctx, w);
- w = ggml_scale(gctx, w, -1.0);
- w = ggml_reshape_2d(gctx, w, w->ne[1], w->ne[2]);
-
- // Remove SOT sequence and EOT
- // Out dimension is (N_TOKENS-sot_sequence_length-1)*N_AUDIO_TOKENS
- w = ggml_view_2d(gctx, w, w->ne[0] - sot_sequence_length - 1, w->ne[1], w->nb[1], sot_sequence_length * w->nb[0]);
-
- // Compute
- struct ggml_cgraph * gf = ggml_new_graph(gctx);
- ggml_build_forward_expand(gf, w);
- ggml_graph_compute_with_ctx(gctx, gf, n_threads);
-
- ggml_tensor * alignment = dtw_and_backtrace(gctx, w);
-
- // Place timestamps on segments
- int32_t last_v = 0;
- auto seg_i = state->result_all.begin() + i_segment;
- auto tok_i = seg_i->tokens.begin();
- for (int i = 0; i < alignment->ne[1]; ++i) {
- int32_t v = ggml_get_i32_nd(alignment, 0, i, 0, 0);
- if (v != last_v) {
- int32_t time_index = ggml_get_i32_nd(alignment, 1, i, 0, 0);
- int64_t timestamp = (time_index * 2) + seek; // Each index on DTW result = 20mS audio
- last_v = v;
-
- // Skip non-text tokens
- while (!(tok_i->id < whisper_token_eot(ctx))) {
- ++tok_i;
- if (tok_i == seg_i->tokens.end()) {
- ++seg_i;
- tok_i = seg_i->tokens.begin();
- }
- }
-
- tok_i->t_dtw = timestamp;
- ++tok_i;
- if (tok_i == seg_i->tokens.end()) {
- ++seg_i;
- tok_i = seg_i->tokens.begin();
- }
- }
- }
-
- // Print DTW timestamps
- /*for (size_t i = i_segment; i < i_segment + n_segments; ++i) {
- auto & segment = state->result_all[i];
- for (auto &t: segment.tokens) {
- const char * tok = whisper_token_to_str(ctx, t.id);
- fprintf(stderr, "|%s|(%.2f) ", tok, (float)t.t_dtw/100);
- }
- fprintf(stderr, "\n");
- }*/
-
- ggml_free(gctx);
-}
-
-void whisper_log_set(ggml_log_callback log_callback, void * user_data) {
- g_state.log_callback = log_callback ? log_callback : whisper_log_callback_default;
- g_state.log_callback_user_data = user_data;
-}
-
-GGML_ATTRIBUTE_FORMAT(2, 3)
-static void whisper_log_internal(ggml_log_level level, const char * format, ...) {
- va_list args;
- va_start(args, format);
- char buffer[1024];
- int len = vsnprintf(buffer, 1024, format, args);
- if (len < 1024) {
- g_state.log_callback(level, buffer, g_state.log_callback_user_data);
- } else {
- char* buffer2 = new char[len+1];
- vsnprintf(buffer2, len+1, format, args);
- buffer2[len] = 0;
- g_state.log_callback(level, buffer2, g_state.log_callback_user_data);
- delete[] buffer2;
- }
- va_end(args);
-}
-
-static void whisper_log_callback_default(ggml_log_level level, const char * text, void * user_data) {
- (void) level;
- (void) user_data;
- if (FLAG_log_disable)
- return;
- fputs(text, stderr);
- fflush(stderr);
-}
diff --git a/whisper.cpp/whisper.h b/whisper.cpp/whisper.h
deleted file mode 100644
index b5091c6c..00000000
--- a/whisper.cpp/whisper.h
+++ /dev/null
@@ -1,656 +0,0 @@
-#ifndef WHISPER_H
-#define WHISPER_H
-
-#include "ggml_extend.hpp"
-
-#include <stddef.h>
-#include <stdint.h>
-#include <stdbool.h>
-
-#ifdef __GNUC__
-# define WHISPER_DEPRECATED(func, hint) func __attribute__((deprecated(hint)))
-#elif defined(_MSC_VER)
-# define WHISPER_DEPRECATED(func, hint) __declspec(deprecated(hint)) func
-#else
-# define WHISPER_DEPRECATED(func, hint) func
-#endif
-
-#ifdef WHISPER_SHARED
-# ifdef _WIN32
-# ifdef WHISPER_BUILD
-# define WHISPER_API __declspec(dllexport)
-# else
-# define WHISPER_API __declspec(dllimport)
-# endif
-# else
-# define WHISPER_API __attribute__ ((visibility ("default")))
-# endif
-#else
-# define WHISPER_API
-#endif
-
-#define WHISPER_SAMPLE_RATE 16000
-#define WHISPER_N_FFT 400
-#define WHISPER_N_FFT_HALF (WHISPER_N_FFT / 2 + 1)
-#define WHISPER_HOP_LENGTH 160
-#define WHISPER_CHUNK_SIZE 30
-#define WHISPER_N_SAMPLES (WHISPER_SAMPLE_RATE * WHISPER_CHUNK_SIZE)
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
- //
- // C interface
- //
- // The following interface is thread-safe as long as the sample whisper_context is not used by multiple threads
- // concurrently.
- //
- // Basic usage:
- //
- // #include "whisper.h"
- //
- // ...
- //
- // whisper_context_params cparams = whisper_context_default_params();
- //
- // struct whisper_context * ctx = whisper_init_from_file_with_params("/path/to/ggml-base.en.bin", cparams);
- //
- // if (whisper_full(ctx, wparams, pcmf32.data(), pcmf32.size()) != 0) {
- // fprintf(stderr, "failed to process audio\n");
- // return 7;
- // }
- //
- // const int n_segments = whisper_full_n_segments(ctx);
- // for (int i = 0; i < n_segments; ++i) {
- // const char * text = whisper_full_get_segment_text(ctx, i);
- // printf("%s", text);
- // }
- //
- // whisper_free(ctx);
- //
- // ...
- //
- // This is a demonstration of the most straightforward usage of the library.
- // "pcmf32" contains the RAW audio data in 32-bit floating point format.
- //
- // The interface also allows for more fine-grained control over the computation, but it requires a deeper
- // understanding of how the model works.
- //
-
- struct whisper_context;
- struct whisper_state;
- struct whisper_full_params;
-
- typedef int32_t whisper_pos;
- typedef int32_t whisper_token;
- typedef int32_t whisper_seq_id;
-
- enum whisper_alignment_heads_preset {
- WHISPER_AHEADS_NONE,
- WHISPER_AHEADS_N_TOP_MOST, // All heads from the N-top-most text-layers
- WHISPER_AHEADS_CUSTOM,
- WHISPER_AHEADS_TINY_EN,
- WHISPER_AHEADS_TINY,
- WHISPER_AHEADS_BASE_EN,
- WHISPER_AHEADS_BASE,
- WHISPER_AHEADS_SMALL_EN,
- WHISPER_AHEADS_SMALL,
- WHISPER_AHEADS_MEDIUM_EN,
- WHISPER_AHEADS_MEDIUM,
- WHISPER_AHEADS_LARGE_V1,
- WHISPER_AHEADS_LARGE_V2,
- WHISPER_AHEADS_LARGE_V3,
- };
-
- typedef struct whisper_ahead {
- int n_text_layer;
- int n_head;
- } whisper_ahead;
-
- typedef struct whisper_aheads {
- size_t n_heads;
- const whisper_ahead * heads;
- } whisper_aheads;
-
- struct whisper_context_params {
- bool flash_attn;
- int gpu_device; // CUDA device
-
- // [EXPERIMENTAL] Token-level timestamps with DTW
- bool dtw_token_timestamps;
- enum whisper_alignment_heads_preset dtw_aheads_preset;
-
- int dtw_n_top;
- struct whisper_aheads dtw_aheads;
-
- size_t dtw_mem_size; // TODO: remove
- };
-
- typedef struct whisper_token_data {
- whisper_token id; // token id
- whisper_token tid; // forced timestamp token id
-
- float p; // probability of the token
- float plog; // log probability of the token
- float pt; // probability of the timestamp token
- float ptsum; // sum of probabilities of all timestamp tokens
-
- // token-level timestamp data
- // do not use if you haven't computed token-level timestamps
- int64_t t0; // start time of the token
- int64_t t1; // end time of the token
-
- // [EXPERIMENTAL] Token-level timestamps with DTW
- // do not use if you haven't computed token-level timestamps with dtw
- // Roughly corresponds to the moment in audio in which the token was output
- int64_t t_dtw;
-
- float vlen; // voice length of the token
- } whisper_token_data;
-
- typedef struct whisper_model_loader {
- void * context;
-
- size_t (*read)(void * ctx, void * output, size_t read_size);
- bool (*eof)(void * ctx);
- void (*close)(void * ctx);
- } whisper_model_loader;
-
- // grammar element type
- enum whisper_gretype {
- // end of rule definition
- WHISPER_GRETYPE_END = 0,
-
- // start of alternate definition for rule
- WHISPER_GRETYPE_ALT = 1,
-
- // non-terminal element: reference to rule
- WHISPER_GRETYPE_RULE_REF = 2,
-
- // terminal element: character (code point)
- WHISPER_GRETYPE_CHAR = 3,
-
- // inverse char(s) ([^a], [^a-b] [^abc])
- WHISPER_GRETYPE_CHAR_NOT = 4,
-
- // modifies a preceding WHISPER_GRETYPE_CHAR or LLAMA_GRETYPE_CHAR_ALT to
- // be an inclusive range ([a-z])
- WHISPER_GRETYPE_CHAR_RNG_UPPER = 5,
-
- // modifies a preceding WHISPER_GRETYPE_CHAR or
- // WHISPER_GRETYPE_CHAR_RNG_UPPER to add an alternate char to match ([ab], [a-zA])
- WHISPER_GRETYPE_CHAR_ALT = 6,
- };
-
- typedef struct whisper_grammar_element {
- enum whisper_gretype type;
- uint32_t value; // Unicode code point or rule ID
- } whisper_grammar_element;
-
- // Various functions for loading a ggml whisper model.
- // Allocate (almost) all memory needed for the model.
- // Return NULL on failure
- WHISPER_API struct whisper_context * whisper_init_from_file_with_params (const char * path_model, struct whisper_context_params params);
- WHISPER_API struct whisper_context * whisper_init_from_buffer_with_params(void * buffer, size_t buffer_size, struct whisper_context_params params);
- WHISPER_API struct whisper_context * whisper_init_with_params (struct whisper_model_loader * loader, struct whisper_context_params params);
-
- // These are the same as the above, but the internal state of the context is not allocated automatically
- // It is the responsibility of the caller to allocate the state using whisper_init_state() (#523)
- WHISPER_API struct whisper_context * whisper_init_from_file_with_params_no_state (const char * path_model, struct whisper_context_params params);
- WHISPER_API struct whisper_context * whisper_init_from_buffer_with_params_no_state(void * buffer, size_t buffer_size, struct whisper_context_params params);
- WHISPER_API struct whisper_context * whisper_init_with_params_no_state (struct whisper_model_loader * loader, struct whisper_context_params params);
-
- WHISPER_DEPRECATED(
- WHISPER_API struct whisper_context * whisper_init_from_file(const char * path_model),
- "use whisper_init_from_file_with_params instead"
- );
- WHISPER_DEPRECATED(
- WHISPER_API struct whisper_context * whisper_init_from_buffer(void * buffer, size_t buffer_size),
- "use whisper_init_from_buffer_with_params instead"
- );
- WHISPER_DEPRECATED(
- WHISPER_API struct whisper_context * whisper_init(struct whisper_model_loader * loader),
- "use whisper_init_with_params instead"
- );
- WHISPER_DEPRECATED(
- WHISPER_API struct whisper_context * whisper_init_from_file_no_state(const char * path_model),
- "use whisper_init_from_file_with_params_no_state instead"
- );
- WHISPER_DEPRECATED(
- WHISPER_API struct whisper_context * whisper_init_from_buffer_no_state(void * buffer, size_t buffer_size),
- "use whisper_init_from_buffer_with_params_no_state instead"
- );
- WHISPER_DEPRECATED(
- WHISPER_API struct whisper_context * whisper_init_no_state(struct whisper_model_loader * loader),
- "use whisper_init_with_params_no_state instead"
- );
-
- WHISPER_API struct whisper_state * whisper_init_state(struct whisper_context * ctx);
-
- // Given a context, enable use of OpenVINO for encode inference.
- // model_path: Optional path to OpenVINO encoder IR model. If set to nullptr,
- // the path will be generated from the ggml model path that was passed
- // in to whisper_init_from_file. For example, if 'path_model' was
- // "/path/to/ggml-base.en.bin", then OpenVINO IR model path will be
- // assumed to be "/path/to/ggml-base.en-encoder-openvino.xml".
- // device: OpenVINO device to run inference on ("CPU", "GPU", etc.)
- // cache_dir: Optional cache directory that can speed up init time, especially for
- // GPU, by caching compiled 'blobs' there.
- // Set to nullptr if not used.
- // Returns 0 on success. If OpenVINO is not enabled in build, this simply returns 1.
- WHISPER_API int whisper_ctx_init_openvino_encoder(
- struct whisper_context * ctx,
- const char * model_path,
- const char * device,
- const char * cache_dir);
-
- // Frees all allocated memory
- WHISPER_API void whisper_free (struct whisper_context * ctx);
- WHISPER_API void whisper_free_state(struct whisper_state * state);
- WHISPER_API void whisper_free_params(struct whisper_full_params * params);
- WHISPER_API void whisper_free_context_params(struct whisper_context_params * params);
-
- // Convert RAW PCM audio to log mel spectrogram.
- // The resulting spectrogram is stored inside the default state of the provided whisper context.
- // Returns 0 on success
- WHISPER_API int whisper_pcm_to_mel(
- struct whisper_context * ctx,
- const float * samples,
- int n_samples,
- int n_threads);
-
- WHISPER_API int whisper_pcm_to_mel_with_state(
- struct whisper_context * ctx,
- struct whisper_state * state,
- const float * samples,
- int n_samples,
- int n_threads);
-
- // This can be used to set a custom log mel spectrogram inside the default state of the provided whisper context.
- // Use this instead of whisper_pcm_to_mel() if you want to provide your own log mel spectrogram.
- // n_mel must be 80
- // Returns 0 on success
- WHISPER_API int whisper_set_mel(
- struct whisper_context * ctx,
- const float * data,
- int n_len,
- int n_mel);
-
- WHISPER_API int whisper_set_mel_with_state(
- struct whisper_context * ctx,
- struct whisper_state * state,
- const float * data,
- int n_len,
- int n_mel);
-
- // Run the Whisper encoder on the log mel spectrogram stored inside the default state in the provided whisper context.
- // Make sure to call whisper_pcm_to_mel() or whisper_set_mel() first.
- // offset can be used to specify the offset of the first frame in the spectrogram.
- // Returns 0 on success
- WHISPER_API int whisper_encode(
- struct whisper_context * ctx,
- int offset,
- int n_threads);
-
- WHISPER_API int whisper_encode_with_state(
- struct whisper_context * ctx,
- struct whisper_state * state,
- int offset,
- int n_threads);
-
- // Run the Whisper decoder to obtain the logits and probabilities for the next token.
- // Make sure to call whisper_encode() first.
- // tokens + n_tokens is the provided context for the decoder.
- // n_past is the number of tokens to use from previous decoder calls.
- // Returns 0 on success
- // TODO: add support for multiple decoders
- WHISPER_API int whisper_decode(
- struct whisper_context * ctx,
- const whisper_token * tokens,
- int n_tokens,
- int n_past,
- int n_threads);
-
- WHISPER_API int whisper_decode_with_state(
- struct whisper_context * ctx,
- struct whisper_state * state,
- const whisper_token * tokens,
- int n_tokens,
- int n_past,
- int n_threads);
-
- // Convert the provided text into tokens.
- // The tokens pointer must be large enough to hold the resulting tokens.
- // Returns the number of tokens on success, no more than n_max_tokens
- // Returns a negative number on failure - the number of tokens that would have been returned
- // TODO: not sure if correct
- WHISPER_API int whisper_tokenize(
- struct whisper_context * ctx,
- const char * text,
- whisper_token * tokens,
- int n_max_tokens);
-
- // Return the number of tokens in the provided text
- // Equivalent to: -whisper_tokenize(ctx, text, NULL, 0)
- int whisper_token_count(struct whisper_context * ctx, const char * text);
-
- // Largest language id (i.e. number of available languages - 1)
- WHISPER_API int whisper_lang_max_id(void);
-
- // Return the id of the specified language, returns -1 if not found
- // Examples:
- // "de" -> 2
- // "german" -> 2
- WHISPER_API int whisper_lang_id(const char * lang);
-
- // Return the short string of the specified language id (e.g. 2 -> "de"), returns nullptr if not found
- WHISPER_API const char * whisper_lang_str(int id);
-
- // Return the short string of the specified language name (e.g. 2 -> "german"), returns nullptr if not found
- WHISPER_API const char * whisper_lang_str_full(int id);
-
- // Use mel data at offset_ms to try and auto-detect the spoken language
- // Make sure to call whisper_pcm_to_mel() or whisper_set_mel() first
- // Returns the top language id or negative on failure
- // If not null, fills the lang_probs array with the probabilities of all languages
- // The array must be whisper_lang_max_id() + 1 in size
- // ref: https://github.com/openai/whisper/blob/main/whisper/decoding.py#L18-L69
- WHISPER_API int whisper_lang_auto_detect(
- struct whisper_context * ctx,
- int offset_ms,
- int n_threads,
- float * lang_probs);
-
- WHISPER_API int whisper_lang_auto_detect_with_state(
- struct whisper_context * ctx,
- struct whisper_state * state,
- int offset_ms,
- int n_threads,
- float * lang_probs);
-
- WHISPER_API int whisper_n_len (struct whisper_context * ctx); // mel length
- WHISPER_API int whisper_n_len_from_state(struct whisper_state * state); // mel length
- WHISPER_API int whisper_n_vocab (struct whisper_context * ctx);
- WHISPER_API int whisper_n_text_ctx (struct whisper_context * ctx);
- WHISPER_API int whisper_n_audio_ctx (struct whisper_context * ctx);
- WHISPER_API int whisper_is_multilingual (struct whisper_context * ctx);
-
- WHISPER_API int whisper_model_n_vocab (struct whisper_context * ctx);
- WHISPER_API int whisper_model_n_audio_ctx (struct whisper_context * ctx);
- WHISPER_API int whisper_model_n_audio_state(struct whisper_context * ctx);
- WHISPER_API int whisper_model_n_audio_head (struct whisper_context * ctx);
- WHISPER_API int whisper_model_n_audio_layer(struct whisper_context * ctx);
- WHISPER_API int whisper_model_n_text_ctx (struct whisper_context * ctx);
- WHISPER_API int whisper_model_n_text_state (struct whisper_context * ctx);
- WHISPER_API int whisper_model_n_text_head (struct whisper_context * ctx);
- WHISPER_API int whisper_model_n_text_layer (struct whisper_context * ctx);
- WHISPER_API int whisper_model_n_mels (struct whisper_context * ctx);
- WHISPER_API int whisper_model_ftype (struct whisper_context * ctx);
- WHISPER_API int whisper_model_type (struct whisper_context * ctx);
-
- // Token logits obtained from the last call to whisper_decode()
- // The logits for the last token are stored in the last row
- // Rows: n_tokens
- // Cols: n_vocab
- WHISPER_API float * whisper_get_logits (struct whisper_context * ctx);
- WHISPER_API float * whisper_get_logits_from_state(struct whisper_state * state);
-
- // Token Id -> String. Uses the vocabulary in the provided context
- WHISPER_API const char * whisper_token_to_str(struct whisper_context * ctx, whisper_token token);
- WHISPER_API const char * whisper_model_type_readable(struct whisper_context * ctx);
-
-
- // Special tokens
- WHISPER_API whisper_token whisper_token_eot (struct whisper_context * ctx);
- WHISPER_API whisper_token whisper_token_sot (struct whisper_context * ctx);
- WHISPER_API whisper_token whisper_token_solm(struct whisper_context * ctx);
- WHISPER_API whisper_token whisper_token_prev(struct whisper_context * ctx);
- WHISPER_API whisper_token whisper_token_nosp(struct whisper_context * ctx);
- WHISPER_API whisper_token whisper_token_not (struct whisper_context * ctx);
- WHISPER_API whisper_token whisper_token_beg (struct whisper_context * ctx);
- WHISPER_API whisper_token whisper_token_lang(struct whisper_context * ctx, int lang_id);
-
- // Task tokens
- WHISPER_API whisper_token whisper_token_translate (struct whisper_context * ctx);
- WHISPER_API whisper_token whisper_token_transcribe(struct whisper_context * ctx);
-
- // Performance information from the default state.
- WHISPER_API void whisper_print_timings(struct whisper_context * ctx);
- WHISPER_API void whisper_reset_timings(struct whisper_context * ctx);
-
- // Print system information
- WHISPER_API const char * whisper_print_system_info(void);
-
- ////////////////////////////////////////////////////////////////////////////
-
- // Available sampling strategies
- enum whisper_sampling_strategy {
- WHISPER_SAMPLING_GREEDY, // similar to OpenAI's GreedyDecoder
- WHISPER_SAMPLING_BEAM_SEARCH, // similar to OpenAI's BeamSearchDecoder
- };
-
- // Text segment callback
- // Called on every newly generated text segment
- // Use the whisper_full_...() functions to obtain the text segments
- typedef void (*whisper_new_segment_callback)(struct whisper_context * ctx, struct whisper_state * state, int n_new, void * user_data);
-
- // Progress callback
- typedef void (*whisper_progress_callback)(struct whisper_context * ctx, struct whisper_state * state, int progress, void * user_data);
-
- // Encoder begin callback
- // If not NULL, called before the encoder starts
- // If it returns false, the computation is aborted
- typedef bool (*whisper_encoder_begin_callback)(struct whisper_context * ctx, struct whisper_state * state, void * user_data);
-
- // Logits filter callback
- // Can be used to modify the logits before sampling
- // If not NULL, called after applying temperature to logits
- typedef void (*whisper_logits_filter_callback)(
- struct whisper_context * ctx,
- struct whisper_state * state,
- const whisper_token_data * tokens,
- int n_tokens,
- float * logits,
- void * user_data);
-
- // Parameters for the whisper_full() function
- // If you change the order or add new parameters, make sure to update the default values in whisper.cpp:
- // whisper_full_default_params()
- struct whisper_full_params {
- enum whisper_sampling_strategy strategy;
-
- int n_threads;
- int n_max_text_ctx; // max tokens to use from past text as prompt for the decoder
- int offset_ms; // start offset in ms
- int duration_ms; // audio duration to process in ms
-
- bool translate;
- bool no_context; // do not use past transcription (if any) as initial prompt for the decoder
- bool no_timestamps; // do not generate timestamps
- bool single_segment; // force single segment output (useful for streaming)
- bool print_special; // print special tokens (e.g. <SOT>, <EOT>, <BEG>, etc.)
- bool print_progress; // print progress information
- bool print_realtime; // print results from within whisper.cpp (avoid it, use callback instead)
- bool print_timestamps; // print timestamps for each text segment when printing realtime
-
- // [EXPERIMENTAL] token-level timestamps
- bool token_timestamps; // enable token-level timestamps
- float thold_pt; // timestamp token probability threshold (~0.01)
- float thold_ptsum; // timestamp token sum probability threshold (~0.01)
- int max_len; // max segment length in characters
- bool split_on_word; // split on word rather than on token (when used with max_len)
- int max_tokens; // max tokens per segment (0 = no limit)
-
- // [EXPERIMENTAL] speed-up techniques
- // note: these can significantly reduce the quality of the output
- bool debug_mode; // enable debug_mode provides extra info (eg. Dump log_mel)
- int audio_ctx; // overwrite the audio context size (0 = use default)
-
- // [EXPERIMENTAL] [TDRZ] tinydiarize
- bool tdrz_enable; // enable tinydiarize speaker turn detection
-
- // A regular expression that matches tokens to suppress
- const char * suppress_regex;
-
- // tokens to provide to the whisper decoder as initial prompt
- // these are prepended to any existing text context from a previous call
- // use whisper_tokenize() to convert text to tokens
- // maximum of whisper_n_text_ctx()/2 tokens are used (typically 224)
- const char * initial_prompt;
- const whisper_token * prompt_tokens;
- int prompt_n_tokens;
-
- // for auto-detection, set to nullptr, "" or "auto"
- const char * language;
- bool detect_language;
-
- // common decoding parameters:
- bool suppress_blank; // ref: https://github.com/openai/whisper/blob/f82bc59f5ea234d4b97fb2860842ed38519f7e65/whisper/decoding.py#L89
- bool suppress_non_speech_tokens; // ref: https://github.com/openai/whisper/blob/7858aa9c08d98f75575035ecd6481f462d66ca27/whisper/tokenizer.py#L224-L253
-
- float temperature; // initial decoding temperature, ref: https://ai.stackexchange.com/a/32478
- float max_initial_ts; // ref: https://github.com/openai/whisper/blob/f82bc59f5ea234d4b97fb2860842ed38519f7e65/whisper/decoding.py#L97
- float length_penalty; // ref: https://github.com/openai/whisper/blob/f82bc59f5ea234d4b97fb2860842ed38519f7e65/whisper/transcribe.py#L267
-
- // fallback parameters
- // ref: https://github.com/openai/whisper/blob/f82bc59f5ea234d4b97fb2860842ed38519f7e65/whisper/transcribe.py#L274-L278
- float temperature_inc;
- float entropy_thold; // similar to OpenAI's "compression_ratio_threshold"
- float logprob_thold;
- float no_speech_thold; // TODO: not implemented
-
- struct {
- int best_of; // ref: https://github.com/openai/whisper/blob/f82bc59f5ea234d4b97fb2860842ed38519f7e65/whisper/transcribe.py#L264
- } greedy;
-
- struct {
- int beam_size; // ref: https://github.com/openai/whisper/blob/f82bc59f5ea234d4b97fb2860842ed38519f7e65/whisper/transcribe.py#L265
-
- float patience; // TODO: not implemented, ref: https://arxiv.org/pdf/2204.05424.pdf
- } beam_search;
-
- // called for every newly generated text segment
- whisper_new_segment_callback new_segment_callback;
- void * new_segment_callback_user_data;
-
- // called on each progress update
- whisper_progress_callback progress_callback;
- void * progress_callback_user_data;
-
- // called each time before the encoder starts
- whisper_encoder_begin_callback encoder_begin_callback;
- void * encoder_begin_callback_user_data;
-
- // called each time before ggml computation starts
- ggml_abort_callback abort_callback;
- void * abort_callback_user_data;
-
- // called by each decoder to filter obtained logits
- whisper_logits_filter_callback logits_filter_callback;
- void * logits_filter_callback_user_data;
-
- const whisper_grammar_element ** grammar_rules;
- size_t n_grammar_rules;
- size_t i_start_rule;
- float grammar_penalty;
- };
-
- // NOTE: this function allocates memory, and it is the responsibility of the caller to free the pointer - see whisper_free_context_params & whisper_free_params()
- WHISPER_API struct whisper_context_params * whisper_context_default_params_by_ref(void);
- WHISPER_API struct whisper_context_params whisper_context_default_params (void);
- WHISPER_API struct whisper_full_params * whisper_full_default_params_by_ref(enum whisper_sampling_strategy strategy);
- WHISPER_API struct whisper_full_params whisper_full_default_params (enum whisper_sampling_strategy strategy);
-
- // Run the entire model: PCM -> log mel spectrogram -> encoder -> decoder -> text
- // Not thread safe for same context
- // Uses the specified decoding strategy to obtain the text.
- WHISPER_API int whisper_full(
- struct whisper_context * ctx,
- struct whisper_full_params params,
- const float * samples,
- int n_samples);
-
- WHISPER_API int whisper_full_with_state(
- struct whisper_context * ctx,
- struct whisper_state * state,
- struct whisper_full_params params,
- const float * samples,
- int n_samples);
-
- // Split the input audio in chunks and process each chunk separately using whisper_full_with_state()
- // Result is stored in the default state of the context
- // Not thread safe if executed in parallel on the same context.
- // It seems this approach can offer some speedup in some cases.
- // However, the transcription accuracy can be worse at the beginning and end of each chunk.
- WHISPER_API int whisper_full_parallel(
- struct whisper_context * ctx,
- struct whisper_full_params params,
- const float * samples,
- int n_samples,
- int n_processors);
-
- // Number of generated text segments
- // A segment can be a few words, a sentence, or even a paragraph.
- WHISPER_API int whisper_full_n_segments (struct whisper_context * ctx);
- WHISPER_API int whisper_full_n_segments_from_state(struct whisper_state * state);
-
- // Language id associated with the context's default state
- WHISPER_API int whisper_full_lang_id(struct whisper_context * ctx);
-
- // Language id associated with the provided state
- WHISPER_API int whisper_full_lang_id_from_state(struct whisper_state * state);
-
- // Get the start and end time of the specified segment
- WHISPER_API int64_t whisper_full_get_segment_t0 (struct whisper_context * ctx, int i_segment);
- WHISPER_API int64_t whisper_full_get_segment_t0_from_state(struct whisper_state * state, int i_segment);
-
- WHISPER_API int64_t whisper_full_get_segment_t1 (struct whisper_context * ctx, int i_segment);
- WHISPER_API int64_t whisper_full_get_segment_t1_from_state(struct whisper_state * state, int i_segment);
-
- // Get whether the next segment is predicted as a speaker turn
- WHISPER_API bool whisper_full_get_segment_speaker_turn_next(struct whisper_context * ctx, int i_segment);
- WHISPER_API bool whisper_full_get_segment_speaker_turn_next_from_state(struct whisper_state * state, int i_segment);
-
- // Get the text of the specified segment
- WHISPER_API const char * whisper_full_get_segment_text (struct whisper_context * ctx, int i_segment);
- WHISPER_API const char * whisper_full_get_segment_text_from_state(struct whisper_state * state, int i_segment);
-
- // Get number of tokens in the specified segment
- WHISPER_API int whisper_full_n_tokens (struct whisper_context * ctx, int i_segment);
- WHISPER_API int whisper_full_n_tokens_from_state(struct whisper_state * state, int i_segment);
-
- // Get the token text of the specified token in the specified segment
- WHISPER_API const char * whisper_full_get_token_text (struct whisper_context * ctx, int i_segment, int i_token);
- WHISPER_API const char * whisper_full_get_token_text_from_state(struct whisper_context * ctx, struct whisper_state * state, int i_segment, int i_token);
-
- WHISPER_API whisper_token whisper_full_get_token_id (struct whisper_context * ctx, int i_segment, int i_token);
- WHISPER_API whisper_token whisper_full_get_token_id_from_state(struct whisper_state * state, int i_segment, int i_token);
-
- // Get token data for the specified token in the specified segment
- // This contains probabilities, timestamps, etc.
- WHISPER_API whisper_token_data whisper_full_get_token_data (struct whisper_context * ctx, int i_segment, int i_token);
- WHISPER_API whisper_token_data whisper_full_get_token_data_from_state(struct whisper_state * state, int i_segment, int i_token);
-
- // Get the probability of the specified token in the specified segment
- WHISPER_API float whisper_full_get_token_p (struct whisper_context * ctx, int i_segment, int i_token);
- WHISPER_API float whisper_full_get_token_p_from_state(struct whisper_state * state, int i_segment, int i_token);
-
- ////////////////////////////////////////////////////////////////////////////
-
- // Temporary helpers needed for exposing ggml interface
-
- WHISPER_API int whisper_bench_memcpy (int n_threads);
- WHISPER_API const char * whisper_bench_memcpy_str (int n_threads);
- WHISPER_API int whisper_bench_ggml_mul_mat (int n_threads);
- WHISPER_API const char * whisper_bench_ggml_mul_mat_str(int n_threads);
-
- // Control logging output; default behavior is to print to stderr
-
- WHISPER_API void whisper_log_set(ggml_log_callback log_callback, void * user_data);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif