program to record audio data from the microphone More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_protocols.h"
#include "conversation.h"
#include "gnunet_constants.h"
#include "gnunet_core_service.h"
#include <pulse/simple.h>
#include <pulse/error.h>
#include <pulse/rtclock.h>
#include <pulse/pulseaudio.h>
#include <opus/opus.h>
#include <opus/opus_types.h>
#include <ogg/ogg.h>

Include dependency graph for gnunet-helper-audio-record.c:

Data Structures
struct	OpusHeadPacket

struct	OpusCommentsPacket

Macros
#define	DEBUG_RECORD_PURE_OGG 1

#define	SAMPLING_RATE 48000
	Sampling rate. More...

#define	FRAME_SIZE_MS 40
	How many ms of audio to buffer before encoding them. More...

#define	FRAME_SIZE (SAMPLING_RATE / 1000 * FRAME_SIZE_MS)
	How many samples to buffer before encoding them. More...

#define	PAGE_WATERLINE 800
	Pages are committed when their size goes over this value. More...

#define	MAX_PAYLOAD_BYTES 1024
	Maximum length of opus payload. More...

#define	CHANNELS 1
	Number of channels. More...

#define	CONV_OPUS_PACKET_LOSS_PERCENTAGE 1
	Configures the encoder's expected packet loss percentage. More...

#define	CONV_OPUS_ENCODING_COMPLEXITY 10
	Configures the encoder's computational complexity. More...

#define	CONV_OPUS_INBAND_FEC 1
	Configures the encoder's use of inband forward error correction (FEC). More...

#define	CONV_OPUS_SIGNAL OPUS_SIGNAL_VOICE
	Configures the type of signal being encoded. More...

#define	CONV_OPUS_APP_TYPE OPUS_APPLICATION_VOIP
	Coding mode. More...

Functions
static void	quit (int ret)
	Pulseaudio shutdown task. More...

static void	write_data (const char *ptr, size_t msg_size)

static void	write_page (ogg_page *og)

static void	packetizer ()
	Creates OPUS packets from PCM data. More...

static void	stream_read_callback (pa_stream s, size_t length, void userdata)
	Pulseaudio callback when new data is available. More...

static void	exit_signal_callback (pa_mainloop_api m, pa_signal_event e, int sig, void *userdata)
	Exit callback for SIGTERM and SIGINT. More...

static void	stream_state_callback (pa_stream s, void userdata)
	Pulseaudio stream state callback. More...

static void	context_state_callback (pa_context c, void userdata)
	Pulseaudio context state callback. More...

static void	pa_init ()
	Pulsaudio init. More...

static void	opus_init ()
	OPUS init. More...

static void	ogg_init ()

int	main (int argc, char *argv[])
	The main function for the record helper. More...

Variables
static pa_sample_spec	sample_spec
	Specification for recording. More...

static GNUNET_NETWORK_STRUCT_END pa_mainloop_api *	mainloop_api
	Pulseaudio mainloop api. More...

static pa_mainloop *	m
	Pulseaudio mainloop. More...

static pa_context *	context
	Pulseaudio context. More...

static pa_stream *	stream_in
	Pulseaudio recording stream. More...

static pa_io_event *	stdio_event
	Pulseaudio io events. More...

static OpusEncoder *	enc
	OPUS encoder. More...

static unsigned char *	opus_data
	Buffer for encoded data. More...

static float *	pcm_buffer
	PCM data buffer for one OPUS frame. More...

static int	pcm_length
	Length of the pcm data needed for one OPUS frame. More...

static char *	transmit_buffer
	Audio buffer. More...

static size_t	transmit_buffer_length
	Length of audio buffer. More...

static size_t	transmit_buffer_index
	Read index for transmit buffer. More...

static struct AudioMessage *	audio_message
	Audio message skeleton. More...

static ogg_stream_state	os
	Ogg muxer state. More...

static int32_t	packet_id
	Ogg packet id. More...

static int64_t	enc_granulepos
	Ogg granule for current packet. More...

static int	dump_pure_ogg
	1 to not to write GNUnet message headers, producing pure playable ogg output More...

Detailed Description

program to record audio data from the microphone

