gnunet-helper-audio-playback.c File Reference

program to playback audio data to the speaker 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-playback.c:

Go to the source code of this file.

Data Structures
struct	OpusHeadPacket

Macros
#define	DEBUG_READ_PURE_OGG   1
#define	DEBUG_DUMP_DECODED_OGG   1
#define	MAXLINE   4096
#define	SAMPLING_RATE   48000
#define	CHANNELS   1
#define	MAX_FRAME_SIZE   (960 * 6)
#define	fminf(_x, _y)   ((_x) < (_y) ? (_x) : (_y))
#define	fmaxf(_x, _y)   ((_x) > (_y) ? (_x) : (_y))
#define	float2int(flt)   ((int) (floor (.5 + flt)))

Functions
static GNUNET_NETWORK_STRUCT_END OpusDecoder *	process_header (ogg_packet *op)
	Process an Opus header and setup the opus decoder based on it. More...
static size_t	fwrite_le32 (opus_int32 i32, FILE *file)
static size_t	fwrite_le16 (int i16, FILE *file)
static int	write_wav_header ()
static int64_t	audio_write (int64_t maxout)
static void	quit (int ret)
	Pulseaudio shutdown task. More...
static void	ogg_demux_and_decode ()
static int	stdin_receiver (void *cls, const struct GNUNET_MessageHeader *msg)
	Message callback. More...
static void	stream_write_callback (pa_stream *s, size_t length, void *userdata)
	Callback when data is there for playback. 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	context_state_callback (pa_context *c, void *userdata)
	Pulseaudio stream state callback. More...
static void	pa_init ()
	Pulseaudio initialization. More...
static void	ogg_init ()
static void	drain_callback (pa_stream *s, int success, void *userdata)
int	main (int argc, char *argv[])
	The main function for the playback helper. More...

Variables
static pa_sample_spec	sample_spec
	Pulseaudio specification. More...
static int	dump_to_stdout
static pa_mainloop_api *	mainloop_api
	Pulseaudio mainloop api. More...
static pa_threaded_mainloop *	m
	Pulseaudio threaded mainloop. More...
static pa_context *	context
	Pulseaudio context. More...
static pa_stream *	stream_out
	Pulseaudio output stream. More...
static OpusDecoder *	dec
	OPUS decoder. More...
static float *	pcm_buffer
	PCM data buffer. More...
static int	frame_size
	Number of samples for one frame. More...
static int	ready_pipe [2]
	Pipe we use to signal the main loop that we are ready to receive. More...
static ogg_sync_state	oy
	Ogg I/O state. More...
static ogg_stream_state	os
	Ogg stream state. More...
static int	channels
static int	preskip
static float	gain

Detailed Description

program to playback audio data to the speaker

Author

Siomon Dieterle

Andreas Fuchs

Christian Grothoff

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

Macro Definition Documentation

DEBUG_READ_PURE_OGG

#define DEBUG_READ_PURE_OGG   1

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

DEBUG_DUMP_DECODED_OGG

#define DEBUG_DUMP_DECODED_OGG   1

Definition at line 44 of file gnunet-helper-audio-playback.c.

MAXLINE

#define MAXLINE   4096

Definition at line 46 of file gnunet-helper-audio-playback.c.

SAMPLING_RATE

#define SAMPLING_RATE   48000

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

CHANNELS

#define CHANNELS   1

Definition at line 50 of file gnunet-helper-audio-playback.c.

MAX_FRAME_SIZE

#define MAX_FRAME_SIZE   (960 * 6)

Definition at line 53 of file gnunet-helper-audio-playback.c.

fminf

#define fminf	(		_x,
			_y
	)		((_x) < (_y) ? (_x) : (_y))

fmaxf

#define fmaxf	(		_x,
			_y
	)		((_x) > (_y) ? (_x) : (_y))

float2int

#define float2int

(

flt

)

((int) (floor (.5 + flt)))

Function Documentation

process_header()

static GNUNET_NETWORK_STRUCT_END OpusDecoder * process_header ( ogg_packet *  op )

static

Process an Opus header and setup the opus decoder based on it.

It takes several pointers for header values which are needed elsewhere in the code.

Definition at line 146 of file gnunet-helper-audio-playback.c.

