auto import from //depot/cupcake/@135843

1 files changed, 0 insertions, 533 deletions

diff --git a/hw/goldfish_audio.c b/hw/goldfish_audio.c
deleted file mode 100644
index d0a44b5..0000000
--- a/hw/goldfish_audio.c
+++ /dev/null
@@ -1,533 +0,0 @@
-/* Copyright (C) 2007-2008 The Android Open Source Project
-**
-** This software is licensed under the terms of the GNU General Public
-** License version 2, as published by the Free Software Foundation, and
-** may be copied, distributed, and modified under those terms.
-**
-** This program is distributed in the hope that it will be useful,
-** but WITHOUT ANY WARRANTY; without even the implied warranty of
-** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-** GNU General Public License for more details.
-*/
-#include "qemu_file.h"
-#include "goldfish_device.h"
-#include "audio/audio.h"
-#include "qemu_debug.h"
-#include "android/globals.h"
-
-#define  DEBUG  1
-
-#if DEBUG
-#  define  D(...)  VERBOSE_PRINT(audio,__VA_ARGS__)
-#else
-#  define  D(...)  ((void)0)
-#endif
-
-extern void  dprint(const char*  fmt, ...);
-
-/* define USE_QEMU_AUDIO_IN to 1 to use QEMU's audio subsystem to
- * implement the audio input. if 0, this will try to read a .wav file
- * directly...
- */
-#define  USE_QEMU_AUDIO_IN  1
-
-enum {
-	/* audio status register */
-	AUDIO_INT_STATUS	= 0x00,
-	/* set this to enable IRQ */
-	AUDIO_INT_ENABLE	= 0x04,
-	/* set these to specify buffer addresses */
-	AUDIO_SET_WRITE_BUFFER_1 = 0x08,
-	AUDIO_SET_WRITE_BUFFER_2 = 0x0C,
-	/* set number of bytes in buffer to write */
-	AUDIO_WRITE_BUFFER_1  = 0x10,
-	AUDIO_WRITE_BUFFER_2  = 0x14,
-
-	/* true if audio input is supported */
-	AUDIO_READ_SUPPORTED = 0x18,
-	/* buffer to use for audio input */
-	AUDIO_SET_READ_BUFFER = 0x1C,
-
-	/* driver writes number of bytes to read */
-	AUDIO_START_READ  = 0x20,
-
-	/* number of bytes available in read buffer */
-	AUDIO_READ_BUFFER_AVAILABLE  = 0x24,
-
-	/* AUDIO_INT_STATUS bits */
-
-	/* this bit set when it is safe to write more bytes to the buffer */
-	AUDIO_INT_WRITE_BUFFER_1_EMPTY	= 1U << 0,
-	AUDIO_INT_WRITE_BUFFER_2_EMPTY	= 1U << 1,
-	AUDIO_INT_READ_BUFFER_FULL      = 1U << 2,
-};
-
-
-struct goldfish_audio_state {
-    struct goldfish_device dev;
-    // pointers to our two write buffers
-    uint32_t buffer_1, buffer_2;
-    uint32_t read_buffer;
-    // buffer flags
-    uint32_t int_status;
-    // irq enable mask for int_status
-    uint32_t int_enable;
-
-#if USE_QEMU_AUDIO_IN
-    uint32_t  read_pos;
-    uint32_t  read_size;
-#else
-    // path to file or device to use for input
-    const char* input_source;
-    // true if input is a wav file
-    int input_is_wav;
-    // true if we need to convert stereo -> mono
-    int input_is_stereo;
-    // file descriptor to use for input
-    int input_fd;
-#endif
-
-    // number of bytes available in the read buffer
-    int read_buffer_available;
-
-    // set to 1 or 2 to indicate which buffer we are writing from, or zero if both buffers are empty
-    int current_buffer;
-
-    // current data to write
-    uint8* data_1;
-    uint32_t data_1_length;
-    uint8* data_2;
-    uint32_t data_2_length;
-
-
-    // for QEMU sound output
-    QEMUSoundCard card;
-    SWVoiceOut *voice;
-#if USE_QEMU_AUDIO_IN
-    SWVoiceIn*  voicein;
-#endif
-};
-
-/* update this whenever you change the goldfish_audio_state structure */
-#define  AUDIO_STATE_SAVE_VERSION  1
-
-#define  QFIELD_STRUCT   struct goldfish_audio_state
-QFIELD_BEGIN(audio_state_fields)
-    QFIELD_INT32(buffer_1),
-    QFIELD_INT32(buffer_2),
-    QFIELD_INT32(read_buffer),
-    QFIELD_INT32(int_status),
-    QFIELD_INT32(int_enable),
-#if USE_QEMU_AUDIO_IN
-    QFIELD_INT32(read_pos),
-    QFIELD_INT32(read_size),
-#endif
-    QFIELD_INT32(read_buffer_available),
-    QFIELD_INT32(current_buffer),
-    QFIELD_INT32(data_1_length),
-    QFIELD_INT32(data_2_length),
-QFIELD_END
-
-static void  audio_state_save( QEMUFile*  f, void* opaque )
-{
-    struct goldfish_audio_state*  s = opaque;
-
-    qemu_put_struct(f, audio_state_fields, s);
-
-    /* we can't write data_1 and data_2 directly */
-    qemu_put_be32( f, s->data_1 - phys_ram_base );
-    qemu_put_be32( f, s->data_2 - phys_ram_base );
-}
-
-static int   audio_state_load( QEMUFile*  f, void*  opaque, int  version_id )
-{
-    struct goldfish_audio_state*  s = opaque;
-    int                           ret;
-
-    if (version_id != AUDIO_STATE_SAVE_VERSION)
-        return -1;
-
-    ret = qemu_get_struct(f, audio_state_fields, s);
-    if (!ret) {
-        s->data_1 = qemu_get_be32(f) + phys_ram_base;
-        s->data_2 = qemu_get_be32(f) + phys_ram_base;
-    }
-    return -1;
-}
-
-static void enable_audio(struct goldfish_audio_state *s, int enable)
-{
-    // enable or disable the output voice
-    if (s->voice != NULL)
-        AUD_set_active_out(s->voice,   (enable & (AUDIO_INT_WRITE_BUFFER_1_EMPTY | AUDIO_INT_WRITE_BUFFER_2_EMPTY)) != 0);
-
-    if (s->voicein)
-        AUD_set_active_in (s->voicein, (enable & AUDIO_INT_READ_BUFFER_FULL) != 0);
-    // reset buffer information
-    s->data_1_length = 0;
-    s->data_2_length = 0;
-    s->current_buffer = 0;
-    s->read_pos = 0;
-}
-
-#if USE_QEMU_AUDIO_IN
-static void start_read(struct goldfish_audio_state *s, uint32_t count)
-{
-    //printf( "... goldfish audio start_read, count=%d\n", count );
-    s->read_size = count;
-    s->read_buffer_available = 0;
-    s->read_pos  = 0;
-}
-#else
-static void start_read(struct goldfish_audio_state *s, uint32_t count)
-{
-    uint8   wav_header[44];
-    int result;
-
-    if (!s->input_source) return;
-
-    if (s->input_fd < 0) {
-        s->input_fd = open(s->input_source, O_BINARY | O_RDONLY);
-
-        if (s->input_fd < 0) {
-            fprintf(stderr, "goldfish_audio could not open %s for audio input\n", s->input_source);
-            s->input_source = NULL; // set to to avoid endless retries
-            return;
-        }
-
-        // skip WAV header if we have a WAV file
-        if (s->input_is_wav) {
-            if (read(s->input_fd, wav_header, sizeof(wav_header)) != sizeof(wav_header)) {
-                fprintf(stderr, "goldfish_audio could not read WAV file header %s\n", s->input_source);
-                s->input_fd = -1;
-                s->input_source = NULL; // set to to avoid endless retries
-                return;
-            }
-
-            // is the WAV file stereo?
-            s->input_is_stereo = (wav_header[22] == 2);
-        } else {
-            // assume input from an audio device is stereo
-            s->input_is_stereo = 1;
-        }
-    }
-
-    uint8* buffer = (uint8*)phys_ram_base + s->read_buffer;
-    if (s->input_is_stereo) {
-        // need to read twice as much data
-        count *= 2;
-    }
-
-try_again:
-    result = read(s->input_fd, buffer, count);
-    if (result == 0 && s->input_is_wav) {
-        // end of file, so seek back to the beginning
-       lseek(s->input_fd, sizeof(wav_header), SEEK_SET);
-       goto try_again;
-    }
-
-    if (result > 0 && s->input_is_stereo) {
-        // we need to convert stereo to mono
-        uint8* src  = (uint8*)buffer;
-        uint8* dest = src;
-        int count = result/2;
-        while (count-- > 0) {
-            int  sample1 = src[0] | (src[1] << 8);
-            int  sample2 = src[2] | (src[3] << 8);
-            int  sample  = (sample1 + sample2) >> 1;
-            dst[0] = (uint8_t) sample;
-            dst[1] = (uint8_t)(sample >> 8);
-            src   += 4;
-            dst   += 2;
-        }
-
-        // we reduced the number of bytes by 2
-        result /= 2;
-    }
-
-    s->read_buffer_available = (result > 0 ? result : 0);
-    s->int_status |= AUDIO_INT_READ_BUFFER_FULL;
-    goldfish_device_set_irq(&s->dev, 0, (s->int_status & s->int_enable));
-}
-#endif
-
-static uint32_t goldfish_audio_read(void *opaque, target_phys_addr_t offset)
-{
-    uint32_t ret;
-    struct goldfish_audio_state *s = opaque;
-    offset -= s->dev.base;
-    switch(offset) {
-        case AUDIO_INT_STATUS:
-            // return current buffer status flags
-            ret = s->int_status & s->int_enable;
-            if(ret) {
-                goldfish_device_set_irq(&s->dev, 0, 0);
-            }
-            return ret;
-
-	case AUDIO_READ_SUPPORTED:
-#if USE_QEMU_AUDIO_IN
-            D("%s: AUDIO_READ_SUPPORTED returns %d", __FUNCTION__,
-              (s->voicein != NULL));
-            return (s->voicein != NULL);
-#else
-            return (s->input_source ? 1 : 0);
-#endif
-
-	case AUDIO_READ_BUFFER_AVAILABLE:
-            D("%s: AUDIO_READ_BUFFER_AVAILABLE returns %d", __FUNCTION__,
-               s->read_buffer_available);
-	    return s->read_buffer_available;
-
-        default:
-            cpu_abort (cpu_single_env, "goldfish_audio_read: Bad offset %x\n", offset);
-            return 0;
-    }
-}
-
-static void goldfish_audio_write(void *opaque, target_phys_addr_t offset, uint32_t val)
-{
-    struct goldfish_audio_state *s = opaque;
-    offset -= s->dev.base;
-
-    switch(offset) {
-        case AUDIO_INT_ENABLE:
-            /* enable buffer empty interrupts */
-            D("%s: AUDIO_INT_ENABLE %d", __FUNCTION__, val );
-            enable_audio(s, val);
-            s->int_enable = val;
-            s->int_status = (AUDIO_INT_WRITE_BUFFER_1_EMPTY | AUDIO_INT_WRITE_BUFFER_2_EMPTY);
-            goldfish_device_set_irq(&s->dev, 0, (s->int_status & s->int_enable));
-            break;
-        case AUDIO_SET_WRITE_BUFFER_1:
-            /* save pointer to buffer 1 */
-            s->buffer_1 = val;
-            break;
-        case AUDIO_SET_WRITE_BUFFER_2:
-            /* save pointer to buffer 2 */
-            s->buffer_2 = val;
-            break;
-        case AUDIO_WRITE_BUFFER_1:
-            /* record that data in buffer 1 is ready to write */
-            if (s->current_buffer == 0) s->current_buffer = 1;
-            s->data_1 = phys_ram_base + s->buffer_1;
-            s->data_1_length = val;
-            s->int_status &= ~AUDIO_INT_WRITE_BUFFER_1_EMPTY;
-            break;
-        case AUDIO_WRITE_BUFFER_2:
-            /* record that data in buffer 2 is ready to write */
-            if (s->current_buffer == 0) s->current_buffer = 2;
-            s->data_2 = phys_ram_base + s->buffer_2;
-            s->data_2_length = val;
-            s->int_status &= ~AUDIO_INT_WRITE_BUFFER_2_EMPTY;
-            break;
-
-	case AUDIO_SET_READ_BUFFER:
-            /* save pointer to the read buffer */
-            s->read_buffer = val;
-            D( "%s: AUDIO_SET_READ_BUFFER %p", __FUNCTION__, (void*)val );
-            break;
-
-        case AUDIO_START_READ:
-            D( "%s: AUDIO_START_READ %d", __FUNCTION__, val );
-            start_read(s, val);
-            s->int_status &= ~AUDIO_INT_READ_BUFFER_FULL;
-            goldfish_device_set_irq(&s->dev, 0, (s->int_status & s->int_enable));
-            break;
-
-        default:
-            cpu_abort (cpu_single_env, "goldfish_audio_write: Bad offset %x\n", offset);
-    }
-}
-
-static void goldfish_audio_callback(void *opaque, int free)
-{
-    struct goldfish_audio_state *s = opaque;
-    int new_status = 0;
-
-    /* loop until free is zero or both buffers are empty */
-    while (free && s->current_buffer) {
-
-        /* write data in buffer 1 */
-        while (free && s->current_buffer == 1) {
-            int write = s->data_1_length;
-            if (write > free) write = free;
-
-            int written = AUD_write(s->voice, s->data_1, write);
-            if (written) {
-                D("%s: sent %d bytes to audio output", __FUNCTION__, write);
-                s->data_1 += written;
-                s->data_1_length -= written;
-                free -= written;
-
-                if (s->data_1_length == 0) {
-                    new_status |= AUDIO_INT_WRITE_BUFFER_1_EMPTY;
-                    s->current_buffer = (s->data_2_length ? 2 : 0);
-                }
-            } else {
-                break;
-            }
-        }
-
-        /* write data in buffer 2 */
-        while (free && s->current_buffer == 2) {
-            int write = s->data_2_length;
-            if (write > free) write = free;
-
-            int written = AUD_write(s->voice, s->data_2, write);
-            if (written) {
-                D("%s: sent %d bytes to audio output", __FUNCTION__, write);
-                s->data_2 += written;
-                s->data_2_length -= written;
-                free -= written;
-
-                if (s->data_2_length == 0) {
-                    new_status |= AUDIO_INT_WRITE_BUFFER_2_EMPTY;
-                    s->current_buffer = (s->data_1_length ? 1 : 0);
-                }
-            } else {
-                break;
-            }
-        }
-    }
-
-    if (new_status && new_status != s->int_status) {
-        s->int_status |= new_status;
-        goldfish_device_set_irq(&s->dev, 0, (s->int_status & s->int_enable));
-    }
-}
-
-#if USE_QEMU_AUDIO_IN
-static void
-goldfish_audio_in_callback(void *opaque, int avail)
-{
-    struct goldfish_audio_state *s = opaque;
-    int new_status = 0;
-
-    if (s->read_pos >= s->read_size)
-        return;
-
-    if (0 && s->read_size > 0)
-        D("%s: in %d (pos=%d size=%d)", __FUNCTION__,
-           avail, s->read_pos, s->read_size );
-
-    while (avail > 0) {
-        int     pos     = s->read_pos;
-        int     missing = s->read_size - pos;
-        uint8*  buffer  = (uint8*)phys_ram_base + s->read_buffer + pos;
-        int     read;
-        int     avail2 = (avail > missing) ? missing : avail;
-
-        read = AUD_read(s->voicein, buffer, avail2);
-        if (read == 0)
-            break;
-
-        if (avail2 > 0)
-            D("%s: AUD_read(%d) returned %d", __FUNCTION__, avail2, read);
-
-        s->read_buffer_available += read;
-
-        avail -= read;
-        pos   += read;
-        if (pos == s->read_size) {
-            new_status |= AUDIO_INT_READ_BUFFER_FULL;
-            D("%s: AUDIO_INT_READ_BUFFER_FULL available=%d", __FUNCTION__, s->read_buffer_available);
-        }
-        s->read_pos = pos;
-    }
-
-    if (new_status && new_status != s->int_status) {
-        s->int_status |= new_status;
-        goldfish_device_set_irq(&s->dev, 0, (s->int_status & s->int_enable));
-    }
-}
-#endif /* USE_QEMU_AUDIO_IN */
-
-static CPUReadMemoryFunc *goldfish_audio_readfn[] = {
-   goldfish_audio_read,
-   goldfish_audio_read,
-   goldfish_audio_read
-};
-
-static CPUWriteMemoryFunc *goldfish_audio_writefn[] = {
-   goldfish_audio_write,
-   goldfish_audio_write,
-   goldfish_audio_write
-};
-
-void goldfish_audio_init(uint32_t base, int id, const char* input_source)
-{
-    struct goldfish_audio_state *s;
-    audsettings_t as;
-
-    /* nothing to do if no audio input and output */
-    if (!android_hw->hw_audioOutput && !android_hw->hw_audioInput)
-        return;
-
-    s = (struct goldfish_audio_state *)qemu_mallocz(sizeof(*s));
-    s->dev.name = "goldfish_audio";
-    s->dev.id = id;
-    s->dev.base = base;
-    s->dev.size = 0x1000;
-    s->dev.irq_count = 1;
-
-#ifndef USE_QEMU_AUDIO_IN
-    s->input_fd = -1;
-    if (input_source) {
-        s->input_source = input_source;
-        char* extension = strrchr(input_source, '.');
-        if (extension && strcasecmp(extension, ".wav") == 0) {
-            s->input_is_wav = 1;
-        }
-     }
-#endif
-
-    AUD_register_card( &glob_audio_state, "goldfish_audio", &s->card);
-
-    as.freq = 44100;
-    as.nchannels = 2;
-    as.fmt = AUD_FMT_S16;
-    as.endianness = AUDIO_HOST_ENDIANNESS;
-
-    if (android_hw->hw_audioOutput) {
-        s->voice = AUD_open_out (
-            &s->card,
-            s->voice,
-            "goldfish_audio",
-            s,
-            goldfish_audio_callback,
-            &as
-            );
-        if (!s->voice) {
-            dprint("warning: opening audio output failed\n");
-            return;
-        }
-    }
-
-#if USE_QEMU_AUDIO_IN
-    as.freq       = 8000;
-    as.nchannels  = 1;
-    as.fmt        = AUD_FMT_S16;
-    as.endianness = AUDIO_HOST_ENDIANNESS;
-
-    if (android_hw->hw_audioInput) {
-        s->voicein = AUD_open_in (
-            &s->card,
-            NULL,
-            "goldfish_audio_in",
-            s,
-            goldfish_audio_in_callback,
-            &as
-            );
-        if (!s->voicein) {
-            dprint("warning: opening audio input failed\n");
-        }
-    }
-#endif
-
-    goldfish_device_add(&s->dev, goldfish_audio_readfn, goldfish_audio_writefn, s);
-
-    register_savevm( "audio_state", 0, AUDIO_STATE_SAVE_VERSION,
-                     audio_state_save, audio_state_load, s );
-}
-