Author: Siomon Dieterle; Andreas Fuchs; Christian Grothoff

Definition in file gnunet-helper-audio-record.c.

Macro Definition Documentation

◆ DEBUG_RECORD_PURE_OGG

#define DEBUG_RECORD_PURE_OGG 1

Definition at line 43 of file gnunet-helper-audio-record.c.

◆ SAMPLING_RATE

#define SAMPLING_RATE 48000

Sampling rate.

Definition at line 48 of file gnunet-helper-audio-record.c.

◆ FRAME_SIZE_MS

#define FRAME_SIZE_MS 40

How many ms of audio to buffer before encoding them.

Possible values: 60, 40, 20, 10, 5, 2.5

Definition at line 55 of file gnunet-helper-audio-record.c.

◆ FRAME_SIZE

#define FRAME_SIZE (SAMPLING_RATE / 1000 * FRAME_SIZE_MS)

How many samples to buffer before encoding them.

Definition at line 60 of file gnunet-helper-audio-record.c.

◆ PAGE_WATERLINE

#define PAGE_WATERLINE 800

Pages are committed when their size goes over this value.

Note that in practice we flush pages VERY often (every frame), which means that pages NEVER really get to be this big. With one-packet-per-page, pages are roughly 100-300 bytes each.

This value is chosen to make MAX_PAYLOAD_BYTES=1024 fit into a single page.

Definition at line 71 of file gnunet-helper-audio-record.c.

◆ MAX_PAYLOAD_BYTES

#define MAX_PAYLOAD_BYTES 1024

Maximum length of opus payload.

Definition at line 76 of file gnunet-helper-audio-record.c.

◆ CHANNELS

#define CHANNELS 1

Number of channels.

Definition at line 81 of file gnunet-helper-audio-record.c.

◆ CONV_OPUS_PACKET_LOSS_PERCENTAGE

#define CONV_OPUS_PACKET_LOSS_PERCENTAGE 1

Configures the encoder's expected packet loss percentage.

Higher values will trigger progressively more loss resistant behavior in the encoder at the expense of quality at a given bitrate in the lossless case, but greater quality under loss.

Definition at line 90 of file gnunet-helper-audio-record.c.

◆ CONV_OPUS_ENCODING_COMPLEXITY

#define CONV_OPUS_ENCODING_COMPLEXITY 10

Configures the encoder's computational complexity.

The supported range is 0-10 inclusive with 10 representing the highest complexity.

Definition at line 98 of file gnunet-helper-audio-record.c.

◆ CONV_OPUS_INBAND_FEC

#define CONV_OPUS_INBAND_FEC 1

Configures the encoder's use of inband forward error correction (FEC).

Note: This is only applicable to the LPC layer.

Definition at line 105 of file gnunet-helper-audio-record.c.

◆ CONV_OPUS_SIGNAL

#define CONV_OPUS_SIGNAL OPUS_SIGNAL_VOICE

Configures the type of signal being encoded.

This is a hint which helps the encoder's mode selection.

Possible values: OPUS_AUTO - (default) Encoder detects the type automatically. OPUS_SIGNAL_VOICE - Bias thresholds towards choosing LPC or Hybrid modes. OPUS_SIGNAL_MUSIC - Bias thresholds towards choosing MDCT modes.

Definition at line 117 of file gnunet-helper-audio-record.c.

◆ CONV_OPUS_APP_TYPE

#define CONV_OPUS_APP_TYPE OPUS_APPLICATION_VOIP

Coding mode.

Possible values: OPUS_APPLICATION_VOIP - gives best quality at a given bitrate for voice signals. It enhances the input signal by high-pass filtering and emphasizing formants and harmonics. Optionally it includes in-band forward error correction to protect against packet loss. Use this mode for typical VoIP applications. Because of the enhancement, even at high bitrates the output may sound different from the input. OPUS_APPLICATION_AUDIO - gives best quality at a given bitrate for most non-voice signals like music. Use this mode for music and mixed (music/voice) content, broadcast, and applications requiring less than 15 ms of coding delay. OPUS_APPLICATION_RESTRICTED_LOWDELAY - configures low-delay mode that disables the speech-optimized mode in exchange for slightly reduced delay. This mode can only be set on an newly initialized or freshly reset encoder because it changes the codec delay.

