Merge pull request #3230 from PaulBoersma/master

-

Author: PaulBoersma

external/portaudio/pa_endianness.h

@@ -70,13 +70,13 @@ extern "C"
 #if defined(NDEBUG)
     #define PA_VALIDATE_ENDIANNESS
 #else
-    #if defined(PA_LITTLE_ENDIAN)
+    #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
         #define PA_VALIDATE_ENDIANNESS \
         { \
             const long nativeOne = 1; \
             assert( "PortAudio: compile time and runtime endianness don't match" && (((char *)&nativeOne)[0]) == 1 ); \
         }
-    #elif defined(PA_BIG_ENDIAN)
+    #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
         #define PA_VALIDATE_ENDIANNESS \
         { \
             const long nativeOne = 1; \

external/whispercpp/READ_ME.TXT

@@ -338,9 +338,82 @@ with
 	#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
 ```
 
-4. Models
+4. General compatibility with C++
+---------------------------------
+4.1. Assigning from `void *`
+----------------------------
+This is ruled out in C++, so we cast according to the following examples:
+```
+	galloc->node_allocs = ggml_calloc(graph->n_nodes, sizeof(struct node_alloc));   // C
+	galloc->node_allocs = (struct node_alloc *) ggml_calloc(graph->n_nodes, sizeof(struct node_alloc));   // C++
+
+	result->vals = GGML_CALLOC(result->set.size, sizeof(struct ggml_tensor *));   // C
+	result->vals = (struct ggml_tensor **) GGML_CALLOC(result->set.size, sizeof(struct ggml_tensor *));   // C++
+
+	char * const data = tensor->data;   // C
+	char * const data = (char *) tensor->data;   // C++
+
+	const float * l = left;   // C
+	const float * l = (const float *) left;   // C++
+
+	quantize_row_q2_K_ref(src, dst, (int64_t)nrow*n_per_row);   // C
+	quantize_row_q2_K_ref(src, (block_q2_K *) dst, (int64_t)nrow*n_per_row);   // C++
+
+	char (*atomic_current_chunk)[CACHE_LINE_SIZE] = blabla   // C
+	char (*atomic_current_chunk)[CACHE_LINE_SIZE] = (char (*)[CACHE_LINE_SIZE]) blabla   // C++
+```
+
+4.2. Assigning int to enum
+--------------------------
+This is also ruled out in C++, so we cast according to the following examples:
+```
+	const enum ggml_op_pool op = ggml_get_op_params_i32(tensor, 0);
+	const enum ggml_op_pool op = (enum ggml_op_pool) ggml_get_op_params_i32(tensor, 0);
+
+	p->prio = 0;   // C
+	p->prio = (enum ggml_sched_priority) 0;   // C++
+
+	static struct ggml_state g_state = {0};   // C
+	static struct ggml_state g_state {};   // C++
+```
+
+4.3. Assignments in initializer lists
+-------------------------------------
+Types have to match more closely in C++, so we cast according to the following examples:
+```
+	*cgraph = (struct ggml_cgraph) { size, ...   // C
+	*cgraph = (struct ggml_cgraph) { (int) size, ...   // C++
+
+	int32_t params[] = { nb1, nb2, nb3, offset, inplace ? 1 : 0 };   // C
+	int32_t params[] = { (int32_t) nb1, (int32_t) nb2, (int32_t) nb3, (int32_t) offset, inplace ? 1 : 0 };   // C++
+
+	MMID_MATRIX_ROW(i02, matrix_row_counts[i02]) = (struct mmid_row_mapping) {id, iid1};   // C
+	MMID_MATRIX_ROW(i02, matrix_row_counts[i02]) = (struct mmid_row_mapping) {id, (int32_t) iid1};   // C++
+
+	union { uint16_t u16; ggml_fp16_t fp16; } u = {i};   // C
+	union { uint16_t u16; ggml_fp16_t fp16; } u = { (uint16_t) i };   // C++
+
+    struct ggml_compute_params params = {
+        /*.ith        =*/ state->ith,
+        /*.nth        =*/ atomic_load_explicit(&tp->n_graph, memory_order_relaxed) & GGML_THREADPOOL_N_THREADS_MASK,
+        /*.wsize      =*/ cplan->work_size,
+        /*.wdata      =*/ cplan->work_data,
+        /*.threadpool =*/ tp,
+        /*.use_ref    =*/ cplan->use_ref,
+    };   // C
+    struct ggml_compute_params params = {
+        /*.ith        =*/ state->ith,
+        /*.nth        =*/ (int) (atomic_load_explicit(&tp->n_graph, memory_order_relaxed) & GGML_THREADPOOL_N_THREADS_MASK),
+        /*.wsize      =*/ cplan->work_size,
+        /*.wdata      =*/ cplan->work_data,
+        /*.threadpool =*/ tp,
+        /*.use_ref    =*/ cplan->use_ref,
+    };   // C++
+```
+
+5. Models
 ---------
-4.1. Bringing Silero-VAD model to Praat source code
+5.1. Bringing Silero-VAD model to Praat source code
 ---------------------------------------------------
 First, we download the ggml Silero model from the original whisper.cpp repository:
 ```
@@ -353,10 +426,10 @@ We then convert this binary to a C header using `xxd` and copy it to external/wh
 xxd -i -n ggml_silero_bin -n whisper.cpp/models/ggml-silero-v6.2.0.bin > praat/external/whispercpp/ggml-silero-vad-model-data.h
 ```
 
-4.2. Segmentation
+5.2. Segmentation
 -----------------
 todo
 
-4.3. Embedding
+5.3. Embedding
 --------------
-todo
+todo

external/whispercpp/ggml-alloc.cpp

@@ -159,7 +159,7 @@ static int ggml_dyn_tallocr_new_chunk(struct ggml_dyn_tallocr * alloc, size_t mi
     if (alloc->n_chunks >= GGML_VBUFFER_MAX_CHUNKS) {
         return -1;
     }
-    struct tallocr_chunk * chunk = ggml_calloc(1, sizeof(struct tallocr_chunk));
+    struct tallocr_chunk * chunk = (struct tallocr_chunk *) ggml_calloc(1, sizeof(struct tallocr_chunk));
     chunk->n_free_blocks = 1;
     chunk->free_blocks[0].offset = 0;
     // available space in a chunk is limited to max_chunk_size, but can be higher if:
@@ -497,13 +497,13 @@ ggml_gallocr_t ggml_gallocr_new_n(ggml_backend_buffer_type_t * bufts, int n_bufs
     ggml_gallocr_t galloc = (ggml_gallocr_t)ggml_calloc(1, sizeof(struct ggml_gallocr));
     GGML_ASSERT(galloc != NULL);
 
-    galloc->bufts = ggml_calloc(n_bufs, sizeof(ggml_backend_buffer_type_t));
+    galloc->bufts = (ggml_backend_buffer_type_t *) ggml_calloc(n_bufs, sizeof(ggml_backend_buffer_type_t));
     GGML_ASSERT(galloc->bufts != NULL);
 
-    galloc->buffers = ggml_calloc(n_bufs, sizeof(struct vbuffer *));
+    galloc->buffers = (struct vbuffer **) ggml_calloc(n_bufs, sizeof(struct vbuffer *));
     GGML_ASSERT(galloc->buffers != NULL);
 
-    galloc->buf_tallocs = ggml_calloc(n_bufs, sizeof(struct ggml_dyn_tallocr *));
+    galloc->buf_tallocs = (struct ggml_dyn_tallocr **) ggml_calloc(n_bufs, sizeof(struct ggml_dyn_tallocr *));
     GGML_ASSERT(galloc->buf_tallocs != NULL);
 
     for (int i = 0; i < n_bufs; i++) {
@@ -833,7 +833,7 @@ static bool ggml_gallocr_reserve_n_impl(
         GGML_ASSERT(galloc->hash_set.keys != NULL);
 
         ggml_raw_free(galloc->hash_values);
-        galloc->hash_values = ggml_malloc(sizeof(struct hash_node) * galloc->hash_set.size);
+        galloc->hash_values = (struct hash_node *) ggml_malloc(sizeof(struct hash_node) * galloc->hash_set.size);
         GGML_ASSERT(galloc->hash_values != NULL);
     }
 
@@ -848,7 +848,7 @@ static bool ggml_gallocr_reserve_n_impl(
     // set the node_allocs from the hash table
     if (galloc->n_nodes < graph->n_nodes) {
         ggml_raw_free(galloc->node_allocs);
-        galloc->node_allocs = ggml_calloc(graph->n_nodes, sizeof(struct node_alloc));
+        galloc->node_allocs = (struct node_alloc *) ggml_calloc(graph->n_nodes, sizeof(struct node_alloc));
         GGML_ASSERT(galloc->node_allocs != NULL);
     }
     galloc->n_nodes = graph->n_nodes;
@@ -881,7 +881,7 @@ static bool ggml_gallocr_reserve_n_impl(
     }
     if (galloc->n_leafs < graph->n_leafs) {
         ggml_raw_free(galloc->leaf_allocs);
-        galloc->leaf_allocs = ggml_calloc(graph->n_leafs, sizeof(galloc->leaf_allocs[0]));
+        galloc->leaf_allocs = (struct leaf_alloc *) ggml_calloc(graph->n_leafs, sizeof(galloc->leaf_allocs[0]));
         GGML_ASSERT(galloc->leaf_allocs != NULL);
     }
     galloc->n_leafs = graph->n_leafs;
@@ -1134,7 +1134,7 @@ static bool alloc_tensor_range(struct ggml_context * ctx,
         return false;
     }
 
-    *buffers = ggml_realloc(*buffers, sizeof(ggml_backend_buffer_t) * (*n_buffers + 1));
+    *buffers = (ggml_backend_buffer_t *) ggml_realloc(*buffers, sizeof(ggml_backend_buffer_t) * (*n_buffers + 1));
     (*buffers)[(*n_buffers)++] = buffer;
 
     struct ggml_tallocr tallocr = ggml_tallocr_new(buffer);

external/whispercpp/ggml-cpu.cpp

@@ -372,7 +372,7 @@ struct ggml_state {
     struct ggml_numa_nodes numa;
 };
 
-static struct ggml_state g_state = {0};
+static struct ggml_state g_state {};
 
 void ggml_barrier(struct ggml_threadpool * tp) {
     int n_threads = atomic_load_explicit(&tp->n_graph, memory_order_relaxed) & GGML_THREADPOOL_N_THREADS_MASK;
@@ -572,7 +572,7 @@ struct ggml_tensor * ggml_set_i32 (struct ggml_tensor * tensor, int32_t value) {
     const int nc    = tensor->ne[0];
     const size_t n1 = tensor->nb[1];
 
-    char * const data = tensor->data;
+    char * const data = (char *) tensor->data;
 
     switch (tensor->type) {
         case GGML_TYPE_I8:
@@ -631,7 +631,7 @@ struct ggml_tensor * ggml_set_f32(struct ggml_tensor * tensor, float value) {
     const int nc    = tensor->ne[0];
     const size_t n1 = tensor->nb[1];
 
-    char * const data = tensor->data;
+    char * const data = (char *) tensor->data;
 
     switch (tensor->type) {
         case GGML_TYPE_I8:
@@ -1116,7 +1116,7 @@ UseGgmlGemm1:;
 #endif
 
     if (src1->type != vec_dot_type) {
-        char * wdata = params->wdata;
+        char * wdata = (char *) params->wdata;
 
         const size_t nbw0 = ggml_type_size(vec_dot_type);
         const size_t nbw1 = ggml_row_size(vec_dot_type, ne10);
@@ -1368,18 +1368,18 @@ static void ggml_compute_forward_mul_mat_id(
     }
 
     int64_t * matrix_row_counts = // [n_as]
-        incr_ptr_aligned(&wdata_cur, n_as*sizeof(int64_t), sizeof(int64_t));
+        (int64_t *) incr_ptr_aligned(&wdata_cur, n_as*sizeof(int64_t), sizeof(int64_t));
 
     struct mmid_row_mapping * matrix_rows = // [n_as][ids->ne[0]*ids->ne[1]]
-        incr_ptr_aligned(&wdata_cur, n_as*ids->ne[0]*ids->ne[1]*sizeof(struct mmid_row_mapping), sizeof(int64_t));
+        (struct mmid_row_mapping *) incr_ptr_aligned(&wdata_cur, n_as*ids->ne[0]*ids->ne[1]*sizeof(struct mmid_row_mapping), sizeof(int64_t));
 
     char (*atomic_current_chunk)[CACHE_LINE_SIZE] = // [n_as]
-        incr_ptr_aligned(&wdata_cur, CACHE_LINE_SIZE * n_as, CACHE_LINE_SIZE);
+        (char (*)[CACHE_LINE_SIZE]) incr_ptr_aligned(&wdata_cur, CACHE_LINE_SIZE * n_as, CACHE_LINE_SIZE);
 
     GGML_ASSERT(params->wsize >= (size_t)((char *) wdata_cur - (char *) params->wdata));
 
     if (src1->type != vec_dot_type) {
-        char * wdata = params->wdata;
+        char * wdata = (char *) params->wdata;
 
         const size_t nbw0 = ggml_type_size(vec_dot_type);
         const size_t nbw1 = ggml_row_size(vec_dot_type, ne10);
@@ -1426,7 +1426,7 @@ static void ggml_compute_forward_mul_mat_id(
 
                 assert(i02 >= 0 && i02 < n_as);
 
-                MMID_MATRIX_ROW(i02, matrix_row_counts[i02]) = (struct mmid_row_mapping) {id, iid1};
+                MMID_MATRIX_ROW(i02, matrix_row_counts[i02]) = (struct mmid_row_mapping) {id, (int32_t) iid1};
                 matrix_row_counts[i02] += 1;
             }
         }
@@ -2767,7 +2767,7 @@ static thread_ret_t ggml_graph_compute_thread(void * data) {
 
     struct ggml_compute_params params = {
         /*.ith        =*/ state->ith,
-        /*.nth        =*/ atomic_load_explicit(&tp->n_graph, memory_order_relaxed) & GGML_THREADPOOL_N_THREADS_MASK,
+        /*.nth        =*/ (int) (atomic_load_explicit(&tp->n_graph, memory_order_relaxed) & GGML_THREADPOOL_N_THREADS_MASK),
         /*.wsize      =*/ cplan->work_size,
         /*.wdata      =*/ cplan->work_data,
         /*.threadpool =*/ tp,
@@ -2960,7 +2960,7 @@ static struct ggml_threadpool * ggml_threadpool_new_impl(
                 struct ggml_cplan * cplan) {
 
     struct ggml_threadpool * threadpool =
-        ggml_aligned_malloc(sizeof(struct ggml_threadpool));
+        (struct ggml_threadpool *) ggml_aligned_malloc(sizeof(struct ggml_threadpool));
     {
         threadpool->cgraph           = cgraph;
         threadpool->cplan            = cplan;
@@ -2980,7 +2980,7 @@ static struct ggml_threadpool * ggml_threadpool_new_impl(
 
     // Allocate and init workers state
     const size_t workers_size = sizeof(struct ggml_compute_state) * tpp->n_threads;
-    struct ggml_compute_state * workers = ggml_aligned_malloc(workers_size);
+    struct ggml_compute_state * workers = (struct ggml_compute_state *) ggml_aligned_malloc(workers_size);
 
     memset(workers, 0, workers_size);
     for (int j = 0; j < tpp->n_threads; j++) {
@@ -3512,7 +3512,7 @@ void ggml_cpu_init(void) {
                 union {
                     uint16_t u16;
                     ggml_fp16_t fp16;
-                } u = {i};
+                } u = { (uint16_t) i };
                 float f = GGML_COMPUTE_FP16_TO_FP32(u.fp16);
                 ggml_table_f32_f16[i] = f;
                 ggml_table_gelu_f16[i] = GGML_CPU_FP32_TO_FP16(ggml_gelu_f32(f));