| /* libSoX CVSD (Continuously Variable Slope Delta modulation) |
| * conversion routines |
| * |
| * The CVSD format is described in the MIL Std 188 113, which is |
| * available from http://bbs.itsi.disa.mil:5580/T3564 |
| * |
| * Copyright (C) 1996 |
| * Thomas Sailer (sailer@ife.ee.ethz.ch) (HB9JNX/AE4WA) |
| * Swiss Federal Institute of Technology, Electronics Lab |
| * |
| * This library is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU Lesser General Public License as published by |
| * the Free Software Foundation; either version 2.1 of the License, or (at |
| * your option) any later version. |
| * |
| * This library is distributed in the hope that 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 library; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
| * |
| * Change History: |
| * |
| * June 1, 1998 - Chris Bagwell (cbagwell@sprynet.com) |
| * Fixed compile warnings reported by Kjetil Torgrim Homme |
| * <kjetilho@ifi.uio.no> |
| * |
| * June 20, 2006 - Kimberly Rockwell (pyxis13317 (at) yahoo.com) |
| * Speed optimization: Unrolled float_conv() loop in seperate |
| * functions for encoding and decoding. 15% speed up decoding. |
| * |
| * Aug. 24, 2009 - P. Chaintreuil (sox-cvsd-peep (at) parallaxshift.com) |
| * Speed optimization: Replaced calls to memmove() with a |
| * mirrored circular buffer. This doubles the size of the |
| * dec.output_filter (48 -> 96 floats) and enc.input_filter |
| * (16 -> 32 floats), but keeps the memory from having to |
| * be copied so many times. 56% speed increase decoding; |
| * less than 5% encoding speed increase. |
| */ |
| |
| #include "third_party/sox/src/src/sox_i.h" |
| #include "third_party/sox/src/src/cvsd.h" |
| #include "third_party/sox/src/src/cvsdfilt.h" |
| |
| #include <string.h> |
| #include <time.h> |
| |
| /* ---------------------------------------------------------------------- */ |
| /* |
| * private data structures |
| */ |
| |
| typedef cvsd_priv_t priv_t; |
| |
| static int debug_count = 0; |
| |
| /* ---------------------------------------------------------------------- */ |
| |
| /* This float_conv() function is not used as more specialized/optimized |
| * versions exist below. However, those new versions are tied to |
| * very percise filters defined in cvsdfilt.h. If those are modified |
| * or different filters are found to be required, this function may |
| * be needed. Thus I leave it here for possible future use, but commented |
| * out to avoid compiler warnings about it not being used. |
| static float float_conv(float const *fp1, float const *fp2,int n) |
| { |
| float res = 0; |
| for(; n > 0; n--) |
| res += (*fp1++) * (*fp2++); |
| return res; |
| } |
| */ |
| |
| static float float_conv_enc(float const *fp1, float const *fp2) |
| { |
| /* This is a specialzed version of float_conv() for encoding |
| * which simply assumes a CVSD_ENC_FILTERLEN (16) length of |
| * the two arrays and unrolls that loop. |
| * |
| * fp1 should be the enc.input_filter array and must be |
| * CVSD_ENC_FILTERLEN (16) long. |
| * |
| * fp2 should be one of the enc_filter_xx_y() tables listed |
| * in cvsdfilt.h. At minimum, fp2 must be CVSD_ENC_FILTERLEN |
| * (16) entries long. |
| */ |
| float res = 0; |
| |
| /* unrolling loop */ |
| res += fp1[0] * fp2[0]; |
| res += fp1[1] * fp2[1]; |
| res += fp1[2] * fp2[2]; |
| res += fp1[3] * fp2[3]; |
| res += fp1[4] * fp2[4]; |
| res += fp1[5] * fp2[5]; |
| res += fp1[6] * fp2[6]; |
| res += fp1[7] * fp2[7]; |
| res += fp1[8] * fp2[8]; |
| res += fp1[9] * fp2[9]; |
| res += fp1[10] * fp2[10]; |
| res += fp1[11] * fp2[11]; |
| res += fp1[12] * fp2[12]; |
| res += fp1[13] * fp2[13]; |
| res += fp1[14] * fp2[14]; |
| res += fp1[15] * fp2[15]; |
| |
| return res; |
| } |
| |
| static float float_conv_dec(float const *fp1, float const *fp2) |
| { |
| /* This is a specialzed version of float_conv() for decoding |
| * which assumes a specific length and structure to the data |
| * in fp2. |
| * |
| * fp1 should be the dec.output_filter array and must be |
| * CVSD_DEC_FILTERLEN (48) long. |
| * |
| * fp2 should be one of the dec_filter_xx() tables listed |
| * in cvsdfilt.h. fp2 is assumed to be CVSD_DEC_FILTERLEN |
| * (48) entries long, is assumed to have 0.0 in the last |
| * entry, and is a symmetrical mirror around fp2[23] (ie, |
| * fp2[22] == fp2[24], fp2[0] == fp2[47], etc). |
| */ |
| float res = 0; |
| |
| /* unrolling loop, also taking advantage of the symmetry |
| * of the sampling rate array*/ |
| res += (fp1[0] + fp1[46]) * fp2[0]; |
| res += (fp1[1] + fp1[45]) * fp2[1]; |
| res += (fp1[2] + fp1[44]) * fp2[2]; |
| res += (fp1[3] + fp1[43]) * fp2[3]; |
| res += (fp1[4] + fp1[42]) * fp2[4]; |
| res += (fp1[5] + fp1[41]) * fp2[5]; |
| res += (fp1[6] + fp1[40]) * fp2[6]; |
| res += (fp1[7] + fp1[39]) * fp2[7]; |
| res += (fp1[8] + fp1[38]) * fp2[8]; |
| res += (fp1[9] + fp1[37]) * fp2[9]; |
| res += (fp1[10] + fp1[36]) * fp2[10]; |
| res += (fp1[11] + fp1[35]) * fp2[11]; |
| res += (fp1[12] + fp1[34]) * fp2[12]; |
| res += (fp1[13] + fp1[33]) * fp2[13]; |
| res += (fp1[14] + fp1[32]) * fp2[14]; |
| res += (fp1[15] + fp1[31]) * fp2[15]; |
| res += (fp1[16] + fp1[30]) * fp2[16]; |
| res += (fp1[17] + fp1[29]) * fp2[17]; |
| res += (fp1[18] + fp1[28]) * fp2[18]; |
| res += (fp1[19] + fp1[27]) * fp2[19]; |
| res += (fp1[20] + fp1[26]) * fp2[20]; |
| res += (fp1[21] + fp1[25]) * fp2[21]; |
| res += (fp1[22] + fp1[24]) * fp2[22]; |
| res += (fp1[23]) * fp2[23]; |
| |
| return res; |
| } |
| |
| /* ---------------------------------------------------------------------- */ |
| /* |
| * some remarks about the implementation of the CVSD decoder |
| * the principal integrator is integrated into the output filter |
| * to achieve this, the coefficients of the output filter are multiplied |
| * with (1/(1-1/z)) in the initialisation code. |
| * the output filter must have a sharp zero at f=0 (i.e. the sum of the |
| * filter parameters must be zero). This prevents an accumulation of |
| * DC voltage at the principal integration. |
| */ |
| /* ---------------------------------------------------------------------- */ |
| |
| static void cvsdstartcommon(sox_format_t * ft) |
| { |
| priv_t *p = (priv_t *) ft->priv; |
| |
| p->cvsd_rate = (ft->signal.rate <= 24000) ? 16000 : 32000; |
| ft->signal.rate = 8000; |
| ft->signal.channels = 1; |
| lsx_rawstart(ft, sox_true, sox_false, sox_true, SOX_ENCODING_CVSD, 1); |
| /* |
| * initialize the decoder |
| */ |
| p->com.overload = 0x5; |
| p->com.mla_int = 0; |
| /* |
| * timeconst = (1/e)^(200 / SR) = exp(-200/SR) |
| * SR is the sampling rate |
| */ |
| p->com.mla_tc0 = exp((-200.0)/((float)(p->cvsd_rate))); |
| /* |
| * phase_inc = 32000 / SR |
| */ |
| p->com.phase_inc = 32000 / p->cvsd_rate; |
| /* |
| * initialize bit shift register |
| */ |
| p->bit.shreg = p->bit.cnt = 0; |
| p->bit.mask = 1; |
| /* |
| * count the bytes written |
| */ |
| p->bytes_written = 0; |
| p->com.v_min = 1; |
| p->com.v_max = -1; |
| lsx_report("cvsd: bit rate %dbit/s, bits from %s", p->cvsd_rate, |
| ft->encoding.reverse_bits ? "msb to lsb" : "lsb to msb"); |
| } |
| |
| /* ---------------------------------------------------------------------- */ |
| |
| int lsx_cvsdstartread(sox_format_t * ft) |
| { |
| priv_t *p = (priv_t *) ft->priv; |
| float *fp1; |
| int i; |
| |
| cvsdstartcommon(ft); |
| |
| p->com.mla_tc1 = 0.1 * (1 - p->com.mla_tc0); |
| p->com.phase = 0; |
| /* |
| * initialize the output filter coeffs (i.e. multiply |
| * the coeffs with (1/(1-1/z)) to achieve integration |
| * this is now done in the filter parameter generation utility |
| */ |
| /* |
| * zero the filter |
| */ |
| for(fp1 = p->c.dec.output_filter, i = CVSD_DEC_FILTERLEN*2; i > 0; i--) |
| *fp1++ = 0; |
| /* initialize mirror circular buffer offset to anything sane. */ |
| p->c.dec.offset = CVSD_DEC_FILTERLEN - 1; |
| |
| return (SOX_SUCCESS); |
| } |
| |
| /* ---------------------------------------------------------------------- */ |
| |
| int lsx_cvsdstartwrite(sox_format_t * ft) |
| { |
| priv_t *p = (priv_t *) ft->priv; |
| float *fp1; |
| int i; |
| |
| cvsdstartcommon(ft); |
| |
| p->com.mla_tc1 = 0.1 * (1 - p->com.mla_tc0); |
| p->com.phase = 4; |
| /* |
| * zero the filter |
| */ |
| for(fp1 = p->c.enc.input_filter, i = CVSD_ENC_FILTERLEN*2; i > 0; i--) |
| *fp1++ = 0; |
| p->c.enc.recon_int = 0; |
| /* initialize mirror circular buffer offset to anything sane. */ |
| p->c.enc.offset = CVSD_ENC_FILTERLEN - 1; |
| |
| return(SOX_SUCCESS); |
| } |
| |
| /* ---------------------------------------------------------------------- */ |
| |
| int lsx_cvsdstopwrite(sox_format_t * ft) |
| { |
| priv_t *p = (priv_t *) ft->priv; |
| |
| if (p->bit.cnt) { |
| lsx_writeb(ft, p->bit.shreg); |
| p->bytes_written++; |
| } |
| lsx_debug("cvsd: min slope %f, max slope %f", |
| p->com.v_min, p->com.v_max); |
| |
| return (SOX_SUCCESS); |
| } |
| |
| /* ---------------------------------------------------------------------- */ |
| |
| int lsx_cvsdstopread(sox_format_t * ft) |
| { |
| priv_t *p = (priv_t *) ft->priv; |
| |
| lsx_debug("cvsd: min value %f, max value %f", |
| p->com.v_min, p->com.v_max); |
| |
| return(SOX_SUCCESS); |
| } |
| |
| /* ---------------------------------------------------------------------- */ |
| |
| size_t lsx_cvsdread(sox_format_t * ft, sox_sample_t *buf, size_t nsamp) |
| { |
| priv_t *p = (priv_t *) ft->priv; |
| size_t done = 0; |
| float oval; |
| |
| while (done < nsamp) { |
| if (!p->bit.cnt) { |
| if (lsx_read_b_buf(ft, &(p->bit.shreg), (size_t) 1) != 1) |
| return done; |
| p->bit.cnt = 8; |
| p->bit.mask = 1; |
| } |
| /* |
| * handle one bit |
| */ |
| p->bit.cnt--; |
| p->com.overload = ((p->com.overload << 1) | |
| (!!(p->bit.shreg & p->bit.mask))) & 7; |
| p->bit.mask <<= 1; |
| p->com.mla_int *= p->com.mla_tc0; |
| if ((p->com.overload == 0) || (p->com.overload == 7)) |
| p->com.mla_int += p->com.mla_tc1; |
| |
| /* shift output filter window in mirror cirular buffer. */ |
| if (p->c.dec.offset != 0) |
| --p->c.dec.offset; |
| else p->c.dec.offset = CVSD_DEC_FILTERLEN - 1; |
| /* write into both halves of the mirror circular buffer */ |
| if (p->com.overload & 1) |
| { |
| p->c.dec.output_filter[p->c.dec.offset] = p->com.mla_int; |
| p->c.dec.output_filter[p->c.dec.offset + CVSD_DEC_FILTERLEN] = p->com.mla_int; |
| } |
| else |
| { |
| p->c.dec.output_filter[p->c.dec.offset] = -p->com.mla_int; |
| p->c.dec.output_filter[p->c.dec.offset + CVSD_DEC_FILTERLEN] = -p->com.mla_int; |
| } |
| |
| /* |
| * check if the next output is due |
| */ |
| p->com.phase += p->com.phase_inc; |
| if (p->com.phase >= 4) { |
| oval = float_conv_dec( |
| p->c.dec.output_filter + p->c.dec.offset, |
| (p->cvsd_rate < 24000) ? |
| dec_filter_16 : dec_filter_32); |
| lsx_debug_more("input %d %f\n", debug_count, p->com.mla_int); |
| lsx_debug_more("recon %d %f\n", debug_count, oval); |
| debug_count++; |
| |
| if (oval > p->com.v_max) |
| p->com.v_max = oval; |
| if (oval < p->com.v_min) |
| p->com.v_min = oval; |
| *buf++ = (oval * ((float)SOX_SAMPLE_MAX)); |
| done++; |
| } |
| p->com.phase &= 3; |
| } |
| return done; |
| } |
| |
| /* ---------------------------------------------------------------------- */ |
| |
| size_t lsx_cvsdwrite(sox_format_t * ft, const sox_sample_t *buf, size_t nsamp) |
| { |
| priv_t *p = (priv_t *) ft->priv; |
| size_t done = 0; |
| float inval; |
| |
| for(;;) { |
| /* |
| * check if the next input is due |
| */ |
| if (p->com.phase >= 4) { |
| if (done >= nsamp) |
| return done; |
| |
| /* shift input filter window in mirror cirular buffer. */ |
| if (p->c.enc.offset != 0) |
| --p->c.enc.offset; |
| else p->c.enc.offset = CVSD_ENC_FILTERLEN - 1; |
| |
| /* write into both halves of the mirror circular buffer */ |
| p->c.enc.input_filter[p->c.enc.offset] = |
| p->c.enc.input_filter[p->c.enc.offset |
| + CVSD_ENC_FILTERLEN] = |
| (*buf++) / |
| ((float)SOX_SAMPLE_MAX); |
| done++; |
| } |
| p->com.phase &= 3; |
| /* insert input filter here! */ |
| inval = float_conv_enc( |
| p->c.enc.input_filter + p->c.enc.offset, |
| (p->cvsd_rate < 24000) ? |
| (enc_filter_16[(p->com.phase >= 2)]) : |
| (enc_filter_32[p->com.phase])); |
| /* |
| * encode one bit |
| */ |
| p->com.overload = (((p->com.overload << 1) | |
| (inval > p->c.enc.recon_int)) & 7); |
| p->com.mla_int *= p->com.mla_tc0; |
| if ((p->com.overload == 0) || (p->com.overload == 7)) |
| p->com.mla_int += p->com.mla_tc1; |
| if (p->com.mla_int > p->com.v_max) |
| p->com.v_max = p->com.mla_int; |
| if (p->com.mla_int < p->com.v_min) |
| p->com.v_min = p->com.mla_int; |
| if (p->com.overload & 1) { |
| p->c.enc.recon_int += p->com.mla_int; |
| p->bit.shreg |= p->bit.mask; |
| } else |
| p->c.enc.recon_int -= p->com.mla_int; |
| if ((++(p->bit.cnt)) >= 8) { |
| lsx_writeb(ft, p->bit.shreg); |
| p->bytes_written++; |
| p->bit.shreg = p->bit.cnt = 0; |
| p->bit.mask = 1; |
| } else |
| p->bit.mask <<= 1; |
| p->com.phase += p->com.phase_inc; |
| lsx_debug_more("input %d %f\n", debug_count, inval); |
| lsx_debug_more("recon %d %f\n", debug_count, p->c.enc.recon_int); |
| debug_count++; |
| } |
| } |
| |
| /* ---------------------------------------------------------------------- */ |
| /* |
| * DVMS file header |
| */ |
| |
| /* FIXME: eliminate these 4 functions */ |
| |
| static uint32_t get32_le(unsigned char **p) |
| { |
| uint32_t val = (((*p)[3]) << 24) | (((*p)[2]) << 16) | |
| (((*p)[1]) << 8) | (**p); |
| (*p) += 4; |
| return val; |
| } |
| |
| static uint16_t get16_le(unsigned char **p) |
| { |
| unsigned val = (((*p)[1]) << 8) | (**p); |
| (*p) += 2; |
| return val; |
| } |
| |
| static void put32_le(unsigned char **p, uint32_t val) |
| { |
| *(*p)++ = val & 0xff; |
| *(*p)++ = (val >> 8) & 0xff; |
| *(*p)++ = (val >> 16) & 0xff; |
| *(*p)++ = (val >> 24) & 0xff; |
| } |
| |
| static void put16_le(unsigned char **p, unsigned val) |
| { |
| *(*p)++ = val & 0xff; |
| *(*p)++ = (val >> 8) & 0xff; |
| } |
| |
| struct dvms_header { |
| char Filename[14]; |
| unsigned Id; |
| unsigned State; |
| time_t Unixtime; |
| unsigned Usender; |
| unsigned Ureceiver; |
| size_t Length; |
| unsigned Srate; |
| unsigned Days; |
| unsigned Custom1; |
| unsigned Custom2; |
| char Info[16]; |
| char extend[64]; |
| unsigned Crc; |
| }; |
| |
| #define DVMS_HEADER_LEN 120 |
| |
| /* ---------------------------------------------------------------------- */ |
| |
| static int dvms_read_header(sox_format_t * ft, struct dvms_header *hdr) |
| { |
| unsigned char hdrbuf[DVMS_HEADER_LEN]; |
| unsigned char *pch = hdrbuf; |
| int i; |
| unsigned sum; |
| |
| if (lsx_readbuf(ft, hdrbuf, sizeof(hdrbuf)) != sizeof(hdrbuf)) |
| { |
| return (SOX_EOF); |
| } |
| for(i = sizeof(hdrbuf), sum = 0; i > /*2*/3; i--) /* Deti bug */ |
| sum += *pch++; |
| pch = hdrbuf; |
| memcpy(hdr->Filename, pch, sizeof(hdr->Filename)); |
| pch += sizeof(hdr->Filename); |
| hdr->Id = get16_le(&pch); |
| hdr->State = get16_le(&pch); |
| hdr->Unixtime = get32_le(&pch); |
| hdr->Usender = get16_le(&pch); |
| hdr->Ureceiver = get16_le(&pch); |
| hdr->Length = get32_le(&pch); |
| hdr->Srate = get16_le(&pch); |
| hdr->Days = get16_le(&pch); |
| hdr->Custom1 = get16_le(&pch); |
| hdr->Custom2 = get16_le(&pch); |
| memcpy(hdr->Info, pch, sizeof(hdr->Info)); |
| pch += sizeof(hdr->Info); |
| memcpy(hdr->extend, pch, sizeof(hdr->extend)); |
| pch += sizeof(hdr->extend); |
| hdr->Crc = get16_le(&pch); |
| if (sum != hdr->Crc) |
| { |
| lsx_report("DVMS header checksum error, read %u, calculated %u", |
| hdr->Crc, sum); |
| return (SOX_EOF); |
| } |
| return (SOX_SUCCESS); |
| } |
| |
| /* ---------------------------------------------------------------------- */ |
| |
| /* |
| * note! file must be seekable |
| */ |
| static int dvms_write_header(sox_format_t * ft, struct dvms_header *hdr) |
| { |
| unsigned char hdrbuf[DVMS_HEADER_LEN]; |
| unsigned char *pch = hdrbuf; |
| unsigned char *pchs = hdrbuf; |
| int i; |
| unsigned sum; |
| |
| memcpy(pch, hdr->Filename, sizeof(hdr->Filename)); |
| pch += sizeof(hdr->Filename); |
| put16_le(&pch, hdr->Id); |
| put16_le(&pch, hdr->State); |
| put32_le(&pch, (unsigned)hdr->Unixtime); |
| put16_le(&pch, hdr->Usender); |
| put16_le(&pch, hdr->Ureceiver); |
| put32_le(&pch, (unsigned) hdr->Length); |
| put16_le(&pch, hdr->Srate); |
| put16_le(&pch, hdr->Days); |
| put16_le(&pch, hdr->Custom1); |
| put16_le(&pch, hdr->Custom2); |
| memcpy(pch, hdr->Info, sizeof(hdr->Info)); |
| pch += sizeof(hdr->Info); |
| memcpy(pch, hdr->extend, sizeof(hdr->extend)); |
| pch += sizeof(hdr->extend); |
| for(i = sizeof(hdrbuf), sum = 0; i > /*2*/3; i--) /* Deti bug */ |
| sum += *pchs++; |
| hdr->Crc = sum; |
| put16_le(&pch, hdr->Crc); |
| if (lsx_seeki(ft, (off_t)0, SEEK_SET) < 0) |
| { |
| lsx_report("seek failed\n: %s",strerror(errno)); |
| return (SOX_EOF); |
| } |
| if (lsx_writebuf(ft, hdrbuf, sizeof(hdrbuf)) != sizeof(hdrbuf)) |
| { |
| lsx_report("%s",strerror(errno)); |
| return (SOX_EOF); |
| } |
| return (SOX_SUCCESS); |
| } |
| |
| /* ---------------------------------------------------------------------- */ |
| |
| static void make_dvms_hdr(sox_format_t * ft, struct dvms_header *hdr) |
| { |
| priv_t *p = (priv_t *) ft->priv; |
| size_t len; |
| char * comment = lsx_cat_comments(ft->oob.comments); |
| |
| memset(hdr->Filename, 0, sizeof(hdr->Filename)); |
| len = strlen(ft->filename); |
| if (len >= sizeof(hdr->Filename)) |
| len = sizeof(hdr->Filename)-1; |
| memcpy(hdr->Filename, ft->filename, len); |
| hdr->Id = hdr->State = 0; |
| hdr->Unixtime = sox_globals.repeatable? 0 : time(NULL); |
| hdr->Usender = hdr->Ureceiver = 0; |
| hdr->Length = p->bytes_written; |
| hdr->Srate = p->cvsd_rate/100; |
| hdr->Days = hdr->Custom1 = hdr->Custom2 = 0; |
| memset(hdr->Info, 0, sizeof(hdr->Info)); |
| len = strlen(comment); |
| if (len >= sizeof(hdr->Info)) |
| len = sizeof(hdr->Info)-1; |
| memcpy(hdr->Info, comment, len); |
| memset(hdr->extend, 0, sizeof(hdr->extend)); |
| free(comment); |
| } |
| |
| /* ---------------------------------------------------------------------- */ |
| |
| int lsx_dvmsstartread(sox_format_t * ft) |
| { |
| struct dvms_header hdr; |
| int rc; |
| |
| rc = dvms_read_header(ft, &hdr); |
| if (rc){ |
| lsx_fail_errno(ft,SOX_EHDR,"unable to read DVMS header"); |
| return rc; |
| } |
| |
| lsx_debug("DVMS header of source file \"%s\":", ft->filename); |
| lsx_debug(" filename \"%.14s\"", hdr.Filename); |
| lsx_debug(" id 0x%x", hdr.Id); |
| lsx_debug(" state 0x%x", hdr.State); |
| lsx_debug(" time %s", ctime(&hdr.Unixtime)); /* ctime generates lf */ |
| lsx_debug(" usender %u", hdr.Usender); |
| lsx_debug(" ureceiver %u", hdr.Ureceiver); |
| lsx_debug(" length %" PRIuPTR, hdr.Length); |
| lsx_debug(" srate %u", hdr.Srate); |
| lsx_debug(" days %u", hdr.Days); |
| lsx_debug(" custom1 %u", hdr.Custom1); |
| lsx_debug(" custom2 %u", hdr.Custom2); |
| lsx_debug(" info \"%.16s\"", hdr.Info); |
| ft->signal.rate = (hdr.Srate < 240) ? 16000 : 32000; |
| lsx_debug("DVMS rate %dbit/s using %gbit/s deviation %g%%", |
| hdr.Srate*100, ft->signal.rate, |
| ((ft->signal.rate - hdr.Srate*100) * 100) / ft->signal.rate); |
| rc = lsx_cvsdstartread(ft); |
| if (rc) |
| return rc; |
| |
| return(SOX_SUCCESS); |
| } |
| |
| /* ---------------------------------------------------------------------- */ |
| |
| int lsx_dvmsstartwrite(sox_format_t * ft) |
| { |
| struct dvms_header hdr; |
| int rc; |
| |
| rc = lsx_cvsdstartwrite(ft); |
| if (rc) |
| return rc; |
| |
| make_dvms_hdr(ft, &hdr); |
| rc = dvms_write_header(ft, &hdr); |
| if (rc){ |
| lsx_fail_errno(ft,rc,"cannot write DVMS header"); |
| return rc; |
| } |
| |
| if (!ft->seekable) |
| lsx_warn("Length in output .DVMS header will wrong since can't seek to fix it"); |
| |
| return(SOX_SUCCESS); |
| } |
| |
| /* ---------------------------------------------------------------------- */ |
| |
| int lsx_dvmsstopwrite(sox_format_t * ft) |
| { |
| struct dvms_header hdr; |
| int rc; |
| |
| lsx_cvsdstopwrite(ft); |
| if (!ft->seekable) |
| { |
| lsx_warn("File not seekable"); |
| return (SOX_EOF); |
| } |
| if (lsx_seeki(ft, (off_t)0, 0) != 0) |
| { |
| lsx_fail_errno(ft,errno,"Can't rewind output file to rewrite DVMS header."); |
| return(SOX_EOF); |
| } |
| make_dvms_hdr(ft, &hdr); |
| rc = dvms_write_header(ft, &hdr); |
| if(rc){ |
| lsx_fail_errno(ft,rc,"cannot write DVMS header"); |
| return rc; |
| } |
| return rc; |
| } |