Definition at line 138 of file gnunet-helper-audio-record.c.

Function Documentation

◆ quit()

static void quit ( int ret )

static

Pulseaudio shutdown task.

Definition at line 270 of file gnunet-helper-audio-record.c.

 {
   mainloop_api->quit (mainloop_api,
                       ret);
   exit (ret);
 }

References mainloop_api, and ret.

Referenced by context_state_callback(), exit_signal_callback(), packetizer(), stream_read_callback(), stream_state_callback(), and write_data().

Here is the caller graph for this function:

◆ write_data()

static void write_data	(	const char *	ptr,
		size_t	msg_size
	)

static

Definition at line 279 of file gnunet-helper-audio-record.c.

 {
   ssize_t ret;
   size_t off;
  
   off = 0;
   while (off < msg_size)
   {
     ret = write (STDOUT_FILENO,
                  &ptr[off],
                  msg_size - off);
     if (0 >= ret)
     {
       if (-1 == ret)
         GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
                              "write");
       quit (2);
     }
     off += ret;
   }
 }

References GNUNET_ERROR_TYPE_ERROR, GNUNET_log_strerror, quit(), and ret.

Referenced by write_page().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ write_page()

static void write_page ( ogg_page * og )

static

Definition at line 304 of file gnunet-helper-audio-record.c.

 {
   static unsigned long long toff;
   size_t msg_size;
  
   msg_size = sizeof(struct AudioMessage) + og->header_len + og->body_len;
   audio_message->header.size = htons ((uint16_t) msg_size);
   GNUNET_memcpy (&audio_message[1], og->header, og->header_len);
   GNUNET_memcpy (((char *) &audio_message[1]) + og->header_len, og->body,
                  og->body_len);
  
   toff += msg_size;
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Sending %u bytes of audio data (total: %llu)\n",
               (unsigned int) msg_size,
               toff);
 #ifdef DEBUG_RECORD_PURE_OGG
   if (dump_pure_ogg)
     write_data ((const char *) &audio_message[1],
                 og->header_len + og->body_len);
   else
 #endif
   write_data ((const char *) audio_message,
               msg_size);
 }

References audio_message, dump_pure_ogg, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_memcpy, AudioMessage::header, GNUNET_MessageHeader::size, and write_data().

Referenced by ogg_init(), and packetizer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ packetizer()

static void packetizer ( )

static

Creates OPUS packets from PCM data.

Definition at line 335 of file gnunet-helper-audio-record.c.

 {
   char *nbuf;
   size_t new_size;
   int32_t len;
   ogg_packet op;
   ogg_page og;
  
   while (transmit_buffer_length >= transmit_buffer_index + pcm_length)
   {
     GNUNET_memcpy (pcm_buffer,
                    &transmit_buffer[transmit_buffer_index],
                    pcm_length);
     transmit_buffer_index += pcm_length;
     len =
       opus_encode_float (enc, pcm_buffer, FRAME_SIZE, opus_data,
                          MAX_PAYLOAD_BYTES);
  
     if (len < 0)
     {
       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                   _ ("opus_encode_float() failed: %s. Aborting\n"),
                   opus_strerror (len));
       quit (5);
     }
     if (((uint32_t) len) > UINT16_MAX - sizeof(struct AudioMessage))
     {
       GNUNET_break (0);
       continue;
     }
  
     /* As per OggOpus spec, granule is calculated as if the audio
        had 48kHz sampling rate. */
     enc_granulepos += FRAME_SIZE * 48000 / SAMPLING_RATE;
  
     op.packet = (unsigned char *) opus_data;
     op.bytes = len;
     op.b_o_s = 0;
     op.e_o_s = 0;
     op.granulepos = enc_granulepos;
     op.packetno = packet_id++;
     ogg_stream_packetin (&os, &op);
  
     while (ogg_stream_flush_fill (&os, &og, PAGE_WATERLINE))
     {
       if (((unsigned long long) og.header_len)
           + ((unsigned long long) og.body_len) >
           UINT16_MAX - sizeof(struct AudioMessage))
       {
         GNUNET_assert (0);
         continue;
       }
       write_page (&og);
     }
   }
  
   new_size = transmit_buffer_length - transmit_buffer_index;
   if (0 != new_size)
   {
     nbuf = pa_xmalloc (new_size);
     memmove (nbuf,
              &transmit_buffer[transmit_buffer_index],
              new_size);
     pa_xfree (transmit_buffer);
     transmit_buffer = nbuf;
   }
   else
   {
     pa_xfree (transmit_buffer);
     transmit_buffer = NULL;
   }
   transmit_buffer_index = 0;
   transmit_buffer_length = new_size;
 }

