view release on metacpan or  search on metacpan

Data/Data.xs  view on Meta::CPAN

  }
 else
  {
   float *d = Audio_more(aTHX_ lau,1);
   *d = (float) SvNV(sv);
  }
}

Audio *
Audio_overload_init(pTHX_ Audio *lau, SV **argp,int dorev, SV *right, SV *rev)
{
 SV *left  = argp[0];
 if (SvOK(rev))
  {
   /* Not assignment form */
   char *type = AUDIO_CLASS(left);
   SV *tsv = Nullsv;
   Audio *tau = Audio_new(aTHX_ &tsv,lau->rate,lau->flags,0,type);
   if (dorev && SvTRUE(rev))
    {
     SV *tsv = left;
     left    = right;
     argp[1] = tsv;
    }
   Audio_append_sv(aTHX_ tau,left);
   argp[0] = tsv;
   return tau;
  }
 return lau;
}

MODULE = Audio::Data	PACKAGE = Audio::Data	PREFIX = Audio_

PROTOTYPES: DISABLE

SV *
Audio_shorts(au)
Audio *	au;

void
Audio_silence(au, time = 0.1)
Audio *	au;
float	time;

void
Audio_tone(au,freq,dur = 0.1, amp = 0.5)
Audio *	au;
float	freq;
float	dur
float	amp

void
Audio_noise(au,dur = 0.1, amp = 0.5)
Audio *	au;
float	dur
float	amp

void
DESTROY(au)
Audio *	au
PPCODE:
 {
  if (au->comment)
   SvREFCNT_dec(au->comment);
  if (au->data)
   SvREFCNT_dec(au->data);
 }

Audio *
create(class)
char *	class
PREINIT:
  Audio x;
CODE:
 {
  Zero(&x,1,Audio);
  x.comment = newSV(0);
  x.data    = newSVpv("",0);
  RETVAL    = &x;
 }
OUTPUT:
  RETVAL

void
Audio_clone(Audio *au)
CODE:
{
 SV *result = Nullsv;
 Audio *rau = Audio_new(aTHX_ &result,au->rate,au->flags,0,AUDIO_CLASS(ST(0)));
 Audio_append_sv(aTHX_ rau, ST(0));
 ST(0) = result;
 XSRETURN(1);
}

void
Audio_timerange(Audio *au, float t0, float t1)
CODE:
{
 SV *result = Nullsv;
 UV samples = Audio_samples(au);
 UV start = au->rate*t0;
 UV end   = au->rate*t1+0.5;
 Audio *rau = Audio_new(aTHX_ &result,au->rate,au->flags,end-start,AUDIO_CLASS(ST(0)));
 if (start < samples)
  {
   float *d   = AUDIO_DATA(rau);
   float *s   = AUDIO_DATA(au)+start;
   if (end > samples)
    end = samples;
   Copy(s,d,(end-start)*AUDIO_WORDS(au),float);
  }
 ST(0) = result;
 XSRETURN(1);
}

void
Audio_bounds(Audio *au, float t0 = 0.0, float t1 = Audio_duration(au))
CODE:
{
 UV samples = Audio_samples(au);
 UV start = au->rate*t0;

Data/Data.xs  view on Meta::CPAN

  Zero(&tmp,1,Audio);
  tmp.data = newSVpvn("",0);
  tmp.rate = au->rate;
  d = Audio_more(aTHX_ &tmp,n);
  Audio_difference(n,x,d);
  sv_setref_pvn((ST(0) = sv_2mortal(newSV(0))),"Audio::Data",(char *)&tmp,sizeof(tmp));
  XSRETURN(1);
 }

void
Audio_lpc(Audio *au,int order,SV *ac = 0, SV *rf = 0)
CODE:
{
 char *type = AUDIO_CLASS(ST(0));
 SV *result = Nullsv;
 Audio *lpc = Audio_new(aTHX_ &result,au->rate, 0, order+1,type);
 float *acf = AUDIO_DATA(Audio_new(aTHX_ &ac, au->rate, 0, order+1,type));
 float *ref = AUDIO_DATA(Audio_new(aTHX_ &rf, au->rate, 0, order+1,type));
 int length = Audio_samples(au);
 float *sig = AUDIO_DATA(au);
 if (AUDIO_COMPLEX(au))
  croak("Cannot process complex data");
 order = Audio_lpc(length,sig,order,acf,ref,AUDIO_DATA(lpc));
 ST(0) = result;
 XSRETURN(1);
}


void
Audio_durbin(au)
Audio * au
CODE:
 {
  int n = Audio_samples(au);
  SV *result = Nullsv;
  Audio *tmp = Audio_new(aTHX_ &result,au->rate,au->flags,n,AUDIO_CLASS(ST(0)));
  float *x = AUDIO_DATA(au);
  float *d = AUDIO_DATA(tmp);
  if (AUDIO_COMPLEX(au))
   croak("Cannot process complex data");
  Audio_durbin(n-1,x,d);
  ST(0) = result;
  XSRETURN(1);
 }

void
Audio_conjugate(au,right,rev)
Audio *		au
SV *		right
SV *		rev
CODE:
 {
  ST(2) = &PL_sv_no;
  au = Audio_overload_init(aTHX_ au, &ST(0),0,right,rev);
  Audio_conjugate(Audio_samples(au),Audio_complex(au),1.0);
 }

