Rewrite Opus writer to use libopus instead of libopusenc

Per maintainer request, replaced libopusenc dependency with libopus.
The implementation now manually handles OGG muxing using libogg,
similar to the existing Vorbis writer.

Co-authored-by: arkq <6979798+arkq@users.noreply.github.com>

Author: Copilot

CMakeLists.txt

@@ -85,7 +85,7 @@ if(ENABLE_VORBIS)
 endif()
 
 if(ENABLE_OPUS)
-	pkg_check_modules(Opus REQUIRED IMPORTED_TARGET libopusenc ogg)
+	pkg_check_modules(Opus REQUIRED IMPORTED_TARGET opus ogg)
 	target_sources(svarcore PRIVATE src/writer-opus.c)
 	target_link_libraries(svarcore PkgConfig::Opus)
 endif()

src/writer-opus.c

@@ -12,51 +12,196 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <time.h>
 
-#include <opusenc.h>
+#include <ogg/ogg.h>
+#include <opus/opus.h>
 
 #include "log.h"
 #include "pcm.h"
 #include "writer.h"
 
+/* Opus frame size in milliseconds (20ms is recommended) */
+#define OPUS_FRAME_MS 20
+
 struct writer_opus {
-	OggOpusEnc * enc;
-	OggOpusComments * comments;
-	char * pathname;
-	int bitrate_min;
-	int bitrate_max;
+	ogg_stream_state ogg_s;
+	OpusEncoder * enc;
+	FILE * fp;
 	unsigned int channels;
 	unsigned int sampling;
+	int bitrate;
+	/* Buffer for Opus encoding */
+	int16_t * pcm_buffer;
+	size_t pcm_buffer_size;  /* in frames */
+	size_t pcm_buffer_used;  /* in frames */
+	/* Packet number for granulepos calculation */
+	int64_t packet_count;
+	int64_t granule_pos;
+	/* Comment string */
+	char * comment;
 };
 
