| /* tinyplay.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 <string.h> |
| |
| #include "config.h" |
| #include "tinyplay.h" |
| |
| #define ID_RIFF 0x46464952 |
| #define ID_WAVE 0x45564157 |
| #define ID_FMT 0x20746d66 |
| #define ID_DATA 0x61746164 |
| |
| struct riff_wave_header { |
| uint32_t riff_id; |
| uint32_t riff_sz; |
| uint32_t wave_id; |
| }; |
| |
| struct chunk_header { |
| uint32_t id; |
| uint32_t sz; |
| }; |
| |
| struct chunk_fmt { |
| 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; |
| }; |
| |
| static |
| void play_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); |
| |
| int tinyplay_main(const struct audio_tool_config *config, int argc, char **argv, |
| int legacy_mode) |
| { |
| FILE *file; |
| struct riff_wave_header riff_wave_header; |
| struct chunk_header chunk_header; |
| struct chunk_fmt chunk_fmt; |
| unsigned int device = 0; |
| unsigned int card = 0; |
| unsigned int period_size = 1024; |
| unsigned int period_count = 4; |
| unsigned int duration = -1; |
| int arg; |
| char *filename; |
| int more_chunks = 1; |
| |
| if ((!legacy_mode && argc != 2) || (legacy_mode && argc != 1)) { |
| fprintf(stderr, "Usage: audio-tool [options] play file.wav\n"); |
| return 1; |
| } |
| |
| if (legacy_mode) |
| arg = 0; |
| else |
| arg = 1; |
| |
| filename = argv[1]; |
| file = fopen(filename, "rb"); |
| if (!file) { |
| fprintf(stderr, "Unable to open file '%s'\n", filename); |
| return 1; |
| } |
| |
| device = config->device; |
| period_size = config->period_size; |
| period_count = config->num_periods; |
| card = config->card; |
| duration = config->duration; |
| |
| fread(&riff_wave_header, sizeof(riff_wave_header), 1, file); |
| if ((riff_wave_header.riff_id != ID_RIFF) || |
| (riff_wave_header.wave_id != ID_WAVE)) { |
| fprintf(stderr, "Error: '%s' is not a riff/wave file\n", filename); |
| fclose(file); |
| return 1; |
| } |
| |
| do { |
| fread(&chunk_header, sizeof(chunk_header), 1, file); |
| |
| switch (chunk_header.id) { |
| case ID_FMT: |
| fread(&chunk_fmt, sizeof(chunk_fmt), 1, file); |
| /* If the format header is larger, skip the rest */ |
| if (chunk_header.sz > sizeof(chunk_fmt)) |
| fseek(file, chunk_header.sz - sizeof(chunk_fmt), SEEK_CUR); |
| break; |
| case ID_DATA: |
| /* Stop looking for chunks */ |
| more_chunks = 0; |
| break; |
| default: |
| /* Unknown chunk, skip bytes */ |
| fseek(file, chunk_header.sz, SEEK_CUR); |
| } |
| } while (more_chunks); |
| |
| play_sample(file, card, device, chunk_fmt.num_channels, chunk_fmt.sample_rate, |
| chunk_fmt.bits_per_sample, period_size, period_count, duration); |
| |
| fclose(file); |
| |
| return 0; |
| } |
| |
| static |
| void play_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; |
| int size; |
| int num_read; |
| unsigned long requested; |
| unsigned long written = 0; |
| |
| 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 == 16) |
| config.format = PCM_FORMAT_S16_LE; |
| config.start_threshold = 0; |
| config.stop_threshold = 0; |
| config.silence_threshold = 0; |
| |
| pcm = pcm_open(card, device, PCM_OUT, &config); |
| if (!pcm || !pcm_is_ready(pcm)) { |
| fprintf(stderr, "Unable to open PCM device %u (%s)\n", |
| device, pcm_get_error(pcm)); |
| return; |
| } |
| |
| 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; |
| } |
| |
| if (duration) |
| requested = pcm_frames_to_bytes(pcm, rate * duration); |
| else |
| requested = 0; |
| |
| printf("Playing sample: %u ch, %u hz, %u bit\n", channels, rate, bits); |
| |
| do { |
| num_read = fread(buffer, 1, size, file); |
| if (num_read > 0) { |
| if (pcm_write(pcm, buffer, num_read)) { |
| fprintf(stderr, "Error playing sample\n"); |
| break; |
| } |
| } |
| written += num_read; |
| } while ((num_read > 0) && (!requested || (written < requested))); |
| |
| free(buffer); |
| pcm_close(pcm); |
| } |
| |