{
  int err;
  OpusDecoder *dec;
  struct OpusHeadPacket header;
 
  if (((unsigned int) op->bytes) < sizeof(header))
    return NULL;
  GNUNET_memcpy (&header,
                 op->packet,
                 sizeof(header));
  header.preskip = GNUNET_le16toh (header.preskip);
  header.sampling_rate = GNUNET_le32toh (header.sampling_rate);
  header.gain = GNUNET_le16toh (header.gain);
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Header: v%u, %u-ch, skip %u, %uHz, %u gain\n",
              header.version,
              header.channels,
              header.preskip,
              header.sampling_rate,
              header.gain);
  channels = header.channels;
  preskip = header.preskip;
 
  if (header.channel_mapping != 0)
  {
    fprintf (stderr,
             "This implementation does not support non-mono streams\n");
    return NULL;
  }
 
  dec = opus_decoder_create (SAMPLING_RATE, channels, &err);
  if (OPUS_OK != err)
  {
    fprintf (stderr,
             "Cannot create encoder: %s\n",
             opus_strerror (err));
    return NULL;
  }
  if (! dec)
  {
    fprintf (stderr,
             "Decoder initialization failed: %s\n",
             opus_strerror (err));
    return NULL;
  }
 
  if (0 != header.gain)
  {
    /*Gain API added in a newer libopus version, if we don't have it
       we apply the gain ourselves. We also add in a user provided
       manual gain at the same time.*/
    int gainadj = (int) header.gain;
    err = opus_decoder_ctl (dec, OPUS_SET_GAIN (gainadj));
    if (OPUS_UNIMPLEMENTED == err)
    {
      gain = pow (10.0, gainadj / 5120.0);
    }
    else if (OPUS_OK != err)
    {
      fprintf (stderr, "Error setting gain: %s\n", opus_strerror (err));
      return NULL;
    }
  }
 
  return dec;
}

References OpusHeadPacket::channel_mapping, channels, OpusHeadPacket::channels, dec, gain, OpusHeadPacket::gain, GNUNET_ERROR_TYPE_DEBUG, GNUNET_le16toh, GNUNET_le32toh, GNUNET_log, GNUNET_memcpy, op, preskip, OpusHeadPacket::preskip, SAMPLING_RATE, OpusHeadPacket::sampling_rate, and OpusHeadPacket::version.

Referenced by ogg_demux_and_decode().

Here is the caller graph for this function:

fwrite_le32()

static size_t fwrite_le32 ( opus_int32  i32, FILE *  file  )

static

Definition at line 218 of file gnunet-helper-audio-playback.c.

{
  unsigned char buf[4];
 
  buf[0] = (unsigned char) (i32 & 0xFF);
  buf[1] = (unsigned char) (i32 >> 8 & 0xFF);
  buf[2] = (unsigned char) (i32 >> 16 & 0xFF);
  buf[3] = (unsigned char) (i32 >> 24 & 0xFF);
  return fwrite (buf, 4, 1, file);
}

Referenced by write_wav_header().

Here is the caller graph for this function:

fwrite_le16()

static size_t fwrite_le16 ( int  i16, FILE *  file  )

static

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

{
  unsigned char buf[2];
 
  buf[0] = (unsigned char) (i16 & 0xFF);
  buf[1] = (unsigned char) (i16 >> 8 & 0xFF);
  return fwrite (buf, 2, 1, file);
}

Referenced by write_wav_header().

Here is the caller graph for this function:

write_wav_header()

static int write_wav_header ( )

static

Definition at line 242 of file gnunet-helper-audio-playback.c.

{
  int ret;
  FILE *file = stdout;
 
  ret = fprintf (file, "RIFF") >= 0;
  ret &= fwrite_le32 (0x7fffffff, file);
 
  ret &= fprintf (file, "WAVEfmt ") >= 0;
  ret &= fwrite_le32 (16, file);
  ret &= fwrite_le16 (1, file);
  ret &= fwrite_le16 (channels, file);
  ret &= fwrite_le32 (SAMPLING_RATE, file);
  ret &= fwrite_le32 (2 * channels * SAMPLING_RATE, file);
  ret &= fwrite_le16 (2 * channels, file);
  ret &= fwrite_le16 (16, file);
 
  ret &= fprintf (file, "data") >= 0;
  ret &= fwrite_le32 (0x7fffffff, file);
 
  return ! ret ? -1 : 16;
}

