e8558e228a
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@10159 a1c6a512-1295-4272-9138-f99709370657
1103 lines
28 KiB
C
1103 lines
28 KiB
C
/***************************************************************************
|
|
* __________ __ ___.
|
|
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
|
|
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
|
|
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
|
|
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
|
|
* \/ \/ \/ \/ \/
|
|
* $Id$
|
|
*
|
|
* Copyright (C) 2005 by Linus Nielsen Feltzing
|
|
*
|
|
* All files in this archive are subject to the GNU General Public License.
|
|
* See the file COPYING in the source tree root for full license agreement.
|
|
*
|
|
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
|
|
* KIND, either express or implied.
|
|
*
|
|
****************************************************************************/
|
|
|
|
#include "config.h"
|
|
#include "debug.h"
|
|
#include "panic.h"
|
|
#include "thread.h"
|
|
|
|
#include <kernel.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <stdarg.h>
|
|
#include <string.h>
|
|
|
|
#include "cpu.h"
|
|
#include "i2c.h"
|
|
#include "power.h"
|
|
#include "uda1380.h"
|
|
#include "system.h"
|
|
#include "usb.h"
|
|
|
|
#include "buffer.h"
|
|
#include "audio.h"
|
|
#include "button.h"
|
|
#include "file.h"
|
|
#include "sprintf.h"
|
|
#include "logf.h"
|
|
#include "button.h"
|
|
#include "lcd.h"
|
|
#include "lcd-remote.h"
|
|
#include "pcm_playback.h"
|
|
#include "pcm_record.h"
|
|
|
|
extern int boost_counter; /* used for boost check */
|
|
|
|
/***************************************************************************/
|
|
|
|
static volatile bool is_recording; /* We are recording */
|
|
static volatile bool is_stopping; /* Are we going to stop */
|
|
static volatile bool is_paused; /* We have paused */
|
|
static volatile bool is_error; /* An error has occured */
|
|
|
|
static volatile unsigned long num_rec_bytes; /* Num bytes recorded */
|
|
static volatile unsigned long num_file_bytes; /* Num bytes written to current file */
|
|
static volatile int error_count; /* Number of DMA errors */
|
|
|
|
static long record_start_time; /* Value of current_tick when recording was started */
|
|
static long pause_start_time; /* Value of current_tick when pause was started */
|
|
static volatile int buffered_chunks; /* number of valid chunks in buffer */
|
|
static unsigned int sample_rate; /* Sample rate at time of recording start */
|
|
static int rec_source; /* Current recording source */
|
|
|
|
static int wav_file;
|
|
static char recording_filename[MAX_PATH];
|
|
|
|
static volatile bool init_done, close_done, record_done, stop_done, pause_done, resume_done, new_file_done;
|
|
|
|
static short peak_left, peak_right;
|
|
|
|
/***************************************************************************/
|
|
|
|
/*
|
|
Some estimates:
|
|
Normal recording rate: 44100 HZ * 4 = 176 KB/s
|
|
Total buffer size: 32 MB / 176 KB/s = 181s before writing to disk
|
|
*/
|
|
|
|
#define CHUNK_SIZE 8192 /* Multiple of 4 */
|
|
#define WRITE_THRESHOLD 250 /* (2 MB) Write when this many chunks (or less) until buffer full */
|
|
|
|
#define GET_CHUNK(x) (short*)(&rec_buffer[CHUNK_SIZE*(x)])
|
|
|
|
static unsigned int rec_buffer_offset;
|
|
static unsigned char *rec_buffer; /* Circular recording buffer */
|
|
static int num_chunks; /* Number of chunks available in rec_buffer */
|
|
|
|
|
|
/*
|
|
Overrun occures when DMA needs to write a new chunk and write_index == read_index
|
|
Solution to this is to optimize pcmrec_callback, use cpu_boost or save to disk
|
|
more often.
|
|
*/
|
|
|
|
static volatile int write_index; /* Current chunk the DMA is writing to */
|
|
static volatile int read_index; /* Oldest chunk that is not written to disk */
|
|
static volatile int read2_index; /* Latest chunk that has not been converted to little endian */
|
|
static long pre_record_ticks; /* pre-record time expressed in ticks */
|
|
static int pre_record_chunks; /* pre-record time expressed in chunks */
|
|
|
|
/***************************************************************************/
|
|
|
|
static struct event_queue pcmrec_queue;
|
|
static long pcmrec_stack[(DEFAULT_STACK_SIZE + 0x1000)/sizeof(long)];
|
|
static const char pcmrec_thread_name[] = "pcmrec";
|
|
|
|
static void pcmrec_thread(void);
|
|
static void pcmrec_dma_start(void);
|
|
static void pcmrec_dma_stop(void);
|
|
|
|
/* Event IDs */
|
|
#define PCMREC_INIT 1 /* Enable recording */
|
|
#define PCMREC_CLOSE 2
|
|
|
|
#define PCMREC_START 3 /* Start a new recording */
|
|
#define PCMREC_STOP 4 /* Stop the current recording */
|
|
#define PCMREC_PAUSE 10
|
|
#define PCMREC_RESUME 11
|
|
#define PCMREC_NEW_FILE 12
|
|
#define PCMREC_SET_GAIN 13
|
|
|
|
/*******************************************************************/
|
|
/* Functions that are not executing in the pcmrec_thread first */
|
|
/*******************************************************************/
|
|
|
|
/* Creates pcmrec_thread */
|
|
void pcm_rec_init(void)
|
|
{
|
|
queue_init(&pcmrec_queue);
|
|
create_thread(pcmrec_thread, pcmrec_stack, sizeof(pcmrec_stack), pcmrec_thread_name);
|
|
}
|
|
|
|
|
|
/* Initializes recording:
|
|
* - Set up the UDA1380 for recording
|
|
* - Prepare for DMA transfers
|
|
*/
|
|
|
|
void audio_init_recording(unsigned int buffer_offset)
|
|
{
|
|
rec_buffer_offset = buffer_offset;
|
|
init_done = false;
|
|
queue_post(&pcmrec_queue, PCMREC_INIT, 0);
|
|
|
|
while(!init_done)
|
|
sleep_thread();
|
|
wake_up_thread();
|
|
}
|
|
|
|
void audio_close_recording(void)
|
|
{
|
|
close_done = false;
|
|
queue_post(&pcmrec_queue, PCMREC_CLOSE, 0);
|
|
|
|
while(!close_done)
|
|
sleep_thread();
|
|
wake_up_thread();
|
|
}
|
|
|
|
unsigned long pcm_rec_status(void)
|
|
{
|
|
unsigned long ret = 0;
|
|
|
|
if (is_recording)
|
|
ret |= AUDIO_STATUS_RECORD;
|
|
if (is_paused)
|
|
ret |= AUDIO_STATUS_PAUSE;
|
|
if (is_error)
|
|
ret |= AUDIO_STATUS_ERROR;
|
|
|
|
return ret;
|
|
}
|
|
|
|
unsigned long audio_recorded_time(void)
|
|
{
|
|
if (is_recording)
|
|
{
|
|
if (is_paused)
|
|
return pause_start_time - record_start_time;
|
|
else
|
|
return current_tick - record_start_time;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
unsigned long audio_num_recorded_bytes(void)
|
|
{
|
|
if (is_recording)
|
|
return num_rec_bytes;
|
|
|
|
return 0;
|
|
}
|
|
|
|
#ifdef HAVE_SPDIF_IN
|
|
/* Only the last six of these are standard rates, but all sample rates are
|
|
* possible, so we support some other common ones as well.
|
|
*/
|
|
static unsigned long spdif_sample_rates[] = {
|
|
8000, 11025, 12000, 16000, 22050, 24000,
|
|
32000, 44100, 48000, 64000, 88200, 96000
|
|
};
|
|
|
|
/* Return SPDIF sample rate. Since we base our reading on the actual SPDIF
|
|
* sample rate (which might be a bit inaccurate), we round off to the closest
|
|
* sample rate that is supported by SPDIF.
|
|
*/
|
|
unsigned long audio_get_spdif_sample_rate(void)
|
|
{
|
|
int i = 0;
|
|
unsigned long measured_rate;
|
|
const int upper_bound = sizeof(spdif_sample_rates)/sizeof(long) - 1;
|
|
|
|
/* The following formula is specified in MCF5249 user's manual section
|
|
* 17.6.1. The 3*(1 << 13) part will need changing if the setup of the
|
|
* PHASECONFIG register is ever changed. The 128 divide is because of the
|
|
* fact that the SPDIF clock is the sample rate times 128.
|
|
*/
|
|
measured_rate = (unsigned long)((unsigned long long)FREQMEAS*CPU_FREQ/
|
|
((1 << 15)*3*(1 << 13))/128);
|
|
/* Find which SPDIF sample rate we're closest to. */
|
|
while (spdif_sample_rates[i] < measured_rate && i < upper_bound) ++i;
|
|
if (i > 0 && i < upper_bound)
|
|
{
|
|
long diff1 = measured_rate - spdif_sample_rates[i - 1];
|
|
long diff2 = spdif_sample_rates[i] - measured_rate;
|
|
|
|
if (diff2 > diff1) --i;
|
|
}
|
|
return spdif_sample_rates[i];
|
|
}
|
|
#endif
|
|
|
|
#ifdef HAVE_SPDIF_POWER
|
|
static bool spdif_power_setting;
|
|
|
|
void audio_set_spdif_power_setting(bool on)
|
|
{
|
|
spdif_power_setting = on;
|
|
}
|
|
#endif
|
|
|
|
/**
|
|
* Sets the audio source
|
|
*
|
|
* This functions starts feeding the CPU with audio data over the I2S bus
|
|
*
|
|
* @param source 0=mic, 1=line-in, 2=spdif
|
|
*/
|
|
void audio_set_recording_options(int frequency, int quality,
|
|
int source, int channel_mode,
|
|
bool editable, int prerecord_time)
|
|
{
|
|
/* TODO: */
|
|
(void)quality;
|
|
(void)channel_mode;
|
|
(void)editable;
|
|
|
|
/* NOTE: Coldfire UDA based recording does not yet support anything other
|
|
* than 44.1kHz sampling rate, so we limit it to that case here now. SPDIF
|
|
* based recording will overwrite this value with the proper sample rate in
|
|
* audio_record(), and will not be affected by this.
|
|
*/
|
|
frequency = 44100;
|
|
pre_record_ticks = prerecord_time * HZ;
|
|
pre_record_chunks = ((frequency * prerecord_time * 4)/CHUNK_SIZE)+1;
|
|
if(pre_record_chunks >= (num_chunks-250))
|
|
{
|
|
/* we can't prerecord more than our buffersize minus treshold to write to disk! */
|
|
pre_record_chunks = num_chunks-250;
|
|
/* don't forget to recalculate that time! */
|
|
pre_record_ticks = ((pre_record_chunks * CHUNK_SIZE)/(4*frequency)) * HZ;
|
|
}
|
|
|
|
//logf("pcmrec: src=%d", source);
|
|
|
|
rec_source = source;
|
|
#ifdef HAVE_SPDIF_POWER
|
|
/* Check if S/PDIF output power should be switched off or on. NOTE: assumes
|
|
both optical in and out is controlled by the same power source, which is
|
|
the case on H1x0. */
|
|
spdif_power_enable((source == 2) || spdif_power_setting);
|
|
#endif
|
|
switch (source)
|
|
{
|
|
/* mic */
|
|
case 0:
|
|
/* Generate int. when 6 samples in FIFO, PDIR2 src = IIS1recv */
|
|
DATAINCONTROL = 0xc020;
|
|
uda1380_enable_recording(true);
|
|
break;
|
|
|
|
/* line-in */
|
|
case 1:
|
|
/* Generate int. when 6 samples in FIFO, PDIR2 src = IIS1recv */
|
|
DATAINCONTROL = 0xc020;
|
|
uda1380_enable_recording(false);
|
|
break;
|
|
#ifdef HAVE_SPDIF_IN
|
|
/* SPDIF */
|
|
case 2:
|
|
/* Int. when 6 samples in FIFO. PDIR2 source = ebu1RcvData */
|
|
DATAINCONTROL = 0xc038;
|
|
#ifdef HAVE_SPDIF_POWER
|
|
EBU1CONFIG = spdif_power_setting ? (1 << 2) : 0;
|
|
/* Input source is EBUin1, Feed-through monitoring if desired */
|
|
#else
|
|
EBU1CONFIG = (1 << 2);
|
|
/* Input source is EBUin1, Feed-through monitoring */
|
|
#endif
|
|
uda1380_disable_recording();
|
|
break;
|
|
#endif
|
|
}
|
|
|
|
sample_rate = frequency;
|
|
|
|
/* Monitoring: route the signals through the coldfire audio interface. */
|
|
|
|
IIS2CONFIG = 0x800; /* Reset before reprogram */
|
|
#ifdef HAVE_SPDIF_IN
|
|
if (source == 2) {
|
|
/* SCLK2 = Audioclk/4 (can't use EBUin clock), TXSRC = EBU1rcv, 64 bclk/wclk */
|
|
IIS2CONFIG = (6 << 12) | (7 << 8) | (4 << 2);
|
|
/* S/PDIF feed-through already configured */
|
|
}
|
|
else
|
|
{
|
|
/* SCLK2 follow IIS1 (UDA clock), TXSRC = IIS1rcv, 64 bclk/wclk */
|
|
IIS2CONFIG = (8 << 12) | (4 << 8) | (4 << 2);
|
|
|
|
EBU1CONFIG = 0x800; /* Reset before reprogram */
|
|
/* SCLK2, TXSRC = IIS1recv, validity, normal operation */
|
|
EBU1CONFIG = (7 << 12) | (4 << 8) | (1 << 5) | (5 << 2);
|
|
}
|
|
#else
|
|
/* SCLK2 follow IIS1 (UDA clock), TXSRC = IIS1rcv, 64 bclk/wclk */
|
|
IIS2CONFIG = (8 << 12) | (4 << 8) | (4 << 2);
|
|
#endif
|
|
}
|
|
|
|
|
|
/**
|
|
* Note that microphone is mono, only left value is used
|
|
* See uda1380_set_recvol() for exact ranges.
|
|
*
|
|
* @param type 0=line-in (radio), 1=mic
|
|
*
|
|
*/
|
|
void audio_set_recording_gain(int left, int right, int type)
|
|
{
|
|
uda1380_set_recvol(left, right, type);
|
|
}
|
|
|
|
|
|
/**
|
|
* Start recording
|
|
*
|
|
* Use audio_set_recording_options first to select recording options
|
|
*/
|
|
void audio_record(const char *filename)
|
|
{
|
|
if (is_recording)
|
|
{
|
|
logf("record while recording");
|
|
return;
|
|
}
|
|
|
|
strncpy(recording_filename, filename, MAX_PATH - 1);
|
|
recording_filename[MAX_PATH - 1] = 0;
|
|
|
|
#ifdef HAVE_SPDIF_IN
|
|
if (rec_source == 2)
|
|
sample_rate = audio_get_spdif_sample_rate();
|
|
#endif
|
|
|
|
record_done = false;
|
|
queue_post(&pcmrec_queue, PCMREC_START, 0);
|
|
|
|
while(!record_done)
|
|
sleep_thread();
|
|
wake_up_thread();
|
|
}
|
|
|
|
|
|
void audio_new_file(const char *filename)
|
|
{
|
|
logf("pcm_new_file");
|
|
|
|
new_file_done = false;
|
|
|
|
strncpy(recording_filename, filename, MAX_PATH - 1);
|
|
recording_filename[MAX_PATH - 1] = 0;
|
|
|
|
queue_post(&pcmrec_queue, PCMREC_NEW_FILE, 0);
|
|
|
|
while(!new_file_done)
|
|
sleep_thread();
|
|
wake_up_thread();
|
|
|
|
logf("pcm_new_file done");
|
|
}
|
|
|
|
/**
|
|
*
|
|
*/
|
|
void audio_stop_recording(void)
|
|
{
|
|
if (!is_recording)
|
|
return;
|
|
|
|
logf("pcm_stop");
|
|
|
|
stop_done = false;
|
|
queue_post(&pcmrec_queue, PCMREC_STOP, 0);
|
|
|
|
while(!stop_done)
|
|
sleep_thread();
|
|
wake_up_thread();
|
|
|
|
logf("pcm_stop done");
|
|
}
|
|
|
|
void audio_pause_recording(void)
|
|
{
|
|
if (!is_recording)
|
|
{
|
|
logf("pause when not recording");
|
|
return;
|
|
}
|
|
if (is_paused)
|
|
{
|
|
logf("pause when paused");
|
|
return;
|
|
}
|
|
|
|
pause_done = false;
|
|
queue_post(&pcmrec_queue, PCMREC_PAUSE, 0);
|
|
|
|
while(!pause_done)
|
|
sleep_thread();
|
|
wake_up_thread();
|
|
}
|
|
|
|
void audio_resume_recording(void)
|
|
{
|
|
if (!is_paused)
|
|
{
|
|
logf("resume when not paused");
|
|
return;
|
|
}
|
|
|
|
resume_done = false;
|
|
queue_post(&pcmrec_queue, PCMREC_RESUME, 0);
|
|
|
|
while(!resume_done)
|
|
sleep_thread();
|
|
wake_up_thread();
|
|
}
|
|
|
|
/* return peaks as int, so convert from short first
|
|
note that peak values are always positive */
|
|
void pcm_rec_get_peaks(int *left, int *right)
|
|
{
|
|
if (left)
|
|
*left = (int)peak_left;
|
|
if (right)
|
|
*right = (int)peak_right;
|
|
peak_left = 0;
|
|
peak_right = 0;
|
|
}
|
|
|
|
/***************************************************************************/
|
|
/* Functions that executes in the context of pcmrec_thread */
|
|
/***************************************************************************/
|
|
|
|
/**
|
|
* Process the chunks using read_index and write_index.
|
|
*
|
|
* This function is called when queue_get_w_tmo times out.
|
|
*
|
|
* Other functions can also call this function with flush = true when
|
|
* they want to save everything in the buffers to disk.
|
|
*
|
|
*/
|
|
|
|
static void pcmrec_callback(bool flush) ICODE_ATTR;
|
|
static void pcmrec_callback(bool flush)
|
|
{
|
|
int num_ready, num_free, num_new;
|
|
short *ptr;
|
|
short value;
|
|
int i, j, w;
|
|
|
|
w = write_index;
|
|
|
|
num_new = w - read2_index;
|
|
if (num_new < 0)
|
|
num_new += num_chunks;
|
|
|
|
for (i=0; i<num_new; i++)
|
|
{
|
|
/* Convert the samples to little-endian so we only have to write later
|
|
(Less hd-spinning time), also do peak detection while we're at it
|
|
*/
|
|
ptr = GET_CHUNK(read2_index);
|
|
for (j=0; j<CHUNK_SIZE/4; j++)
|
|
{
|
|
value = *ptr;
|
|
if(value > peak_left)
|
|
peak_left = value;
|
|
else if (-value > peak_left)
|
|
peak_left = -value;
|
|
|
|
*ptr = htole16(value);
|
|
ptr++;
|
|
|
|
value = *ptr;
|
|
if(value > peak_right)
|
|
peak_right = value;
|
|
else if (-value > peak_right)
|
|
peak_right = -value;
|
|
|
|
*ptr = htole16(value);
|
|
ptr++;
|
|
}
|
|
|
|
if(is_recording && !is_paused)
|
|
num_rec_bytes += CHUNK_SIZE;
|
|
|
|
read2_index++;
|
|
if (read2_index >= num_chunks)
|
|
read2_index = 0;
|
|
}
|
|
|
|
if ((!is_recording || is_paused) && !flush)
|
|
{
|
|
/* not recording = no saving to disk, fake buffer clearing */
|
|
read_index = write_index;
|
|
return;
|
|
}
|
|
|
|
num_ready = w - read_index;
|
|
if (num_ready < 0)
|
|
num_ready += num_chunks;
|
|
|
|
num_free = num_chunks - num_ready;
|
|
|
|
if (num_free <= WRITE_THRESHOLD || flush)
|
|
{
|
|
bool must_boost = (boost_counter ? false : true);
|
|
|
|
logf("writing: %d (%d)", num_ready, flush);
|
|
|
|
if(must_boost)
|
|
cpu_boost(true);
|
|
|
|
for (i=0; i<num_ready; i++)
|
|
{
|
|
if (write(wav_file, GET_CHUNK(read_index), CHUNK_SIZE) != CHUNK_SIZE)
|
|
{
|
|
if(must_boost)
|
|
cpu_boost(false);
|
|
logf("pcmrec: write err");
|
|
pcmrec_dma_stop();
|
|
return;
|
|
}
|
|
|
|
num_file_bytes += CHUNK_SIZE;
|
|
|
|
read_index++;
|
|
if (read_index >= num_chunks)
|
|
read_index = 0;
|
|
yield();
|
|
}
|
|
|
|
if(must_boost)
|
|
cpu_boost(false);
|
|
|
|
/* sync file */
|
|
fsync(wav_file);
|
|
|
|
logf("done");
|
|
}
|
|
}
|
|
|
|
/* Abort dma transfer */
|
|
static void pcmrec_dma_stop(void)
|
|
{
|
|
DCR1 = 0;
|
|
|
|
is_error = true;
|
|
is_recording = false;
|
|
|
|
error_count++;
|
|
|
|
logf("dma1 stopped");
|
|
}
|
|
|
|
static void pcmrec_dma_start(void)
|
|
{
|
|
DAR1 = (unsigned long)GET_CHUNK(write_index); /* Destination address */
|
|
SAR1 = (unsigned long)&PDIR2; /* Source address */
|
|
BCR1 = CHUNK_SIZE; /* Bytes to transfer */
|
|
|
|
/* Start the DMA transfer.. */
|
|
DCR1 = DMA_INT | DMA_EEXT | DMA_CS | DMA_DINC | DMA_START;
|
|
|
|
#ifdef HAVE_SPDIF_IN
|
|
INTERRUPTCLEAR = 0x03c00000;
|
|
#endif
|
|
|
|
/* pre-recording: buffer count */
|
|
buffered_chunks = 0;
|
|
|
|
logf("dma1 started");
|
|
}
|
|
|
|
|
|
/* DMA1 Interrupt is called when the DMA has finished transfering a chunk */
|
|
void DMA1(void) __attribute__ ((interrupt_handler, section(".icode")));
|
|
void DMA1(void)
|
|
{
|
|
int res = DSR1;
|
|
|
|
DSR1 = 1; /* Clear interrupt */
|
|
|
|
if (res & 0x70)
|
|
{
|
|
DCR1 = 0; /* Stop DMA transfer */
|
|
error_count++;
|
|
|
|
logf("dma1 err: 0x%x", res);
|
|
|
|
DAR1 = (unsigned long)GET_CHUNK(write_index); /* Destination address */
|
|
BCR1 = CHUNK_SIZE;
|
|
DCR1 = DMA_INT | DMA_EEXT | DMA_CS | DMA_DINC | DMA_START;
|
|
}
|
|
#ifdef HAVE_SPDIF_IN
|
|
else if ((rec_source == 2) && (INTERRUPTSTAT & 0x01c00000)) /* valnogood, symbolerr, parityerr */
|
|
{
|
|
INTERRUPTCLEAR = 0x03c00000;
|
|
error_count++;
|
|
|
|
logf("spdif err");
|
|
|
|
if (is_stopping)
|
|
{
|
|
DCR1 = 0; /* Stop DMA transfer */
|
|
is_stopping = false;
|
|
|
|
logf("dma1 stopping");
|
|
}
|
|
else
|
|
{
|
|
DAR1 = (unsigned long)GET_CHUNK(write_index); /* Destination address */
|
|
BCR1 = CHUNK_SIZE;
|
|
}
|
|
}
|
|
#endif
|
|
else
|
|
{
|
|
write_index++;
|
|
if (write_index >= num_chunks)
|
|
write_index = 0;
|
|
|
|
/* update number of valid chunks for pre-recording */
|
|
if(buffered_chunks < num_chunks)
|
|
buffered_chunks++;
|
|
|
|
if (is_stopping)
|
|
{
|
|
DCR1 = 0; /* Stop DMA transfer */
|
|
is_stopping = false;
|
|
|
|
logf("dma1 stopping");
|
|
}
|
|
else if (write_index == read_index)
|
|
{
|
|
DCR1 = 0; /* Stop DMA transfer */
|
|
is_recording = false;
|
|
|
|
logf("dma1 overrun");
|
|
|
|
}
|
|
else
|
|
{
|
|
DAR1 = (unsigned long)GET_CHUNK(write_index); /* Destination address */
|
|
BCR1 = CHUNK_SIZE;
|
|
}
|
|
}
|
|
|
|
IPR |= (1<<15); /* Clear pending interrupt request */
|
|
}
|
|
|
|
/* Create WAVE file and write header */
|
|
/* Sets returns 0 if success, -1 on failure */
|
|
static int start_wave(void)
|
|
{
|
|
unsigned char header[44] =
|
|
{
|
|
'R','I','F','F',0,0,0,0,'W','A','V','E','f','m','t',' ',
|
|
0x10,0,0,0,1,0,2,0,0,0,0,0,0,0,0,0,
|
|
4,0,0x10,0,'d','a','t','a',0,0,0,0
|
|
};
|
|
unsigned long avg_bytes_per_sec;
|
|
|
|
wav_file = open(recording_filename, O_RDWR|O_CREAT|O_TRUNC);
|
|
if (wav_file < 0)
|
|
{
|
|
wav_file = -1;
|
|
logf("rec: create failed: %d", wav_file);
|
|
is_error = true;
|
|
return -1;
|
|
}
|
|
/* Now set the sample rate field of the WAV header to what it should be */
|
|
header[24] = (unsigned char)(sample_rate & 0xff);
|
|
header[25] = (unsigned char)(sample_rate >> 8);
|
|
header[26] = (unsigned char)(sample_rate >> 16);
|
|
header[27] = (unsigned char)(sample_rate >> 24);
|
|
/* And then the average bytes per second field */
|
|
avg_bytes_per_sec = sample_rate*4; /* Hard coded to 16 bit stereo */
|
|
header[28] = (unsigned char)(avg_bytes_per_sec & 0xff);
|
|
header[29] = (unsigned char)(avg_bytes_per_sec >> 8);
|
|
header[30] = (unsigned char)(avg_bytes_per_sec >> 16);
|
|
header[31] = (unsigned char)(avg_bytes_per_sec >> 24);
|
|
|
|
if (sizeof(header) != write(wav_file, header, sizeof(header)))
|
|
{
|
|
close(wav_file);
|
|
wav_file = -1;
|
|
logf("rec: write failed");
|
|
is_error = true;
|
|
return -1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* Update header and set correct length values */
|
|
static void close_wave(void)
|
|
{
|
|
long l;
|
|
|
|
if (wav_file != -1)
|
|
{
|
|
l = htole32(num_file_bytes + 36);
|
|
lseek(wav_file, 4, SEEK_SET);
|
|
write(wav_file, &l, 4);
|
|
|
|
l = htole32(num_file_bytes);
|
|
lseek(wav_file, 40, SEEK_SET);
|
|
write(wav_file, &l, 4);
|
|
|
|
close(wav_file);
|
|
wav_file = -1;
|
|
}
|
|
}
|
|
|
|
static void pcmrec_start(void)
|
|
{
|
|
int pre_chunks = pre_record_chunks; /* recalculate every time! */
|
|
long pre_ticks = pre_record_ticks; /* recalculate every time! */
|
|
|
|
logf("pcmrec_start");
|
|
|
|
if (is_recording)
|
|
{
|
|
logf("already recording");
|
|
record_done = true;
|
|
return;
|
|
}
|
|
|
|
if (wav_file != -1)
|
|
close(wav_file);
|
|
|
|
if (start_wave() != 0)
|
|
{
|
|
/* failed to create the file */
|
|
record_done = true;
|
|
return;
|
|
}
|
|
|
|
/* pre-recording calculation */
|
|
if(buffered_chunks < pre_chunks)
|
|
{
|
|
/* not enough good chunks available - limit pre-record time */
|
|
pre_chunks = buffered_chunks;
|
|
pre_ticks = ((buffered_chunks * CHUNK_SIZE)/(4*sample_rate)) * HZ;
|
|
}
|
|
record_start_time = current_tick - pre_ticks;
|
|
|
|
read_index = write_index - pre_chunks;
|
|
if(read_index < 0)
|
|
{
|
|
read_index += num_chunks;
|
|
}
|
|
|
|
peak_left = 0;
|
|
peak_right = 0;
|
|
|
|
num_rec_bytes = pre_chunks * CHUNK_SIZE;
|
|
num_file_bytes = 0;
|
|
pause_start_time = 0;
|
|
|
|
is_stopping = false;
|
|
is_paused = false;
|
|
is_recording = true;
|
|
|
|
record_done = true;
|
|
}
|
|
|
|
static void pcmrec_stop(void)
|
|
{
|
|
logf("pcmrec_stop");
|
|
|
|
if (!is_recording)
|
|
{
|
|
stop_done = true;
|
|
return;
|
|
}
|
|
|
|
if (!is_paused)
|
|
{
|
|
/* wait for recording to finish */
|
|
is_stopping = true;
|
|
|
|
while (is_stopping && is_recording)
|
|
sleep_thread();
|
|
wake_up_thread();
|
|
|
|
is_stopping = false;
|
|
}
|
|
|
|
is_recording = false;
|
|
|
|
/* Flush buffers to file */
|
|
pcmrec_callback(true);
|
|
|
|
close_wave();
|
|
|
|
stop_done = true;
|
|
|
|
/* Finally start dma again for peakmeters and pre-recoding to work. */
|
|
pcmrec_dma_start();
|
|
|
|
logf("pcmrec_stop done");
|
|
}
|
|
|
|
static void pcmrec_new_file(void)
|
|
{
|
|
logf("pcmrec_new_file");
|
|
|
|
if (!is_recording)
|
|
{
|
|
logf("not recording");
|
|
new_file_done = true;
|
|
return;
|
|
}
|
|
|
|
/* Since pcmrec_callback() blocks until the data has been written,
|
|
here is a good approximation when recording to the new file starts
|
|
*/
|
|
record_start_time = current_tick;
|
|
num_rec_bytes = 0;
|
|
|
|
if (is_paused)
|
|
pause_start_time = record_start_time;
|
|
|
|
/* Flush what we got in buffers to file */
|
|
pcmrec_callback(true);
|
|
|
|
close_wave();
|
|
|
|
num_file_bytes = 0;
|
|
|
|
/* start the new file */
|
|
if (start_wave() != 0)
|
|
{
|
|
logf("new_file failed");
|
|
pcmrec_stop();
|
|
}
|
|
|
|
new_file_done = true;
|
|
logf("pcmrec_new_file done");
|
|
}
|
|
|
|
static void pcmrec_pause(void)
|
|
{
|
|
logf("pcmrec_pause");
|
|
|
|
if (!is_recording)
|
|
{
|
|
logf("pause: not recording");
|
|
pause_done = true;
|
|
return;
|
|
}
|
|
|
|
/* Abort DMA transfer and flush to file? */
|
|
|
|
is_stopping = true;
|
|
|
|
while (is_stopping && is_recording)
|
|
sleep_thread();
|
|
wake_up_thread();
|
|
|
|
pause_start_time = current_tick;
|
|
is_paused = true;
|
|
|
|
/* Flush what we got in buffers to file */
|
|
pcmrec_callback(true);
|
|
|
|
pause_done = true;
|
|
|
|
logf("pcmrec_pause done");
|
|
}
|
|
|
|
|
|
static void pcmrec_resume(void)
|
|
{
|
|
logf("pcmrec_resume");
|
|
|
|
if (!is_paused)
|
|
{
|
|
logf("resume: not paused");
|
|
resume_done = true;
|
|
return;
|
|
}
|
|
|
|
is_paused = false;
|
|
is_recording = true;
|
|
|
|
/* Compensate for the time we have been paused */
|
|
if (pause_start_time)
|
|
{
|
|
record_start_time += current_tick - pause_start_time;
|
|
pause_start_time = 0;
|
|
}
|
|
|
|
pcmrec_dma_start();
|
|
|
|
resume_done = true;
|
|
|
|
logf("pcmrec_resume done");
|
|
}
|
|
|
|
/**
|
|
* audio_init_recording calls this function using PCMREC_INIT
|
|
*
|
|
*/
|
|
static void pcmrec_init(void)
|
|
{
|
|
unsigned long buffer_size;
|
|
|
|
wav_file = -1;
|
|
read_index = 0;
|
|
read2_index = 0;
|
|
write_index = 0;
|
|
pre_record_chunks = 0;
|
|
pre_record_ticks = 0;
|
|
|
|
peak_left = 0;
|
|
peak_right = 0;
|
|
|
|
num_rec_bytes = 0;
|
|
num_file_bytes = 0;
|
|
record_start_time = 0;
|
|
pause_start_time = 0;
|
|
buffered_chunks = 0;
|
|
|
|
is_recording = false;
|
|
is_stopping = false;
|
|
is_paused = false;
|
|
is_error = false;
|
|
|
|
rec_buffer = (unsigned char*)(((unsigned long)audiobuf + rec_buffer_offset) & ~3);
|
|
buffer_size = (long)audiobufend - (long)audiobuf - rec_buffer_offset - 16;
|
|
|
|
logf("buf size: %d kb", buffer_size/1024);
|
|
|
|
num_chunks = buffer_size / CHUNK_SIZE;
|
|
|
|
logf("num_chunks: %d", num_chunks);
|
|
|
|
IIS1CONFIG = 0x800; /* Stop any playback */
|
|
AUDIOGLOB |= 0x180; /* IIS1 fifo auto sync = on, PDIR2 auto sync = on */
|
|
DATAINCONTROL = 0xc000; /* Generate Interrupt when 6 samples in fifo */
|
|
|
|
DIVR1 = 55; /* DMA1 is mapped into vector 55 in system.c */
|
|
DMACONFIG = 1; /* DMA0Req = PDOR3, DMA1Req = PDIR2 */
|
|
DMAROUTE = (DMAROUTE & 0xffff00ff) | DMA1_REQ_AUDIO_2;
|
|
ICR7 = 0x1c; /* Enable interrupt at level 7, priority 0 */
|
|
IMR &= ~(1<<15); /* bit 15 is DMA1 */
|
|
|
|
#ifdef HAVE_SPDIF_IN
|
|
PHASECONFIG = 0x34; /* Gain = 3*2^13, source = EBUIN */
|
|
#endif
|
|
pcmrec_dma_start();
|
|
|
|
init_done = 1;
|
|
}
|
|
|
|
static void pcmrec_close(void)
|
|
{
|
|
uda1380_disable_recording();
|
|
|
|
#ifdef HAVE_SPDIF_POWER
|
|
spdif_power_enable(spdif_power_setting);
|
|
#endif
|
|
DMAROUTE = (DMAROUTE & 0xffff00ff);
|
|
ICR7 = 0x00; /* Disable interrupt */
|
|
IMR |= (1<<15); /* bit 15 is DMA1 */
|
|
|
|
/* Reset PDIR2 data flow */
|
|
DATAINCONTROL = 0x200;
|
|
close_done = true;
|
|
}
|
|
|
|
static void pcmrec_thread(void)
|
|
{
|
|
struct event ev;
|
|
|
|
logf("thread pcmrec start");
|
|
|
|
error_count = 0;
|
|
|
|
while (1)
|
|
{
|
|
queue_wait_w_tmo(&pcmrec_queue, &ev, HZ / 40);
|
|
|
|
switch (ev.id)
|
|
{
|
|
case PCMREC_INIT:
|
|
pcmrec_init();
|
|
break;
|
|
|
|
case PCMREC_CLOSE:
|
|
pcmrec_close();
|
|
break;
|
|
|
|
case PCMREC_START:
|
|
pcmrec_start();
|
|
break;
|
|
|
|
case PCMREC_STOP:
|
|
pcmrec_stop();
|
|
break;
|
|
|
|
case PCMREC_PAUSE:
|
|
pcmrec_pause();
|
|
break;
|
|
|
|
case PCMREC_RESUME:
|
|
pcmrec_resume();
|
|
break;
|
|
|
|
case PCMREC_NEW_FILE:
|
|
pcmrec_new_file();
|
|
break;
|
|
|
|
case SYS_TIMEOUT:
|
|
pcmrec_callback(false);
|
|
break;
|
|
|
|
case SYS_USB_CONNECTED:
|
|
if (!is_recording && !is_stopping)
|
|
{
|
|
usb_acknowledge(SYS_USB_CONNECTED_ACK);
|
|
usb_wait_for_disconnect(&pcmrec_queue);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
logf("thread pcmrec done");
|
|
}
|
|
|
|
/* Select VINL & VINR source: 0=Line-in, 1=FM Radio */
|
|
void pcm_rec_mux(int source)
|
|
{
|
|
#ifdef IRIVER_H300_SERIES
|
|
if(source == 0)
|
|
and_l(~0x40000000, &GPIO_OUT); /* Line In */
|
|
else
|
|
or_l(0x40000000, &GPIO_OUT); /* FM radio */
|
|
|
|
or_l(0x40000000, &GPIO_ENABLE);
|
|
or_l(0x40000000, &GPIO_FUNCTION);
|
|
#else
|
|
if(source == 0)
|
|
and_l(~0x00800000, &GPIO_OUT); /* Line In */
|
|
else
|
|
or_l(0x00800000, &GPIO_OUT); /* FM radio */
|
|
|
|
or_l(0x00800000, &GPIO_ENABLE);
|
|
or_l(0x00800000, &GPIO_FUNCTION);
|
|
#endif
|
|
}
|