References _, enc, enc_granulepos, FRAME_SIZE, GNUNET_assert, GNUNET_break, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_memcpy, len, MAX_PAYLOAD_BYTES, op, opus_data, os, packet_id, PAGE_WATERLINE, pcm_buffer, pcm_length, quit(), SAMPLING_RATE, transmit_buffer, transmit_buffer_index, transmit_buffer_length, and write_page().

Referenced by stream_read_callback().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ stream_read_callback()

static void stream_read_callback	(	pa_stream *	s,
		size_t	length,
		void *	userdata
	)

static

Pulseaudio callback when new data is available.

Definition at line 415 of file gnunet-helper-audio-record.c.

 {
   const void *data;
  
   (void) userdata;
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Got %u/%d bytes of PCM data\n",
               (unsigned int) length,
               pcm_length);
  
   GNUNET_assert (NULL != s);
   GNUNET_assert (length > 0);
   if (stdio_event)
     mainloop_api->io_enable (stdio_event, PA_IO_EVENT_OUTPUT);
  
   if (pa_stream_peek (s, (const void **) &data, &length) < 0)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 _ ("pa_stream_peek() failed: %s\n"),
                 pa_strerror (pa_context_errno (context)));
     quit (1);
     return;
   }
   GNUNET_assert (NULL != data);
   GNUNET_assert (length > 0);
   if (NULL != transmit_buffer)
   {
     transmit_buffer = pa_xrealloc (transmit_buffer,
                                    transmit_buffer_length + length);
     GNUNET_memcpy (&transmit_buffer[transmit_buffer_length],
                    data,
                    length);
     transmit_buffer_length += length;
   }
   else
   {
     transmit_buffer = pa_xmalloc (length);
     GNUNET_memcpy (transmit_buffer, data, length);
     transmit_buffer_length = length;
     transmit_buffer_index = 0;
   }
   pa_stream_drop (s);
   packetizer ();
 }

References _, context, data, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_memcpy, mainloop_api, packetizer(), pcm_length, quit(), stdio_event, transmit_buffer, transmit_buffer_index, and transmit_buffer_length.

Referenced by context_state_callback().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ exit_signal_callback()

static void exit_signal_callback	(	pa_mainloop_api *	m,
		pa_signal_event *	e,
		int	sig,
		void *	userdata
	)

static

Exit callback for SIGTERM and SIGINT.

Definition at line 467 of file gnunet-helper-audio-record.c.

 {
   (void) m;
   (void) e;
   (void) sig;
   (void) userdata;
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
               _ ("Got signal, exiting.\n"));
   quit (1);
 }

References _, e, GNUNET_ERROR_TYPE_INFO, GNUNET_log, m, and quit().

Referenced by pa_init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ stream_state_callback()

static void stream_state_callback	(	pa_stream *	s,
		void *	userdata
	)

static

Pulseaudio stream state callback.