References channels, fwrite_le16(), fwrite_le32(), ret, and SAMPLING_RATE.

Referenced by audio_write().

Here is the call graph for this function:

Here is the caller graph for this function:

audio_write()

static int64_t audio_write ( int64_t  maxout )

static

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

{
  int64_t sampout = 0;
  int tmp_skip;
  unsigned out_len;
  unsigned to_write;
  float *output;
 
#ifdef DEBUG_DUMP_DECODED_OGG
  static int wrote_wav_header;
 
  if (dump_to_stdout && ! wrote_wav_header)
  {
    write_wav_header ();
    wrote_wav_header = 1;
  }
#endif
  maxout = 0 > maxout ? 0 : maxout;
  do
  {
    tmp_skip = (preskip > frame_size) ? (int) frame_size : preskip;
    preskip -= tmp_skip;
    output = pcm_buffer + channels * tmp_skip;
    out_len = frame_size - tmp_skip;
    if (out_len > MAX_FRAME_SIZE)
      exit (6);
    frame_size = 0;
 
    to_write = out_len < maxout ? out_len : (unsigned) maxout;
    if (0 < maxout)
    {
      int64_t wrote = 0;
      wrote = to_write;
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Writing %u * %u * %u = %llu bytes into PA\n",
                  to_write,
                  channels,
                  (unsigned int) sizeof(float),
                  (unsigned long long) (to_write * channels * sizeof(float)));
#ifdef DEBUG_DUMP_DECODED_OGG
      if (dump_to_stdout)
      {
# define fminf(_x, _y) ((_x) < (_y) ? (_x) : (_y))
# define fmaxf(_x, _y) ((_x) > (_y) ? (_x) : (_y))
# define float2int(flt) ((int) (floor (.5 + flt)))
        int i;
        int16_t *out = alloca (sizeof(short) * MAX_FRAME_SIZE * channels);
        for (i = 0; i < (int) out_len * channels; i++)
          out[i] = (short) float2int (fmaxf (-32768, fminf (output[i] * 32768.f,
                                                            32767)));
 
        fwrite (out, 2 * channels, out_len < maxout ? out_len : maxout, stdout);
      }
      else
#endif
      if (pa_stream_write
            (stream_out, output, to_write * channels * sizeof(float), NULL, 0,
            PA_SEEK_RELATIVE) < 0)
      {
        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                    _ ("pa_stream_write() failed: %s\n"),
                    pa_strerror (pa_context_errno (context)));
      }
      sampout += wrote;
      maxout -= wrote;
    }
  }
  while (0 < frame_size && 0 < maxout);
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Wrote %" PRId64 " samples\n",
              sampout);
  return sampout;
}

References _, channels, context, dump_to_stdout, float2int, fmaxf, fminf, frame_size, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, MAX_FRAME_SIZE, pcm_buffer, preskip, stream_out, and write_wav_header().

Referenced by ogg_demux_and_decode().

Here is the call graph for this function:

Here is the caller graph for this function:

quit()

static void quit ( int  ret )

static

Pulseaudio shutdown task.

Definition at line 350 of file gnunet-helper-audio-playback.c.

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

References mainloop_api, and ret.

Referenced by context_state_callback(), exit_signal_callback(), and ogg_demux_and_decode().

Here is the caller graph for this function:

ogg_demux_and_decode()

static void ogg_demux_and_decode ( )

static

Definition at line 359 of file gnunet-helper-audio-playback.c.

