/*
* Create file writer port.
*/
PJ_DEF(pj_status_t) pjmedia_wav_writer_port_create( pj_pool_t *pool,
const char *filename,
unsigned sampling_rate,
unsigned channel_count,
unsigned samples_per_frame,
unsigned bits_per_sample,
unsigned flags,
pj_ssize_t buff_size,
pjmedia_port **p_port )
{
struct file_port *fport;
pjmedia_wave_hdr wave_hdr;
pj_ssize_t size;
pj_str_t name;
pj_status_t status;
/* Check arguments. */
PJ_ASSERT_RETURN(pool && filename && p_port, PJ_EINVAL);
/* Only supports 16bits per sample for now.
* See flush_buffer().
*/
PJ_ASSERT_RETURN(bits_per_sample == 16, PJ_EINVAL);
/* Create file port instance. */
fport = PJ_POOL_ZALLOC_T(pool, struct file_port);
PJ_ASSERT_RETURN(fport != NULL, PJ_ENOMEM);
/* Initialize port info. */
pj_strdup2(pool, &name, filename);
pjmedia_port_info_init(&fport->base.info, &name, SIGNATURE,
sampling_rate, channel_count, bits_per_sample,
samples_per_frame);
fport->base.get_frame = &file_get_frame;
fport->base.put_frame = &file_put_frame;
fport->base.on_destroy = &file_on_destroy;
if (flags == PJMEDIA_FILE_WRITE_ALAW) {
fport->fmt_tag = PJMEDIA_WAVE_FMT_TAG_ALAW;
fport->bytes_per_sample = 1;
} else if (flags == PJMEDIA_FILE_WRITE_ULAW) {
fport->fmt_tag = PJMEDIA_WAVE_FMT_TAG_ULAW;
fport->bytes_per_sample = 1;
} else {
fport->fmt_tag = PJMEDIA_WAVE_FMT_TAG_PCM;
fport->bytes_per_sample = 2;
}
/* Open file in write and read mode.
* We need the read mode because we'll modify the WAVE header once
* the recording has completed.
*/
status = pj_file_open(pool, filename, PJ_O_WRONLY, &fport->fd);
if (status != PJ_SUCCESS)
return status;
/* Initialize WAVE header */
pj_bzero(&wave_hdr, sizeof(pjmedia_wave_hdr));
wave_hdr.riff_hdr.riff = PJMEDIA_RIFF_TAG;
wave_hdr.riff_hdr.file_len = 0; /* will be filled later */
wave_hdr.riff_hdr.wave = PJMEDIA_WAVE_TAG;
wave_hdr.fmt_hdr.fmt = PJMEDIA_FMT_TAG;
wave_hdr.fmt_hdr.len = 16;
wave_hdr.fmt_hdr.fmt_tag = (pj_uint16_t)fport->fmt_tag;
wave_hdr.fmt_hdr.nchan = (pj_int16_t)channel_count;
wave_hdr.fmt_hdr.sample_rate = sampling_rate;
wave_hdr.fmt_hdr.bytes_per_sec = sampling_rate * channel_count *
fport->bytes_per_sample;
wave_hdr.fmt_hdr.block_align = (pj_uint16_t)
(fport->bytes_per_sample * channel_count);
wave_hdr.fmt_hdr.bits_per_sample = (pj_uint16_t)
(fport->bytes_per_sample * 8);
wave_hdr.data_hdr.data = PJMEDIA_DATA_TAG;
wave_hdr.data_hdr.len = 0; /* will be filled later */
/* Convert WAVE header from host byte order to little endian
* before writing the header.
*/
pjmedia_wave_hdr_host_to_file(&wave_hdr);
/* Write WAVE header */
if (fport->fmt_tag != PJMEDIA_WAVE_FMT_TAG_PCM) {
pjmedia_wave_subchunk fact_chunk;
pj_uint32_t tmp = 0;
fact_chunk.id = PJMEDIA_FACT_TAG;
fact_chunk.len = 4;
PJMEDIA_WAVE_NORMALIZE_SUBCHUNK(&fact_chunk);
/* Write WAVE header without DATA chunk header */
size = sizeof(pjmedia_wave_hdr) - sizeof(wave_hdr.data_hdr);
status = pj_file_write(fport->fd, &wave_hdr, &size);
if (status != PJ_SUCCESS) {
pj_file_close(fport->fd);
return status;
}
/* Write FACT chunk if it stores compressed data */
size = sizeof(fact_chunk);
status = pj_file_write(fport->fd, &fact_chunk, &size);
if (status != PJ_SUCCESS) {
pj_file_close(fport->fd);
return status;
}
size = 4;
status = pj_file_write(fport->fd, &tmp, &size);
if (status != PJ_SUCCESS) {
pj_file_close(fport->fd);
return status;
}
/* Write DATA chunk header */
size = sizeof(wave_hdr.data_hdr);
status = pj_file_write(fport->fd, &wave_hdr.data_hdr, &size);
if (status != PJ_SUCCESS) {
pj_file_close(fport->fd);
return status;
}
} else {
size = sizeof(pjmedia_wave_hdr);
status = pj_file_write(fport->fd, &wave_hdr, &size);
if (status != PJ_SUCCESS) {
pj_file_close(fport->fd);
return status;
}
}
/* Set buffer size. */
if (buff_size < 1) buff_size = PJMEDIA_FILE_PORT_BUFSIZE;
fport->bufsize = buff_size;
/* Check that buffer size is greater than bytes per frame */
pj_assert(fport->bufsize >= PJMEDIA_PIA_AVG_FSZ(&fport->base.info));
/* Allocate buffer and set initial write position */
fport->buf = (char*) pj_pool_alloc(pool, fport->bufsize);
if (fport->buf == NULL) {
pj_file_close(fport->fd);
return PJ_ENOMEM;
}
fport->writepos = fport->buf;
/* Done. */
*p_port = &fport->base;
PJ_LOG(4,(THIS_FILE,
"File writer '%.*s' created: samp.rate=%d, bufsize=%uKB",
(int)fport->base.info.name.slen,
fport->base.info.name.ptr,
PJMEDIA_PIA_SRATE(&fport->base.info),
fport->bufsize / 1000));
return PJ_SUCCESS;
}
/*
* Create wave list player.
*/
PJ_DEF(pj_status_t) pjmedia_wav_playlist_create(pj_pool_t *pool,
const pj_str_t *port_label,
const pj_str_t file_list[],
int file_count,
unsigned ptime,
unsigned options,
pj_ssize_t buff_size,
pjmedia_port **p_port)
{
struct playlist_port *fport;
pj_off_t pos;
pj_status_t status;
int index;
pj_bool_t has_wave_info = PJ_FALSE;
pj_str_t tmp_port_label;
char filename[PJ_MAXPATH]; /* filename for open operations. */
/* Check arguments. */
PJ_ASSERT_RETURN(pool && file_list && file_count && p_port, PJ_EINVAL);
/* Normalize port_label */
if (port_label == NULL || port_label->slen == 0) {
tmp_port_label = pj_str("WAV playlist");
port_label = &tmp_port_label;
}
/* Be sure all files exist */
for (index=0; index<file_count; index++) {
PJ_ASSERT_RETURN(file_list[index].slen < PJ_MAXPATH, PJ_ENAMETOOLONG);
pj_memcpy(filename, file_list[index].ptr, file_list[index].slen);
filename[file_list[index].slen] = '\0';
/* Check the file really exists. */
if (!pj_file_exists(filename)) {
PJ_LOG(4,(THIS_FILE,
"WAV playlist error: file '%s' not found",
filename));
return PJ_ENOTFOUND;
}
}
/* Normalize ptime */
if (ptime == 0)
ptime = 20;
/* Create fport instance. */
fport = create_file_list_port(pool, port_label);
if (!fport) {
return PJ_ENOMEM;
}
/* start with the first file. */
fport->current_file = 0;
fport->max_file = file_count;
/* Create file descriptor list */
fport->fd_list = pj_pool_zalloc(pool, sizeof(pj_oshandle_t)*file_count);
if (!fport->fd_list) {
return PJ_ENOMEM;
}
/* Create file size list */
fport->fsize_list = pj_pool_alloc(pool, sizeof(pj_off_t)*file_count);
if (!fport->fsize_list) {
return PJ_ENOMEM;
}
/* Create start of WAVE data list */
fport->start_data_list = pj_pool_alloc(pool, sizeof(unsigned)*file_count);
if (!fport->start_data_list) {
return PJ_ENOMEM;
}
/* Create file position list */
fport->fpos_list = pj_pool_alloc(pool, sizeof(pj_off_t)*file_count);
if (!fport->fpos_list) {
return PJ_ENOMEM;
}
/* Create file buffer once for this operation.
*/
if (buff_size < 1) buff_size = PJMEDIA_FILE_PORT_BUFSIZE;
fport->bufsize = buff_size;
/* Create buffer. */
fport->buf = pj_pool_alloc(pool, fport->bufsize);
if (!fport->buf) {
return PJ_ENOMEM;
}
/* Initialize port */
fport->options = options;
fport->readpos = fport->buf;
/* ok run this for all files to be sure all are good for playback. */
for (index=file_count-1; index>=0; index--) {
pjmedia_wave_hdr wavehdr;
pj_ssize_t size_to_read, size_read;
/* we end with the last one so we are good to go if still in function*/
pj_memcpy(filename, file_list[index].ptr, file_list[index].slen);
filename[file_list[index].slen] = '\0';
/* Get the file size. */
fport->current_file = index;
fport->fsize_list[index] = pj_file_size(filename);
/* Size must be more than WAVE header size */
if (fport->fsize_list[index] <= sizeof(pjmedia_wave_hdr)) {
status = PJMEDIA_ENOTVALIDWAVE;
goto on_error;
}
/* Open file. */
status = pj_file_open( pool, filename, PJ_O_RDONLY,
&fport->fd_list[index]);
if (status != PJ_SUCCESS)
goto on_error;
/* Read the file header plus fmt header only. */
size_read = size_to_read = sizeof(wavehdr) - 8;
status = pj_file_read( fport->fd_list[index], &wavehdr, &size_read);
if (status != PJ_SUCCESS) {
goto on_error;
}
if (size_read != size_to_read) {
status = PJMEDIA_ENOTVALIDWAVE;
goto on_error;
}
/* Normalize WAVE header fields values from little-endian to host
* byte order.
*/
pjmedia_wave_hdr_file_to_host(&wavehdr);
/* Validate WAVE file. */
if (wavehdr.riff_hdr.riff != PJMEDIA_RIFF_TAG ||
wavehdr.riff_hdr.wave != PJMEDIA_WAVE_TAG ||
wavehdr.fmt_hdr.fmt != PJMEDIA_FMT_TAG)
{
TRACE_((THIS_FILE,
"actual value|expected riff=%x|%x, wave=%x|%x fmt=%x|%x",
wavehdr.riff_hdr.riff, PJMEDIA_RIFF_TAG,
wavehdr.riff_hdr.wave, PJMEDIA_WAVE_TAG,
wavehdr.fmt_hdr.fmt, PJMEDIA_FMT_TAG));
status = PJMEDIA_ENOTVALIDWAVE;
goto on_error;
}
/* Must be PCM with 16bits per sample */
if (wavehdr.fmt_hdr.fmt_tag != 1 ||
wavehdr.fmt_hdr.bits_per_sample != 16)
{
status = PJMEDIA_EWAVEUNSUPP;
goto on_error;
}
/* Block align must be 2*nchannels */
if (wavehdr.fmt_hdr.block_align !=
wavehdr.fmt_hdr.nchan * BYTES_PER_SAMPLE)
{
status = PJMEDIA_EWAVEUNSUPP;
goto on_error;
}
/* If length of fmt_header is greater than 16, skip the remaining
* fmt header data.
*/
if (wavehdr.fmt_hdr.len > 16) {
size_to_read = wavehdr.fmt_hdr.len - 16;
status = pj_file_setpos(fport->fd_list[index], size_to_read,
PJ_SEEK_CUR);
if (status != PJ_SUCCESS) {
goto on_error;
}
}
/* Repeat reading the WAVE file until we have 'data' chunk */
for (;;) {
pjmedia_wave_subchunk subchunk;
size_read = 8;
status = pj_file_read(fport->fd_list[index], &subchunk,
&size_read);
if (status != PJ_SUCCESS || size_read != 8) {
status = PJMEDIA_EWAVETOOSHORT;
goto on_error;
}
/* Normalize endianness */
PJMEDIA_WAVE_NORMALIZE_SUBCHUNK(&subchunk);
/* Break if this is "data" chunk */
if (subchunk.id == PJMEDIA_DATA_TAG) {
wavehdr.data_hdr.data = PJMEDIA_DATA_TAG;
wavehdr.data_hdr.len = subchunk.len;
break;
}
/* Otherwise skip the chunk contents */
size_to_read = subchunk.len;
status = pj_file_setpos(fport->fd_list[index], size_to_read,
PJ_SEEK_CUR);
if (status != PJ_SUCCESS) {
goto on_error;
}
}
/* Current file position now points to start of data */
status = pj_file_getpos(fport->fd_list[index], &pos);
fport->start_data_list[index] = (unsigned)pos;
/* Validate length. */
if (wavehdr.data_hdr.len != fport->fsize_list[index] -
fport->start_data_list[index])
{
status = PJMEDIA_EWAVEUNSUPP;
goto on_error;
}
if (wavehdr.data_hdr.len < 400) {
status = PJMEDIA_EWAVETOOSHORT;
goto on_error;
}
/* It seems like we have a valid WAVE file. */
/* Update port info if we don't have one, otherwise check
* that the WAV file has the same attributes as previous files.
*/
if (!has_wave_info) {
fport->base.info.channel_count = wavehdr.fmt_hdr.nchan;
fport->base.info.clock_rate = wavehdr.fmt_hdr.sample_rate;
fport->base.info.bits_per_sample = wavehdr.fmt_hdr.bits_per_sample;
fport->base.info.samples_per_frame = fport->base.info.clock_rate *
wavehdr.fmt_hdr.nchan *
ptime / 1000;
fport->base.info.bytes_per_frame =
fport->base.info.samples_per_frame *
fport->base.info.bits_per_sample / 8;
has_wave_info = PJ_TRUE;
} else {
/* Check that this file has the same characteristics as the other
* files.
*/
if (wavehdr.fmt_hdr.nchan != fport->base.info.channel_count ||
wavehdr.fmt_hdr.sample_rate != fport->base.info.clock_rate ||
wavehdr.fmt_hdr.bits_per_sample != fport->base.info.bits_per_sample)
{
/* This file has different characteristics than the other
* files.
*/
PJ_LOG(4,(THIS_FILE,
"WAV playlist error: file '%s' has differrent number"
" of channels, sample rate, or bits per sample",
filename));
status = PJMEDIA_EWAVEUNSUPP;
goto on_error;
}
}
/* Set initial position of the file. */
fport->fpos_list[index] = fport->start_data_list[index];
}
/* Fill up the buffer. */
status = file_fill_buffer(fport);
if (status != PJ_SUCCESS) {
goto on_error;
}
/* Done. */
*p_port = &fport->base;
PJ_LOG(4,(THIS_FILE,
"WAV playlist '%.*s' created: samp.rate=%d, ch=%d, bufsize=%uKB",
(int)port_label->slen,
port_label->ptr,
fport->base.info.clock_rate,
fport->base.info.channel_count,
fport->bufsize / 1000));
return PJ_SUCCESS;
on_error:
for (index=0; index<file_count; ++index) {
if (fport->fd_list[index] != 0)
pj_file_close(fport->fd_list[index]);
}
return status;
}