Definition at line 486 of file gnunet-helper-audio-record.c.

 {
   (void) userdata;
   GNUNET_assert (NULL != s);
   switch (pa_stream_get_state (s))
   {
   case PA_STREAM_CREATING:
   case PA_STREAM_TERMINATED:
     break;
  
   case PA_STREAM_READY:
     {
       const pa_buffer_attr *a;
       char cmt[PA_CHANNEL_MAP_SNPRINT_MAX];
       char sst[PA_SAMPLE_SPEC_SNPRINT_MAX];
  
       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                   _ ("Stream successfully created.\n"));
  
       if (! (a = pa_stream_get_buffer_attr (s)))
       {
         GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                     _ ("pa_stream_get_buffer_attr() failed: %s\n"),
                     pa_strerror (pa_context_errno
                                    (pa_stream_get_context (s))));
       }
       else
       {
         GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                     _ ("Buffer metrics: maxlength=%u, fragsize=%u\n"),
                     a->maxlength, a->fragsize);
       }
       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                   _ ("Using sample spec '%s', channel map '%s'.\n"),
                   pa_sample_spec_snprint (sst, sizeof(sst),
                                           pa_stream_get_sample_spec (s)),
                   pa_channel_map_snprint (cmt, sizeof(cmt),
                                           pa_stream_get_channel_map (s)));
  
       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                   _ ("Connected to device %s (%u, %ssuspended).\n"),
                   pa_stream_get_device_name (s),
                   pa_stream_get_device_index (s),
                   pa_stream_is_suspended (s) ? "" : "not ");
     }
     break;
  
   case PA_STREAM_FAILED:
   default:
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 _ ("Stream error: %s\n"),
                 pa_strerror (pa_context_errno (pa_stream_get_context (s))));
     quit (1);
   }
 }

References _, GNUNET_assert, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_log, and quit().

Referenced by context_state_callback().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ context_state_callback()

static void context_state_callback	(	pa_context *	c,
		void *	userdata
	)

static

Pulseaudio context state callback.

Definition at line 548 of file gnunet-helper-audio-record.c.

 {
   (void) userdata;
   GNUNET_assert (c);
  
   switch (pa_context_get_state (c))
   {
   case PA_CONTEXT_CONNECTING:
   case PA_CONTEXT_AUTHORIZING:
   case PA_CONTEXT_SETTING_NAME:
     break;
  
   case PA_CONTEXT_READY:
     {
       int r;
       pa_buffer_attr na;
  
       GNUNET_assert (! stream_in);
       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                   _ ("Connection established.\n"));
       if (! (stream_in =
                pa_stream_new (c, "GNUNET_VoIP recorder", &sample_spec, NULL)))
       {
         GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                     _ ("pa_stream_new() failed: %s\n"),
                     pa_strerror (pa_context_errno (c)));
         goto fail;
       }
       pa_stream_set_state_callback (stream_in, &stream_state_callback, NULL);
       pa_stream_set_read_callback (stream_in, &stream_read_callback, NULL);
       memset (&na, 0, sizeof(na));
       na.maxlength = UINT32_MAX;
       na.fragsize = pcm_length;
       if ((r = pa_stream_connect_record (stream_in, NULL, &na,
                                          PA_STREAM_ADJUST_LATENCY)) < 0)
       {
         GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                     _ ("pa_stream_connect_record() failed: %s\n"),
                     pa_strerror (pa_context_errno (c)));
         goto fail;
       }
  
       break;
     }
  
   case PA_CONTEXT_TERMINATED:
     quit (0);
     break;
  
   case PA_CONTEXT_FAILED:
   default:
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 _ ("Connection failure: %s\n"),
                 pa_strerror (pa_context_errno (c)));
     goto fail;
   }
   return;
  
 fail:
   quit (1);
 }

References _, GNUNET_assert, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_log, pcm_length, quit(), sample_spec, stream_in, stream_read_callback(), and stream_state_callback().

Referenced by pa_init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ pa_init()

static void pa_init ( )

static

Pulsaudio init.

Definition at line 616 of file gnunet-helper-audio-record.c.

 {
   int r;
   int i;
  
   if (! pa_sample_spec_valid (&sample_spec))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 _ ("Wrong Spec\n"));
   }
   /* set up main record loop */
   if (! (m = pa_mainloop_new ()))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 _ ("pa_mainloop_new() failed.\n"));
   }
   mainloop_api = pa_mainloop_get_api (m);
  
   /* listen to signals */
   r = pa_signal_init (mainloop_api);
   GNUNET_assert (r == 0);
   pa_signal_new (SIGINT, &exit_signal_callback, NULL);
   pa_signal_new (SIGTERM, &exit_signal_callback, NULL);
  
   /* connect to the main pulseaudio context */
  
   if (! (context = pa_context_new (mainloop_api, "GNUNET VoIP")))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 _ ("pa_context_new() failed.\n"));
   }
   pa_context_set_state_callback (context, &context_state_callback, NULL);
   if (pa_context_connect (context, NULL, 0, NULL) < 0)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 _ ("pa_context_connect() failed: %s\n"),
                 pa_strerror (pa_context_errno (context)));
   }
   if (pa_mainloop_run (m, &i) < 0)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 _ ("pa_mainloop_run() failed.\n"));
   }
 }