{
  ogg_page og;
  static int stream_init;
  int64_t page_granule = 0;
  ogg_packet op;
  static int has_opus_stream;
  static int has_tags_packet;
  static int32_t opus_serialno;
  static int64_t link_out;
  static int64_t packet_count;
  int eos = 0;
  static int total_links;
  static int gran_offset;
 
  while (1 == ogg_sync_pageout (&oy, &og))
  {
    if (0 == stream_init)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Initialized the stream\n");
      ogg_stream_init (&os, ogg_page_serialno (&og));
      stream_init = 1;
    }
    if (ogg_page_serialno (&og) != os.serialno)
    {
      /* so all streams are read. */
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Re-set serial number\n");
      ogg_stream_reset_serialno (&os, ogg_page_serialno (&og));
    }
    /*Add page to the bitstream*/
    ogg_stream_pagein (&os, &og);
    page_granule = ogg_page_granulepos (&og);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Reading page that ends at %" PRId64 "\n",
                page_granule);
    /*Extract all available packets*/
    while (1 == ogg_stream_packetout (&os, &op))
    {
      /*OggOpus streams are identified by a magic string in the initial
         stream header.*/
      if (op.b_o_s && (op.bytes >= 8) && ! memcmp (op.packet, "OpusHead", 8))
      {
        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                    "Got Opus Header\n");
        if (has_opus_stream && has_tags_packet)
        {
          /*If we're seeing another BOS OpusHead now it means
             the stream is chained without an EOS.
             This can easily happen if record helper is terminated unexpectedly.
           */
          has_opus_stream = 0;
          if (dec)
            opus_decoder_destroy (dec);
          dec = NULL;
          fprintf (stderr,
                   "\nWarning: stream %" PRId64
                   " ended without EOS and a new stream began.\n",
                   (int64_t) os.serialno);
        }
        if (! has_opus_stream)
        {
          if ((packet_count > 0) && (opus_serialno == os.serialno) )
          {
            fprintf (stderr,
                     "\nError: Apparent chaining without changing serial number (%"
                     PRId64 "==%" PRId64 ").\n",
                     (int64_t) opus_serialno, (int64_t) os.serialno);
            quit (1);
          }
          opus_serialno = os.serialno;
          has_opus_stream = 1;
          has_tags_packet = 0;
          link_out = 0;
          packet_count = 0;
          eos = 0;
          total_links++;
          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                      "Got header for stream %" PRId64 ", this is %dth link\n",
                      (int64_t) opus_serialno, total_links);
        }
        else
        {
          fprintf (stderr, "\nWarning: ignoring opus stream %" PRId64 "\n",
                   (int64_t) os.serialno);
        }
      }
      if (! has_opus_stream || (os.serialno != opus_serialno) )
      {
        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                    "breaking out\n");
        break;
      }
      /*If first packet in a logical stream, process the Opus header*/
      if (0 == packet_count)
      {
        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                    "Decoding header\n");
        dec = process_header (&op);
        if (! dec)
          quit (1);
 
        if ((0 != ogg_stream_packetout (&os, &op)) || (255 ==
                                                       og.header[og.header_len
                                                                 - 1]) )
        {
          /*The format specifies that the initial header and tags packets are on their
             own pages. To aid implementors in discovering that their files are wrong
             we reject them explicitly here. In some player designs files like this would
             fail even without an explicit test.*/
          fprintf (stderr,
                   "Extra packets on initial header page. Invalid stream.\n");
          quit (1);
        }
 
        /*Remember how many samples at the front we were told to skip
           so that we can adjust the timestamp counting.*/
        gran_offset = preskip;
 
        if (! pcm_buffer)
        {
          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                      "Allocating %u * %u * %u = %llu bytes of buffer space\n",
                      MAX_FRAME_SIZE,
                      channels,
                      (unsigned int) sizeof(float),
                      (unsigned long long) (MAX_FRAME_SIZE * channels
                                            * sizeof(float)));
          pcm_buffer = pa_xmalloc (sizeof(float) * MAX_FRAME_SIZE * channels);
        }
      }
      else if (1 == packet_count)
      {
        has_tags_packet = 1;
        if ((0 != ogg_stream_packetout (&os, &op)) || (255 ==
                                                       og.header[og.header_len
                                                                 - 1]) )
        {
          fprintf (stderr,
                   "Extra packets on initial tags page. Invalid stream.\n");
          quit (1);
        }
      }
      else
      {
        int ret;
        int64_t maxout;
        int64_t outsamp;
 
        /*End of stream condition*/
        if (op.e_o_s && (os.serialno == opus_serialno) )
        {
          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                      "Got EOS\n");
          eos = 1;         /* don't care for anything except opus eos */
        }
 
        /*Decode Opus packet*/
        ret = opus_decode_float (dec,
                                 (const unsigned char *) op.packet,
                                 op.bytes,
                                 pcm_buffer,
                                 MAX_FRAME_SIZE, 0);
 
        /*If the decoder returned less than zero, we have an error.*/
        if (0 > ret)
        {
          fprintf (stderr, "Decoding error: %s\n", opus_strerror (ret));
          break;
        }
        frame_size = ret;
        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                    "Decoded %d bytes/channel (%d bytes) from %u compressed bytes\n",
                    ret,
                    ret * channels,
                    (unsigned int) op.bytes);
 
        /*Apply header gain, if we're not using an opus library new
           enough to do this internally.*/
        if (0 != gain)
        {
          int i;
          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                      "Applying gain %f\n",
                      gain);
          for (i = 0; i < frame_size * channels; i++)
            pcm_buffer[i] *= gain;
        }
 
        /*This handles making sure that our output duration respects
           the final end-trim by not letting the output sample count
           get ahead of the granpos indicated value.*/
        maxout = ((page_granule - gran_offset) * SAMPLING_RATE / 48000)
                 - link_out;
        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                    "Writing audio packet %" PRId64 ", at most %" PRId64
                    " samples\n",
                    packet_count, maxout);
 
        outsamp = audio_write (0 > maxout ? 0 : maxout);
        link_out += outsamp;
      }
      packet_count++;
    }
    if (eos)
    {
      has_opus_stream = 0;
      if (dec)
        opus_decoder_destroy (dec);
      dec = NULL;
    }
  }
}