void
Audio_data(au,...)
Audio *		au
PPCODE:
 {
  int gimme = GIMME_V;
  if (items > 1)
   {
    int i;
    au->flags &= ~AUDIO_F_COMPLEX;
    SvCUR(au->data) = 0;
    for (i=1; i < items; i++)
     {
      Audio_append_sv(aTHX_ au,ST(i));
     }
   }
  if (gimme == G_VOID)
   {
    XSRETURN(0);
   }
  else if (gimme == G_ARRAY)
   {
    STRLEN sz;
    int count = 0;
    float *p = (float *) SvPV(au->data,sz);
    while (sz >= sizeof(float))
     {
      double d = *p++;
      XPUSHs(sv_2mortal(newSVnv(d)));
      sz -= sizeof(float);
      count++;
     }
    XSRETURN(count);
   }
  else
   {
    XPUSHs(SvREFCNT_inc(au->data));
    XSRETURN(1);
   }
 }

void
Audio_dB(au,start = 0, count = (GIMME == G_ARRAY) ? Audio_samples(au)-start : 1)
Audio *		au
int		start
int		count
PPCODE:
 {
  int n = Audio_samples(au);
  float *p = AUDIO_DATA(au)+start*AUDIO_WORDS(au);
  /* Min noticable value in 16bit is 1/(2**15) - call that 100dB */
  float min = 1.0/(1 << 15);
  float dB0 = 10*log10(min);
  if (start+count > n)
   count = n - start;
  if (AUDIO_COMPLEX(au))
   {
    for (n=0; n < count; n++)
     {
      float r = *p++;
      float i = *p++;
      r = sqrt(r*r+i*i);
      /* hack to avoid log10(0) yielding NaN or fault */
      if (r < min)
       r = min;
      XPUSHs(sv_2mortal(newSVnv(10*log10(r)-dB0)));
     }
   }
  else
   {
    for (n=0; n < count; n++)
     {
      float r = *p++;
      if (r < 0)
       r = -r;
      /* hack to avoid log10(0) yielding NaN or fault */
      if (r < min)
       r = min;
      XPUSHs(sv_2mortal(newSVnv(10*log10(r)-dB0)));
     }
   }
  XSRETURN(count);
 }

void
Audio_amplitude(au,start = 0, count = (GIMME == G_ARRAY) ? Audio_samples(au)-start : 1)
Audio *		au
int		start
int		count
PPCODE:
 {
  int n = Audio_samples(au);
  float *p = AUDIO_DATA(au)+start*AUDIO_WORDS(au);
  if (start+count > n)
   count = n - start;
  if (AUDIO_COMPLEX(au))
   {
    for (n=0; n < count; n++)
     {
      float r = *p++;
      float i = *p++;
      XPUSHs(sv_2mortal(newSVnv(sqrt(r*r+i*i))));
     }
   }
  else
   {
    for (n=0; n < count; n++)
     {
      float r = *p++;
      XPUSHs(sv_2mortal(newSVnv(r)));
     }
   }
  XSRETURN(count);
 }

void
Audio_phase(au,start = 0, count = (GIMME == G_ARRAY) ? Audio_samples(au)-start : 1)
Audio *		au
int		start
int		count
PPCODE:
 {
  int n = Audio_samples(au);
  float *p = AUDIO_DATA(au)+start*AUDIO_WORDS(au);
  if (start+count > n)
   count = n - start;
  if (AUDIO_COMPLEX(au))
   {
    for (n=0; n < count; n++)
     {
      float r = *p++;
      float i = *p++;
      XPUSHs(sv_2mortal(newSVnv(atan2(i,r))));
     }
   }
  else
   {
    for (n=0; n < count; n++)
     {
      XPUSHs(sv_2mortal(newSVnv(0)));
     }
   }
  XSRETURN(count);
 }


void
Audio_Load(au,fh)
Audio *		au
InputStream	fh

void
Audio_Save(au,fh,comment = NULL)
Audio *		au
OutputStream	fh
char *		comment

MODULE = Audio::Data	PACKAGE = Audio::Filter::AllPole	PREFIX = AllPole_

void
AllPole_process(au,...)
Audio *		au
PPCODE:
 {
  XSRETURN(Audio_filter_process(aTHX_ au,&Audio_AllPole,items,&ST(0)));
 }

MODULE = Audio::Data	PACKAGE = Audio::Filter::FIR	PREFIX = FIR_

void
FIR_process(au,...)
Audio *		au
PPCODE:
 {
  XSRETURN(Audio_filter_process(aTHX_ au,&Audio_FIR,items,&ST(0)));
 }


MODULE = Audio::Data	PACKAGE = Audio::Data	PREFIX = AUDIO_

void
AUDIO_r2_fft(au)
Audio *		au

void
AUDIO_r2_ifft(au)
Audio *		au

void
AUDIO_r4_fft(au)
Audio *		au

void
AUDIO_r4_ifft(au)
Audio *		au

void
AUDIO_complex_debug(au,f = PerlIO_stdout())
Audio *		au
OutputStream	f

BOOT:
 {
  sv_setiv(perl_get_sv("Audio::Data::AudioVtab",1),(IV) AudioVGet());
 }