References _, context, context_state_callback(), exit_signal_callback(), GNUNET_assert, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, m, mainloop_api, and sample_spec.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ opus_init()

static void opus_init ( )

static

OPUS init.

Definition at line 666 of file gnunet-helper-audio-record.c.

 {
   int err;
  
   pcm_length = FRAME_SIZE * CHANNELS * sizeof(float);
   pcm_buffer = pa_xmalloc (pcm_length);
   opus_data = GNUNET_malloc (MAX_PAYLOAD_BYTES);
   enc = opus_encoder_create (SAMPLING_RATE,
                              CHANNELS,
                              CONV_OPUS_APP_TYPE,
                              &err);
   opus_encoder_ctl (enc,
                     OPUS_SET_PACKET_LOSS_PERC (
                       CONV_OPUS_PACKET_LOSS_PERCENTAGE));
   opus_encoder_ctl (enc,
                     OPUS_SET_COMPLEXITY (CONV_OPUS_ENCODING_COMPLEXITY));
   opus_encoder_ctl (enc,
                     OPUS_SET_INBAND_FEC (CONV_OPUS_INBAND_FEC));
   opus_encoder_ctl (enc,
                     OPUS_SET_SIGNAL (CONV_OPUS_SIGNAL));
 }

References CHANNELS, CONV_OPUS_APP_TYPE, CONV_OPUS_ENCODING_COMPLEXITY, CONV_OPUS_INBAND_FEC, CONV_OPUS_PACKET_LOSS_PERCENTAGE, CONV_OPUS_SIGNAL, enc, FRAME_SIZE, GNUNET_malloc, MAX_PAYLOAD_BYTES, opus_data, pcm_buffer, pcm_length, and SAMPLING_RATE.

Referenced by main().

Here is the caller graph for this function:

◆ ogg_init()

static void ogg_init ( )

static

Definition at line 690 of file gnunet-helper-audio-record.c.

 {
   int serialno;
   struct OpusHeadPacket headpacket;
   struct OpusCommentsPacket *commentspacket;
   size_t commentspacket_len;
  
   serialno = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_STRONG,
                                        0x7FFFFFFF);
   /*Initialize Ogg stream struct*/
   if (-1 == ogg_stream_init (&os, serialno))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 _ ("ogg_stream_init() failed.\n"));
     exit (3);
   }
  
   packet_id = 0;
  
   /*Write header*/
   {
     ogg_packet op;
     ogg_page og;
     const char *opusver;
     int vendor_length;
  
     GNUNET_memcpy (headpacket.magic, "OpusHead", 8);
     headpacket.version = 1;
     headpacket.channels = CHANNELS;
     headpacket.preskip = GNUNET_htole16 (0);
     headpacket.sampling_rate = GNUNET_htole32 (SAMPLING_RATE);
     headpacket.gain = GNUNET_htole16 (0);
     headpacket.channel_mapping = 0; /* Mono or stereo */
  
     op.packet = (unsigned char *) &headpacket;
     op.bytes = sizeof(headpacket);
     op.b_o_s = 1;
     op.e_o_s = 0;
     op.granulepos = 0;
     op.packetno = packet_id++;
     ogg_stream_packetin (&os, &op);
  
     /* Head packet must be alone on its page */
     while (ogg_stream_flush (&os, &og))
     {
       write_page (&og);
     }
  
     commentspacket_len = sizeof(*commentspacket);
     opusver = opus_get_version_string ();
     vendor_length = strlen (opusver);
     commentspacket_len += vendor_length;
     commentspacket_len += sizeof(uint32_t);
  
     commentspacket = (struct OpusCommentsPacket *) malloc (commentspacket_len);
     if (NULL == commentspacket)
     {
       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                   _ ("Failed to allocate %u bytes for second packet\n"),
                   (unsigned int) commentspacket_len);
       exit (5);
     }
  
     GNUNET_memcpy (commentspacket->magic, "OpusTags", 8);
     commentspacket->vendor_length = GNUNET_htole32 (vendor_length);
     GNUNET_memcpy (&commentspacket[1], opusver, vendor_length);
     *(uint32_t *) &((char *) &commentspacket[1])[vendor_length] = \
       GNUNET_htole32 (0);    /* no tags */
  
     op.packet = (unsigned char *) commentspacket;
     op.bytes = commentspacket_len;
     op.b_o_s = 0;
     op.e_o_s = 0;
     op.granulepos = 0;
     op.packetno = packet_id++;
     ogg_stream_packetin (&os, &op);
  
     /* Comment packets must not be mixed with audio packets on their pages */
     while (ogg_stream_flush (&os, &og))
     {
       write_page (&og);
     }
  
     free (commentspacket);
   }
 }

