GNUnet  0.11.x
gnunet-conversation-test.c
Go to the documentation of this file.
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 
26 #include "platform.h"
27 #include "gnunet_util_lib.h"
28 #include "gnunet_speaker_lib.h"
29 #include "gnunet_microphone_lib.h"
30 
34 #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5)
35 
36 
40 struct Recording
41 {
45  struct Recording *next;
46 
50  struct Recording *prev;
51 
55  size_t size;
56 };
57 
58 
62 static int ret;
63 
68 
73 
78 
82 static struct GNUNET_SCHEDULER_Task *st;
83 
87 static struct Recording *rec_head;
88 
92 static struct Recording *rec_tail;
93 
94 
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 
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;
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  {
150  "Replaying %u bytes\n",
151  (unsigned int) rec->size);
152  speaker->play (speaker->cls,
153  rec->size,
154  &rec[1]);
155  }
158  &do_shutdown,
159  NULL);
160 }
161 
162 
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;
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);
185  rec_tail,
186  rec);
187 }
188 
189 
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,
213  NULL);
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..."),
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;
228  return;
229  }
230 }
231 
232 
240 int
241 main (int argc,
242  char *const *argv)
243 {
244  static const struct GNUNET_GETOPT_CommandLineOption options[] = {
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 */
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
#define TIMEOUT
How long do we record before we replay?
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
Definition: gnunet-abd.c:36
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_shutdown(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run on shutdown, that is when a CTRL-C signal is received, or when GNUNET_SCHEDULER_shutdown() is being invoked.
Definition: scheduler.c:1300
GNUNET_MICROPHONE_DisableCallback disable_microphone
Turn the microphone off.
int GNUNET_STRINGS_get_utf8_args(int argc, char *const *argv, int *u8argc, char *const **u8argv)
Returns utf-8 encoded arguments.
Definition: strings.c:1438
static size_t data_size
Number of bytes in data.
Definition: gnunet-abd.c:187
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_SPEAKER_Handle * GNUNET_SPEAKER_create_from_hardware(const struct GNUNET_CONFIGURATION_Handle *cfg)
Create a speaker that corresponds to the speaker hardware of our system.
Definition: speaker.c:158
GNUNET_SPEAKER_PlayCallback play
Play audio.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
GNUNET_MICROPHONE_EnableCallback enable_microphone
Turn on the microphone.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
Definition of a command line option.
A recording we made.
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:526
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_OPTION_END
Definition: 002.c:13
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
static int ret
Final status code.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1253
void * cls
Closure for the callbacks.
const char * GNUNET_STRINGS_relative_time_to_string(struct GNUNET_TIME_Relative delta, int do_round)
Give relative time in human-readable fancy format.
Definition: strings.c:687
GNUNET_SPEAKER_EnableCallback enable_speaker
Turn on the speaker.
struct Recording * prev
Kept in a DLL.
static struct Recording * rec_tail
Tail of DLL with recorded frames.
void * cls
Closure for the callbacks.
int main(int argc, char *const *argv)
The main function of our code to test microphone and speaker.
static struct Recording * rec_head
Head of DLL with recorded frames.
static void do_shutdown(void *cls)
Terminate test.
#define GNUNET_CONTAINER_DLL_insert_tail(head, tail, element)
Insert an element at the tail of a DLL.
void GNUNET_SPEAKER_destroy(struct GNUNET_SPEAKER_Handle *speaker)
Destroy a speaker.
Definition: speaker.c:182
static void switch_to_speaker(void *cls)
Terminate recording process and switch to playback.
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.
void GNUNET_MICROPHONE_destroy(struct GNUNET_MICROPHONE_Handle *microphone)
Destroy a microphone.
Definition: microphone.c:193
configuration data
Definition: configuration.c:85
static struct GNUNET_SCHEDULER_Task * switch_task
Task scheduled to switch from recording to playback.
#define GNUNET_log(kind,...)
Entry in list of pending tasks.
Definition: scheduler.c:134
static void record(void *cls, size_t data_size, const void *data)
Process recorded audio data.
size_t size
Number of bytes that follow.
int GNUNET_PROGRAM_run(int argc, char *const *argv, const char *binaryName, const char *binaryHelp, const struct GNUNET_GETOPT_CommandLineOption *options, GNUNET_PROGRAM_Main task, void *task_cls)
Run a standard GNUnet command startup sequence (initialize loggers and configuration, parse options).
Definition: program.c:367
#define GNUNET_YES
Definition: gnunet_common.h:77
A microphone is a device that can capture or otherwise produce audio data.
static struct GNUNET_SCHEDULER_Task * st
The shutdown task.
uint32_t data
The data value.
struct GNUNET_MICROPHONE_Handle * GNUNET_MICROPHONE_create_from_hardware(const struct GNUNET_CONFIGURATION_Handle *cfg)
Create a microphone that corresponds to the microphone hardware of our system.
Definition: microphone.c:170
A speaker is a device that can play or record audio data.
static struct GNUNET_MICROPHONE_Handle * microphone
Handle to the microphone.
#define GNUNET_malloc(size)
Wrapper around malloc.
static struct GNUNET_SPEAKER_Handle * speaker
Handle to the speaker.
#define GNUNET_free(ptr)
Wrapper around free.
struct Recording * next
Kept in a DLL.
#define gettext_noop(String)
Definition: gettext.h:69
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:966