tool to test speaker and microphone (for end users!) More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_speaker_lib.h"
#include "gnunet_microphone_lib.h"

Include dependency graph for gnunet-conversation-test.c:

Go to the source code of this file.

Data Structures
struct	Recording
	A recording we made. More...

Macros
#define	TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5)
	How long do we record before we replay? More...

Functions
static void	do_shutdown (void *cls)
	Terminate test. More...

static void	switch_to_speaker (void *cls)
	Terminate recording process and switch to playback. More...

static void	record (void cls, size_t data_size, const void data)
	Process recorded audio data. More...

static void	run (void cls, char const args, const char cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
	Main function that will be run by the scheduler. More...

int	main (int argc, char const argv)
	The main function of our code to test microphone and speaker. More...

Variables
static int	ret
	Final status code. More...

static struct GNUNET_MICROPHONE_Handle *	microphone
	Handle to the microphone. More...

static struct GNUNET_SPEAKER_Handle *	speaker
	Handle to the speaker. More...

static struct GNUNET_SCHEDULER_Task *	switch_task
	Task scheduled to switch from recording to playback. More...

static struct GNUNET_SCHEDULER_Task *	st
	The shutdown task. More...

static struct Recording *	rec_head
	Head of DLL with recorded frames. More...

static struct Recording *	rec_tail
	Tail of DLL with recorded frames. More...

Detailed Description

tool to test speaker and microphone (for end users!)

Author: Christian Grothoff

Definition in file gnunet-conversation-test.c.

Macro Definition Documentation

◆ TIMEOUT

#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5)

How long do we record before we replay?

Definition at line 34 of file gnunet-conversation-test.c.

Function Documentation

◆ do_shutdown()

static void do_shutdown ( void * cls )

static

Terminate test.

Parameters

cls NULL

Definition at line 101 of file gnunet-conversation-test.c.

{
  struct Recording *rec;
 
  (void) cls;
  if (NULL != switch_task)
    GNUNET_SCHEDULER_cancel (switch_task);
  if (NULL != microphone)
    GNUNET_MICROPHONE_destroy (microphone);
  if (NULL != speaker)
    GNUNET_SPEAKER_destroy (speaker);
  while (NULL != (rec = rec_head))
  {
    GNUNET_CONTAINER_DLL_remove (rec_head,
                                 rec_tail,
                                 rec);
    GNUNET_free (rec);
  }
  fprintf (stderr,
           _ ("\nEnd of transmission.  Have a GNU day.\n"));
}

References _, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_MICROPHONE_destroy(), GNUNET_SCHEDULER_cancel(), GNUNET_SPEAKER_destroy(), microphone, rec_head, rec_tail, speaker, and switch_task.

Referenced by run(), and switch_to_speaker().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ switch_to_speaker()

static void switch_to_speaker ( void * cls )

static

Terminate recording process and switch to playback.

Parameters

cls NULL

Definition at line 130 of file gnunet-conversation-test.c.

{
  (void) cls;
  switch_task = NULL;
  microphone->disable_microphone (microphone->cls);
  if (GNUNET_OK !=
      speaker->enable_speaker (speaker->cls))
  {
    fprintf (stderr,
             "Failed to enable microphone\n");
    ret = 1;
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  fprintf (stderr,
           _ (
             "\new are now playing your recording back.  If you can hear it, your audio settings are working..."));
  for (struct Recording *rec = rec_head; NULL != rec; rec = rec->next)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Replaying %u bytes\n",
                (unsigned int) rec->size);
    speaker->play (speaker->cls,
                   rec->size,
                   &rec[1]);
  }
  GNUNET_SCHEDULER_cancel (st);
  st = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
                                     &do_shutdown,
                                     NULL);
}

References _, GNUNET_MICROPHONE_Handle::cls, GNUNET_SPEAKER_Handle::cls, GNUNET_MICROPHONE_Handle::disable_microphone, do_shutdown(), GNUNET_SPEAKER_Handle::enable_speaker, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_OK, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_cancel(), GNUNET_SCHEDULER_shutdown(), microphone, Recording::next, GNUNET_SPEAKER_Handle::play, rec_head, ret, speaker, st, switch_task, and TIMEOUT.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ record()

static void record	(	void *	cls,
		size_t	data_size,
		const void *	data
	)

