| /* |
| * BSD LICENSE |
| * |
| * tinyplay command line player for compress audio offload in alsa |
| * Copyright (c) 2011-2012, Intel Corporation |
| * All rights reserved. |
| * |
| * Author: Vinod Koul <vinod.koul@linux.intel.com> |
| * |
| * 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 Intel Corporation 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 COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT OWNER OR CONTRIBUTORS 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. |
| * |
| * LGPL LICENSE |
| * |
| * tinyplay command line player for compress audio offload in alsa |
| * Copyright (c) 2011-2012, Intel Corporation. |
| * |
| * This program is free software; you can redistribute it and/or modify it |
| * under the terms and conditions of the GNU Lesser General Public License, |
| * version 2.1, as published by the Free Software Foundation. |
| * |
| * This program is distributed in the hope it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public |
| * License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public License |
| * along with this program; if not, write to |
| * the Free Software Foundation, Inc., |
| * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA. |
| */ |
| |
| #include <stdint.h> |
| #include <linux/types.h> |
| #include <fcntl.h> |
| #include <errno.h> |
| #include <unistd.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <signal.h> |
| #include <stdbool.h> |
| #include <getopt.h> |
| #include <sys/time.h> |
| #define __force |
| #define __bitwise |
| #define __user |
| #include "sound/compress_params.h" |
| #include "sound/asound.h" |
| #include "tinycompress/tinycompress.h" |
| #include "tinycompress/tinymp3.h" |
| #include <string.h> |
| |
| static int verbose; |
| |
| static void usage(void) |
| { |
| fprintf(stderr, "usage: cplay [OPTIONS] filename\n" |
| "-c\tcard number\n" |
| "-d\tdevice node\n" |
| "-b\tbuffer size\n" |
| "-f\tfragments\n\n" |
| "-v\tverbose mode\n" |
| "-p\tpcm input\n" |
| "-h\tPrints this help list\n\n" |
| "Example:\n" |
| "\tcplay -c 1 -d 2 test.mp3\n" |
| "\tcplay -f 5 test.mp3\n"); |
| |
| exit(EXIT_FAILURE); |
| } |
| |
| void play_samples(char *name, unsigned int card, unsigned int device, |
| unsigned long buffer_size, unsigned int frag); |
| void play_pcm_samples(char *name, unsigned int card, unsigned int device, |
| unsigned long buffer_size, unsigned int frag); |
| struct mp3_header { |
| uint16_t sync; |
| uint8_t format1; |
| uint8_t format2; |
| }; |
| |
| int parse_mp3_header(struct mp3_header *header, unsigned int *num_channels, |
| unsigned int *sample_rate, unsigned int *bit_rate) |
| { |
| int ver_idx, mp3_version, layer, bit_rate_idx, sample_rate_idx, channel_idx; |
| |
| /* check sync bits */ |
| if ((header->sync & MP3_SYNC) != MP3_SYNC) { |
| fprintf(stderr, "Error: Can't find sync word\n"); |
| return -1; |
| } |
| ver_idx = (header->sync >> 11) & 0x03; |
| mp3_version = ver_idx == 0 ? MPEG25 : ((ver_idx & 0x1) ? MPEG1 : MPEG2); |
| layer = 4 - ((header->sync >> 9) & 0x03); |
| bit_rate_idx = ((header->format1 >> 4) & 0x0f); |
| sample_rate_idx = ((header->format1 >> 2) & 0x03); |
| channel_idx = ((header->format2 >> 6) & 0x03); |
| |
| if (sample_rate_idx == 3 || layer == 4 || bit_rate_idx == 15) { |
| fprintf(stderr, "Error: Can't find valid header\n"); |
| return -1; |
| } |
| *num_channels = (channel_idx == MONO ? 1 : 2); |
| *sample_rate = mp3_sample_rates[mp3_version][sample_rate_idx]; |
| *bit_rate = (mp3_bit_rates[mp3_version][layer - 1][bit_rate_idx]) * 1000; |
| if (verbose) |
| printf("%s: exit\n", __func__); |
| return 0; |
| } |
| |
| int parse_pcm_header(FILE **file, uint16_t *num_channels, |
| unsigned int *sample_rate, uint16_t *bit_rate) |
| { |
| char title[5] = " "; |
| int size = 0; |
| fread(title, 4, 1, *file); |
| if (strcmp(title, "RIFF") != 0) { |
| fprintf(stderr, "invalid file\n"); |
| return -1; |
| } |
| |
| //skip total file size |
| fseek(*file, 4, SEEK_CUR); |
| |
| char format[5] = " "; |
| fread(format, 4, 1, *file); |
| if (strcmp(format, "WAVE") != 0) { |
| fprintf(stderr, "invalid format\n"); |
| return -1; |
| } |
| |
| fread(title, 4, 1, *file); |
| fread(&size, 4, 1, *file); |
| while (strcmp(title, "fmt ") != 0){ |
| fseek(*file, size, SEEK_CUR); |
| fread(title, 4, 1, *file); |
| fread(&size, 4, 1, *file); |
| if (feof(*file)) { |
| fprintf(stderr, "missing format information\n"); |
| return -1; |
| } |
| } |
| |
| uint16_t audioformat, blockalign; |
| unsigned int byterate; |
| fread(&audioformat, 2, 1, *file); |
| fread(num_channels, 2, 1, *file); |
| fread(sample_rate, 4, 1, *file); |
| fread(&byterate, 4, 1, *file); |
| fread(&blockalign, 2, 1, *file); |
| fread(bit_rate, 2, 1, *file); |
| fseek(*file, size - 16, SEEK_CUR); |
| |
| fread(title, 4, 1, *file); |
| fread(&size, 4, 1, *file); |
| while (strcmp(title, "data") != 0){ |
| fseek(*file, size, SEEK_CUR); |
| fread(title, 4, 1, *file); |
| fread(&size, 4, 1, *file); |
| if (feof(*file)) { |
| fprintf(stderr, "missing data\n"); |
| return -1; |
| } |
| } |
| return 0; |
| } |
| |
| int check_codec_format_supported(unsigned int card, unsigned int device, struct snd_codec *codec) |
| { |
| if (is_codec_supported(card, device, COMPRESS_IN, codec) == false) { |
| fprintf(stderr, "Error: This codec or format is not supported by DSP\n"); |
| return -1; |
| } |
| return 0; |
| } |
| |
| static int print_time(struct compress *compress) |
| { |
| unsigned int avail; |
| struct timespec tstamp; |
| |
| if (compress_get_hpointer(compress, &avail, &tstamp) != 0) { |
| fprintf(stderr, "Error querying timestamp\n"); |
| fprintf(stderr, "ERR: %s\n", compress_get_error(compress)); |
| return -1; |
| } else |
| fprintf(stderr, "DSP played %jd.%jd\n", (intmax_t)tstamp.tv_sec, (intmax_t)tstamp.tv_nsec*1000); |
| return 0; |
| } |
| |
| static int readFromFile2Buffer(char *buffer, FILE** file, int size, uint16_t bits){ |
| int num_read = 0; |
| if (bits == 24){ |
| int i; |
| int pos = 0; |
| for (i = 0; i < size; i = i + 4) { |
| *(buffer + pos) = 0; |
| pos += 1; |
| num_read += 3 * fread(buffer + pos, 3, 1, *file); |
| pos += 3; |
| num_read += 1; |
| } |
| } else { |
| num_read = fread(buffer, 1, size, *file); |
| } |
| |
| return num_read; |
| } |
| |
| int main(int argc, char **argv) |
| { |
| char *file; |
| unsigned long buffer_size = 0; |
| int c; |
| unsigned int card = 0, device = 0, frag = 0; |
| bool pcm = false; |
| |
| if (argc < 2) |
| usage(); |
| |
| verbose = 0; |
| while ((c = getopt(argc, argv, "hvpb:f:c:d:")) != -1) { |
| switch (c) { |
| case 'h': |
| usage(); |
| break; |
| case 'b': |
| buffer_size = strtol(optarg, NULL, 0); |
| break; |
| case 'f': |
| frag = strtol(optarg, NULL, 10); |
| break; |
| case 'c': |
| card = strtol(optarg, NULL, 10); |
| break; |
| case 'd': |
| device = strtol(optarg, NULL, 10); |
| break; |
| case 'v': |
| verbose = 1; |
| break; |
| case 'p': |
| pcm = true; |
| break; |
| default: |
| exit(EXIT_FAILURE); |
| } |
| } |
| if (optind >= argc) |
| usage(); |
| |
| file = argv[optind]; |
| if (!pcm) { |
| play_samples(file, card, device, buffer_size, frag); |
| } else if (pcm) { |
| fprintf(stderr, "Playing pcm samples\n"); |
| play_pcm_samples(file, card, device, buffer_size, frag); |
| } |
| |
| fprintf(stderr, "Finish Playing.... Close Normally\n"); |
| exit(EXIT_SUCCESS); |
| } |
| |
| void play_samples(char *name, unsigned int card, unsigned int device, |
| unsigned long buffer_size, unsigned int frag) |
| { |
| struct compr_config config; |
| struct snd_codec codec; |
| struct compress *compress; |
| struct mp3_header header; |
| FILE *file; |
| char *buffer; |
| int size, num_read, wrote; |
| unsigned int channels, rate, bits; |
| |
| if (verbose) |
| printf("%s: entry\n", __func__); |
| file = fopen(name, "rb"); |
| if (!file) { |
| fprintf(stderr, "Unable to open file '%s'\n", name); |
| exit(EXIT_FAILURE); |
| } |
| |
| fread(&header, sizeof(header), 1, file); |
| |
| if (parse_mp3_header(&header, &channels, &rate, &bits) == -1) { |
| fclose(file); |
| exit(EXIT_FAILURE); |
| } |
| |
| codec.id = SND_AUDIOCODEC_MP3; |
| codec.ch_in = channels; |
| codec.ch_out = channels; |
| codec.sample_rate = rate; |
| if (!codec.sample_rate) { |
| fprintf(stderr, "invalid sample rate %d\n", rate); |
| fclose(file); |
| exit(EXIT_FAILURE); |
| } |
| codec.bit_rate = bits; |
| codec.rate_control = 0; |
| codec.profile = 0; |
| codec.level = 0; |
| codec.ch_mode = 0; |
| codec.format = 0; |
| if ((buffer_size != 0) && (frag != 0)) { |
| config.fragment_size = buffer_size/frag; |
| config.fragments = frag; |
| } else { |
| /* use driver defaults */ |
| config.fragment_size = 0; |
| config.fragments = 0; |
| } |
| config.codec = &codec; |
| |
| compress = compress_open(card, device, COMPRESS_IN, &config); |
| if (!compress || !is_compress_ready(compress)) { |
| fprintf(stderr, "Unable to open Compress device %d:%d\n", |
| card, device); |
| fprintf(stderr, "ERR: %s\n", compress_get_error(compress)); |
| goto FILE_EXIT; |
| }; |
| if (verbose) |
| printf("%s: Opened compress device\n", __func__); |
| size = config.fragment_size; |
| buffer = malloc(size * config.fragments); |
| if (!buffer) { |
| fprintf(stderr, "Unable to allocate %d bytes\n", size); |
| goto COMP_EXIT; |
| } |
| |
| /* we will write frag fragment_size and then start */ |
| num_read = fread(buffer, 1, size * config.fragments, file); |
| if (num_read > 0) { |
| if (verbose) |
| printf("%s: Doing first buffer write of %d\n", __func__, num_read); |
| wrote = compress_write(compress, buffer, num_read); |
| if (wrote < 0) { |
| fprintf(stderr, "Error %d playing sample\n", wrote); |
| fprintf(stderr, "ERR: %s\n", compress_get_error(compress)); |
| goto BUF_EXIT; |
| } |
| if (wrote != num_read) { |
| /* TODO: Buufer pointer needs to be set here */ |
| fprintf(stderr, "We wrote %d, DSP accepted %d\n", num_read, wrote); |
| } |
| } |
| printf("Playing file %s On Card %u device %u, with buffer of %lu bytes\n", |
| name, card, device, buffer_size); |
| printf("Format %u Channels %u, %u Hz, Bit Rate %d\n", |
| SND_AUDIOCODEC_MP3, channels, rate, bits); |
| |
| compress_start(compress); |
| if (verbose) |
| printf("%s: You should hear audio NOW!!!\n", __func__); |
| |
| do { |
| num_read = fread(buffer, 1, size, file); |
| if (num_read > 0) { |
| wrote = compress_write(compress, buffer, num_read); |
| if (wrote < 0) { |
| fprintf(stderr, "Error playing sample\n"); |
| fprintf(stderr, "ERR: %s\n", compress_get_error(compress)); |
| goto BUF_EXIT; |
| } |
| if (wrote != num_read) { |
| /* TODO: Buffer pointer needs to be set here */ |
| fprintf(stderr, "We wrote %d, DSP accepted %d\n", num_read, wrote); |
| } |
| if (verbose) { |
| print_time(compress); |
| printf("%s: wrote %d\n", __func__, wrote); |
| } |
| } |
| } while (num_read > 0); |
| |
| if (verbose) |
| printf("%s: exit success\n", __func__); |
| /* issue drain if it supports */ |
| compress_drain(compress); |
| free(buffer); |
| fclose(file); |
| compress_close(compress); |
| return; |
| BUF_EXIT: |
| free(buffer); |
| COMP_EXIT: |
| compress_close(compress); |
| FILE_EXIT: |
| fclose(file); |
| if (verbose) |
| printf("%s: exit failure\n", __func__); |
| exit(EXIT_FAILURE); |
| } |
| |
| void play_pcm_samples(char *name, unsigned int card, unsigned int device, |
| unsigned long buffer_size, unsigned int frag) |
| { |
| struct compr_config config; |
| struct snd_codec codec; |
| struct compress *compress; |
| struct mp3_header header; |
| FILE *file; |
| char *buffer; |
| int frag_size, num_read, wrote; |
| unsigned int rate, byterate; |
| uint16_t channels, bits; |
| |
| if (verbose) |
| printf("%s: entry\n", __func__); |
| file = fopen(name, "rb"); |
| if (!file) { |
| fprintf(stderr, "Unable to open file '%s'\n", name); |
| exit(EXIT_FAILURE); |
| } |
| |
| if (parse_pcm_header(&file, &channels, &rate, &bits) == -1){ |
| fprintf(stderr, "invalid header\n"); |
| exit(EXIT_FAILURE); |
| } |
| |
| codec.id = SND_AUDIOCODEC_PCM; |
| codec.ch_in = channels; |
| codec.ch_out = channels; |
| codec.sample_rate = compress_get_alsa_rate(rate); |
| if (!codec.sample_rate) { |
| fprintf(stderr, "invalid sample rate %d\n", rate); |
| fclose(file); |
| exit(EXIT_FAILURE); |
| } |
| codec.bit_rate = bits; |
| codec.rate_control = 0; |
| codec.profile = 0; |
| codec.level = 0; |
| codec.ch_mode = 0; |
| if (bits == 16) { |
| codec.format = SNDRV_PCM_FORMAT_S16_LE; |
| } else if (bits == 24) { |
| codec.format = SNDRV_PCM_FORMAT_S24_LE; |
| } else { |
| fprintf(stderr, "invalid bit rate %d\n", bits); |
| fclose(file); |
| exit(EXIT_FAILURE); |
| } |
| |
| if ((buffer_size != 0) && (frag != 0)) { |
| /* Make sure the buffer size and fragments are multiple of 2, or 24 for multi channel*/ |
| unsigned int temp_size = (channels > 2)? 24 : 2; |
| while (temp_size < buffer_size) |
| temp_size *= 2; |
| buffer_size = temp_size; |
| |
| unsigned int temp_frag = 1; |
| while (temp_frag < frag) |
| temp_frag *= 2; |
| |
| config.fragment_size = temp_size/temp_frag; |
| config.fragments = temp_frag; |
| } else { |
| /* Now set to suggested value. set to 0 for using driver defaults */ |
| config.fragment_size = (channels > 2)? 12288 : 8192; |
| config.fragments = 4; |
| } |
| if (verbose) |
| printf("%s: Buffer size: %d Fragment size: %d Fragments: %d\n", |
| __func__, config.fragment_size * config.fragments, |
| config.fragment_size, config.fragments); |
| |
| config.codec = &codec; |
| |
| compress = compress_open(card, device, COMPRESS_IN, &config); |
| if (!compress || !is_compress_ready(compress)) { |
| fprintf(stderr, "Unable to open Compress device %d:%d\n", |
| card, device); |
| fprintf(stderr, "ERR: %s\n", compress_get_error(compress)); |
| goto FILE_EXIT; |
| }; |
| if (verbose) |
| printf("%s: Opened compress device\n", __func__); |
| frag_size = config.fragment_size; |
| printf("frag_size %d frags %d", frag_size, config.fragments); |
| buffer = malloc(frag_size * config.fragments); |
| if (!buffer) { |
| fprintf(stderr, "Unable to allocate %d bytes\n", frag_size); |
| goto COMP_EXIT; |
| } |
| |
| /* we will write frag fragment_size and then start */ |
| num_read = readFromFile2Buffer(buffer, &file, frag_size * config.fragments, bits); |
| /*Zero padded each 3 byte into 4 byte, the number read must be greater than size / 4 */ |
| if (num_read > ((bits == 16)? 0 : frag_size * (int)config.fragments / 4)) { |
| if (verbose) |
| printf("%s: Doing first buffer write of %d\n", __func__, num_read); |
| wrote = compress_write(compress, buffer, num_read); |
| if (wrote < 0) { |
| fprintf(stderr, "Error %d playing sample\n", wrote); |
| fprintf(stderr, "ERR: %s\n", compress_get_error(compress)); |
| goto BUF_EXIT; |
| } |
| if (wrote != num_read) { |
| /* TODO: Buufer pointer needs to be set here */ |
| fprintf(stderr, "We wrote %d, DSP accepted %d\n", num_read, wrote); |
| } |
| } |
| printf("Playing file %s On Card %u device %u, with buffer of %lu bytes\n", |
| name, card, device, buffer_size); |
| printf("Format %u Channels %u, %u Hz, Bit Rate %d\n", |
| SND_AUDIOCODEC_MP3, channels, rate, bits); |
| |
| compress_start(compress); |
| if (verbose) |
| printf("%s: You should hear audio NOW!!!\n", __func__); |
| |
| do { |
| num_read = readFromFile2Buffer(buffer, &file, frag_size, bits); |
| if (num_read > ((bits == 16)? 0 : frag_size / 4)) { |
| wrote = compress_write(compress, buffer, num_read); |
| if (wrote < 0) { |
| fprintf(stderr, "Error playing sample\n"); |
| fprintf(stderr, "ERR: %s\n", compress_get_error(compress)); |
| goto BUF_EXIT; |
| } |
| if (wrote != num_read) { |
| /* TODO: Buffer pointer needs to be set here */ |
| fprintf(stderr, "We wrote %d, DSP accepted %d\n", num_read, wrote); |
| } |
| if (verbose) { |
| print_time(compress); |
| printf("%s: wrote %d\n", __func__, wrote); |
| } |
| } |
| } while ((!feof(file))); |
| |
| if (verbose) |
| printf("%s: exit success\n", __func__); |
| /* issue drain if it supports */ |
| compress_drain(compress); |
| free(buffer); |
| fclose(file); |
| compress_close(compress); |
| return; |
| BUF_EXIT: |
| free(buffer); |
| COMP_EXIT: |
| compress_close(compress); |
| FILE_EXIT: |
| fclose(file); |
| if (verbose) |
| printf("%s: exit failure\n", __func__); |
| exit(EXIT_FAILURE); |
| } |
| |