References _, OpusHeadPacket::channel_mapping, OpusHeadPacket::channels, CHANNELS, OpusHeadPacket::gain, GNUNET_CRYPTO_QUALITY_STRONG, GNUNET_CRYPTO_random_u32(), GNUNET_ERROR_TYPE_ERROR, GNUNET_htole16, GNUNET_htole32, GNUNET_log, GNUNET_memcpy, OpusHeadPacket::magic, OpusCommentsPacket::magic, op, os, packet_id, OpusHeadPacket::preskip, OpusHeadPacket::sampling_rate, SAMPLING_RATE, OpusCommentsPacket::vendor_length, OpusHeadPacket::version, and write_page().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ main()

int main	(	int	argc,
		char *	argv[]
	)

The main function for the record helper.

Parameters

argc	number of arguments from the command line
argv	command line arguments

Returns: 0 ok, 1 on error

Definition at line 786 of file gnunet-helper-audio-record.c.

 {
   (void) argc;
   (void) argv;
   GNUNET_assert (GNUNET_OK ==
                  GNUNET_log_setup ("gnunet-helper-audio-record",
                                    "WARNING",
                                    NULL));
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Audio source starts\n");
   audio_message = GNUNET_malloc (UINT16_MAX);
   audio_message->header.type = htons (GNUNET_MESSAGE_TYPE_CONVERSATION_AUDIO);
  
 #ifdef DEBUG_RECORD_PURE_OGG
   dump_pure_ogg = getenv ("GNUNET_RECORD_PURE_OGG") ? 1 : 0;
 #endif
   ogg_init ();
   opus_init ();
   pa_init ();
   return 0;
 }

