|
|
@@ -0,0 +1,1484 @@
|
|
|
+
|
|
|
+/* pvfileio.c */
|
|
|
+/* pvocex format test routines*/
|
|
|
+/* Initial version RWD May 2000.
|
|
|
+ * All rights reserved: work in progress!
|
|
|
+ * Manifestly not a complete API yet!
|
|
|
+ * In particular, error returns are kept very simplistic at the moment.
|
|
|
+ * (and are not even very consistent yet...)
|
|
|
+ * In time, a full set of error values and messages will be developed.
|
|
|
+ *
|
|
|
+ * NB: the RIFF<WAVE> functions only look for, and accept, a PVOCEX format file.
|
|
|
+ * NB also: if windows.h is included anywhere (should be no need in this file,
|
|
|
+ * or in pvfileio.h),
|
|
|
+ * the WAVE_FORMAT~ symbols may need to be #ifndef-ed.
|
|
|
+ */
|
|
|
+
|
|
|
+/* very simple CUSTOM window chunk:
|
|
|
+ *
|
|
|
+ * <PVXW><size><data>
|
|
|
+ *
|
|
|
+ * where size as usual gives the size of the data in bytes.
|
|
|
+ * the size in samples much match dwWinlen (which may not be the same as N (fft length)
|
|
|
+ * the sample type must be the same as that of the pvoc data itself
|
|
|
+ * (only floatsams supported so far)
|
|
|
+ * values must be normalized to peak of 1.0
|
|
|
+ */
|
|
|
+//#ifdef WINDOWS
|
|
|
+//#include "stdafx.h"
|
|
|
+//#endif
|
|
|
+
|
|
|
+#include <stdio.h>
|
|
|
+#include <stdlib.h>
|
|
|
+#include <memory.h>
|
|
|
+#include <string.h>
|
|
|
+#include <fcntl.h>
|
|
|
+#include <sys/types.h>
|
|
|
+#include <sys/stat.h>
|
|
|
+#ifdef _WIN32
|
|
|
+#include <io.h>
|
|
|
+#endif
|
|
|
+#ifdef unix
|
|
|
+#include <unistd.h>
|
|
|
+#define O_BINARY (0)
|
|
|
+#define _S_IWRITE S_IWRITE
|
|
|
+#define _S_IREAD S_IREAD
|
|
|
+#endif
|
|
|
+
|
|
|
+#ifdef _DEBUG
|
|
|
+#include <assert.h>
|
|
|
+#endif
|
|
|
+#include "pvdefs.h"
|
|
|
+#include "pvfileio.h"
|
|
|
+
|
|
|
+/* NB probably no good on 64bit platforms */
|
|
|
+#define REVDWBYTES(t) ( (((t)&0xff) << 24) | (((t)&0xff00) << 8) | (((t)&0xff0000) >> 8) | (((t)>>24) & 0xff) )
|
|
|
+#define REVWBYTES(t) ( (((t)&0xff) << 8) | (((t)>>8) &0xff) )
|
|
|
+#define TAG(a,b,c,d) ( ((a)<<24) | ((b)<<16) | ((c)<<8) | (d) )
|
|
|
+#define WAVE_FORMAT_EXTENSIBLE (0xFFFE)
|
|
|
+#ifndef WAVE_FORMAT_PCM
|
|
|
+#define WAVE_FORMAT_PCM (0x0001)
|
|
|
+#endif
|
|
|
+#define WAVE_FORMAT_IEEE_FLOAT (0x0003)
|
|
|
+
|
|
|
+
|
|
|
+const GUID KSDATAFORMAT_SUBTYPE_PVOC = {
|
|
|
+ 0x8312b9c2,
|
|
|
+ 0x2e6e,
|
|
|
+ 0x11d4,
|
|
|
+ { 0xa8, 0x24, 0xde, 0x5b, 0x96, 0xc3, 0xab, 0x21 }
|
|
|
+};
|
|
|
+
|
|
|
+
|
|
|
+static char *pv_errstr = "";
|
|
|
+
|
|
|
+#define MAXFILES (16)
|
|
|
+/* or any desired larger number: will be dynamically allocated one day */
|
|
|
+typedef union {
|
|
|
+ int32_t lsamp;
|
|
|
+ float fsamp;
|
|
|
+ unsigned char bytes[4];
|
|
|
+} SND_SAMP;
|
|
|
+
|
|
|
+typedef struct pvoc_file {
|
|
|
+ WAVEFORMATEX fmtdata;
|
|
|
+ PVOCDATA pvdata;
|
|
|
+ /* RWD 2022 to help CDP pvocex extension, requires two-stage file creation/update */
|
|
|
+ int32_t propsoffset;
|
|
|
+ int32_t needsupdate; //for two-stage creation/update CDP-style
|
|
|
+ int32_t fmtchunkoffset;
|
|
|
+ int32_t datachunkoffset;
|
|
|
+ int32_t nFrames; /* no of frames in file */
|
|
|
+ int32_t FramePos; /* where we are in file */
|
|
|
+ int32_t curpos;
|
|
|
+ int32_t fd;
|
|
|
+ int32_t to_delete;
|
|
|
+ int32_t readonly;
|
|
|
+ int32_t do_byte_reverse;
|
|
|
+ char *name;
|
|
|
+ float *customWindow;
|
|
|
+
|
|
|
+} PVOCFILE;
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+static PVOCFILE *files[MAXFILES];
|
|
|
+
|
|
|
+static int32_t pvoc_writeheader(int32_t ofd);
|
|
|
+static int32_t pvoc_readheader(int32_t ifd,WAVEFORMATPVOCEX *pWfpx);
|
|
|
+
|
|
|
+int32_t pvoc_getdatasize_bytes(int32_t fd)
|
|
|
+{
|
|
|
+ int32_t datachunksize, framesize;
|
|
|
+
|
|
|
+ if(files[fd]==NULL)
|
|
|
+ return -1;
|
|
|
+ if(files[fd]->nFrames == 0)
|
|
|
+ return 0;
|
|
|
+ framesize = files[fd]->pvdata.nAnalysisBins * 2 * sizeof(float);
|
|
|
+ datachunksize = files[fd]->nFrames * framesize * files[fd]->fmtdata.nChannels;
|
|
|
+ return datachunksize;
|
|
|
+}
|
|
|
+
|
|
|
+static int32_t write_guid(int32_t fd,int32_t byterev,const GUID *pGuid)
|
|
|
+{
|
|
|
+ int32_t written;
|
|
|
+#ifdef _DEBUG
|
|
|
+ assert(fd >= 0);
|
|
|
+ assert(pGuid);
|
|
|
+#endif
|
|
|
+
|
|
|
+ if(byterev){
|
|
|
+ GUID guid;
|
|
|
+ guid.Data1 = REVDWBYTES(pGuid->Data1);
|
|
|
+ guid.Data2 = REVWBYTES(pGuid->Data2);
|
|
|
+ guid.Data3 = REVWBYTES(pGuid->Data3);
|
|
|
+ memcpy((char *) (guid.Data4),(char *) (pGuid->Data4),8);
|
|
|
+ written = write(fd,(char *) &guid,sizeof(GUID));
|
|
|
+ }
|
|
|
+ else
|
|
|
+ written = write(fd,(char *) pGuid,sizeof(GUID));
|
|
|
+
|
|
|
+ return written;
|
|
|
+
|
|
|
+}
|
|
|
+
|
|
|
+static int32_t compare_guids(const GUID *gleft, const GUID *gright)
|
|
|
+{
|
|
|
+ const char *left = (const char *) gleft, *right = (const char *) gright;
|
|
|
+ return !memcmp(left,right,sizeof(GUID));
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+static int32_t write_pvocdata(int32_t fd,int32_t byterev,const PVOCDATA *pData)
|
|
|
+{
|
|
|
+ int32_t written;
|
|
|
+ // int32_t dwval;
|
|
|
+#ifdef _DEBUG
|
|
|
+ assert(fd >= 0);
|
|
|
+ assert(pData);
|
|
|
+#endif
|
|
|
+
|
|
|
+ if(byterev){
|
|
|
+ int32_t revdwval;
|
|
|
+ PVOCDATA data;
|
|
|
+ SND_SAMP ssamp;
|
|
|
+ data.wWordFormat = REVWBYTES(pData->wWordFormat);
|
|
|
+ data.wAnalFormat = REVWBYTES(pData->wAnalFormat);
|
|
|
+ data.wSourceFormat = REVWBYTES(pData->wSourceFormat);
|
|
|
+ data.wWindowType = REVWBYTES(pData->wWindowType);
|
|
|
+ data.nAnalysisBins = REVDWBYTES(pData->nAnalysisBins);
|
|
|
+ data.dwWinlen = REVDWBYTES(pData->dwWinlen);
|
|
|
+ data.dwOverlap = REVDWBYTES(pData->dwOverlap);
|
|
|
+ data.dwFrameAlign = REVDWBYTES(pData->dwFrameAlign);
|
|
|
+
|
|
|
+ ssamp.fsamp = pData->fAnalysisRate;
|
|
|
+ //dwval = * (int32_t *) &(pData->fAnalysisRate);
|
|
|
+ ssamp.lsamp = REVDWBYTES(/*dwval*/ ssamp.lsamp);
|
|
|
+ //data.fAnalysisRate = * (float *) &dwval;
|
|
|
+ data.fAnalysisRate = ssamp.fsamp;
|
|
|
+
|
|
|
+ ssamp.fsamp = pData->fWindowParam;
|
|
|
+ //dwval = * ( int32_t *) &(pData->fWindowParam);
|
|
|
+ revdwval = REVDWBYTES(ssamp.lsamp);
|
|
|
+ //dwval = REVDWBYTES(dwval);
|
|
|
+ //data.fWindowParam = * (float *) &dwval;
|
|
|
+ data.fWindowParam = ssamp.fsamp;
|
|
|
+
|
|
|
+ written = write(fd,(char *) &data,sizeof(PVOCDATA));
|
|
|
+ }
|
|
|
+ else
|
|
|
+ written = write(fd,(char *) pData,sizeof(PVOCDATA));
|
|
|
+
|
|
|
+ return written;
|
|
|
+
|
|
|
+}
|
|
|
+
|
|
|
+static int32_t write_fmt(int fd, int byterev,const WAVEFORMATEX *pfmt)
|
|
|
+{
|
|
|
+ /*NB have to write out each element, as not guaranteed alignment othewise.
|
|
|
+ * Consider it documentation. */
|
|
|
+
|
|
|
+#ifdef _DEBUG
|
|
|
+ assert(fd >=0);
|
|
|
+ assert(pfmt);
|
|
|
+ assert(pfmt->cbSize == 62);
|
|
|
+#endif
|
|
|
+
|
|
|
+ if(byterev){
|
|
|
+ WAVEFORMATEX fmt;
|
|
|
+ fmt.wFormatTag = REVWBYTES(pfmt->wFormatTag);
|
|
|
+ fmt.nChannels = REVWBYTES(pfmt->nChannels);
|
|
|
+ fmt.nSamplesPerSec = REVDWBYTES(pfmt->nSamplesPerSec);
|
|
|
+ fmt.nAvgBytesPerSec = REVDWBYTES(pfmt->nAvgBytesPerSec);
|
|
|
+ fmt.nBlockAlign = REVWBYTES(pfmt->nBlockAlign);
|
|
|
+ fmt.wBitsPerSample = REVWBYTES(pfmt->wBitsPerSample);
|
|
|
+ fmt.cbSize = REVWBYTES(pfmt->cbSize);
|
|
|
+
|
|
|
+ if(write(fd,(char *) &(fmt.wFormatTag),sizeof(WORD)) != sizeof(WORD)
|
|
|
+ || write(fd,(char *) &(fmt.nChannels),sizeof(WORD)) != sizeof(WORD)
|
|
|
+ || write(fd,(char *) &(fmt.nSamplesPerSec),sizeof(DWORD)) != sizeof(DWORD)
|
|
|
+ || write(fd,(char *) &(fmt.nAvgBytesPerSec),sizeof(DWORD)) != sizeof(DWORD)
|
|
|
+ || write(fd,(char *) &(fmt.nBlockAlign),sizeof(WORD)) != sizeof(WORD)
|
|
|
+ || write(fd,(char *) &(fmt.wBitsPerSample),sizeof(WORD)) != sizeof(WORD)
|
|
|
+ || write(fd,(char *) &(fmt.cbSize),sizeof(WORD)) != sizeof(WORD))
|
|
|
+
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ }
|
|
|
+ else {
|
|
|
+ if(write(fd,(char *) &(pfmt->wFormatTag),sizeof(WORD)) != sizeof(WORD)
|
|
|
+ || write(fd,(char *) &(pfmt->nChannels),sizeof(WORD)) != sizeof(WORD)
|
|
|
+ || write(fd,(char *) &(pfmt->nSamplesPerSec),sizeof(DWORD)) != sizeof(DWORD)
|
|
|
+ || write(fd,(char *) &(pfmt->nAvgBytesPerSec),sizeof(DWORD)) != sizeof(DWORD)
|
|
|
+ || write(fd,(char *) &(pfmt->nBlockAlign),sizeof(WORD)) != sizeof(WORD)
|
|
|
+ || write(fd,(char *) &(pfmt->wBitsPerSample),sizeof(WORD)) != sizeof(WORD)
|
|
|
+ || write(fd,(char *) &(pfmt->cbSize),sizeof(WORD)) != sizeof(WORD))
|
|
|
+
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ return SIZEOF_WFMTEX;
|
|
|
+}
|
|
|
+
|
|
|
+static int32_t pvoc_writeWindow(int32_t fd,int32_t byterev,float *window,DWORD length)
|
|
|
+{
|
|
|
+ if(byterev){
|
|
|
+ /* don't corrupt source array! */
|
|
|
+ DWORD i;
|
|
|
+ int32_t lval, *lp = (int32_t *) window;
|
|
|
+
|
|
|
+ for(i=0;i < length; i++){
|
|
|
+ lval = *lp++;
|
|
|
+ lval = REVDWBYTES(lval);
|
|
|
+ if(write(fd,(char *)&lval,sizeof(int32_t)) != sizeof(int32_t))
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else{
|
|
|
+ if(write(fd,(char *) window,length * sizeof(float)) != (int32_t)(length*sizeof(float)))
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ return (int32_t)(length * sizeof(float));
|
|
|
+}
|
|
|
+
|
|
|
+static int32_t pvoc_readWindow(int fd, int byterev, float *window,DWORD length)
|
|
|
+{
|
|
|
+ if(byterev){
|
|
|
+ DWORD i;
|
|
|
+ int32_t got,oval,lval, *lp = (int32_t *) window;
|
|
|
+#ifdef SINGLE_FLOAT
|
|
|
+ for(i=0;i < length;i++){
|
|
|
+ if(read(fd,(char *)&lval,sizeof(int32_t)) != sizeof(int32_t))
|
|
|
+ return 0;
|
|
|
+ oval = REVDWBYTES(lval);
|
|
|
+ *lp++ = oval;
|
|
|
+ }
|
|
|
+#else
|
|
|
+ /* read whole block then swap...should be faster */
|
|
|
+ got = read(fd,(char *) window,length * sizeof(float));
|
|
|
+ if(got != (int)(length * sizeof(float)))
|
|
|
+ return 0;
|
|
|
+ /* then byterev */
|
|
|
+ for(i=0;i < length;i++){
|
|
|
+ lval = *lp;
|
|
|
+ oval = REVDWBYTES(lval);
|
|
|
+ *lp++ = oval;
|
|
|
+ }
|
|
|
+
|
|
|
+#endif
|
|
|
+ }
|
|
|
+ else{
|
|
|
+ if(read(fd,(char *) window,length * sizeof(float)) != (int)(length * sizeof(float)))
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ return length * sizeof(float);
|
|
|
+
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+const char *pvoc_errorstr()
|
|
|
+{
|
|
|
+ return (const char *) pv_errstr;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+/* thanks to the SNDAN programmers for this! */
|
|
|
+/* return 0 for big-endian machine, 1 for little-endian machine*/
|
|
|
+/* probably no good for 16bit swapping though */
|
|
|
+static int32_t byte_order()
|
|
|
+{
|
|
|
+ int32_t one = 1;
|
|
|
+ char* endptr = (char *) &one;
|
|
|
+ return (*endptr);
|
|
|
+}
|
|
|
+
|
|
|
+/***** loosely modelled on CDP sfsys ******
|
|
|
+ * This is a static array, but coul be made dynamic in an OOP sort of way.
|
|
|
+ * The idea is that all low-level operations and data
|
|
|
+ * are completely hidden from the user, so that internal format changes can be made
|
|
|
+ * with little or no disruption to the public functions.
|
|
|
+ * But avoiding the full monty of a C++ implementation.
|
|
|
+
|
|
|
+ *******************************************/
|
|
|
+
|
|
|
+int32_t init_pvsys(void)
|
|
|
+{
|
|
|
+ int32_t i;
|
|
|
+
|
|
|
+ if(files[0] != NULL) {
|
|
|
+ pv_errstr = "\npvsys: already initialized";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ for(i = 0;i < MAXFILES;i++)
|
|
|
+ files[i] = NULL;
|
|
|
+
|
|
|
+ return 1;
|
|
|
+}
|
|
|
+
|
|
|
+static void prepare_pvfmt(WAVEFORMATEX *pfmt,DWORD chans, DWORD srate,
|
|
|
+ pv_stype stype)
|
|
|
+{
|
|
|
+
|
|
|
+#ifdef _DEBUG
|
|
|
+ assert(pfmt);
|
|
|
+#endif
|
|
|
+
|
|
|
+
|
|
|
+ pfmt->wFormatTag = WAVE_FORMAT_EXTENSIBLE;
|
|
|
+ pfmt->nChannels = (WORD) chans;
|
|
|
+ pfmt->nSamplesPerSec = srate;
|
|
|
+ switch(stype){
|
|
|
+ case(STYPE_16):
|
|
|
+ pfmt->wBitsPerSample = (WORD)16;
|
|
|
+ pfmt->nBlockAlign = (WORD)(chans * 2 * sizeof(char));
|
|
|
+
|
|
|
+ break;
|
|
|
+ case(STYPE_24):
|
|
|
+ pfmt->wBitsPerSample = (WORD) 24;
|
|
|
+ pfmt->nBlockAlign = (WORD)(chans * 3 * sizeof(char));
|
|
|
+ break;
|
|
|
+ case(STYPE_32):
|
|
|
+ case(STYPE_IEEE_FLOAT):
|
|
|
+ pfmt->wBitsPerSample = (WORD) 32;
|
|
|
+ pfmt->nBlockAlign = (WORD)(chans * 4 * sizeof(char));
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+#ifdef _DEBUG
|
|
|
+ assert(0);
|
|
|
+#endif
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ pfmt->nAvgBytesPerSec = pfmt->nBlockAlign * srate;
|
|
|
+ /* if we have extended WindowParam fields, or something ,will need to adjust this */
|
|
|
+ pfmt->cbSize = 62;
|
|
|
+
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+/* lots of different ways of doing this! */
|
|
|
+/* we will need one in the form:
|
|
|
+ * in pvoc_fmtcreate(const char *fname,PVOCDATA *p_pvfmt, WAVEFORMATEX *p_wvfmt);
|
|
|
+ */
|
|
|
+
|
|
|
+/* a simple minimalist function to begin with!*/
|
|
|
+/*set D to 0, and/or dwWinlen to 0, to use internal default */
|
|
|
+/* fWindow points to userdef window, or is NULL */
|
|
|
+/* NB currently this does not enforce a soundfile extension; probably it should... */
|
|
|
+int32_t pvoc_createfile(const char *filename,
|
|
|
+ DWORD fftlen,DWORD overlap,DWORD chans,
|
|
|
+ DWORD format,int32_t srate,
|
|
|
+ pv_stype stype,pv_wtype wtype,
|
|
|
+ float wparam,float *fWindow,DWORD dwWinlen)
|
|
|
+{
|
|
|
+
|
|
|
+ int32_t i;
|
|
|
+ long N,D;
|
|
|
+ char *pname;
|
|
|
+ PVOCFILE *pfile = NULL;
|
|
|
+ float winparam = 0.0f;
|
|
|
+
|
|
|
+ N = fftlen; /* keep the CARL varnames for now */
|
|
|
+ D = overlap;
|
|
|
+
|
|
|
+ if(N == 0 || chans <=0 || filename==NULL || D > N) {
|
|
|
+ pv_errstr = "\npvsys: bad arguments";
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+ if(/*format < PVOC_AMP_FREQ ||*/ format > PVOC_COMPLEX) { /* RWD unsigned, so nothing < 0 possible */
|
|
|
+ pv_errstr = "\npvsys: bad format parameter";
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+
|
|
|
+ if(!(wtype >= PVOC_DEFAULT && wtype <= PVOC_CUSTOM)){
|
|
|
+ pv_errstr = "\npvsys: bad window type";
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* load it, but ca't write until we have a PVXW chunk definition...*/
|
|
|
+ if(wtype==PVOC_CUSTOM){
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ if(wtype==PVOC_DEFAULT)
|
|
|
+ wtype = PVOC_HAMMING;
|
|
|
+
|
|
|
+ if(wtype==PVOC_KAISER)
|
|
|
+ if(wparam != 0.0f)
|
|
|
+ winparam = wparam;
|
|
|
+ /*will need an internal default for window parameters...*/
|
|
|
+
|
|
|
+ for(i=0;i < MAXFILES;i++)
|
|
|
+ if(files[i]==NULL)
|
|
|
+ break;
|
|
|
+ if(i==MAXFILES) {
|
|
|
+ pv_errstr = "\npvsys: too many files open";
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+ pfile = (PVOCFILE *) malloc(sizeof(PVOCFILE));
|
|
|
+
|
|
|
+ if(pfile==NULL){
|
|
|
+ pv_errstr = "\npvsys: no memory";
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+ pname = (char *) malloc(strlen(filename)+1);
|
|
|
+ if(pname == NULL){
|
|
|
+ free(pfile);
|
|
|
+ pv_errstr = "\npvsys: no memory";
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+ pfile->customWindow = NULL;
|
|
|
+ /* setup rendering inforamtion */
|
|
|
+ prepare_pvfmt(&pfile->fmtdata,chans,srate,stype);
|
|
|
+
|
|
|
+ strcpy(pname,filename);
|
|
|
+
|
|
|
+ pfile->pvdata.wWordFormat = PVOC_IEEE_FLOAT;
|
|
|
+ pfile->pvdata.wAnalFormat = (WORD) format;
|
|
|
+ pfile->pvdata.wSourceFormat = (stype == STYPE_IEEE_FLOAT ? WAVE_FORMAT_IEEE_FLOAT : WAVE_FORMAT_PCM);
|
|
|
+ pfile->pvdata.wWindowType = wtype;
|
|
|
+ pfile->pvdata.nAnalysisBins = (N>>1) + 1;
|
|
|
+ if(dwWinlen==0)
|
|
|
+ pfile->pvdata.dwWinlen = N;
|
|
|
+ else
|
|
|
+ pfile->pvdata.dwWinlen = dwWinlen;
|
|
|
+ if(D==0)
|
|
|
+ pfile->pvdata.dwOverlap = N/8;
|
|
|
+ else
|
|
|
+ pfile->pvdata.dwOverlap = D;
|
|
|
+ pfile->pvdata.dwFrameAlign = pfile->pvdata.nAnalysisBins * 2 * sizeof(float);
|
|
|
+ pfile->pvdata.fAnalysisRate = (float)srate / (float) pfile->pvdata.dwOverlap;
|
|
|
+ pfile->pvdata.fWindowParam = winparam;
|
|
|
+ pfile->to_delete = 0;
|
|
|
+ pfile->readonly = 0;
|
|
|
+ pfile->needsupdate = 0; //could be overruled later, but only once!
|
|
|
+
|
|
|
+ if(fWindow!= NULL){
|
|
|
+ pfile->customWindow = malloc(dwWinlen * sizeof(float));
|
|
|
+ if(pfile->customWindow==NULL){
|
|
|
+ pv_errstr = "\npvsys: no memory for custom window";
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+ memcpy((char *)(pfile->customWindow),(char *)fWindow,dwWinlen * sizeof(float));
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ pfile->fd = open(filename,O_BINARY | O_CREAT | O_RDWR | O_TRUNC,_S_IWRITE | _S_IREAD);
|
|
|
+ if(pfile->fd < 0){
|
|
|
+ free(pname);
|
|
|
+ if(pfile->customWindow)
|
|
|
+ free(pfile->customWindow);
|
|
|
+ free(pfile);
|
|
|
+
|
|
|
+ pv_errstr = "\npvsys: unable to create file";
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+ pfile->propsoffset = 0;
|
|
|
+ pfile->datachunkoffset = 0;
|
|
|
+ pfile->nFrames = 0;
|
|
|
+ pfile->FramePos = 0;
|
|
|
+ pfile->curpos = 0;
|
|
|
+ pfile->name = pname;
|
|
|
+ pfile->do_byte_reverse = !byte_order();
|
|
|
+ files[i] = pfile;
|
|
|
+
|
|
|
+ if(!pvoc_writeheader(i)) {
|
|
|
+ close(pfile->fd);
|
|
|
+ remove(pfile->name);
|
|
|
+ free(pfile->name);
|
|
|
+ if(pfile->customWindow)
|
|
|
+ free(pfile->customWindow);
|
|
|
+ free(pfile);
|
|
|
+ files[i] = NULL;
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+
|
|
|
+ return i;
|
|
|
+}
|
|
|
+
|
|
|
+int32_t pvoc_getpvxprops(int32_t ifd, PVOCDATA *data)
|
|
|
+{
|
|
|
+ if(files[ifd]==NULL)
|
|
|
+ return 0;
|
|
|
+#ifdef _DEBUG
|
|
|
+ assert(data != NULL);
|
|
|
+#endif
|
|
|
+ memcpy((char*) data,(char*) &files[ifd]->pvdata,sizeof(PVOCDATA));
|
|
|
+ return 1;
|
|
|
+}
|
|
|
+/* tell pvsys to update pvocdata on close; return 0 for success */
|
|
|
+/* only other way to do this is to test initial params != 0 */
|
|
|
+/* I want to control this explicitly, for now */
|
|
|
+int32_t pvoc_set_needsupdate(int32_t ifd)
|
|
|
+{
|
|
|
+ if(files[ifd]==NULL)
|
|
|
+ return -1;
|
|
|
+ if(files[ifd]->readonly)
|
|
|
+ return -1;
|
|
|
+ files[ifd]->needsupdate = 1;
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+//returns 0 for success
|
|
|
+int32_t pvoc_canupdate(int32_t ifd)
|
|
|
+{
|
|
|
+ if(files[ifd]==NULL || files[ifd]->readonly)
|
|
|
+ return -1;
|
|
|
+ if(files[ifd]->needsupdate)
|
|
|
+ return 0;
|
|
|
+ else
|
|
|
+ return -1;
|
|
|
+}
|
|
|
+
|
|
|
+//ONLY when creating new file using 2-stages.called last thing before file close.
|
|
|
+#if 0
|
|
|
+int32_t pvoc_updateprops(int32_t fd, const PVOCDATA *data)
|
|
|
+{
|
|
|
+ DWORD pos;
|
|
|
+
|
|
|
+ if(files[fd]==NULL)
|
|
|
+ return -1;
|
|
|
+ if(files[fd]->readonly)
|
|
|
+ return -1;
|
|
|
+ if(files[fd]->needsupdate==0)
|
|
|
+ return -1;
|
|
|
+#ifdef _DEBUG
|
|
|
+ // the only field that MUST be set, needed for read/write frames
|
|
|
+ assert(files[fd]->pvdata.nAnalysisBins == data->nAnalysisBins);
|
|
|
+#endif
|
|
|
+ // need to seek to propsoffset, then we can call write_pvocdata
|
|
|
+ pos = lseek(files[fd]->fd,files[fd]->propsoffset,SEEK_SET);
|
|
|
+ if(pos != files[fd]->propsoffset){
|
|
|
+ pv_errstr = "\npvsys: error updating pvoc props";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ return 1;
|
|
|
+}
|
|
|
+#endif
|
|
|
+
|
|
|
+int32_t pvoc_openfile(const char *filename,PVOCDATA *data,WAVEFORMATEX *fmt)
|
|
|
+{
|
|
|
+ int32_t i;
|
|
|
+ WAVEFORMATPVOCEX wfpx;
|
|
|
+ char *pname;
|
|
|
+ PVOCFILE *pfile = NULL;
|
|
|
+// long size = sizeof(WAVEFORMATPVOCEX);
|
|
|
+
|
|
|
+ if(data==NULL || fmt==NULL){
|
|
|
+ pv_errstr = "\npvsys: Internal error: NULL data arrays";
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+
|
|
|
+ for(i=0;i < MAXFILES;i++)
|
|
|
+ if(files[i]==NULL)
|
|
|
+ break;
|
|
|
+ if(i==MAXFILES){
|
|
|
+ pv_errstr = "\npvsys: too many files open";
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+
|
|
|
+ pfile = (PVOCFILE *) malloc(sizeof(PVOCFILE));
|
|
|
+ if(pfile==NULL){
|
|
|
+ pv_errstr = "\npvsys: no memory for file data";
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+ pfile->customWindow = NULL;
|
|
|
+ pname = (char *) malloc(strlen(filename)+1);
|
|
|
+ if(pname == NULL){
|
|
|
+ free(pfile);
|
|
|
+ pv_errstr = "\npvsys: no memory";
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+ pfile->fd = open(filename,O_BINARY | O_RDONLY,_S_IREAD);
|
|
|
+ if(pfile->fd < 0){
|
|
|
+ free(pname);
|
|
|
+ free(pfile);
|
|
|
+ pv_errstr = "\npvsys: unable to create file";
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+ strcpy(pname,filename);
|
|
|
+ pfile->datachunkoffset = 0;
|
|
|
+ pfile->nFrames = 0;
|
|
|
+ pfile->curpos = 0;
|
|
|
+ pfile->FramePos = 0;
|
|
|
+ pfile->name = pname;
|
|
|
+ pfile->do_byte_reverse = !byte_order();
|
|
|
+ pfile->readonly = 1;
|
|
|
+ pfile->needsupdate = 0; // just to state it explicitly!
|
|
|
+ files[i] = pfile;
|
|
|
+
|
|
|
+ if(!pvoc_readheader(i,&wfpx)){
|
|
|
+ close(pfile->fd);
|
|
|
+ free(pfile->name);
|
|
|
+ if(pfile->customWindow)
|
|
|
+ free(pfile->customWindow);
|
|
|
+ free(pfile);
|
|
|
+ files[i] = NULL;
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+
|
|
|
+ memcpy((char *)data, (char *)&(wfpx.data),sizeof(PVOCDATA));
|
|
|
+ memcpy((char *)fmt,(char *)&(wfpx.wxFormat.Format),SIZEOF_WFMTEX);
|
|
|
+
|
|
|
+ files[i] = pfile;
|
|
|
+
|
|
|
+ return i;
|
|
|
+
|
|
|
+}
|
|
|
+
|
|
|
+static int32_t pvoc_readfmt(int32_t fd,int32_t byterev,WAVEFORMATPVOCEX *pWfpx)
|
|
|
+{
|
|
|
+ DWORD dword;
|
|
|
+ WORD word;
|
|
|
+
|
|
|
+#ifdef _DEBUG
|
|
|
+ assert(fd >= 0);
|
|
|
+ assert(pWfpx);
|
|
|
+#endif
|
|
|
+
|
|
|
+ if(read(fd,(char *) &(pWfpx->wxFormat.Format.wFormatTag),sizeof(WORD)) != sizeof(WORD)
|
|
|
+ || read(fd,(char *) &(pWfpx->wxFormat.Format.nChannels),sizeof(WORD)) != sizeof(WORD)
|
|
|
+ || read(fd,(char *) &(pWfpx->wxFormat.Format.nSamplesPerSec),sizeof(DWORD)) != sizeof(DWORD)
|
|
|
+ || read(fd,(char *) &(pWfpx->wxFormat.Format.nAvgBytesPerSec),sizeof(DWORD)) != sizeof(DWORD)
|
|
|
+ || read(fd,(char *) &(pWfpx->wxFormat.Format.nBlockAlign),sizeof(WORD)) != sizeof(WORD)
|
|
|
+ || read(fd,(char *) &(pWfpx->wxFormat.Format.wBitsPerSample),sizeof(WORD)) != sizeof(WORD)
|
|
|
+ || read(fd,(char *) &(pWfpx->wxFormat.Format.cbSize),sizeof(WORD)) != sizeof(WORD)){
|
|
|
+ pv_errstr = "\npvsys: error reading Source format data";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ if(byterev){
|
|
|
+ word = pWfpx->wxFormat.Format.wFormatTag;
|
|
|
+ pWfpx->wxFormat.Format.wFormatTag= REVWBYTES(word);
|
|
|
+ word = pWfpx->wxFormat.Format.nChannels;
|
|
|
+ pWfpx->wxFormat.Format.nChannels = REVWBYTES(word);
|
|
|
+ dword = pWfpx->wxFormat.Format.nSamplesPerSec;
|
|
|
+ pWfpx->wxFormat.Format.nSamplesPerSec = REVDWBYTES(dword);
|
|
|
+ dword = pWfpx->wxFormat.Format.nAvgBytesPerSec;
|
|
|
+ pWfpx->wxFormat.Format.nAvgBytesPerSec = REVDWBYTES(dword);
|
|
|
+ word = pWfpx->wxFormat.Format.nBlockAlign;
|
|
|
+ pWfpx->wxFormat.Format.nBlockAlign = REVWBYTES(word);
|
|
|
+ word = pWfpx->wxFormat.Format.wBitsPerSample;
|
|
|
+ pWfpx->wxFormat.Format.wBitsPerSample = REVWBYTES(word);
|
|
|
+ word = pWfpx->wxFormat.Format.cbSize;
|
|
|
+ pWfpx->wxFormat.Format.cbSize = REVWBYTES(word);
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /* the first clues this is pvx format...*/
|
|
|
+ if(pWfpx->wxFormat.Format.wFormatTag != WAVE_FORMAT_EXTENSIBLE){
|
|
|
+ pv_errstr = "\npvsys: not a WAVE_EX file";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ if(pWfpx->wxFormat.Format.cbSize != 62){
|
|
|
+ pv_errstr = "\npvsys: bad size for fmt chunk";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ if(read(fd,(char *) &(pWfpx->wxFormat.Samples.wValidBitsPerSample),sizeof(WORD)) != sizeof(WORD)
|
|
|
+ || read(fd,(char *) &(pWfpx->wxFormat.dwChannelMask),sizeof(DWORD)) != sizeof(DWORD)
|
|
|
+ || read(fd,(char *) &(pWfpx->wxFormat.SubFormat),sizeof(GUID)) != sizeof(GUID)){
|
|
|
+ pv_errstr = "\npvsys: error reading Extended format data";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ if(byterev){
|
|
|
+ word = pWfpx->wxFormat.Samples.wValidBitsPerSample;
|
|
|
+ pWfpx->wxFormat.Samples.wValidBitsPerSample = REVWBYTES(word);
|
|
|
+ dword = pWfpx->wxFormat.dwChannelMask;
|
|
|
+ pWfpx->wxFormat.dwChannelMask = REVDWBYTES(dword);
|
|
|
+
|
|
|
+ dword = pWfpx->wxFormat.SubFormat.Data1;
|
|
|
+ pWfpx->wxFormat.SubFormat.Data1 = REVDWBYTES(dword);
|
|
|
+ word = pWfpx->wxFormat.SubFormat.Data2;
|
|
|
+ pWfpx->wxFormat.SubFormat.Data2 = REVWBYTES(word);
|
|
|
+ word = pWfpx->wxFormat.SubFormat.Data3;
|
|
|
+ pWfpx->wxFormat.SubFormat.Data3 = REVWBYTES(word);
|
|
|
+ /* don't need to reverse the char array */
|
|
|
+ }
|
|
|
+
|
|
|
+ /* ... but this is the clincher */
|
|
|
+ if(!compare_guids(&(pWfpx->wxFormat.SubFormat),&KSDATAFORMAT_SUBTYPE_PVOC)){
|
|
|
+ pv_errstr = "\npvsys: not a PVOCEX file";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ if(read(fd,(char *) &(pWfpx->dwVersion),sizeof(DWORD)) != sizeof(DWORD)
|
|
|
+ || read(fd,(char *) &(pWfpx->dwDataSize),sizeof(DWORD)) != sizeof(DWORD)
|
|
|
+ || read(fd,(char *) &(pWfpx->data),sizeof(PVOCDATA)) != sizeof(PVOCDATA)){
|
|
|
+ pv_errstr = "\npvsys: error reading Extended pvoc format data";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ if(byterev){
|
|
|
+ SND_SAMP ssamp;
|
|
|
+ dword = pWfpx->dwVersion;
|
|
|
+ pWfpx->dwVersion = REVDWBYTES(dword);
|
|
|
+
|
|
|
+ /* check it now! */
|
|
|
+ if(pWfpx->dwVersion != PVX_VERSION){
|
|
|
+ pv_errstr = "\npvsys: unknown pvocex Version";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ dword = pWfpx->dwDataSize;
|
|
|
+ pWfpx->dwDataSize = REVDWBYTES(dword);
|
|
|
+
|
|
|
+ word = pWfpx->data.wWordFormat;
|
|
|
+ pWfpx->data.wWordFormat= REVWBYTES(word);
|
|
|
+ word = pWfpx->data.wAnalFormat;
|
|
|
+ pWfpx->data.wAnalFormat= REVWBYTES(word);
|
|
|
+ word = pWfpx->data.wSourceFormat;
|
|
|
+ pWfpx->data.wSourceFormat= REVWBYTES(word);
|
|
|
+ word = pWfpx->data.wWindowType;
|
|
|
+ pWfpx->data.wWindowType= REVWBYTES(word);
|
|
|
+
|
|
|
+ dword = pWfpx->data.nAnalysisBins;
|
|
|
+ pWfpx->data.nAnalysisBins = REVDWBYTES(dword);
|
|
|
+ dword = pWfpx->data.dwWinlen;
|
|
|
+ pWfpx->data.dwWinlen = REVDWBYTES(dword);
|
|
|
+ dword = pWfpx->data.dwOverlap;
|
|
|
+ pWfpx->data.dwOverlap = REVDWBYTES(dword);
|
|
|
+ dword = pWfpx->data.dwFrameAlign;
|
|
|
+ pWfpx->data.dwFrameAlign = REVDWBYTES(dword);
|
|
|
+
|
|
|
+ ssamp.fsamp = pWfpx->data.fAnalysisRate;
|
|
|
+ //dword = * (DWORD *)&(pWfpx->data.fAnalysisRate); /* RWD TODO: use union */
|
|
|
+ //dword = REVDWBYTES(dword);
|
|
|
+ ssamp.lsamp = REVDWBYTES(ssamp.lsamp);
|
|
|
+ //pWfpx->data.fAnalysisRate = *(float *)&dword;
|
|
|
+ pWfpx->data.fAnalysisRate = ssamp.fsamp;
|
|
|
+
|
|
|
+ ssamp.fsamp = pWfpx->data.fWindowParam;
|
|
|
+ //dword = * (DWORD *)&(pWfpx->data.fWindowParam);
|
|
|
+ //dword = REVDWBYTES(dword);
|
|
|
+ ssamp.lsamp = REVDWBYTES(ssamp.lsamp);
|
|
|
+ //pWfpx->data.fWindowParam = *(float *)&dword;
|
|
|
+ pWfpx->data.fWindowParam = ssamp.fsamp;
|
|
|
+
|
|
|
+ }
|
|
|
+ if(pWfpx->dwVersion != PVX_VERSION){
|
|
|
+ pv_errstr = "\npvsys: unknown pvocex Version";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ return 1;
|
|
|
+
|
|
|
+
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+static int32_t pvoc_readheader(int32_t ifd,WAVEFORMATPVOCEX *pWfpx)
|
|
|
+{
|
|
|
+ DWORD tag, size,riffsize;
|
|
|
+ int32_t fmtseen = 0, /* dataseen = 0,*/ windowseen = 0;
|
|
|
+// DWORD windowlength = 0;
|
|
|
+
|
|
|
+#ifdef _DEBUG
|
|
|
+ assert(pWfpx);
|
|
|
+ assert(files[ifd]);
|
|
|
+ assert(files[ifd]->fd >= 0);
|
|
|
+ size = sizeof(WAVEFORMATEXTENSIBLE);
|
|
|
+ size += 2 * sizeof(DWORD);
|
|
|
+ size += sizeof(PVOCDATA);
|
|
|
+#endif
|
|
|
+
|
|
|
+ if(read(files[ifd]->fd,(char *) &tag,sizeof(DWORD)) != sizeof(DWORD)
|
|
|
+ || read(files[ifd]->fd,(char *) &size,sizeof(DWORD)) != sizeof(DWORD)){
|
|
|
+ pv_errstr = "\npvsys: error reading header";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ if(files[ifd]->do_byte_reverse)
|
|
|
+ size = REVDWBYTES(size);
|
|
|
+ else
|
|
|
+ tag = REVDWBYTES(tag);
|
|
|
+
|
|
|
+ if(tag != TAG('R','I','F','F')){
|
|
|
+ pv_errstr = "\npvsys: not a RIFF file";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ if(size < 24 * sizeof(DWORD) + SIZEOF_FMTPVOCEX){
|
|
|
+ pv_errstr = "\npvsys: file too small";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ riffsize = size;
|
|
|
+ if(read(files[ifd]->fd,(char *) &tag,sizeof(DWORD)) != sizeof(DWORD)){
|
|
|
+ pv_errstr = "\npvsys: error reading header";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ if(!files[ifd]->do_byte_reverse)
|
|
|
+ tag = REVDWBYTES(tag);
|
|
|
+
|
|
|
+ if(tag != TAG('W','A','V','E')){
|
|
|
+ pv_errstr = "\npvsys: not a WAVE file";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ riffsize -= sizeof(DWORD);
|
|
|
+ /*loop for chunks */
|
|
|
+ while(riffsize > 0){
|
|
|
+ if(read(files[ifd]->fd,(char *) &tag,sizeof(DWORD)) != sizeof(DWORD)
|
|
|
+ || read(files[ifd]->fd,(char *) &size,sizeof(DWORD)) != sizeof(DWORD)){
|
|
|
+ pv_errstr = "\npvsys: error reading header";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ if(files[ifd]->do_byte_reverse)
|
|
|
+ size = REVDWBYTES(size);
|
|
|
+ else
|
|
|
+ tag = REVDWBYTES(tag);
|
|
|
+ riffsize -= 2 * sizeof(DWORD);
|
|
|
+ switch(tag){
|
|
|
+ case TAG('f','m','t',' '):
|
|
|
+ /* bail out if not a pvoc file: not trying to read all WAVE formats!*/
|
|
|
+ if(size < SIZEOF_FMTPVOCEX){
|
|
|
+ pv_errstr = "\npvsys: not a PVOC-EX file";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ if(!pvoc_readfmt(files[ifd]->fd,files[ifd]->do_byte_reverse,pWfpx)){
|
|
|
+ pv_errstr = "\npvsys: error reading format chunk";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ riffsize -= SIZEOF_FMTPVOCEX;
|
|
|
+ fmtseen = 1;
|
|
|
+ memcpy((char *)&(files[ifd]->fmtdata),(char *)&(pWfpx->wxFormat),SIZEOF_WFMTEX);
|
|
|
+ memcpy((char *)&(files[ifd]->pvdata),(char *)&(pWfpx->data),sizeof(PVOCDATA));
|
|
|
+ break;
|
|
|
+ case TAG('P','V','X','W'):
|
|
|
+ if(!fmtseen){
|
|
|
+ pv_errstr = "\npvsys: PVXW chunk found before fmt chunk.";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ if(files[ifd]->pvdata.wWindowType!=PVOC_CUSTOM){
|
|
|
+ /*whaddayado? can you warn the user and continue?*/
|
|
|
+ pv_errstr = "\npvsys: PVXW chunk found but custom window not specified";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ files[ifd]->customWindow = malloc(files[ifd]->pvdata.dwWinlen * sizeof(float));
|
|
|
+ if(files[ifd]->customWindow == NULL){
|
|
|
+ pv_errstr = "\npvsys: no memory for custom window data.";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ if(pvoc_readWindow(files[ifd]->fd,files[ifd]->do_byte_reverse,
|
|
|
+ files[ifd]->customWindow,files[ifd]->pvdata.dwWinlen)
|
|
|
+ != (int)(files[ifd]->pvdata.dwWinlen * sizeof(float))){
|
|
|
+ pv_errstr = "\npvsys: error reading window data.";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ windowseen = 1;
|
|
|
+ break;
|
|
|
+ case TAG('d','a','t','a'):
|
|
|
+ if(riffsize - size != 0){
|
|
|
+ pv_errstr = "\npvsys: bad RIFF file";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ if(!fmtseen){
|
|
|
+ pv_errstr = "\npvsys: bad format, data chunk before fmt chunk";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ if(files[ifd]->pvdata.wWindowType==PVOC_CUSTOM)
|
|
|
+ if(!windowseen){
|
|
|
+ pv_errstr = "\npvsys: custom window chunk PVXW not found";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ files[ifd]->datachunkoffset = lseek(files[ifd]->fd,0,SEEK_CUR);
|
|
|
+ files[ifd]->curpos = files[ifd]->datachunkoffset;
|
|
|
+ /* not m/c frames, for now */
|
|
|
+ files[ifd]->nFrames = size / files[ifd]->pvdata.dwFrameAlign;
|
|
|
+
|
|
|
+ return 1;
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ /* skip any onknown chunks */
|
|
|
+ riffsize -= 2 * sizeof(DWORD);
|
|
|
+ if(lseek(files[ifd]->fd,size,SEEK_CUR) < 0){
|
|
|
+ pv_errstr = "\npvsys: error skipping unknown WAVE chunk";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ riffsize -= size;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+ /* if here, something very wrong!*/
|
|
|
+ pv_errstr = "\npvsys: bad format in RIFF file";
|
|
|
+ return 0;
|
|
|
+
|
|
|
+}
|
|
|
+
|
|
|
+static int32_t pvoc_writeheader(int ofd)
|
|
|
+{
|
|
|
+ int32_t tag,size,version;
|
|
|
+ WORD validbits;
|
|
|
+
|
|
|
+ const GUID *pGuid = &KSDATAFORMAT_SUBTYPE_PVOC;
|
|
|
+
|
|
|
+#ifdef _DEBUG
|
|
|
+ assert(files[ofd] != NULL);
|
|
|
+ assert(files[ofd]->fd >=0);
|
|
|
+#endif
|
|
|
+
|
|
|
+
|
|
|
+ tag = TAG('R','I','F','F');
|
|
|
+ size = 0;
|
|
|
+ if(files[ofd]->do_byte_reverse)
|
|
|
+ size = REVDWBYTES(size);
|
|
|
+ if(!files[ofd]->do_byte_reverse)
|
|
|
+ tag = REVDWBYTES(tag);
|
|
|
+
|
|
|
+ if(write(files[ofd]->fd,&tag,sizeof(int32_t)) != sizeof(int32_t)
|
|
|
+ || write(files[ofd]->fd,&size,sizeof(int32_t)) != sizeof(int32_t)) {
|
|
|
+ pv_errstr = "\npvsys: error writing header";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ tag = TAG('W','A','V','E');
|
|
|
+ if(!files[ofd]->do_byte_reverse)
|
|
|
+ tag = REVDWBYTES(tag);
|
|
|
+ if(write(files[ofd]->fd,&tag,sizeof(int32_t)) != sizeof(int32_t)){
|
|
|
+ pv_errstr = "\npvsys: error writing header";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ tag = TAG('f','m','t',' ');
|
|
|
+ size = SIZEOF_WFMTEX + sizeof(WORD) +
|
|
|
+ sizeof(DWORD)
|
|
|
+ + sizeof(GUID)
|
|
|
+ + 2*sizeof(DWORD)
|
|
|
+ + sizeof(PVOCDATA);
|
|
|
+ if(files[ofd]->do_byte_reverse)
|
|
|
+ size = REVDWBYTES(size);
|
|
|
+ if(!files[ofd]->do_byte_reverse)
|
|
|
+ tag = REVDWBYTES(tag);
|
|
|
+ if(write(files[ofd]->fd,(char *)&tag,sizeof(int32_t)) != sizeof(int32_t)
|
|
|
+ || write(files[ofd]->fd,(char *)&size,sizeof(int32_t)) != sizeof(int32_t)) {
|
|
|
+ pv_errstr = "\npvsys: error writing header";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ /* we need to record where we are, as we may have to update fmt data before file close */
|
|
|
+ files[ofd]->fmtchunkoffset = lseek(files[ofd]->fd,0,SEEK_CUR);
|
|
|
+
|
|
|
+ if(write_fmt(files[ofd]->fd,files[ofd]->do_byte_reverse,&(files[ofd]->fmtdata)) != SIZEOF_WFMTEX){
|
|
|
+ pv_errstr = "\npvsys: error writing fmt chunk";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ validbits = files[ofd]->fmtdata.wBitsPerSample; /*nothing fancy here */
|
|
|
+ if(files[ofd]->do_byte_reverse)
|
|
|
+ validbits = REVWBYTES(validbits);
|
|
|
+
|
|
|
+ if(write(files[ofd]->fd,(char *) &validbits,sizeof(WORD)) != sizeof(WORD)){
|
|
|
+ pv_errstr = "\npvsys: error writing fmt chunk";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ /* we will take this from a WAVE_EX file, in due course */
|
|
|
+ size = 0; /*dwChannelMask*/
|
|
|
+ if(write(files[ofd]->fd,(char *)&size,sizeof(DWORD)) != sizeof(DWORD)){
|
|
|
+ pv_errstr = "\npvsys: error writing fmt chunk";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ if(write_guid(files[ofd]->fd,files[ofd]->do_byte_reverse,pGuid) != sizeof(GUID)){
|
|
|
+ pv_errstr = "\npvsys: error writing fmt chunk";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ version = 1;
|
|
|
+ size = sizeof(PVOCDATA);
|
|
|
+ if(files[ofd]->do_byte_reverse){
|
|
|
+ version = REVDWBYTES(version);
|
|
|
+ size = REVDWBYTES(size);
|
|
|
+ }
|
|
|
+
|
|
|
+ if(write(files[ofd]->fd,&version,sizeof(int32_t)) != sizeof(int32_t)
|
|
|
+ || write(files[ofd]->fd,&size,sizeof(int32_t)) != sizeof(int32_t)){
|
|
|
+ pv_errstr = "\npvsys: error writing fmt chunk";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+/* RWD new 2022 so we can update all pvocex props on closing new file */
|
|
|
+ files[ofd]->propsoffset = lseek(files[ofd]->fd,0,SEEK_CUR);
|
|
|
+
|
|
|
+ if(write_pvocdata(files[ofd]->fd,files[ofd]->do_byte_reverse,&(files[ofd]->pvdata)) != sizeof(PVOCDATA)){
|
|
|
+ pv_errstr = "\npvsys: error writing fmt chunk";
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ /* VERY experimental; may not even be a good idea...*/
|
|
|
+
|
|
|
+ if(files[ofd]->customWindow){
|
|
|
+ tag = TAG('P','V','X','W');
|
|
|
+ size = files[ofd]->pvdata.dwWinlen * sizeof(float);
|
|
|
+ if(files[ofd]->do_byte_reverse)
|
|
|
+ size = REVDWBYTES(size);
|
|
|
+ else
|
|
|
+ tag = REVDWBYTES(tag);
|
|
|
+ if(write(files[ofd]->fd,(char *)&tag,sizeof(int32_t)) != sizeof(int32_t)
|
|
|
+ || write(files[ofd]->fd,(char *)&size,sizeof(int32_t)) != sizeof(int32_t)) {
|
|
|
+ pv_errstr = "\npvsys: error writing header";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ if(pvoc_writeWindow(files[ofd]->fd,
|
|
|
+ files[ofd]->do_byte_reverse,
|
|
|
+ files[ofd]->customWindow,
|
|
|
+ files[ofd]->pvdata.dwWinlen)!= (int)(files[ofd]->pvdata.dwWinlen * sizeof(float))){
|
|
|
+ pv_errstr = "\npvsys: error writing window data.";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /* no other chunks to write yet! */
|
|
|
+ tag = TAG('d','a','t','a');
|
|
|
+ if(!files[ofd]->do_byte_reverse)
|
|
|
+ tag = REVDWBYTES(tag);
|
|
|
+ if(write(files[ofd]->fd,&tag,sizeof(int32_t)) != sizeof(int32_t)){
|
|
|
+ pv_errstr = "\npvsys: write error writing header";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* we need to update size later on...*/
|
|
|
+
|
|
|
+ size = 0;
|
|
|
+ if(write(files[ofd]->fd,&size,sizeof(int32_t)) != sizeof(int32_t)){
|
|
|
+ pv_errstr = "\npvsys: write error writing header";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ files[ofd]->datachunkoffset = lseek(files[ofd]->fd,0,SEEK_CUR);
|
|
|
+
|
|
|
+ files[ofd]->curpos = files[ofd]->datachunkoffset;
|
|
|
+ return 1;
|
|
|
+}
|
|
|
+
|
|
|
+/* called by pvoc_closefile() */
|
|
|
+/* which checks "readonly", if not set, file is newly created */
|
|
|
+static int32_t pvoc_updateheader(int ofd)
|
|
|
+{
|
|
|
+ int32_t riffsize,datasize;
|
|
|
+ DWORD pos;
|
|
|
+
|
|
|
+#ifdef _DEBUG
|
|
|
+ assert(files[ofd]);
|
|
|
+ assert(files[ofd]->fd >= 0);
|
|
|
+ //assert(files[ofd]->curpos == lseek(files[ofd]->fd,0,SEEK_CUR));
|
|
|
+ assert(!files[ofd]->readonly);
|
|
|
+#endif
|
|
|
+ datasize = files[ofd]->curpos - files[ofd]->datachunkoffset;
|
|
|
+ pos = lseek(files[ofd]->fd,files[ofd]->datachunkoffset-sizeof(DWORD),SEEK_SET);
|
|
|
+ if(pos != files[ofd]->datachunkoffset-sizeof(DWORD)){
|
|
|
+ pv_errstr = "\npvsys: seek error updating data chunk";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ if(files[ofd]->do_byte_reverse)
|
|
|
+ datasize = REVDWBYTES(datasize);
|
|
|
+ if(write(files[ofd]->fd,(char *) &datasize,sizeof(DWORD)) != sizeof(DWORD)){
|
|
|
+ pv_errstr = "\npvsys: write error updating data chunk";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ riffsize = files[ofd]->curpos - 2* sizeof(DWORD);
|
|
|
+ if(files[ofd]->do_byte_reverse)
|
|
|
+ riffsize = REVDWBYTES(riffsize);
|
|
|
+ pos = lseek(files[ofd]->fd,sizeof(DWORD),SEEK_SET);
|
|
|
+ if(pos != sizeof(DWORD)){
|
|
|
+ pv_errstr = "\npvsys: seek error updating riff chunk";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ if(write(files[ofd]->fd,(char *) &riffsize,sizeof(DWORD)) != sizeof(DWORD)){
|
|
|
+ pv_errstr = "\npvsys: write error updating riff chunk";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ // update PVOCDATA and WAVEFORMATEX fields if required
|
|
|
+ if(files[ofd]->needsupdate){
|
|
|
+#ifdef _DEBUG
|
|
|
+ fprintf(stderr,"updating in pvoc_update_header()\n");
|
|
|
+#endif
|
|
|
+ pos = lseek(files[ofd]->fd,files[ofd]->fmtchunkoffset,SEEK_SET);
|
|
|
+ if(pos != files[ofd]->fmtchunkoffset){
|
|
|
+ pv_errstr = "\npvsys: seek error updating fmt data";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ pos = write_fmt(files[ofd]->fd,files[ofd]->do_byte_reverse,&(files[ofd]->fmtdata));
|
|
|
+ if(pos != SIZEOF_WFMTEX){
|
|
|
+ pv_errstr = "\npvsys: write error updating fmt data";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ pos = lseek(files[ofd]->fd,files[ofd]->propsoffset,SEEK_SET);
|
|
|
+ if(pos != files[ofd]->propsoffset){
|
|
|
+ pv_errstr = "\npvsys: seek error updating pvx data";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ //int32_t write_pvocdata(int32_t fd,int32_t byterev,const PVOCDATA *pData)
|
|
|
+ pos = write_pvocdata(files[ofd]->fd,files[ofd]->do_byte_reverse,&(files[ofd]->pvdata));
|
|
|
+ if(pos != sizeof(PVOCDATA)){
|
|
|
+ pv_errstr = "\npvsys: write error updating pvx data";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ pos = lseek(files[ofd]->fd,0,SEEK_END);
|
|
|
+ if(pos < 0){
|
|
|
+ pv_errstr = "\npvsys: seek error seeking to end of file";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ return 1;
|
|
|
+}
|
|
|
+
|
|
|
+int32_t pvoc_update_closefile(int ofd, const PVOCDATA *data, const WAVEFORMATEXTENSIBLE *wfx)
|
|
|
+{
|
|
|
+ if(files[ofd]==NULL){
|
|
|
+ pv_errstr = "\npvsys: file does not exist";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ if(files[ofd]->fd < 0){
|
|
|
+ pv_errstr = "\npvsys: file not open";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ if(files[ofd]->readonly) {
|
|
|
+ pv_errstr = "\ncannot update readonly file"; // probably an input file
|
|
|
+ }
|
|
|
+ else {
|
|
|
+ memcpy((char*) &files[ofd]->fmtdata, (char*) &wfx->Format, sizeof(WAVEFORMATEX));
|
|
|
+ memcpy((char*) &files[ofd]->pvdata, (char*) data, sizeof(PVOCDATA));
|
|
|
+ }
|
|
|
+ return pvoc_closefile(ofd);
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+int32_t pvoc_closefile(int ofd)
|
|
|
+{
|
|
|
+ if(files[ofd]==NULL){
|
|
|
+ pv_errstr = "\npvsys: file does not exist";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ if(files[ofd]->fd < 0){
|
|
|
+ pv_errstr = "\npvsys: file not open";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ if(!files[ofd]->readonly) {
|
|
|
+ if(!pvoc_updateheader(ofd))
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ close(files[ofd]->fd);
|
|
|
+ if(files[ofd]->to_delete && !(files[ofd]->readonly))
|
|
|
+ remove(files[ofd]->name);
|
|
|
+
|
|
|
+ free(files[ofd]->name);
|
|
|
+ free(files[ofd]);
|
|
|
+ files[ofd] = 0;
|
|
|
+
|
|
|
+ return 1;
|
|
|
+}
|
|
|
+
|
|
|
+/* does not directly address m/c streams, or alternative numeric formats, yet
|
|
|
+ * so for m/c files, write each frame in turn, for each channel.
|
|
|
+ * The format requires multi-channel frames to be interleaved in the usual way:
|
|
|
+ * if nChannels= 4, the file will contain:
|
|
|
+ * frame[0][0],frame[0][1],frame[0][2],frame[0][3],frme[1][0],frame[1][1].....
|
|
|
+ *
|
|
|
+ * The idea is to offer e.g. a floats version and a longs version ONLY, but
|
|
|
+ * independently of the underlying representation, so that the user can write a floats
|
|
|
+ * block, even though the underlying format might be longs or doubles. Most importantly,
|
|
|
+ * the user does not have to deal with byte-reversal, which would otherwise always be the case
|
|
|
+ * it the user had direct access to the file.
|
|
|
+ *
|
|
|
+ * So these functions are the most likely to change over time!.
|
|
|
+ *
|
|
|
+ * return 0 for error, 1 for success. This could change....
|
|
|
+
|
|
|
+
|
|
|
+ */
|
|
|
+int32_t pvoc_putframes(int ofd,const float *frame,int32_t numframes)
|
|
|
+{
|
|
|
+ DWORD i;
|
|
|
+ DWORD towrite; /* count in 'words' */
|
|
|
+ int32_t temp,*lfp;
|
|
|
+
|
|
|
+
|
|
|
+ if(files[ofd]==NULL){
|
|
|
+ pv_errstr = "\npvsys: bad file descriptor";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ if(files[ofd]->fd < 0){
|
|
|
+ pv_errstr = "\npvsys: file not open";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ /* NB doubles not supported yet */
|
|
|
+
|
|
|
+ towrite = files[ofd]->pvdata.nAnalysisBins * 2 * numframes;
|
|
|
+
|
|
|
+ if(files[ofd]->do_byte_reverse){
|
|
|
+ /* do this without overwriting source data! */
|
|
|
+ lfp = (int32_t *) frame;
|
|
|
+ for(i=0;i < towrite; i++){
|
|
|
+ temp = *lfp++;
|
|
|
+ temp = REVDWBYTES(temp);
|
|
|
+ if(write(files[ofd]->fd,(char *) &temp,sizeof(int32_t)) != sizeof(int32_t)){
|
|
|
+ pv_errstr = "\npvsys: error writing data";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else {
|
|
|
+ if(write(files[ofd]->fd,(char *) frame,towrite * sizeof(float)) != (int32_t)(towrite * sizeof(float))){
|
|
|
+ pv_errstr = "\npvsys: error writing data";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ files[ofd]->FramePos += numframes;
|
|
|
+ files[ofd]->nFrames += numframes;
|
|
|
+ files[ofd]->curpos += towrite * sizeof(float);
|
|
|
+ return 1;
|
|
|
+}
|
|
|
+
|
|
|
+/* Simplistic read function
|
|
|
+ * best practice here is to read nChannels frames *
|
|
|
+ * return -1 for error, 0 for EOF, else numframes read
|
|
|
+ */
|
|
|
+int32_t pvoc_getframes(int32_t ifd,float *frames,DWORD nframes)
|
|
|
+{
|
|
|
+ int32_t i;
|
|
|
+ int32_t toread;
|
|
|
+ int32_t oval,temp,*lfp;
|
|
|
+ int32_t got;
|
|
|
+ int32_t rc = -1;
|
|
|
+ if(files[ifd]==NULL){
|
|
|
+ pv_errstr = "\npvsys: bad file descriptor";
|
|
|
+ return rc;
|
|
|
+ }
|
|
|
+ if(files[ifd]->fd < 0){
|
|
|
+ pv_errstr = "\npvsys: file not open";
|
|
|
+ return rc;
|
|
|
+ }
|
|
|
+
|
|
|
+ toread = files[ifd]->pvdata.nAnalysisBins * 2 * nframes;
|
|
|
+
|
|
|
+ if(files[ifd]->do_byte_reverse){
|
|
|
+ lfp = (int32_t *) frames;
|
|
|
+#ifdef SINGLE_FLOAT
|
|
|
+ for(i=0;i < toread;i++){
|
|
|
+ if((got=read(files[ifd]->fd,(char *) &temp,sizeof(int32_t))) <0){
|
|
|
+ pv_errstr = "\npvsys: error reading data";
|
|
|
+ return rc;
|
|
|
+ }
|
|
|
+ if(got < sizeof(int32_t)){
|
|
|
+ /* file size incorrect? */
|
|
|
+ return 0; /* assume EOF */
|
|
|
+ }
|
|
|
+ temp = REVDWBYTES(temp);
|
|
|
+ *lfp++ = temp;
|
|
|
+ }
|
|
|
+#else
|
|
|
+ /* much faster on G4!!! */
|
|
|
+ got = read(files[ifd]->fd,(char *)frames,toread * sizeof(float));
|
|
|
+ if(got < 0){
|
|
|
+ pv_errstr = "\npvsys: error reading data";
|
|
|
+ return rc;
|
|
|
+ }
|
|
|
+ for(i=0;i < got / sizeof(float);i++){
|
|
|
+ temp = *lfp;
|
|
|
+ oval = REVDWBYTES(temp);
|
|
|
+ *lfp++ = oval;
|
|
|
+ }
|
|
|
+ if(got < (int)(toread * sizeof(float))){
|
|
|
+ /* some (user?) error in file size: return integral number of frames read*/
|
|
|
+ toread = got / (files[ifd]->pvdata.nAnalysisBins * 2 * sizeof(float));
|
|
|
+ /* RWD 4:2002 need to revise this too */
|
|
|
+ nframes = toread;
|
|
|
+ }
|
|
|
+
|
|
|
+#endif
|
|
|
+ rc = nframes; /*RWD 4:2002 */
|
|
|
+ }
|
|
|
+ else{
|
|
|
+ if((got = read(files[ifd]->fd,(char *)frames,toread * sizeof(float))) < (int32_t)(toread * sizeof(float))){
|
|
|
+ if(got < 0){
|
|
|
+ pv_errstr = "\npvsys: error reading data";
|
|
|
+ return rc;
|
|
|
+ }
|
|
|
+ else if(got < (int)(toread * sizeof(float))){
|
|
|
+ /* some (user?) error in file size: return integral number of frames read*/
|
|
|
+ toread = got / (files[ifd]->pvdata.nAnalysisBins * 2 * sizeof(float));
|
|
|
+ rc = toread;
|
|
|
+ /* RWD 4:2002 need to revise this too */
|
|
|
+ nframes = toread;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else
|
|
|
+ rc = nframes;
|
|
|
+ }
|
|
|
+ /*files[ifd]->curpos += (toread * sizeof(float));*/
|
|
|
+ files[ifd]->curpos += got; /* RWD 4:2002 */
|
|
|
+ files[ifd]->FramePos += nframes;
|
|
|
+
|
|
|
+ return rc;
|
|
|
+}
|
|
|
+// return 0 for success, -1 for error
|
|
|
+int32_t pvoc_rewind(int32_t ifd,int32_t skip_first_frame)
|
|
|
+{
|
|
|
+ int32_t rc = -1;
|
|
|
+ int32_t fd;
|
|
|
+ int32_t pos;
|
|
|
+ int32_t skipsize = 0;
|
|
|
+ int32_t skipframes = 0;
|
|
|
+
|
|
|
+ if(files[ifd]==NULL){
|
|
|
+ pv_errstr = "\npvsys: bad file descriptor";
|
|
|
+ return rc;
|
|
|
+ }
|
|
|
+ if(files[ifd]->fd < 0){
|
|
|
+ pv_errstr = "\npvsys: file not open";
|
|
|
+ return rc;
|
|
|
+ }
|
|
|
+ skipframes = files[ifd]->fmtdata.nChannels;
|
|
|
+ //skipsize = files[ifd]->pvdata.dwFrameAlign * skipframes;
|
|
|
+
|
|
|
+
|
|
|
+ fd = files[ifd]->fd;
|
|
|
+ pos = files[ifd]->datachunkoffset;
|
|
|
+ if(skip_first_frame){
|
|
|
+ skipsize = files[ifd]->pvdata.dwFrameAlign * skipframes;
|
|
|
+ pos += skipsize;
|
|
|
+ }
|
|
|
+ if(lseek(fd,pos,SEEK_SET) != pos ) {
|
|
|
+ pv_errstr = "\npvsys: error rewinding file";
|
|
|
+ return rc;
|
|
|
+ }
|
|
|
+ files[ifd]->curpos = /* files[ifd]->datachunkoffset + skipsize */ pos;
|
|
|
+ files[ifd]->FramePos = skipframes;
|
|
|
+
|
|
|
+ return 0;
|
|
|
+
|
|
|
+}
|
|
|
+
|
|
|
+/* may be more to do in here later on */
|
|
|
+int32_t pvsys_release(void)
|
|
|
+{
|
|
|
+ int32_t i;
|
|
|
+
|
|
|
+ for(i=0;i < MAXFILES;i++){
|
|
|
+ if(files[i]) {
|
|
|
+#ifdef _DEBUG
|
|
|
+ fprintf(stderr,"\nDEBUG WARNING: file %d still open!\n",i);
|
|
|
+#endif
|
|
|
+ if(!pvoc_closefile(i)){
|
|
|
+ pv_errstr = "\npvsys: unable to close file on termination";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return 1;
|
|
|
+}
|
|
|
+
|
|
|
+/*return raw framecount: channel-agnostic for now */
|
|
|
+int32_t pvoc_framecount(int32_t ifd)
|
|
|
+{
|
|
|
+ if(files[ifd]==NULL)
|
|
|
+ return -1;
|
|
|
+
|
|
|
+ return files[ifd]->nFrames;
|
|
|
+}
|
|
|
+/* RWD Jan 2014 */
|
|
|
+// return -1 for error, else framepos
|
|
|
+int32_t pvoc_framepos(int32_t ifd)
|
|
|
+{
|
|
|
+ if(files[ifd]==NULL)
|
|
|
+ return -1;
|
|
|
+
|
|
|
+ return files[ifd]->FramePos;
|
|
|
+}
|
|
|
+// return -1 for error, 0 for success
|
|
|
+//NB framecount always disregards chans. But offset represents m/c block: offset*2 to get frames
|
|
|
+int32_t pvoc_seek_mcframe(int32_t ifd, int32_t offset, int32_t mode)
|
|
|
+{
|
|
|
+ // DWORD mcframealign;
|
|
|
+ DWORD rawoffset;
|
|
|
+ int32_t rc = -1;
|
|
|
+ int32_t mcframealign;
|
|
|
+
|
|
|
+ if(files[ifd]==NULL)
|
|
|
+ return -1;
|
|
|
+ mcframealign = files[ifd]->pvdata.dwFrameAlign * files[ifd]->fmtdata.nChannels;
|
|
|
+ rawoffset = offset * mcframealign;
|
|
|
+ switch(mode){
|
|
|
+ case SEEK_SET:
|
|
|
+ // offset is m/c quantity, e.g. 2 * frame for stereo
|
|
|
+ if(offset >= (files[ifd]->nFrames / files[ifd]->fmtdata.nChannels)){
|
|
|
+ pv_errstr = "\npvsys: seek target beyond end of file";
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ rawoffset += files[ifd]->datachunkoffset;
|
|
|
+ if(lseek(files[ifd]->fd,rawoffset,SEEK_SET) != rawoffset ) {
|
|
|
+ pv_errstr = "\npvsys: seek error, SEEK_SET";
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+ files[ifd]->curpos = rawoffset;
|
|
|
+ files[ifd]->FramePos = offset * files[ifd]->fmtdata.nChannels;
|
|
|
+ rc = 0;
|
|
|
+ break;
|
|
|
+ case SEEK_END:
|
|
|
+ // go to end of file + offset, offset <= 0
|
|
|
+ if(offset > 0){
|
|
|
+ pv_errstr = "\npvsys: seek target before start of file, offset must be <= 0";
|
|
|
+ break;
|
|
|
+ }
|
|
|
+#ifdef _DEBUG
|
|
|
+ fprintf(stderr,"pvoc_seek_mcframe: fd = %d\n",ifd);
|
|
|
+#endif
|
|
|
+ //NB not relative to datachunkoffset in this case
|
|
|
+ if(lseek(files[ifd]->fd,rawoffset,SEEK_END) < 0){
|
|
|
+ pv_errstr = "\npvsys: seek error, SEEK_END";
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+#ifdef _DEBUG
|
|
|
+ fprintf(stderr,"pvoc_seek_mcframe: files[%d]->nFrames = %d\n",ifd,files[ifd]->nFrames);
|
|
|
+#endif
|
|
|
+ files[ifd]->FramePos = files[ifd]->nFrames - (offset * files[ifd]->fmtdata.nChannels);
|
|
|
+ files[ifd]->curpos = files[ifd]->FramePos * files[ifd]->pvdata.dwFrameAlign;
|
|
|
+#ifdef _DEBUG
|
|
|
+ fprintf(stderr,"pvoc_seek_mcframe: got curpos = %d\n",files[ifd]->curpos);
|
|
|
+#endif
|
|
|
+ rc = 0; //success!
|
|
|
+ break;
|
|
|
+ case SEEK_CUR:
|
|
|
+ // covered by pvoc_framepos(), equiv to a pvoc_tell() function.
|
|
|
+ pv_errstr = "\npvsys: SEEK_CUR mode not supported yet!";
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ return rc;
|
|
|
+}
|
richarddobson