+/* Create OpusHead header packet according to RFC 7845 */
+static int create_opus_header(unsigned char * header, unsigned int channels, unsigned int sampling) {
+	memset(header, 0, 19);
+	memcpy(header, "OpusHead", 8);
+	header[8] = 1; /* Version */
+	header[9] = channels;
+	/* Pre-skip: number of samples at 48kHz to discard from start */
+	uint16_t preskip = 0;
+	header[10] = preskip & 0xFF;
+	header[11] = (preskip >> 8) & 0xFF;
+	/* Input sample rate */
+	header[12] = sampling & 0xFF;
+	header[13] = (sampling >> 8) & 0xFF;
+	header[14] = (sampling >> 16) & 0xFF;
+	header[15] = (sampling >> 24) & 0xFF;
+	/* Output gain in dB (Q7.8 format) */
+	uint16_t gain = 0;
+	header[16] = gain & 0xFF;
+	header[17] = (gain >> 8) & 0xFF;
+	/* Channel mapping family */
+	header[18] = 0; /* 0 = mono/stereo */
+	return 19;
+}
+
+/* Create OpusTags header packet */
+static int create_opus_tags(unsigned char ** tags, const char * comment) {
+	const char * vendor = "libopus";
+	uint32_t vendor_len = strlen(vendor);
+	uint32_t comment_len = comment ? strlen("ENCODER=") + strlen(comment) : 0;
+	uint32_t user_comment_count = comment ? 1 : 0;
+	
+	/* Calculate total size */
+	size_t total_size = 8 + 4 + vendor_len + 4; /* "OpusTags" + vendor_len + vendor + count */
+	if (comment)
+		total_size += 4 + comment_len; /* comment_len + comment */
+	
+	*tags = malloc(total_size);
+	if (*tags == NULL)
+		return -1;
+	
+	unsigned char * p = *tags;
+	memcpy(p, "OpusTags", 8);
+	p += 8;
+	
+	/* Vendor string length (little-endian) */
+	memcpy(p, &vendor_len, 4);
+	p += 4;
+	
+	/* Vendor string */
+	memcpy(p, vendor, vendor_len);
+	p += vendor_len;
+	
+	/* User comment list length */
+	memcpy(p, &user_comment_count, 4);
+	p += 4;
+	
+	if (comment) {
+		char * tag;
+		size_t tag_len = 8 + strlen(comment) + 1;
+		if ((tag = malloc(tag_len)) == NULL) {
+			free(*tags);
+			return -1;
+		}
+		snprintf(tag, tag_len, "ENCODER=%s", comment);
+		comment_len = strlen(tag);
+		
+		/* Comment length */
+		memcpy(p, &comment_len, 4);
+		p += 4;
+		
+		/* Comment */
+		memcpy(p, tag, comment_len);
+		p += comment_len;
+		
+		free(tag);
+	}
+	
+	return p - *tags;
+}
+
 static int writer_opus_open(struct writer * writer, const char * pathname) {
 	struct writer_opus * w = writer->w;
 
 	writer->close(writer);
 
-	/* Store the pathname for later use when creating the encoder */
-	free(w->pathname);
-	if ((w->pathname = strdup(pathname)) == NULL)
+	if ((w->fp = fopen(pathname, "w")) == NULL)
 		return -1;
 
+	/* Create Opus encoder */
 	int error;
-	/* Create encoder with file path, comments, sample rate, channels, and family
-	 * Family 0 is used for mono/stereo (up to 2 channels) */
-	int family = w->channels <= 2 ? 0 : 1;
-	w->enc = ope_encoder_create_file(w->pathname, w->comments, w->sampling, w->channels, family, &error);
-	
-	if (w->enc == NULL) {
-		error("Couldn't create Opus encoder: %s", ope_strerror(error));
+	w->enc = opus_encoder_create(48000, w->channels, OPUS_APPLICATION_AUDIO, &error);
+	if (w->enc == NULL || error != OPUS_OK) {
+		error("Couldn't create Opus encoder: %d", error);
+		fclose(w->fp);
+		w->fp = NULL;
 		errno = EINVAL;
 		return -1;
 	}
 
-	/* Set bitrate constraints using encoder control interface */
-	if (w->bitrate_max > 0) {
-		if (ope_encoder_ctl(w->enc, OPUS_SET_BITRATE(w->bitrate_max)) != OPE_OK)
-			warn("Couldn't set Opus max bitrate");
+	/* Set bitrate */
+	if (w->bitrate > 0) {
+		if (opus_encoder_ctl(w->enc, OPUS_SET_BITRATE(w->bitrate)) != OPUS_OK)
+			warn("Couldn't set Opus bitrate");
 	}
 
+	/* Initialize OGG stream */
+	ogg_stream_init(&w->ogg_s, time(NULL));
+
+	/* Create and write OpusHead header */
+	unsigned char header[19];
+	int header_len = create_opus_header(header, w->channels, w->sampling);
+	
+	ogg_packet op;
+	op.packet = header;
+	op.bytes = header_len;
+	op.b_o_s = 1; /* Beginning of stream */
+	op.e_o_s = 0;
+	op.granulepos = 0;
+	op.packetno = 0;
+	
+	ogg_stream_packetin(&w->ogg_s, &op);
+	
+	/* Write header pages */
+	ogg_page og;
+	while (ogg_stream_flush(&w->ogg_s, &og)) {
+		fwrite(og.header, 1, og.header_len, w->fp);
+		fwrite(og.body, 1, og.body_len, w->fp);
+	}
+
+	/* Create and write OpusTags header */
+	unsigned char * tags = NULL;
+	int tags_len = create_opus_tags(&tags, w->comment);
+	if (tags_len < 0) {
+		opus_encoder_destroy(w->enc);
+		w->enc = NULL;
+		ogg_stream_clear(&w->ogg_s);
+		fclose(w->fp);
+		w->fp = NULL;
+		return -1;
+	}
+	
+	op.packet = tags;
+	op.bytes = tags_len;
+	op.b_o_s = 0;
+	op.e_o_s = 0;
+	op.granulepos = 0;
+	op.packetno = 1;
+	
+	ogg_stream_packetin(&w->ogg_s, &op);
+	free(tags);
+	
+	while (ogg_stream_flush(&w->ogg_s, &og)) {
+		fwrite(og.header, 1, og.header_len, w->fp);
+		fwrite(og.body, 1, og.body_len, w->fp);
+	}
+
+	w->packet_count = 2; /* We've written 2 header packets */
+	w->granule_pos = 0;
+	w->pcm_buffer_used = 0;
+
 	writer->opened = true;
 	return 0;
 }
@@ -65,38 +210,112 @@ static void writer_opus_close(struct writer * writer) {
 	struct writer_opus * w = writer->w;
 	writer->opened = false;
 
-	if (w->enc == NULL)
+	if (w->fp == NULL)
 		return;
 
-	/* Finalize the stream */
-	ope_encoder_drain(w->enc);
-	ope_encoder_destroy(w->enc);
-	w->enc = NULL;
+	/* Encode any remaining PCM data */
+	if (w->pcm_buffer_used > 0) {
+		unsigned char packet[4000];
+		int nbBytes = opus_encode(w->enc, w->pcm_buffer, w->pcm_buffer_used, packet, sizeof(packet));
+		
+		if (nbBytes > 0) {
+			/* Calculate granule position (samples at 48kHz) */
+			w->granule_pos += w->pcm_buffer_used * 48000 / w->sampling;
+			
+			ogg_packet op;
+			op.packet = packet;
+			op.bytes = nbBytes;
+			op.b_o_s = 0;
+			op.e_o_s = 1; /* End of stream */
+			op.granulepos = w->granule_pos;
+			op.packetno = w->packet_count++;
+			
+			ogg_stream_packetin(&w->ogg_s, &op);
+		}
+	}
+
+	/* Flush remaining pages */
+	ogg_page og;
+	while (ogg_stream_flush(&w->ogg_s, &og)) {
+		fwrite(og.header, 1, og.header_len, w->fp);
+		fwrite(og.body, 1, og.body_len, w->fp);
+	}
+
+	if (w->enc != NULL) {
+		opus_encoder_destroy(w->enc);
+		w->enc = NULL;
+	}
+	ogg_stream_clear(&w->ogg_s);
+	fclose(w->fp);
+	w->fp = NULL;
 }
 
 static ssize_t writer_opus_write(struct writer * writer, const void * buffer, size_t frames) {
 	struct writer_opus * w = writer->w;
+	const int16_t * pcm = (const int16_t *)buffer;
+	size_t frames_written = 0;
 
-	/* Write 16-bit PCM samples to the encoder */
-	int ret = ope_encoder_write(w->enc, (const opus_int16 *)buffer, frames);
-	
-	if (ret != OPE_OK) {
-		error("Opus encoding error: %s", ope_strerror(ret));
-		return -1;
+	while (frames > 0) {
+		/* Calculate how many frames we can add to buffer */
+		size_t frames_to_copy = w->pcm_buffer_size - w->pcm_buffer_used;
+		if (frames_to_copy > frames)
+			frames_to_copy = frames;
+
+		/* Copy PCM data to buffer */
+		memcpy(w->pcm_buffer + w->pcm_buffer_used * w->channels,
+		       pcm + frames_written * w->channels,
+		       frames_to_copy * w->channels * sizeof(int16_t));
+		
+		w->pcm_buffer_used += frames_to_copy;
+		frames_written += frames_to_copy;
+		frames -= frames_to_copy;
+
+		/* If buffer is full, encode it */
+		if (w->pcm_buffer_used >= w->pcm_buffer_size) {
+			unsigned char packet[4000];
+			int nbBytes = opus_encode(w->enc, w->pcm_buffer, w->pcm_buffer_size, packet, sizeof(packet));
+			
+			if (nbBytes < 0) {
+				error("Opus encoding error: %d", nbBytes);
+				return -1;
+			}
+
+			if (nbBytes > 0) {
+				/* Update granule position (samples at 48kHz) */
+				w->granule_pos += w->pcm_buffer_size * 48000 / w->sampling;
+				
+				ogg_packet op;
+				op.packet = packet;
+				op.bytes = nbBytes;
+				op.b_o_s = 0;
+				op.e_o_s = 0;
+				op.granulepos = w->granule_pos;
+				op.packetno = w->packet_count++;
+				
+				ogg_stream_packetin(&w->ogg_s, &op);
+
+				/* Write out any pages */
+				ogg_page og;
+				while (ogg_stream_pageout(&w->ogg_s, &og)) {
+					fwrite(og.header, 1, og.header_len, w->fp);
+					fwrite(og.body, 1, og.body_len, w->fp);
+				}
+			}
+
+			w->pcm_buffer_used = 0;
+		}
 	}
 
-	/* Return the number of frames written (libopusenc doesn't return byte count) */
-	return frames;
+	return frames_written;
 }
 
 static void writer_opus_free(struct writer * writer) {
 	if (writer == NULL)
 		return;
 	struct writer_opus * w = writer->w;
 	writer->close(writer);
-	if (w->comments != NULL)
-		ope_comments_destroy(w->comments);
-	free(w->pathname);
+	free(w->pcm_buffer);
+	free(w->comment);
 	free(writer->w);
 	free(writer);
 }
@@ -127,30 +346,30 @@ struct writer * writer_opus_new(
 		return NULL;
 	}
 
-	w->bitrate_min = bitrate_min; /* Currently unused - Opus uses single bitrate setting */
-	w->bitrate_max = bitrate_max;
+	w->bitrate = bitrate_max > 0 ? bitrate_max : 64000;
 	w->channels = channels;
 	w->sampling = sampling;
 
-	/* Create comments object */
-	w->comments = ope_comments_create();
-	if (w->comments == NULL) {
-		writer_opus_free(writer);
+	/* Calculate frame size in samples at the input sample rate
+	 * Opus always works at 48kHz internally, so we need to buffer data */
+	w->pcm_buffer_size = (sampling * OPUS_FRAME_MS) / 1000;
+	w->pcm_buffer = malloc(w->pcm_buffer_size * channels * sizeof(int16_t));
+	if (w->pcm_buffer == NULL) {
+		free(writer->w);
+		free(writer);
 		return NULL;
 	}
+	w->pcm_buffer_used = 0;
 
 	if (comment != NULL) {
-		/* Use dynamic allocation to avoid VLA stack overflow issues */
-		size_t tag_len = 8 + strlen(comment) + 1;
-		char *tag = malloc(tag_len);
-		if (tag == NULL) {
+		w->comment = strdup(comment);
+		if (w->comment == NULL) {
 			writer_opus_free(writer);
 			return NULL;
 		}
-		snprintf(tag, tag_len, "ENCODER=%s", comment);
-		ope_comments_add_string(w->comments, tag);
-		free(tag);
 	}
 
+	(void)bitrate_min; /* Unused */
+
 	return writer;
 }