References audio_write(), channels, dec, frame_size, gain, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, MAX_FRAME_SIZE, op, os, oy, pcm_buffer, preskip, process_header(), quit(), ret, and SAMPLING_RATE.

Referenced by main(), and stdin_receiver().

Here is the call graph for this function:

Here is the caller graph for this function:

stdin_receiver()

static int stdin_receiver ( void *  cls, const struct GNUNET_MessageHeader *  msg  )

static

Message callback.

Parameters

msg	message we received.

Returns

GNUNET_OK on success, GNUNET_NO to stop further processing due to disconnect (no error) GNUNET_SYSERR to stop further processing due to error

Definition at line 584 of file gnunet-helper-audio-playback.c.

{
  struct AudioMessage *audio;
  char *data;
  size_t payload_len;
 
  (void) cls;
  switch (ntohs (msg->type))
  {
  case GNUNET_MESSAGE_TYPE_CONVERSATION_AUDIO:
    audio = (struct AudioMessage *) msg;
    payload_len = ntohs (audio->header.size) - sizeof(struct AudioMessage);
 
    /*Get the ogg buffer for writing*/
    data = ogg_sync_buffer (&oy, payload_len);
    /*Read bitstream from input file*/
    GNUNET_memcpy (data, (const unsigned char *) &audio[1], payload_len);
    ogg_sync_wrote (&oy, payload_len);
 
    ogg_demux_and_decode ();
    break;
 
  default:
    break;
  }
  return GNUNET_OK;
}

References data, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_CONVERSATION_AUDIO, GNUNET_OK, AudioMessage::header, msg, ogg_demux_and_decode(), oy, GNUNET_MessageHeader::size, and GNUNET_MessageHeader::type.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

stream_write_callback()

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

static

Callback when data is there for playback.

Definition at line 618 of file gnunet-helper-audio-playback.c.

{
  /* unblock 'main' */
  (void) userdata;
  (void) length;
  (void) s;
  if (-1 != ready_pipe[1])
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Unblocking main loop!\n");
    (void) write (ready_pipe[1], "r", 1);
  }
}

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, and ready_pipe.

Referenced by context_state_callback().

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 639 of file gnunet-helper-audio-playback.c.

{
  (void) m;
  (void) e;
  (void) sig;
  (void) userdata;
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              _ ("gnunet-helper-audio-playback - Got signal, exiting\n"));
  quit (1);
}

References _, 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:

context_state_callback()

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

static

Pulseaudio stream state callback.

Definition at line 658 of file gnunet-helper-audio-playback.c.

