1 /* Copyright (C) 2007-2008 The Android Open Source Project
2 **
3 ** This software is licensed under the terms of the GNU General Public
4 ** License version 2, as published by the Free Software Foundation, and
5 ** may be copied, distributed, and modified under those terms.
6 **
7 ** This program is distributed in the hope that it will be useful,
8 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
9 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 ** GNU General Public License for more details.
11 */
12 #include "qemu_file.h"
13 #include "goldfish_device.h"
14 #include "audio/audio.h"
15 #include "qemu_debug.h"
16 #include "android/globals.h"
17
18 #define DEBUG 1
19
20 #if DEBUG
21 # define D(...) VERBOSE_PRINT(audio,__VA_ARGS__)
22 #else
23 # define D(...) ((void)0)
24 #endif
25
26 extern void dprint(const char* fmt, ...);
27
28 /* define USE_QEMU_AUDIO_IN to 1 to use QEMU's audio subsystem to
29 * implement the audio input. if 0, this will try to read a .wav file
30 * directly...
31 */
32 #define USE_QEMU_AUDIO_IN 1
33
34 enum {
35 /* audio status register */
36 AUDIO_INT_STATUS = 0x00,
37 /* set this to enable IRQ */
38 AUDIO_INT_ENABLE = 0x04,
39 /* set these to specify buffer addresses */
40 AUDIO_SET_WRITE_BUFFER_1 = 0x08,
41 AUDIO_SET_WRITE_BUFFER_2 = 0x0C,
42 /* set number of bytes in buffer to write */
43 AUDIO_WRITE_BUFFER_1 = 0x10,
44 AUDIO_WRITE_BUFFER_2 = 0x14,
45
46 /* true if audio input is supported */
47 AUDIO_READ_SUPPORTED = 0x18,
48 /* buffer to use for audio input */
49 AUDIO_SET_READ_BUFFER = 0x1C,
50
51 /* driver writes number of bytes to read */
52 AUDIO_START_READ = 0x20,
53
54 /* number of bytes available in read buffer */
55 AUDIO_READ_BUFFER_AVAILABLE = 0x24,
56
57 /* AUDIO_INT_STATUS bits */
58
59 /* this bit set when it is safe to write more bytes to the buffer */
60 AUDIO_INT_WRITE_BUFFER_1_EMPTY = 1U << 0,
61 AUDIO_INT_WRITE_BUFFER_2_EMPTY = 1U << 1,
62 AUDIO_INT_READ_BUFFER_FULL = 1U << 2,
63 };
64
65 struct goldfish_audio_buff {
66 uint32_t address;
67 uint32_t length;
68 uint8* data;
69 uint32_t capacity;
70 uint32_t offset;
71 };
72
73
74 struct goldfish_audio_state {
75 struct goldfish_device dev;
76 // buffer flags
77 uint32_t int_status;
78 // irq enable mask for int_status
79 uint32_t int_enable;
80
81 #ifndef USE_QEMU_AUDIO_IN
82 // address of the read buffer
83 uint32_t read_buffer;
84 // path to file or device to use for input
85 const char* input_source;
86 // true if input is a wav file
87 int input_is_wav;
88 // true if we need to convert stereo -> mono
89 int input_is_stereo;
90 // file descriptor to use for input
91 int input_fd;
92 #endif
93
94 // number of bytes available in the read buffer
95 int read_buffer_available;
96
97 // set to 1 or 2 to indicate which buffer we are writing from, or zero if both buffers are empty
98 int current_buffer;
99
100 // current data to write
101 struct goldfish_audio_buff out_buff1[1];
102 struct goldfish_audio_buff out_buff2[1];
103 struct goldfish_audio_buff in_buff[1];
104
105 // for QEMU sound output
106 QEMUSoundCard card;
107 SWVoiceOut *voice;
108 #if USE_QEMU_AUDIO_IN
109 SWVoiceIn* voicein;
110 #endif
111 };
112
113 static void
goldfish_audio_buff_init(struct goldfish_audio_buff * b)114 goldfish_audio_buff_init( struct goldfish_audio_buff* b )
115 {
116 b->address = 0;
117 b->length = 0;
118 b->data = NULL;
119 b->capacity = 0;
120 b->offset = 0;
121 }
122
123 static void
goldfish_audio_buff_reset(struct goldfish_audio_buff * b)124 goldfish_audio_buff_reset( struct goldfish_audio_buff* b )
125 {
126 b->offset = 0;
127 b->length = 0;
128 }
129
130 static uint32_t
goldfish_audio_buff_length(struct goldfish_audio_buff * b)131 goldfish_audio_buff_length( struct goldfish_audio_buff* b )
132 {
133 return b->length;
134 }
135
136 static void
goldfish_audio_buff_ensure(struct goldfish_audio_buff * b,uint32_t size)137 goldfish_audio_buff_ensure( struct goldfish_audio_buff* b, uint32_t size )
138 {
139 if (b->capacity < size) {
140 b->data = qemu_realloc(b->data, size);
141 b->capacity = size;
142 }
143 }
144
145 static void
goldfish_audio_buff_set_address(struct goldfish_audio_buff * b,uint32_t addr)146 goldfish_audio_buff_set_address( struct goldfish_audio_buff* b, uint32_t addr )
147 {
148 b->address = addr;
149 }
150
151 static void
goldfish_audio_buff_set_length(struct goldfish_audio_buff * b,uint32_t len)152 goldfish_audio_buff_set_length( struct goldfish_audio_buff* b, uint32_t len )
153 {
154 b->length = len;
155 b->offset = 0;
156 goldfish_audio_buff_ensure(b, len);
157 }
158
159 static void
goldfish_audio_buff_read(struct goldfish_audio_buff * b)160 goldfish_audio_buff_read( struct goldfish_audio_buff* b )
161 {
162 cpu_physical_memory_read(b->address, b->data, b->length);
163 }
164
165 static void
goldfish_audio_buff_write(struct goldfish_audio_buff * b)166 goldfish_audio_buff_write( struct goldfish_audio_buff* b )
167 {
168 cpu_physical_memory_write(b->address, b->data, b->length);
169 }
170
171 static int
goldfish_audio_buff_send(struct goldfish_audio_buff * b,int free,struct goldfish_audio_state * s)172 goldfish_audio_buff_send( struct goldfish_audio_buff* b, int free, struct goldfish_audio_state* s )
173 {
174 int ret, write = b->length;
175
176 if (write > free)
177 write = free;
178
179 ret = AUD_write(s->voice, b->data + b->offset, write);
180 b->offset += ret;
181 b->length -= ret;
182 return ret;
183 }
184
185 static int
goldfish_audio_buff_available(struct goldfish_audio_buff * b)186 goldfish_audio_buff_available( struct goldfish_audio_buff* b )
187 {
188 return b->length - b->offset;
189 }
190
191 static int
goldfish_audio_buff_recv(struct goldfish_audio_buff * b,int avail,struct goldfish_audio_state * s)192 goldfish_audio_buff_recv( struct goldfish_audio_buff* b, int avail, struct goldfish_audio_state* s )
193 {
194 int missing = b->length - b->offset;
195 int avail2 = (avail > missing) ? missing : avail;
196 int read;
197
198 read = AUD_read(s->voicein, b->data + b->offset, avail2 );
199 if (read == 0)
200 return 0;
201
202 if (avail2 > 0)
203 D("%s: AUD_read(%d) returned %d", __FUNCTION__, avail2, read);
204
205 cpu_physical_memory_write( b->address + b->offset, b->data, read );
206 b->offset += read;
207
208 return read;
209 }
210
211 static void
goldfish_audio_buff_put(struct goldfish_audio_buff * b,QEMUFile * f)212 goldfish_audio_buff_put( struct goldfish_audio_buff* b, QEMUFile* f )
213 {
214 qemu_put_be32(f, b->address );
215 qemu_put_be32(f, b->length );
216 qemu_put_be32(f, b->offset );
217 qemu_put_buffer(f, b->data, b->length );
218 }
219
220 static void
goldfish_audio_buff_get(struct goldfish_audio_buff * b,QEMUFile * f)221 goldfish_audio_buff_get( struct goldfish_audio_buff* b, QEMUFile* f )
222 {
223 b->address = qemu_get_be32(f);
224 b->length = qemu_get_be32(f);
225 b->offset = qemu_get_be32(f);
226 goldfish_audio_buff_ensure(b, b->length);
227 qemu_get_buffer(f, b->data, b->length);
228 }
229
230 /* update this whenever you change the goldfish_audio_state structure */
231 #define AUDIO_STATE_SAVE_VERSION 2
232
233 #define QFIELD_STRUCT struct goldfish_audio_state
234 QFIELD_BEGIN(audio_state_fields)
QFIELD_INT32(int_status)235 QFIELD_INT32(int_status),
236 QFIELD_INT32(int_enable),
237 QFIELD_INT32(read_buffer_available),
238 QFIELD_INT32(current_buffer),
239 QFIELD_END
240
241 static void audio_state_save( QEMUFile* f, void* opaque )
242 {
243 struct goldfish_audio_state* s = opaque;
244
245 qemu_put_struct(f, audio_state_fields, s);
246
247 goldfish_audio_buff_put (s->out_buff1, f);
248 goldfish_audio_buff_put (s->out_buff2, f);
249 goldfish_audio_buff_put (s->in_buff, f);
250 }
251
audio_state_load(QEMUFile * f,void * opaque,int version_id)252 static int audio_state_load( QEMUFile* f, void* opaque, int version_id )
253 {
254 struct goldfish_audio_state* s = opaque;
255 int ret;
256
257 if (version_id != AUDIO_STATE_SAVE_VERSION)
258 return -1;
259
260 ret = qemu_get_struct(f, audio_state_fields, s);
261 if (!ret) {
262 goldfish_audio_buff_get( s->out_buff1, f );
263 goldfish_audio_buff_get( s->out_buff2, f );
264 goldfish_audio_buff_get (s->in_buff, f);
265 }
266 return ret;
267 }
268
enable_audio(struct goldfish_audio_state * s,int enable)269 static void enable_audio(struct goldfish_audio_state *s, int enable)
270 {
271 // enable or disable the output voice
272 if (s->voice != NULL) {
273 AUD_set_active_out(s->voice, (enable & (AUDIO_INT_WRITE_BUFFER_1_EMPTY | AUDIO_INT_WRITE_BUFFER_2_EMPTY)) != 0);
274 goldfish_audio_buff_reset( s->out_buff1 );
275 goldfish_audio_buff_reset( s->out_buff2 );
276 }
277
278 if (s->voicein) {
279 AUD_set_active_in (s->voicein, (enable & AUDIO_INT_READ_BUFFER_FULL) != 0);
280 goldfish_audio_buff_reset( s->in_buff );
281 }
282 s->current_buffer = 0;
283 }
284
285 #if USE_QEMU_AUDIO_IN
start_read(struct goldfish_audio_state * s,uint32_t count)286 static void start_read(struct goldfish_audio_state *s, uint32_t count)
287 {
288 //printf( "... goldfish audio start_read, count=%d\n", count );
289 goldfish_audio_buff_set_length( s->in_buff, count );
290 s->read_buffer_available = count;
291 }
292 #else
start_read(struct goldfish_audio_state * s,uint32_t count)293 static void start_read(struct goldfish_audio_state *s, uint32_t count)
294 {
295 uint8 wav_header[44];
296 int result;
297
298 if (!s->input_source) return;
299
300 if (s->input_fd < 0) {
301 s->input_fd = open(s->input_source, O_BINARY | O_RDONLY);
302
303 if (s->input_fd < 0) {
304 fprintf(stderr, "goldfish_audio could not open %s for audio input\n", s->input_source);
305 s->input_source = NULL; // set to to avoid endless retries
306 return;
307 }
308
309 // skip WAV header if we have a WAV file
310 if (s->input_is_wav) {
311 if (read(s->input_fd, wav_header, sizeof(wav_header)) != sizeof(wav_header)) {
312 fprintf(stderr, "goldfish_audio could not read WAV file header %s\n", s->input_source);
313 s->input_fd = -1;
314 s->input_source = NULL; // set to to avoid endless retries
315 return;
316 }
317
318 // is the WAV file stereo?
319 s->input_is_stereo = (wav_header[22] == 2);
320 } else {
321 // assume input from an audio device is stereo
322 s->input_is_stereo = 1;
323 }
324 }
325
326 uint8* buffer = (uint8*)phys_ram_base + s->read_buffer;
327 if (s->input_is_stereo) {
328 // need to read twice as much data
329 count *= 2;
330 }
331
332 try_again:
333 result = read(s->input_fd, buffer, count);
334 if (result == 0 && s->input_is_wav) {
335 // end of file, so seek back to the beginning
336 lseek(s->input_fd, sizeof(wav_header), SEEK_SET);
337 goto try_again;
338 }
339
340 if (result > 0 && s->input_is_stereo) {
341 // we need to convert stereo to mono
342 uint8* src = (uint8*)buffer;
343 uint8* dest = src;
344 int count = result/2;
345 while (count-- > 0) {
346 int sample1 = src[0] | (src[1] << 8);
347 int sample2 = src[2] | (src[3] << 8);
348 int sample = (sample1 + sample2) >> 1;
349 dst[0] = (uint8_t) sample;
350 dst[1] = (uint8_t)(sample >> 8);
351 src += 4;
352 dst += 2;
353 }
354
355 // we reduced the number of bytes by 2
356 result /= 2;
357 }
358
359 s->read_buffer_available = (result > 0 ? result : 0);
360 s->int_status |= AUDIO_INT_READ_BUFFER_FULL;
361 goldfish_device_set_irq(&s->dev, 0, (s->int_status & s->int_enable));
362 }
363 #endif
364
goldfish_audio_read(void * opaque,target_phys_addr_t offset)365 static uint32_t goldfish_audio_read(void *opaque, target_phys_addr_t offset)
366 {
367 uint32_t ret;
368 struct goldfish_audio_state *s = opaque;
369 switch(offset) {
370 case AUDIO_INT_STATUS:
371 // return current buffer status flags
372 ret = s->int_status & s->int_enable;
373 if(ret) {
374 goldfish_device_set_irq(&s->dev, 0, 0);
375 }
376 return ret;
377
378 case AUDIO_READ_SUPPORTED:
379 #if USE_QEMU_AUDIO_IN
380 D("%s: AUDIO_READ_SUPPORTED returns %d", __FUNCTION__,
381 (s->voicein != NULL));
382 return (s->voicein != NULL);
383 #else
384 return (s->input_source ? 1 : 0);
385 #endif
386
387 case AUDIO_READ_BUFFER_AVAILABLE:
388 D("%s: AUDIO_READ_BUFFER_AVAILABLE returns %d", __FUNCTION__,
389 s->read_buffer_available);
390 goldfish_audio_buff_write( s->in_buff );
391 return s->read_buffer_available;
392
393 default:
394 cpu_abort (cpu_single_env, "goldfish_audio_read: Bad offset %x\n", offset);
395 return 0;
396 }
397 }
398
goldfish_audio_write(void * opaque,target_phys_addr_t offset,uint32_t val)399 static void goldfish_audio_write(void *opaque, target_phys_addr_t offset, uint32_t val)
400 {
401 struct goldfish_audio_state *s = opaque;
402
403 switch(offset) {
404 case AUDIO_INT_ENABLE:
405 /* enable buffer empty interrupts */
406 D("%s: AUDIO_INT_ENABLE %d", __FUNCTION__, val );
407 enable_audio(s, val);
408 s->int_enable = val;
409 s->int_status = (AUDIO_INT_WRITE_BUFFER_1_EMPTY | AUDIO_INT_WRITE_BUFFER_2_EMPTY);
410 goldfish_device_set_irq(&s->dev, 0, (s->int_status & s->int_enable));
411 break;
412 case AUDIO_SET_WRITE_BUFFER_1:
413 /* save pointer to buffer 1 */
414 D( "%s: AUDIO_SET_WRITE_BUFFER_1 %08x", __FUNCTION__, val);
415 goldfish_audio_buff_set_address( s->out_buff1, val );
416 break;
417 case AUDIO_SET_WRITE_BUFFER_2:
418 /* save pointer to buffer 2 */
419 D( "%s: AUDIO_SET_WRITE_BUFFER_2 %08x", __FUNCTION__, val);
420 goldfish_audio_buff_set_address( s->out_buff2, val );
421 break;
422 case AUDIO_WRITE_BUFFER_1:
423 /* record that data in buffer 1 is ready to write */
424 //D( "%s: AUDIO_WRITE_BUFFER_1 %08x", __FUNCTION__, val);
425 if (s->current_buffer == 0) s->current_buffer = 1;
426 goldfish_audio_buff_set_length( s->out_buff1, val );
427 goldfish_audio_buff_read( s->out_buff1 );
428 s->int_status &= ~AUDIO_INT_WRITE_BUFFER_1_EMPTY;
429 break;
430 case AUDIO_WRITE_BUFFER_2:
431 /* record that data in buffer 2 is ready to write */
432 //D( "%s: AUDIO_WRITE_BUFFER_2 %08x", __FUNCTION__, val);
433 if (s->current_buffer == 0) s->current_buffer = 2;
434 goldfish_audio_buff_set_length( s->out_buff2, val );
435 goldfish_audio_buff_read( s->out_buff2 );
436 s->int_status &= ~AUDIO_INT_WRITE_BUFFER_2_EMPTY;
437 break;
438
439 case AUDIO_SET_READ_BUFFER:
440 /* save pointer to the read buffer */
441 goldfish_audio_buff_set_address( s->in_buff, val );
442 D( "%s: AUDIO_SET_READ_BUFFER %08x", __FUNCTION__, val );
443 break;
444
445 case AUDIO_START_READ:
446 D( "%s: AUDIO_START_READ %d", __FUNCTION__, val );
447 start_read(s, val);
448 s->int_status &= ~AUDIO_INT_READ_BUFFER_FULL;
449 goldfish_device_set_irq(&s->dev, 0, (s->int_status & s->int_enable));
450 break;
451
452 default:
453 cpu_abort (cpu_single_env, "goldfish_audio_write: Bad offset %x\n", offset);
454 }
455 }
456
goldfish_audio_callback(void * opaque,int free)457 static void goldfish_audio_callback(void *opaque, int free)
458 {
459 struct goldfish_audio_state *s = opaque;
460 int new_status = 0;
461
462 /* loop until free is zero or both buffers are empty */
463 while (free && s->current_buffer) {
464
465 /* write data in buffer 1 */
466 while (free && s->current_buffer == 1) {
467 int written = goldfish_audio_buff_send( s->out_buff1, free, s );
468 if (written) {
469 D("%s: sent %5d bytes to audio output (buffer 1)", __FUNCTION__, written);
470 free -= written;
471
472 if (goldfish_audio_buff_length( s->out_buff1 ) == 0) {
473 new_status |= AUDIO_INT_WRITE_BUFFER_1_EMPTY;
474 s->current_buffer = (goldfish_audio_buff_length( s->out_buff2 ) ? 2 : 0);
475 }
476 } else {
477 break;
478 }
479 }
480
481 /* write data in buffer 2 */
482 while (free && s->current_buffer == 2) {
483 int written = goldfish_audio_buff_send( s->out_buff2, free, s );
484 if (written) {
485 D("%s: sent %5d bytes to audio output (buffer 2)", __FUNCTION__, written);
486 free -= written;
487
488 if (goldfish_audio_buff_length( s->out_buff2 ) == 0) {
489 new_status |= AUDIO_INT_WRITE_BUFFER_2_EMPTY;
490 s->current_buffer = (goldfish_audio_buff_length( s->out_buff1 ) ? 1 : 0);
491 }
492 } else {
493 break;
494 }
495 }
496 }
497
498 if (new_status && new_status != s->int_status) {
499 s->int_status |= new_status;
500 goldfish_device_set_irq(&s->dev, 0, (s->int_status & s->int_enable));
501 }
502 }
503
504 #if USE_QEMU_AUDIO_IN
505 static void
goldfish_audio_in_callback(void * opaque,int avail)506 goldfish_audio_in_callback(void *opaque, int avail)
507 {
508 struct goldfish_audio_state *s = opaque;
509 int new_status = 0;
510
511 if (goldfish_audio_buff_available( s->in_buff ) == 0 )
512 return;
513
514 while (avail > 0) {
515 int read = goldfish_audio_buff_recv( s->in_buff, avail, s );
516 if (read == 0)
517 break;
518
519 avail -= read;
520
521 if (goldfish_audio_buff_available( s->in_buff) == 0) {
522 new_status |= AUDIO_INT_READ_BUFFER_FULL;
523 D("%s: AUDIO_INT_READ_BUFFER_FULL available=%d",
524 __FUNCTION__, goldfish_audio_buff_length( s->in_buff ));
525 break;
526 }
527 }
528
529 if (new_status && new_status != s->int_status) {
530 s->int_status |= new_status;
531 goldfish_device_set_irq(&s->dev, 0, (s->int_status & s->int_enable));
532 }
533 }
534 #endif /* USE_QEMU_AUDIO_IN */
535
536 static CPUReadMemoryFunc *goldfish_audio_readfn[] = {
537 goldfish_audio_read,
538 goldfish_audio_read,
539 goldfish_audio_read
540 };
541
542 static CPUWriteMemoryFunc *goldfish_audio_writefn[] = {
543 goldfish_audio_write,
544 goldfish_audio_write,
545 goldfish_audio_write
546 };
547
goldfish_audio_init(uint32_t base,int id,const char * input_source)548 void goldfish_audio_init(uint32_t base, int id, const char* input_source)
549 {
550 struct goldfish_audio_state *s;
551 struct audsettings as;
552
553 /* nothing to do if no audio input and output */
554 if (!android_hw->hw_audioOutput && !android_hw->hw_audioInput)
555 return;
556
557 s = (struct goldfish_audio_state *)qemu_mallocz(sizeof(*s));
558 s->dev.name = "goldfish_audio";
559 s->dev.id = id;
560 s->dev.base = base;
561 s->dev.size = 0x1000;
562 s->dev.irq_count = 1;
563
564 #ifndef USE_QEMU_AUDIO_IN
565 s->input_fd = -1;
566 if (input_source) {
567 s->input_source = input_source;
568 char* extension = strrchr(input_source, '.');
569 if (extension && strcasecmp(extension, ".wav") == 0) {
570 s->input_is_wav = 1;
571 }
572 }
573 #endif
574
575 AUD_register_card( "goldfish_audio", &s->card);
576
577 as.freq = 44100;
578 as.nchannels = 2;
579 as.fmt = AUD_FMT_S16;
580 as.endianness = AUDIO_HOST_ENDIANNESS;
581
582 if (android_hw->hw_audioOutput) {
583 s->voice = AUD_open_out (
584 &s->card,
585 NULL,
586 "goldfish_audio",
587 s,
588 goldfish_audio_callback,
589 &as
590 );
591 if (!s->voice) {
592 dprint("warning: opening audio output failed\n");
593 return;
594 }
595 }
596
597 #if USE_QEMU_AUDIO_IN
598 as.freq = 8000;
599 as.nchannels = 1;
600 as.fmt = AUD_FMT_S16;
601 as.endianness = AUDIO_HOST_ENDIANNESS;
602
603 if (android_hw->hw_audioInput) {
604 s->voicein = AUD_open_in (
605 &s->card,
606 NULL,
607 "goldfish_audio_in",
608 s,
609 goldfish_audio_in_callback,
610 &as
611 );
612 if (!s->voicein) {
613 dprint("warning: opening audio input failed\n");
614 }
615 }
616 #endif
617
618 goldfish_audio_buff_init( s->out_buff1 );
619 goldfish_audio_buff_init( s->out_buff2 );
620 goldfish_audio_buff_init( s->in_buff );
621
622 goldfish_device_add(&s->dev, goldfish_audio_readfn, goldfish_audio_writefn, s);
623
624 register_savevm( "audio_state", 0, AUDIO_STATE_SAVE_VERSION,
625 audio_state_save, audio_state_load, s );
626 }
627
628