src/conversation/gnunet-conversation-test.c

   1 /*
   2      This file is part of GNUnet.
   3      Copyright (C) 2013 GNUnet e.V.
   4
   5      GNUnet is free software: you can redistribute it and/or modify it
   6      under the terms of the GNU Affero General Public License as published
   7      by the Free Software Foundation, either version 3 of the License,
   8      or (at your option) any later version.
   9
  10      GNUnet is distributed in the hope that it will be useful, but
  11      WITHOUT ANY WARRANTY; without even the implied warranty of
  12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13      Affero General Public License for more details.
  14
  15      You should have received a copy of the GNU Affero General Public License
  16      along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17
  18      SPDX-License-Identifier: AGPL3.0-or-later
  19  */
  20
  21 /**
  22  * @file conversation/gnunet-conversation-test.c
  23  * @brief tool to test speaker and microphone (for end users!)
  24  * @author Christian Grothoff
  25  */
  26 #include "platform.h"
  27 #include "gnunet_util_lib.h"
  28 #include "gnunet_speaker_lib.h"
  29 #include "gnunet_microphone_lib.h"
  30
  31 /**
  32  * How long do we record before we replay?
  33  */
  34 #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5)
  35
  36
  37 /**
  38  * A recording we made.
  39  */
  40 struct Recording
  41 {
  42   /**
  43    * Kept in a DLL.
  44    */
  45   struct Recording *next;
  46
  47   /**
  48    * Kept in a DLL.
  49    */
  50   struct Recording *prev;
  51
  52   /**
  53    * Number of bytes that follow.
  54    */
  55   size_t size;
  56 };
  57
  58
  59 /**
  60  * Final status code.
  61  */
  62 static int ret;
  63
  64 /**
  65  * Handle to the microphone.
  66  */
  67 static struct GNUNET_MICROPHONE_Handle *microphone;
  68
  69 /**
  70  * Handle to the speaker.
  71  */
  72 static struct GNUNET_SPEAKER_Handle *speaker;
  73
  74 /**
  75  * Task scheduled to switch from recording to playback.
  76  */
  77 static struct GNUNET_SCHEDULER_Task *switch_task;
  78
  79 /**
  80  * The shutdown task.
  81  */
  82 static struct GNUNET_SCHEDULER_Task *st;
  83
  84 /**
  85  * Head of DLL with recorded frames.
  86  */
  87 static struct Recording *rec_head;
  88
  89 /**
  90  * Tail of DLL with recorded frames.
  91  */
  92 static struct Recording *rec_tail;
  93
  94
  95 /**
  96  * Terminate test.
  97  *
  98  * @param cls NULL
  99  */
 100 static void
 101 do_shutdown (void *cls)
 102 {
 103   struct Recording *rec;
 104
 105   (void) cls;
 106   if (NULL != switch_task)
 107     GNUNET_SCHEDULER_cancel (switch_task);
 108   if (NULL != microphone)
 109     GNUNET_MICROPHONE_destroy (microphone);
 110   if (NULL != speaker)
 111     GNUNET_SPEAKER_destroy (speaker);
 112   while (NULL != (rec = rec_head))
 113   {
 114     GNUNET_CONTAINER_DLL_remove (rec_head,
 115                                  rec_tail,
 116                                  rec);
 117     GNUNET_free (rec);
 118   }
 119   fprintf (stderr,
 120            _ ("\nEnd of transmission.  Have a GNU day.\n"));
 121 }
 122
 123
 124 /**
 125  * Terminate recording process and switch to playback.
 126  *
 127  * @param cls NULL
 128  */
 129 static void
 130 switch_to_speaker (void *cls)
 131 {
 132   (void) cls;
 133   switch_task = NULL;
 134   microphone->disable_microphone (microphone->cls);
 135   if (GNUNET_OK !=
 136       speaker->enable_speaker (speaker->cls))
 137   {
 138     fprintf (stderr,
 139              "Failed to enable microphone\n");
 140     ret = 1;
 141     GNUNET_SCHEDULER_shutdown ();
 142     return;
 143   }
 144   fprintf (stderr,
 145            _ (
 146              "\nWe are now playing your recording back.  If you can hear it, your audio settings are working..."));
 147   for (struct Recording *rec = rec_head; NULL != rec; rec = rec->next)
 148   {
 149     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 150                 "Replaying %u bytes\n",
 151                 (unsigned int) rec->size);
 152     speaker->play (speaker->cls,
 153                    rec->size,
 154                    &rec[1]);
 155   }
 156   GNUNET_SCHEDULER_cancel (st);
 157   st = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
 158                                      &do_shutdown,
 159                                      NULL);
 160 }
 161
 162
 163 /**
 164  * Process recorded audio data.
 165  *
 166  * @param cls clsoure
 167  * @param data_size number of bytes in @a data
 168  * @param data audio data to play
 169  */
 170 static void
 171 record (void *cls,
 172         size_t data_size,
 173         const void *data)
 174 {
 175   struct Recording *rec;
 176
 177   (void) cls;
 178   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 179               "Recorded %u bytes\n",
 180               (unsigned int) data_size);
 181   rec = GNUNET_malloc (sizeof(struct Recording) + data_size);
 182   rec->size = data_size;
 183   GNUNET_memcpy (&rec[1], data, data_size);
 184   GNUNET_CONTAINER_DLL_insert_tail (rec_head,
 185                                     rec_tail,
 186                                     rec);
 187 }
 188
 189
 190 /**
 191  * Main function that will be run by the scheduler.
 192  *
 193  * @param cls closure
 194  * @param args remaining command-line arguments
 195  * @param cfgfile name of the configuration file used (for saving, can be NULL!)
 196  * @param cfg configuration
 197  */
 198 static void
 199 run (void *cls,
 200      char *const *args,
 201      const char *cfgfile,
 202      const struct GNUNET_CONFIGURATION_Handle *cfg)
 203 {
 204   (void) cls;
 205   (void) args;
 206   (void) cfgfile;
 207   microphone = GNUNET_MICROPHONE_create_from_hardware (cfg);
 208   GNUNET_assert (NULL != microphone);
 209   speaker = GNUNET_SPEAKER_create_from_hardware (cfg);
 210   GNUNET_assert (NULL != speaker);
 211   switch_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
 212                                               &switch_to_speaker,
 213                                               NULL);
 214   st = GNUNET_SCHEDULER_add_shutdown (&do_shutdown,
 215                                       NULL);
 216   fprintf (stderr,
 217            _ (
 218              "We will now be recording you for %s. After that time, the recording will be played back to you..."),
 219            GNUNET_STRINGS_relative_time_to_string (TIMEOUT, GNUNET_YES));
 220   if (GNUNET_OK !=
 221       microphone->enable_microphone (microphone->cls,
 222                                      &record, NULL))
 223   {
 224     fprintf (stderr,
 225              "Failed to enable microphone\n");
 226     ret = 1;
 227     GNUNET_SCHEDULER_shutdown ();
 228     return;
 229   }
 230 }
 231
 232
 233 /**
 234  * The main function of our code to test microphone and speaker.
 235  *
 236  * @param argc number of arguments from the command line
 237  * @param argv command line arguments
 238  * @return 0 ok, 1 on error
 239  */
 240 int
 241 main (int argc,
 242       char *const *argv)
 243 {
 244   static const struct GNUNET_GETOPT_CommandLineOption options[] = {
 245     GNUNET_GETOPT_OPTION_END
 246   };
 247
 248   if (GNUNET_OK !=
 249       GNUNET_STRINGS_get_utf8_args (argc, argv,
 250                                     &argc, &argv))
 251     return 2;
 252
 253   ret = (GNUNET_OK ==
 254          GNUNET_PROGRAM_run (argc, argv,
 255                              "gnunet-conversation-test",
 256                              gettext_noop ("help text"),
 257                              options,
 258                              &run,
 259                              NULL)) ? ret : 1;
 260   GNUNET_free ((void *) argv);
 261   return ret;
 262 }
 263
 264
 265 /* end of gnunet-conversation-test.c */