Return to wavcapture.c CVS log

Up to [Qemu by Fabrice Bellard] / qemu / audio

Annotation of qemu/audio/wavcapture.c, revision 1.1.1.5

1.1.1.3   root        1: #include "hw/hw.h"
1.1.1.5 ! root        2: #include "monitor.h"
1.1.1.3   root        3: #include "audio.h"
1.1       root        4: 
                      5: typedef struct {
                      6:     QEMUFile *f;
                      7:     int bytes;
                      8:     char *path;
                      9:     int freq;
                     10:     int bits;
                     11:     int nchannels;
                     12:     CaptureVoiceOut *cap;
                     13: } WAVState;
                     14: 
                     15: /* VICE code: Store number as little endian. */
                     16: static void le_store (uint8_t *buf, uint32_t val, int len)
                     17: {
                     18:     int i;
                     19:     for (i = 0; i < len; i++) {
                     20:         buf[i] = (uint8_t) (val & 0xff);
                     21:         val >>= 8;
                     22:     }
                     23: }
                     24: 
                     25: static void wav_notify (void *opaque, audcnotification_e cmd)
                     26: {
                     27:     (void) opaque;
                     28:     (void) cmd;
                     29: }
                     30: 
                     31: static void wav_destroy (void *opaque)
                     32: {
                     33:     WAVState *wav = opaque;
                     34:     uint8_t rlen[4];
                     35:     uint8_t dlen[4];
                     36:     uint32_t datalen = wav->bytes;
                     37:     uint32_t rifflen = datalen + 36;
                     38: 
1.1.1.2   root       39:     if (wav->f) {
                     40:         le_store (rlen, rifflen, 4);
                     41:         le_store (dlen, datalen, 4);
1.1.1.3   root       42: 
1.1.1.2   root       43:         qemu_fseek (wav->f, 4, SEEK_SET);
                     44:         qemu_put_buffer (wav->f, rlen, 4);
1.1.1.3   root       45: 
1.1.1.2   root       46:         qemu_fseek (wav->f, 32, SEEK_CUR);
                     47:         qemu_put_buffer (wav->f, dlen, 4);
                     48:         qemu_fclose (wav->f);
1.1       root       49:     }
1.1.1.3   root       50: 
1.1.1.2   root       51:     qemu_free (wav->path);
1.1       root       52: }
                     53: 
                     54: static void wav_capture (void *opaque, void *buf, int size)
                     55: {
                     56:     WAVState *wav = opaque;
                     57: 
                     58:     qemu_put_buffer (wav->f, buf, size);
                     59:     wav->bytes += size;
                     60: }
                     61: 
                     62: static void wav_capture_destroy (void *opaque)
                     63: {
                     64:     WAVState *wav = opaque;
                     65: 
                     66:     AUD_del_capture (wav->cap, wav);
                     67: }
                     68: 
                     69: static void wav_capture_info (void *opaque)
                     70: {
                     71:     WAVState *wav = opaque;
                     72:     char *path = wav->path;
                     73: 
1.1.1.5 ! root       74:     monitor_printf(cur_mon, "Capturing audio(%d,%d,%d) to %s: %d bytes\n",
        !            75:                    wav->freq, wav->bits, wav->nchannels,
        !            76:                    path ? path : "<not available>", wav->bytes);
1.1       root       77: }
                     78: 
                     79: static struct capture_ops wav_capture_ops = {
                     80:     .destroy = wav_capture_destroy,
                     81:     .info = wav_capture_info
                     82: };
                     83: 
                     84: int wav_start_capture (CaptureState *s, const char *path, int freq,
                     85:                        int bits, int nchannels)
                     86: {
1.1.1.5 ! root       87:     Monitor *mon = cur_mon;
1.1       root       88:     WAVState *wav;
                     89:     uint8_t hdr[] = {
                     90:         0x52, 0x49, 0x46, 0x46, 0x00, 0x00, 0x00, 0x00, 0x57, 0x41, 0x56,
                     91:         0x45, 0x66, 0x6d, 0x74, 0x20, 0x10, 0x00, 0x00, 0x00, 0x01, 0x00,
                     92:         0x02, 0x00, 0x44, 0xac, 0x00, 0x00, 0x10, 0xb1, 0x02, 0x00, 0x04,
                     93:         0x00, 0x10, 0x00, 0x64, 0x61, 0x74, 0x61, 0x00, 0x00, 0x00, 0x00
                     94:     };
1.1.1.4   root       95:     struct audsettings as;
1.1       root       96:     struct audio_capture_ops ops;
                     97:     int stereo, bits16, shift;
                     98:     CaptureVoiceOut *cap;
                     99: 
                    100:     if (bits != 8 && bits != 16) {
1.1.1.5 ! root      101:         monitor_printf(mon, "incorrect bit count %d, must be 8 or 16\n", bits);
1.1       root      102:         return -1;
                    103:     }
                    104: 
                    105:     if (nchannels != 1 && nchannels != 2) {
1.1.1.5 ! root      106:         monitor_printf(mon, "incorrect channel count %d, must be 1 or 2\n",
        !           107:                        nchannels);
1.1       root      108:         return -1;
                    109:     }
                    110: 
                    111:     stereo = nchannels == 2;
                    112:     bits16 = bits == 16;
                    113: 
                    114:     as.freq = freq;
                    115:     as.nchannels = 1 << stereo;
                    116:     as.fmt = bits16 ? AUD_FMT_S16 : AUD_FMT_U8;
                    117:     as.endianness = 0;
                    118: 
                    119:     ops.notify = wav_notify;
                    120:     ops.capture = wav_capture;
                    121:     ops.destroy = wav_destroy;
                    122: 
                    123:     wav = qemu_mallocz (sizeof (*wav));
                    124: 
                    125:     shift = bits16 + stereo;
                    126:     hdr[34] = bits16 ? 0x10 : 0x08;
                    127: 
                    128:     le_store (hdr + 22, as.nchannels, 2);
                    129:     le_store (hdr + 24, freq, 4);
                    130:     le_store (hdr + 28, freq << shift, 4);
                    131:     le_store (hdr + 32, 1 << shift, 2);
                    132: 
1.1.1.2   root      133:     wav->f = qemu_fopen (path, "wb");
1.1       root      134:     if (!wav->f) {
1.1.1.5 ! root      135:         monitor_printf(mon, "Failed to open wave file `%s'\nReason: %s\n",
        !           136:                        path, strerror (errno));
1.1       root      137:         qemu_free (wav);
                    138:         return -1;
                    139:     }
                    140: 
                    141:     wav->path = qemu_strdup (path);
                    142:     wav->bits = bits;
                    143:     wav->nchannels = nchannels;
                    144:     wav->freq = freq;
                    145: 
                    146:     qemu_put_buffer (wav->f, hdr, sizeof (hdr));
                    147: 
1.1.1.5 ! root      148:     cap = AUD_add_capture (&as, &ops, wav);
1.1       root      149:     if (!cap) {
1.1.1.5 ! root      150:         monitor_printf(mon, "Failed to add audio capture\n");
1.1.1.2   root      151:         qemu_free (wav->path);
                    152:         qemu_fclose (wav->f);
1.1       root      153:         qemu_free (wav);
                    154:         return -1;
                    155:     }
                    156: 
                    157:     wav->cap = cap;
                    158:     s->opaque = wav;
                    159:     s->ops = wav_capture_ops;
                    160:     return 0;
                    161: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.