src/conversation/gnunet-conversation-test.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2013 Christian Grothoff (and other contributing authors)
   4
   5      GNUnet is free software; you can redistribute it and/or modify
   6      it under the terms of the GNU General Public License as published
   7      by the Free Software Foundation; either version 3, or (at your
   8      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      General Public License for more details.
  14
  15      You should have received a copy of the GNU General Public License
  16      along with GNUnet; see the file COPYING.  If not, write to the
  17      Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18      Boston, MA 02111-1307, USA.
  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 GNUNET_SCHEDULER_TaskIdentifier switch_task;
  78
  79 /**
  80  * The shutdown task.
  81  */
  82 static GNUNET_SCHEDULER_TaskIdentifier 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  * @param tc unused
 100  */
 101 static void
 102 do_shutdown (void *cls,
 103              const struct GNUNET_SCHEDULER_TaskContext *tc)
 104 {
 105   struct Recording *rec;
 106
 107   if (GNUNET_SCHEDULER_NO_TASK != switch_task)
 108     GNUNET_SCHEDULER_cancel (switch_task);
 109   if (NULL != microphone)
 110     GNUNET_MICROPHONE_destroy (microphone);
 111   if (NULL != speaker)
 112     GNUNET_SPEAKER_destroy (speaker);
 113   while (NULL != (rec = rec_head))
 114   {
 115     GNUNET_CONTAINER_DLL_remove (rec_head,
 116                                  rec_tail,
 117                                  rec);
 118     GNUNET_free (rec);
 119   }
 120   fprintf (stderr,
 121            _("\nEnd of transmission.  Have a GNU day.\n"));
 122 }
 123
 124
 125 /**
 126  * Terminate recording process and switch to playback.
 127  *
 128  * @param cls NULL
 129  * @param tc unused
 130  */
 131 static void
 132 switch_to_speaker (void *cls,
 133                    const struct GNUNET_SCHEDULER_TaskContext *tc)
 134 {
 135   struct Recording *rec;
 136
 137   switch_task = GNUNET_SCHEDULER_NO_TASK;
 138   microphone->disable_microphone (microphone->cls);
 139   if (GNUNET_OK !=
 140       speaker->enable_speaker (speaker->cls))
 141   {
 142     fprintf (stderr,
 143              "Failed to enable microphone\n");
 144     ret = 1;
 145     GNUNET_SCHEDULER_shutdown ();
 146     return;
 147   }
 148   fprintf (stderr,
 149            _("\nWe are now playing your recording back.  If you can hear it, your audio settings are working..."));
 150   for (rec=rec_head; NULL != rec; rec = rec->next)
 151   {
 152     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 153                 "Replaying %u bytes\n",
 154                 (unsigned int) rec->size);
 155     speaker->play (speaker->cls,
 156                    rec->size,
 157                    &rec[1]);
 158   }
 159   GNUNET_SCHEDULER_cancel (st);
 160   st = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
 161                                      &do_shutdown,
 162                                      NULL);
 163 }
 164
 165
 166 /**
 167  * Process recorded audio data.
 168  *
 169  * @param cls clsoure
 170  * @param data_size number of bytes in @a data
 171  * @param data audio data to play
 172  */
 173 static void
 174 record (void *cls,
 175         size_t data_size,
 176         const void *data)
 177 {
 178   struct Recording *rec;
 179
 180   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 181               "Recorded %u bytes\n",
 182               (unsigned int) data_size);
 183   rec = GNUNET_malloc (sizeof (struct Recording) + data_size);
 184   rec->size = data_size;
 185   memcpy (&rec[1], data, data_size);
 186   GNUNET_CONTAINER_DLL_insert_tail (rec_head,
 187                                     rec_tail,
 188                                     rec);
 189 }
 190
 191
 192 /**
 193  * Main function that will be run by the scheduler.
 194  *
 195  * @param cls closure
 196  * @param args remaining command-line arguments
 197  * @param cfgfile name of the configuration file used (for saving, can be NULL!)
 198  * @param cfg configuration
 199  */
 200 static void
 201 run (void *cls, char *const *args, const char *cfgfile,
 202      const struct GNUNET_CONFIGURATION_Handle *cfg)
 203 {
 204   microphone = GNUNET_MICROPHONE_create_from_hardware (cfg);
 205   GNUNET_assert (NULL != microphone);
 206   speaker = GNUNET_SPEAKER_create_from_hardware (cfg);
 207   GNUNET_assert (NULL != speaker);
 208   switch_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
 209                                               &switch_to_speaker,
 210                                               NULL);
 211   st = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
 212                                      &do_shutdown,
 213                                      NULL);
 214   fprintf (stderr,
 215            _("We will now be recording you for %s. After that time, the recording will be played back to you..."),
 216            GNUNET_STRINGS_relative_time_to_string (TIMEOUT, GNUNET_YES));
 217   if (GNUNET_OK !=
 218       microphone->enable_microphone (microphone->cls,
 219                                      &record, NULL))
 220   {
 221     fprintf (stderr,
 222              "Failed to enable microphone\n");
 223     ret = 1;
 224     GNUNET_SCHEDULER_shutdown ();
 225     return;
 226   }
 227 }
 228
 229
 230 /**
 231  * The main function of our code to test microphone and speaker.
 232  *
 233  * @param argc number of arguments from the command line
 234  * @param argv command line arguments
 235  * @return 0 ok, 1 on error
 236  */
 237 int
 238 main (int argc, char *const *argv)
 239 {
 240   static const struct GNUNET_GETOPT_CommandLineOption options[] = {
 241     GNUNET_GETOPT_OPTION_END
 242   };
 243   if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
 244     return 2;
 245
 246   ret = (GNUNET_OK ==
 247          GNUNET_PROGRAM_run (argc, argv, "gnunet-conversation-test",
 248                              gettext_noop ("help text"), options, &run,
 249                              NULL)) ? ret : 1;
 250   GNUNET_free ((void*) argv);
 251   return ret;
 252 }
 253
 254 /* end of gnunet-conversation-test.c */