{
  int p;
 
  (void) userdata;
  GNUNET_assert (NULL != 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:
    {
      GNUNET_assert (! stream_out);
      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                  _ ("Connection established.\n"));
      if (! (stream_out =
               pa_stream_new (c, "GNUNET VoIP playback", &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_write_callback (stream_out,
                                    &stream_write_callback,
                                    NULL);
      if ((p =
             pa_stream_connect_playback (stream_out, NULL,
                                         NULL,
                                         PA_STREAM_ADJUST_LATENCY
                                         | PA_STREAM_INTERPOLATE_TIMING
                                         | PA_STREAM_AUTO_TIMING_UPDATE,
                                         NULL, NULL)) < 0)
      {
        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                    _ ("pa_stream_connect_playback() 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, p, quit(), sample_spec, stream_out, and stream_write_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

Pulseaudio initialization.

Definition at line 725 of file gnunet-helper-audio-playback.c.

{
  int r;
 
  if (! pa_sample_spec_valid (&sample_spec))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                _ ("Wrong Spec\n"));
  }
  /* set up threaded playback mainloop */
  if (! (m = pa_threaded_mainloop_new ()))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("pa_mainloop_new() failed.\n"));
  }
  mainloop_api = pa_threaded_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_threaded_mainloop_start (m) < 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_ERROR_TYPE_INFO, 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:

ogg_init()

static void ogg_init ( )

static

Definition at line 771 of file gnunet-helper-audio-playback.c.

{
  ogg_sync_init (&oy);
}

References oy.

Referenced by main().

Here is the caller graph for this function:

drain_callback()

static void drain_callback ( pa_stream *  s, int  success, void *  userdata  )

static

Definition at line 778 of file gnunet-helper-audio-playback.c.

{
  (void) s;
  (void) success;
  (void) userdata;
  pa_threaded_mainloop_signal (m,
                               0);
}

References m.

Referenced by main().

Here is the caller graph for this function:

main()

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

The main function for the playback helper.

Parameters

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

Returns

0 ok, 1 on error

Definition at line 796 of file gnunet-helper-audio-playback.c.

{
  static unsigned long long toff;
  char readbuf[MAXLINE];
  struct GNUNET_MessageStreamTokenizer *stdin_mst;
  char c;
  ssize_t ret;
 
#ifdef DEBUG_READ_PURE_OGG
  int read_pure_ogg = getenv ("GNUNET_READ_PURE_OGG") ? 1 : 0;
#endif
 
  (void) argc;
  (void) argv;
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_log_setup ("gnunet-helper-audio-playback",
                                   "WARNING",
                                   NULL));
  if (0 != pipe (ready_pipe))
  {
    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "pipe");
    return 1;
  }
  stdin_mst = GNUNET_MST_create (&stdin_receiver, NULL);
  ogg_init ();
  pa_init ();
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Waiting for PulseAudio to be ready.\n");
  GNUNET_assert (1 == read (ready_pipe[0], &c, 1));
  close (ready_pipe[0]);
  close (ready_pipe[1]);
  ready_pipe[0] = -1;
  ready_pipe[1] = -1;
#ifdef DEBUG_DUMP_DECODED_OGG
  dump_to_stdout = getenv ("GNUNET_DUMP_DECODED_OGG") ? 1 : 0;
#endif
  while (1)
  {
    ret = read (STDIN_FILENO,
                readbuf,
                sizeof(readbuf));
    toff += ret;
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Received %d bytes of audio data (total: %llu)\n",
                (int) ret,
                toff);
    if (0 > ret)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  _ ("Read error from STDIN: %s\n"),
                  strerror (errno));
      break;
    }
    if (0 == ret)
      break;
#ifdef DEBUG_READ_PURE_OGG
    if (read_pure_ogg)
    {
      char *data = ogg_sync_buffer (&oy, ret);
      GNUNET_memcpy (data, readbuf, ret);
      ogg_sync_wrote (&oy, ret);
      ogg_demux_and_decode ();
    }
    else
#endif
    GNUNET_MST_from_buffer (stdin_mst,
                            readbuf, ret,
                            GNUNET_NO, GNUNET_NO);
  }
  GNUNET_MST_destroy (stdin_mst);
  if (stream_out)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Locking\n");
    pa_threaded_mainloop_lock (m);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Draining\n");
    pa_operation *o = pa_stream_drain (stream_out, drain_callback, NULL);
    while (pa_operation_get_state (o) == PA_OPERATION_RUNNING)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Waiting\n");
      pa_threaded_mainloop_wait (m);
    }
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Unreffing\n");
    pa_operation_unref (o);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Unlocking\n");
    pa_threaded_mainloop_unlock (m);
  }
  return 0;
}