References audio_message, dump_pure_ogg, getenv(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_log_setup(), GNUNET_malloc, GNUNET_MESSAGE_TYPE_CONVERSATION_AUDIO, GNUNET_OK, AudioMessage::header, ogg_init(), opus_init(), pa_init(), and GNUNET_MessageHeader::type.

Here is the call graph for this function:

Variable Documentation

◆ sample_spec

pa_sample_spec sample_spec

static

Initial value:

= {
  .format = PA_SAMPLE_FLOAT32LE,
  .rate =  48000 ,
  .channels =  1 
}

Specification for recording.

May change in the future to spec negotiation.

Definition at line 143 of file gnunet-helper-audio-record.c.

Referenced by context_state_callback(), and pa_init().

◆ mainloop_api

GNUNET_NETWORK_STRUCT_END pa_mainloop_api* mainloop_api

static

Pulseaudio mainloop api.

Definition at line 181 of file gnunet-helper-audio-record.c.

Referenced by pa_init(), quit(), and stream_read_callback().

◆ m

pa_mainloop* m

static

Pulseaudio mainloop.

Definition at line 186 of file gnunet-helper-audio-record.c.

Referenced by exit_signal_callback(), and pa_init().

◆ context

pa_context* context

static

Pulseaudio context.

Definition at line 191 of file gnunet-helper-audio-record.c.

Referenced by pa_init(), and stream_read_callback().

◆ stream_in

pa_stream* stream_in

static

Pulseaudio recording stream.

Definition at line 196 of file gnunet-helper-audio-record.c.

Referenced by context_state_callback().

◆ stdio_event

pa_io_event* stdio_event

static

Pulseaudio io events.

Definition at line 201 of file gnunet-helper-audio-record.c.

Referenced by stream_read_callback().

◆ enc

OpusEncoder* enc

static

OPUS encoder.

Definition at line 206 of file gnunet-helper-audio-record.c.

Referenced by encrypt_existing_match(), get_update_information_directory(), GNUNET_FS_tree_encoder_next(), GNUNET_STRINGS_base64url_encode(), opus_init(), packetizer(), and try_match_block().

◆ opus_data

unsigned char* opus_data

static

Buffer for encoded data.

Definition at line 211 of file gnunet-helper-audio-record.c.

Referenced by opus_init(), and packetizer().

◆ pcm_buffer

float* pcm_buffer

static

PCM data buffer for one OPUS frame.

Definition at line 216 of file gnunet-helper-audio-record.c.

Referenced by opus_init(), and packetizer().

◆ pcm_length

int pcm_length

static

Length of the pcm data needed for one OPUS frame.

Definition at line 221 of file gnunet-helper-audio-record.c.

Referenced by context_state_callback(), opus_init(), packetizer(), and stream_read_callback().

◆ transmit_buffer

char* transmit_buffer

static

Audio buffer.

Definition at line 226 of file gnunet-helper-audio-record.c.

Referenced by packetizer(), and stream_read_callback().

◆ transmit_buffer_length

size_t transmit_buffer_length

static

Length of audio buffer.

Definition at line 231 of file gnunet-helper-audio-record.c.

Referenced by packetizer(), and stream_read_callback().

◆ transmit_buffer_index

size_t transmit_buffer_index

static

Read index for transmit buffer.

Definition at line 236 of file gnunet-helper-audio-record.c.

Referenced by packetizer(), and stream_read_callback().

◆ audio_message

struct AudioMessage* audio_message

static

Audio message skeleton.

Definition at line 241 of file gnunet-helper-audio-record.c.

Referenced by main(), and write_page().

◆ os

ogg_stream_state os

static

Ogg muxer state.

Definition at line 246 of file gnunet-helper-audio-record.c.

Referenced by ogg_init(), and packetizer().

◆ packet_id

int32_t packet_id

static

Ogg packet id.

Definition at line 251 of file gnunet-helper-audio-record.c.

Referenced by ogg_init(), and packetizer().

◆ enc_granulepos

int64_t enc_granulepos

static

Ogg granule for current packet.

Definition at line 256 of file gnunet-helper-audio-record.c.

Referenced by packetizer().

◆ dump_pure_ogg

int dump_pure_ogg

static

1 to not to write GNUnet message headers, producing pure playable ogg output

Definition at line 263 of file gnunet-helper-audio-record.c.

Referenced by main(), and write_page().

Data Structures

Macros

Functions

Variables

Detailed Description

Macro Definition Documentation

◆ DEBUG_RECORD_PURE_OGG

◆ SAMPLING_RATE

◆ FRAME_SIZE_MS

◆ FRAME_SIZE

◆ PAGE_WATERLINE

◆ MAX_PAYLOAD_BYTES

◆ CHANNELS

◆ CONV_OPUS_PACKET_LOSS_PERCENTAGE

◆ CONV_OPUS_ENCODING_COMPLEXITY

◆ CONV_OPUS_INBAND_FEC

◆ CONV_OPUS_SIGNAL

◆ CONV_OPUS_APP_TYPE

Function Documentation

◆ quit()

◆ write_data()

◆ write_page()

◆ packetizer()

◆ stream_read_callback()

◆ exit_signal_callback()

◆ stream_state_callback()

◆ context_state_callback()

◆ pa_init()

◆ opus_init()

◆ ogg_init()

◆ main()

Variable Documentation

◆ sample_spec

◆ mainloop_api

◆ m

◆ context

◆ stream_in

◆ stdio_event

◆ enc

◆ opus_data

◆ pcm_buffer

◆ pcm_length

◆ transmit_buffer

◆ transmit_buffer_length

◆ transmit_buffer_index

◆ audio_message

◆ os

◆ packet_id

◆ enc_granulepos

◆ dump_pure_ogg