hifi/xaf/host-apf/playback/xa_playback.c - device/linaro/hikey960 - Gitiles

 /*******************************************************************************
 * Copyright (C) 2018 Cadence Design Systems, Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the
 * "Software"), to use this Software with Cadence processor cores only and
 * not with any other processors and platforms, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

 ******************************************************************************/

 #define MODULE_TAG                      PLYBK

 #include <tinyalsa/asoundlib.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdint.h>
 #include <string.h>
 #include <signal.h>
 #include <sys/ioctl.h>
 #include <fcntl.h>
 #include <unistd.h>
 #include <errno.h>

 #include "xf.h"
 #include "xa_playback.h"

 #if 0
 #define ID_RIFF 0x46464952
 #define ID_WAVE 0x45564157
 #define ID_FMT  0x20746d66
 #define ID_DATA 0x61746164

 #define HIFI_MISC_IOCTL_PCM_GAIN _IOW('A',  0x7b, struct misc_io_pcm_buf_param)
 #define HIFI_DSP_MISC_DRIVER "/dev/hifi_misc"
 struct misc_io_pcm_buf_param {
 	uint64_t			buf;
 	uint32_t			buf_size;
 };

 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 int s_close = 0;

 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);

 void stream_close(int sig)
 {
     /* allow the stream to be closed gracefully */
     signal(sig, SIG_IGN);
     s_close = 1;
 }
 #endif

 #if 0
 int main(int argc, char **argv)
 {
     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;
     char *filename;
     int more_chunks = 1;

     if (argc < 2) {
         fprintf(stderr, "Usage: %s file.wav [-D card] [-d device] [-p period_size]"
                 " [-n n_periods] \n", argv[0]);
         return 1;
     }

     filename = argv[1];
     file = fopen(filename, "rb");
     if (!file) {
         fprintf(stderr, "Unable to open file '%s'\n", filename);
         return 1;
     }

     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);

     /* parse command line arguments */
     argv += 2;
     while (*argv) {
         if (strcmp(*argv, "-d") == 0) {
             argv++;
             if (*argv)
                 device = atoi(*argv);
         }
         if (strcmp(*argv, "-p") == 0) {
             argv++;
             if (*argv)
                 period_size = atoi(*argv);
         }
         if (strcmp(*argv, "-n") == 0) {
             argv++;
             if (*argv)
                 period_count = atoi(*argv);
         }
         if (strcmp(*argv, "-D") == 0) {
             argv++;
             if (*argv)
                 card = atoi(*argv);
         }
         if (*argv)
             argv++;
     }

     play_sample(file, card, device, chunk_fmt.num_channels, chunk_fmt.sample_rate,
                 chunk_fmt.bits_per_sample, period_size, period_count);

     fclose(file);

     return 0;
 }
 #endif

 static int check_param(struct pcm_params *params, unsigned int param, unsigned int value,
                        char *param_name, char *param_unit)
 {
     unsigned int min;
     unsigned int max;
     int is_within_bounds = 1;

     min = pcm_params_get_min(params, param);
     if (value < min) {
         TRACE(ERROR, _x("%s is %u%s, device only supports >= %u%s\n"), param_name, value,
                 param_unit, min, param_unit);
         is_within_bounds = 0;
     }

     max = pcm_params_get_max(params, param);
     if (value > max) {
         TRACE(ERROR, _x("%s is %u%s, device only supports <= %u%s\n"), param_name, value,
                 param_unit, max, param_unit);
         is_within_bounds = 0;
     }

     return is_within_bounds;
 }

 static int sample_is_playable(unsigned int card, unsigned int device, unsigned int channels,
                               unsigned int rate, unsigned int bits, unsigned int period_size,
                               unsigned int period_count)
 {
     struct pcm_params *params;
     int can_play;

     params = pcm_params_get(card, device, PCM_OUT);
     if (params == NULL) {
         TRACE(ERROR, _x("Unable to open PCM device %u.\n"), device);
         return 0;
     }

     can_play = check_param(params, PCM_PARAM_RATE, rate, "Sample rate", "Hz");
     can_play &= check_param(params, PCM_PARAM_CHANNELS, channels, "Sample", " channels");
     can_play &= check_param(params, PCM_PARAM_SAMPLE_BITS, bits, "Bitrate", " bits");
     can_play &= check_param(params, PCM_PARAM_PERIOD_SIZE, period_size, "Period size", "Hz");
     can_play &= check_param(params, PCM_PARAM_PERIODS, period_count, "Period count", "Hz");

     pcm_params_free(params);

     return can_play;
 }

 void *xa_playback_open(unsigned int card,
 		       unsigned int device,
 		       unsigned int channels,
                        unsigned int rate,
 		       unsigned int bits,
 		       unsigned int period_size,
                        unsigned int period_count)
 {
     struct pcm_config config;
     struct pcm *pcm;

     memset(&config, 0, sizeof(config));
     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;

     if (!sample_is_playable(card, device, channels, rate, bits, period_size, period_count)) {
         return NULL;
     }

     pcm = pcm_open(card, device, PCM_OUT, &config);
     if (!pcm || !pcm_is_ready(pcm)) {
         TRACE(ERROR, _x("Unable to open PCM device %u (%s)\n"),
                 device, pcm_get_error(pcm));
         return NULL;
     }

     return pcm;
 }

 int xa_playback_buf(void *handle,
 	 	    const void *data,
  		    unsigned int nbytes)
 {
     int err;

     if (!handle || !data)
 	return XA_PLAYBACK_INVALID_PARAM;

     if (nbytes > 0) {
         err = pcm_write(handle, data, nbytes);

 	if (err == -EINVAL) return XA_PLAYBACK_INVALID_PARAM;
 	if (err == -EPIPE ) return XA_PLAYBACK_UNDERRUN;
     }

     return XA_PLAYBACK_OK;
 }

 int xa_playback_close(void *handle)
 {
     return pcm_close(handle);
 }

 #if 0
 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)
 {
     struct pcm_config config;
     struct pcm *pcm;
     char *buffer;
     int size;
     int num_read;
     int hifi_dsp_fd;
     struct misc_io_pcm_buf_param pcmbuf;

     hifi_dsp_fd = open(HIFI_DSP_MISC_DRIVER, O_RDWR, 0);
     if(hifi_dsp_fd < 0){
         printf("Error opening hifi dsp device %d", errno);
     }

     memset(&config, 0, sizeof(config));
     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;

     if (!sample_is_playable(card, device, channels, rate, bits, period_size, period_count)) {
         return;
     }

     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;
     }

     printf("Playing sample: %u ch, %u hz, %u bit\n", channels, rate, bits);

     /* catch ctrl-c to shutdown cleanly */
     signal(SIGINT, stream_close);

     do {
         num_read = fread(buffer, 1, size, file);

         pcmbuf.buf =(uint64_t) buffer;
         pcmbuf.buf_size = num_read;
         if(hifi_dsp_fd) {
       //      printf("ioctl send \n");
             ioctl(hifi_dsp_fd,HIFI_MISC_IOCTL_PCM_GAIN, &pcmbuf);
         //    printf("ioctl complete \n");
         }

         if (num_read > 0) {
             if (pcm_write(pcm, buffer, num_read)) {
                 fprintf(stderr, "Error playing sample\n");
                 break;
             }
         }
     } while (!s_close && num_read > 0);

     free(buffer);
     pcm_close(pcm);
     close(hifi_dsp_fd);
 }
 #endif
	/*******************************************************************************
	* Copyright (C) 2018 Cadence Design Systems, Inc.
	*
	* Permission is hereby granted, free of charge, to any person obtaining
	* a copy of this software and associated documentation files (the
	* "Software"), to use this Software with Cadence processor cores only and
	* not with any other processors and platforms, subject to
	* the following conditions:
	*
	* The above copyright notice and this permission notice shall be included
	* in all copies or substantial portions of the Software.
	*
	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
	* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
	* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
	* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
	* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
	* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

	******************************************************************************/

	#define MODULE_TAG PLYBK

	#include <tinyalsa/asoundlib.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <stdint.h>
	#include <string.h>
	#include <signal.h>
	#include <sys/ioctl.h>
	#include <fcntl.h>
	#include <unistd.h>
	#include <errno.h>

	#include "xf.h"
	#include "xa_playback.h"

	#if 0
	#define ID_RIFF 0x46464952
	#define ID_WAVE 0x45564157
	#define ID_FMT 0x20746d66
	#define ID_DATA 0x61746164

	#define HIFI_MISC_IOCTL_PCM_GAIN _IOW('A', 0x7b, struct misc_io_pcm_buf_param)
	#define HIFI_DSP_MISC_DRIVER "/dev/hifi_misc"
	struct misc_io_pcm_buf_param {
	uint64_t buf;
	uint32_t buf_size;
	};

	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 int s_close = 0;

	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);

	void stream_close(int sig)
	{
	/* allow the stream to be closed gracefully */
	signal(sig, SIG_IGN);
	s_close = 1;
	}
	#endif

	#if 0
	int main(int argc, char **argv)
	{
	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;
	char *filename;
	int more_chunks = 1;

	if (argc < 2) {
	fprintf(stderr, "Usage: %s file.wav [-D card] [-d device] [-p period_size]"
	" [-n n_periods] \n", argv[0]);
	return 1;
	}

	filename = argv[1];
	file = fopen(filename, "rb");
	if (!file) {
	fprintf(stderr, "Unable to open file '%s'\n", filename);
	return 1;
	}

	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);

	/* parse command line arguments */
	argv += 2;
	while (*argv) {
	if (strcmp(*argv, "-d") == 0) {
	argv++;
	if (*argv)
	device = atoi(*argv);
	}
	if (strcmp(*argv, "-p") == 0) {
	argv++;
	if (*argv)
	period_size = atoi(*argv);
	}
	if (strcmp(*argv, "-n") == 0) {
	argv++;
	if (*argv)
	period_count = atoi(*argv);
	}
	if (strcmp(*argv, "-D") == 0) {
	argv++;
	if (*argv)
	card = atoi(*argv);
	}
	if (*argv)
	argv++;
	}

	play_sample(file, card, device, chunk_fmt.num_channels, chunk_fmt.sample_rate,
	chunk_fmt.bits_per_sample, period_size, period_count);

	fclose(file);

	return 0;
	}
	#endif

	static int check_param(struct pcm_params *params, unsigned int param, unsigned int value,
	char param_name, char param_unit)
	{
	unsigned int min;
	unsigned int max;
	int is_within_bounds = 1;

	min = pcm_params_get_min(params, param);
	if (value < min) {
	TRACE(ERROR, _x("%s is %u%s, device only supports >= %u%s\n"), param_name, value,
	param_unit, min, param_unit);
	is_within_bounds = 0;
	}

	max = pcm_params_get_max(params, param);
	if (value > max) {
	TRACE(ERROR, _x("%s is %u%s, device only supports <= %u%s\n"), param_name, value,
	param_unit, max, param_unit);
	is_within_bounds = 0;
	}

	return is_within_bounds;
	}

	static int sample_is_playable(unsigned int card, unsigned int device, unsigned int channels,
	unsigned int rate, unsigned int bits, unsigned int period_size,
	unsigned int period_count)
	{
	struct pcm_params *params;
	int can_play;

	params = pcm_params_get(card, device, PCM_OUT);
	if (params == NULL) {
	TRACE(ERROR, _x("Unable to open PCM device %u.\n"), device);
	return 0;
	}

	can_play = check_param(params, PCM_PARAM_RATE, rate, "Sample rate", "Hz");
	can_play &= check_param(params, PCM_PARAM_CHANNELS, channels, "Sample", " channels");
	can_play &= check_param(params, PCM_PARAM_SAMPLE_BITS, bits, "Bitrate", " bits");
	can_play &= check_param(params, PCM_PARAM_PERIOD_SIZE, period_size, "Period size", "Hz");
	can_play &= check_param(params, PCM_PARAM_PERIODS, period_count, "Period count", "Hz");

	pcm_params_free(params);

	return can_play;
	}

	void *xa_playback_open(unsigned int card,
	unsigned int device,
	unsigned int channels,
	unsigned int rate,
	unsigned int bits,
	unsigned int period_size,
	unsigned int period_count)
	{
	struct pcm_config config;
	struct pcm *pcm;

	memset(&config, 0, sizeof(config));
	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;

	if (!sample_is_playable(card, device, channels, rate, bits, period_size, period_count)) {
	return NULL;
	}

	pcm = pcm_open(card, device, PCM_OUT, &config);
	if (!pcm \|\| !pcm_is_ready(pcm)) {
	TRACE(ERROR, _x("Unable to open PCM device %u (%s)\n"),
	device, pcm_get_error(pcm));
	return NULL;
	}

	return pcm;
	}

	int xa_playback_buf(void *handle,
	const void *data,
	unsigned int nbytes)
	{
	int err;

	if (!handle \|\| !data)
	return XA_PLAYBACK_INVALID_PARAM;

	if (nbytes > 0) {
	err = pcm_write(handle, data, nbytes);

	if (err == -EINVAL) return XA_PLAYBACK_INVALID_PARAM;
	if (err == -EPIPE ) return XA_PLAYBACK_UNDERRUN;
	}

	return XA_PLAYBACK_OK;
	}

	int xa_playback_close(void *handle)
	{
	return pcm_close(handle);
	}

	#if 0
	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)
	{
	struct pcm_config config;
	struct pcm *pcm;
	char *buffer;
	int size;
	int num_read;
	int hifi_dsp_fd;
	struct misc_io_pcm_buf_param pcmbuf;

	hifi_dsp_fd = open(HIFI_DSP_MISC_DRIVER, O_RDWR, 0);
	if(hifi_dsp_fd < 0){
	printf("Error opening hifi dsp device %d", errno);
	}

	memset(&config, 0, sizeof(config));
	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;

	if (!sample_is_playable(card, device, channels, rate, bits, period_size, period_count)) {
	return;
	}

	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;
	}

	printf("Playing sample: %u ch, %u hz, %u bit\n", channels, rate, bits);

	/* catch ctrl-c to shutdown cleanly */
	signal(SIGINT, stream_close);

	do {
	num_read = fread(buffer, 1, size, file);

	pcmbuf.buf =(uint64_t) buffer;
	pcmbuf.buf_size = num_read;
	if(hifi_dsp_fd) {
	// printf("ioctl send \n");
	ioctl(hifi_dsp_fd,HIFI_MISC_IOCTL_PCM_GAIN, &pcmbuf);
	// printf("ioctl complete \n");
	}

	if (num_read > 0) {
	if (pcm_write(pcm, buffer, num_read)) {
	fprintf(stderr, "Error playing sample\n");
	break;
	}
	}
	} while (!s_close && num_read > 0);

	free(buffer);
	pcm_close(pcm);
	close(hifi_dsp_fd);
	}
	#endif