References _, data, drain_callback(), dump_to_stdout, getenv(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_log_setup(), GNUNET_log_strerror, GNUNET_memcpy, GNUNET_MST_create(), GNUNET_MST_destroy(), GNUNET_MST_from_buffer(), GNUNET_NO, GNUNET_OK, m, MAXLINE, ogg_demux_and_decode(), ogg_init(), oy, pa_init(), ready_pipe, ret, stdin_mst, stdin_receiver(), and stream_out.

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 
}

Pulseaudio specification.

May change in the future.

Definition at line 58 of file gnunet-helper-audio-playback.c.

Referenced by context_state_callback(), and pa_init().

dump_to_stdout

int dump_to_stdout

static

Definition at line 65 of file gnunet-helper-audio-playback.c.

Referenced by audio_write(), and main().

mainloop_api

pa_mainloop_api* mainloop_api

static

Pulseaudio mainloop api.

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

Referenced by pa_init(), and quit().

m

pa_threaded_mainloop* m

static

Pulseaudio threaded mainloop.

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

Referenced by drain_callback(), exit_signal_callback(), main(), and pa_init().

context

pa_context* context

static

Pulseaudio context.

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

Referenced by audio_write(), derive_h(), enqueue_message_control(), get_context_from_member(), get_handle_contact(), get_store_contact(), get_store_contact_raw(), GNUNET_CRYPTO_ecdsa_private_key_derive(), GNUNET_CRYPTO_ecdsa_public_key_derive(), GNUNET_CRYPTO_ecdsa_sign_derived(), GNUNET_CRYPTO_eddsa_private_key_derive(), GNUNET_CRYPTO_eddsa_public_key_derive(), GNUNET_CRYPTO_eddsa_sign_derived(), GNUNET_SCHEDULER_run(), handle_client_evaluate(), handle_id_message(), handle_join_message(), handle_key_message(), handle_recv_message(), notify_srv_handle_message(), pa_init(), process_message_control(), remove_store_contact(), select_add(), select_del(), select_loop(), select_set_wakeup(), select_store_contact_map(), and update_store_contact().

stream_out

pa_stream* stream_out

static

Pulseaudio output stream.

Definition at line 86 of file gnunet-helper-audio-playback.c.

Referenced by audio_write(), context_state_callback(), and main().

dec

OpusDecoder* dec

static

OPUS decoder.

Definition at line 91 of file gnunet-helper-audio-playback.c.

Referenced by getValue__(), ogg_demux_and_decode(), and process_header().

pcm_buffer

float* pcm_buffer

static

PCM data buffer.

Definition at line 96 of file gnunet-helper-audio-playback.c.

Referenced by audio_write(), and ogg_demux_and_decode().

frame_size

int frame_size

static

Number of samples for one frame.

Definition at line 101 of file gnunet-helper-audio-playback.c.

Referenced by audio_write(), and ogg_demux_and_decode().

ready_pipe

int ready_pipe[2]

static

Pipe we use to signal the main loop that we are ready to receive.

Definition at line 106 of file gnunet-helper-audio-playback.c.

Referenced by main(), and stream_write_callback().

oy

ogg_sync_state oy

static

Ogg I/O state.

Definition at line 111 of file gnunet-helper-audio-playback.c.

Referenced by main(), ogg_demux_and_decode(), ogg_init(), and stdin_receiver().

os

ogg_stream_state os

static

Ogg stream state.

Definition at line 116 of file gnunet-helper-audio-playback.c.

Referenced by handle_flow_control(), handle_p2p_estimate(), and ogg_demux_and_decode().

channels

int channels

static

Definition at line 118 of file gnunet-helper-audio-playback.c.

Referenced by audio_write(), ogg_demux_and_decode(), process_header(), and write_wav_header().

preskip

int preskip

static

Definition at line 120 of file gnunet-helper-audio-playback.c.

Referenced by audio_write(), ogg_demux_and_decode(), and process_header().

gain

float gain

static

Definition at line 122 of file gnunet-helper-audio-playback.c.

Referenced by ogg_demux_and_decode(), and process_header().