| /* tinycap.c |
| ** |
| ** Copyright 2011, The Android Open Source Project |
| ** |
| ** Redistribution and use in source and binary forms, with or without |
| ** modification, are permitted provided that the following conditions are met: |
| ** * Redistributions of source code must retain the above copyright |
| ** notice, this list of conditions and the following disclaimer. |
| ** * Redistributions in binary form must reproduce the above copyright |
| ** notice, this list of conditions and the following disclaimer in the |
| ** documentation and/or other materials provided with the distribution. |
| ** * Neither the name of The Android Open Source Project nor the names of |
| ** its contributors may be used to endorse or promote products derived |
| ** from this software without specific prior written permission. |
| ** |
| ** THIS SOFTWARE IS PROVIDED BY The Android Open Source Project ``AS IS'' AND |
| ** ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| ** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| ** ARE DISCLAIMED. IN NO EVENT SHALL The Android Open Source Project BE LIABLE |
| ** FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
| ** DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR |
| ** SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
| ** CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
| ** LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
| ** OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH |
| ** DAMAGE. |
| */ |
| |
| #include <tinyalsa/asoundlib.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <stdint.h> |
| #include <signal.h> |
| #include <string.h> |
| |
| #include "config.h" |
| #include "tinycap.h" |
| |
| #define ID_RIFF 0x46464952 |
| #define ID_WAVE 0x45564157 |
| #define ID_FMT 0x20746d66 |
| #define ID_DATA 0x61746164 |
| |
| #define FORMAT_PCM 1 |
| |
| struct wav_header { |
| uint32_t riff_id; |
| uint32_t riff_sz; |
| uint32_t riff_fmt; |
| uint32_t fmt_id; |
| uint32_t fmt_sz; |
| uint16_t audio_format; |
| uint16_t num_channels; |
| uint32_t sample_rate; |
| uint32_t byte_rate; |
| uint16_t block_align; |
| uint16_t bits_per_sample; |
| uint32_t data_id; |
| uint32_t data_sz; |
| }; |
| |
| int capturing = 1; |
| |
| static |
| unsigned int capture_sample(FILE *file, unsigned int card, unsigned int device, |
| unsigned int channels, unsigned int rate, |
| unsigned int bits, unsigned int period_size, |
| unsigned int period_count, unsigned int duration); |
| |
| void sigint_handler(int sig) |
| { |
| capturing = 0; |
| } |
| |
| int tinycap_main(const struct audio_tool_config *config, int argc, char **argv, |
| int legacy_mode) |
| { |
| FILE *file; |
| struct wav_header header; |
| unsigned int card = 0; |
| unsigned int device = 0; |
| unsigned int channels = 2; |
| unsigned int rate = 44100; |
| unsigned int bits = 16; |
| unsigned int frames; |
| unsigned int period_size = 1024; |
| unsigned int period_count = 4; |
| unsigned int duration = 0; |
| int arg; |
| |
| if ((!legacy_mode && argc != 2) || (legacy_mode && argc != 1)) { |
| fprintf(stderr, "Usage: audio-tool [options] capture file.wav\n"); |
| return 1; |
| } |
| |
| if (legacy_mode) |
| arg = 0; |
| else |
| arg = 1; |
| |
| file = fopen(argv[arg], "wb"); |
| if (!file) { |
| fprintf(stderr, "Unable to create file '%s'\n", argv[arg]); |
| return 1; |
| } |
| |
| device = config->device; |
| channels = config->channels; |
| rate = config->rate; |
| bits = config->bits; |
| card = config->card; |
| period_size = config->period_size; |
| period_count = config->num_periods; |
| duration = config->duration; |
| |
| header.riff_id = ID_RIFF; |
| header.riff_sz = 0; |
| header.riff_fmt = ID_WAVE; |
| header.fmt_id = ID_FMT; |
| header.fmt_sz = 16; |
| header.audio_format = FORMAT_PCM; |
| header.num_channels = channels; |
| header.sample_rate = rate; |
| header.bits_per_sample = bits; |
| header.byte_rate = (header.bits_per_sample / 8) * channels * rate; |
| header.block_align = channels * (header.bits_per_sample / 8); |
| header.data_id = ID_DATA; |
| |
| /* leave enough room for header */ |
| fseek(file, sizeof(struct wav_header), SEEK_SET); |
| |
| /* install signal handler and begin capturing */ |
| signal(SIGINT, sigint_handler); |
| frames = capture_sample(file, card, device, header.num_channels, |
| header.sample_rate, header.bits_per_sample, |
| period_size, period_count, duration); |
| printf("Captured %d frames\n", frames); |
| |
| /* write header now all information is known */ |
| header.data_sz = frames * header.block_align; |
| fseek(file, 0, SEEK_SET); |
| fwrite(&header, sizeof(struct wav_header), 1, file); |
| |
| fclose(file); |
| |
| return 0; |
| } |
| |
| static |
| unsigned int capture_sample(FILE *file, unsigned int card, unsigned int device, |
| unsigned int channels, unsigned int rate, |
| unsigned int bits, unsigned int period_size, |
| unsigned int period_count, unsigned int duration) |
| { |
| struct pcm_config config; |
| struct pcm *pcm; |
| char *buffer; |
| unsigned int size; |
| unsigned int bytes_read = 0; |
| unsigned long requested; |
| |
| config.channels = channels; |
| config.rate = rate; |
| config.period_size = period_size; |
| config.period_count = period_count; |
| if (bits == 32) { |
| config.format = PCM_FORMAT_S32_LE; |
| } else if (bits == 24) { |
| config.format = PCM_FORMAT_S24_3LE; |
| } else if (bits == 16) { |
| config.format = PCM_FORMAT_S16_LE; |
| } else { |
| fprintf(stderr, "Bits per sample %d not supported\n", bits); |
| return 0; |
| } |
| config.start_threshold = 0; |
| config.stop_threshold = 0; |
| config.silence_threshold = 0; |
| |
| pcm = pcm_open(card, device, PCM_IN, &config); |
| if (!pcm || !pcm_is_ready(pcm)) { |
| fprintf(stderr, "Unable to open PCM device (%s)\n", |
| pcm_get_error(pcm)); |
| return 0; |
| } |
| |
| size = pcm_frames_to_bytes(pcm, pcm_get_buffer_size(pcm)); |
| buffer = malloc(size); |
| if (!buffer) { |
| fprintf(stderr, "Unable to allocate %d bytes\n", size); |
| free(buffer); |
| pcm_close(pcm); |
| return 0; |
| } |
| |
| if (duration) |
| requested = pcm_frames_to_bytes(pcm, rate * duration); |
| else |
| requested = 0; |
| |
| printf("Capturing sample: %u ch, %u hz, %u bit\n", channels, rate, bits); |
| |
| while (capturing && (!requested || (bytes_read < requested)) && |
| !pcm_read(pcm, buffer, size)) { |
| if (fwrite(buffer, 1, size, file) != size) { |
| fprintf(stderr,"Error capturing sample\n"); |
| break; |
| } |
| bytes_read += size; |
| } |
| |
| free(buffer); |
| pcm_close(pcm); |
| |
| return bytes_read / ((bits / 8) * channels); |
| } |