static

Process recorded audio data.

Parameters

cls	clsoure
data_size	number of bytes in data
data	audio data to play

Definition at line 171 of file gnunet-conversation-test.c.

{
  struct Recording *rec;
 
  (void) cls;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Recorded %u bytes\n",
              (unsigned int) data_size);
  rec = GNUNET_malloc (sizeof(struct Recording) + data_size);
  rec->size = data_size;
  GNUNET_memcpy (&rec[1], data, data_size);
  GNUNET_CONTAINER_DLL_insert_tail (rec_head,
                                    rec_tail,
                                    rec);
}

References data, data_size, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_malloc, GNUNET_memcpy, rec_head, rec_tail, and Recording::size.

Referenced by add_record(), backtalker_monotime_cb(), cache_answers(), check_for_global_natted(), check_store(), display_record(), forward_reply(), GNUNET_GNSRECORD_JSON_from_gnsrecord(), got_hello(), handle_hello_for_client(), handle_hello_for_incoming(), handle_iterate_result(), handle_result(), handshake_ack_monotime_cb(), handshake_monotime_cb(), hello_add_iter(), hello_iter_cb(), iterate_proc(), messenger_string_to_value(), messenger_value_to_string(), modify_record(), monitor_iterate_cb(), neighbour_dv_monotime_cb(), parse_recordline(), peer_respect_cb(), peerinfo_cb(), PEERSTORE_destroy_record(), PEERSTORE_parse_record_message(), process_notify(), process_peer(), process_peerinfo_peers(), rekey_monotime_cb(), remove_client_query_record(), run(), send_reply(), try_cache(), and watch_notifier().

Here is the caller graph for this function:

◆ run()

static void run	(	void *	cls,
		char const	args,
		const char *	cfgfile,
		const struct GNUNET_CONFIGURATION_Handle *	cfg
	)

static

Main function that will be run by the scheduler.

Parameters

cls	closure
args	remaining command-line arguments
cfgfile	name of the configuration file used (for saving, can be NULL!)
cfg	configuration

Definition at line 199 of file gnunet-conversation-test.c.

{
  (void) cls;
  (void) args;
  (void) cfgfile;
  microphone = GNUNET_MICROPHONE_create_from_hardware (cfg);
  GNUNET_assert (NULL != microphone);
  speaker = GNUNET_SPEAKER_create_from_hardware (cfg);
  GNUNET_assert (NULL != speaker);
  switch_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
                                              &switch_to_speaker,
                                              NULL);
  st = GNUNET_SCHEDULER_add_shutdown (&do_shutdown,
                                      NULL);
  fprintf (stderr,
           _ (
             "We will now be recording you for %s. After that time, the recording will be played back to you..."),
           GNUNET_STRINGS_relative_time_to_string (TIMEOUT, GNUNET_YES));
  if (GNUNET_OK !=
      microphone->enable_microphone (microphone->cls,
                                     &record, NULL))
  {
    fprintf (stderr,
             "Failed to enable microphone\n");
    ret = 1;
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
}

References _, consensus-simulation::args, cfg, GNUNET_MICROPHONE_Handle::cls, do_shutdown(), GNUNET_MICROPHONE_Handle::enable_microphone, GNUNET_assert, GNUNET_MICROPHONE_create_from_hardware(), GNUNET_OK, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), GNUNET_SPEAKER_create_from_hardware(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_YES, microphone, record(), ret, speaker, st, switch_task, switch_to_speaker(), and TIMEOUT.

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 const	argv
	)

The main function of our code to test microphone and speaker.

Parameters

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

Returns: 0 ok, 1 on error

Definition at line 241 of file gnunet-conversation-test.c.

{
  static const struct GNUNET_GETOPT_CommandLineOption options[] = {
    GNUNET_GETOPT_OPTION_END
  };
 
  if (GNUNET_OK !=
      GNUNET_STRINGS_get_utf8_args (argc, argv,
                                    &argc, &argv))
    return 2;
 
  ret = (GNUNET_OK ==
         GNUNET_PROGRAM_run (argc, argv,
                             "gnunet-conversation-test",
                             gettext_noop ("help text"),
                             options,
                             &run,
                             NULL)) ? ret : 1;
  GNUNET_free_nz ((void *) argv);
  return ret;
}