apps/plugins/pdbox/PDa/intern/sfwrite~.c

   1 #ifdef ROCKBOX
   2 #include "plugin.h"
   3 #include "../../pdbox.h"
   4 #else /* ROCKBOX */
   5 #include <unistd.h>
   6 #include <fcntl.h>
   7 #include <errno.h>
   8 #include <stdio.h>
   9 #include <string.h>
  10 #include <unistd.h>
  11 #include <sys/mman.h>
  12 #include <sys/stat.h>
  13 #endif /* ROCKBOX */
  14
  15 #include "../src/m_pd.h"
  16 #include <../src/m_fixed.h>
  17 #include "../src/g_canvas.h"
  18
  19
  20 #define BLOCKTIME 10
  21
  22 #define MAX_CHANS 4
  23
  24 #include "sformat.h"
  25
  26 static t_class *sfwrite_class;
  27
  28 typedef struct _sfwrite
  29 {
  30      t_object x_obj;
  31      t_symbol* filename;
  32      int x_file;
  33
  34      t_int rec;
  35      t_int x_channels;
  36      uint32  size;
  37      t_glist * x_glist;
  38      t_int x_blocked;
  39      t_int x_blockwarn;
  40 } t_sfwrite;
  41
  42
  43 static void sfwrite_wave_setup(t_sfwrite* x,t_wave* w)
  44 {
  45
  46     strncpy(w->w_fileid,"RIFF",4);                  /* chunk id 'RIFF'     */
  47     w->w_chunksize = x->size + sizeof(t_wave) -8;           /* chunk size  */
  48     strncpy(w->w_waveid,"WAVE",4);                  /* wave chunk id 'WAVE'  */
  49     strncpy(w->w_fmtid,"fmt ",4);                   /* format chunk id 'fmt '*/
  50     w->w_fmtchunksize = 16;         /* format chunk size          */
  51     w->w_fmttag = 1;                /* format tag, 1 for PCM      */
  52     w->w_nchannels = x->x_channels;         /* number of channels         */
  53     w->w_samplespersec = 44100;             /* sample rate in hz          */
  54     w->w_navgbytespersec = 44100*x->x_channels*2;           /* average bytes per second   */
  55     w->w_nblockalign = 4;           /* number of bytes per sample */
  56     w->w_nbitspersample = 16;       /* number of bits in a sample */
  57     strncpy(w->w_datachunkid,"data",4);             /* data chunk id 'data'*/
  58     w->w_datachunksize = x->size;         /* length of data chunk       */
  59 }
  60
  61
  62
  63 static void sfwrite_close(t_sfwrite *x)
  64 {
  65      if (x->x_file > 0) {
  66           t_wave w;
  67           sfwrite_wave_setup(x,&w);
  68           lseek(x->x_file,0,SEEK_SET);
  69           write(x->x_file,&w,sizeof(w));
  70           close(x->x_file);
  71      }
  72      x->x_file = -1;
  73 }
  74
  75
  76 static void sfwrite_open(t_sfwrite *x,t_symbol *filename)
  77 {
  78      char fname[MAXPDSTRING];
  79
  80      if (filename == &s_) {
  81           post("sfwrite: open without filename");
  82           return;
  83      }
  84
  85      canvas_makefilename(glist_getcanvas(x->x_glist), filename->s_name,
  86                          fname, MAXPDSTRING);
  87
  88      x->x_blocked = 0;
  89      x->filename = filename;
  90      post("sfwrite: filename = %s",x->filename->s_name);
  91
  92      sfwrite_close(x);
  93
  94 #ifdef ROCKBOX
  95      if ((x->x_file = open(fname, O_RDWR | O_CREAT)) < 0)
  96 #else
  97      if ((x->x_file = open(fname,O_RDWR | O_CREAT,0664)) < 0)
  98 #endif
  99      {
 100           error("can't create %s",fname);
 101           return;
 102      }
 103
 104      /* skip the header */
 105
 106      lseek(x->x_file,sizeof(t_wave),SEEK_SET);
 107      x->size = 0;
 108
 109
 110 }
 111
 112 static void sfwrite_block(t_sfwrite *x, t_floatarg f)
 113 {
 114      x->x_blockwarn = f;
 115 }
 116
 117
 118 static void sfwrite_float(t_sfwrite *x, t_floatarg f)
 119 {
 120   int t = f;
 121   if (t) {
 122        post("sfwrite: start", f);
 123        x->rec=1;
 124   }
 125   else {
 126        post("sfwrite: stop", f);
 127        x->rec=0;
 128   }
 129
 130 }
 131
 132
 133 static short out[4*64];
 134
 135 static t_int *sfwrite_perform(t_int *w)
 136 {
 137      t_sfwrite* x = (t_sfwrite*)(w[1]);
 138      t_sample * in[4];
 139      int c = x->x_channels;
 140      int i,num,n;
 141      short* tout = out;
 142      int ret;
 143      int timebefore,timeafter;
 144      double late;
 145
 146      for (i=0;i < c;i++) {
 147           in[i] = (t_sample *)(w[2+i]);
 148      }
 149
 150      n = num = (int)(w[2+c]);
 151
 152      /* loop */
 153
 154      if (x->rec && x->x_file) {
 155
 156           while (n--) {
 157                for (i=0;i<c;i++)  {
 158                     *tout++ = (*(in[i])++)>>(fix1-16);
 159                }
 160           }
 161
 162           timebefore = sys_getrealtime();
 163           if ((ret =write(x->x_file,out,sizeof(short)*num*c)) < (signed int)sizeof(short)*num*c) {
 164                post("sfwrite: short write %d",ret);
 165
 166                }
 167           timeafter = sys_getrealtime();
 168           late = timeafter - timebefore;
 169
 170 #if 0
 171           /* OK, we let only 10 ms block here */
 172           if (late > BLOCKTIME && x->x_blockwarn) {
 173                post("sfwrite blocked %f ms",late*1000);
 174                x->x_blocked++;
 175                if (x->x_blocked > x->x_blockwarn) {
 176                     x->rec = 0;
 177                     post("maximum blockcount %d reached, recording stopped (set blockcount with \"block <num>\"",x->x_blockwarn);
 178                }
 179           }
 180 #endif
 181           x->size +=64*x->x_channels*sizeof(short) ;
 182      }
 183
 184      return (w+3+c);
 185 }
 186
 187
 188
 189 static void sfwrite_dsp(t_sfwrite *x, t_signal **sp)
 190 {
 191      switch (x->x_channels) {
 192      case 1:
 193           dsp_add(sfwrite_perform, 3, x, sp[0]->s_vec,
 194                    sp[0]->s_n);
 195           break;
 196      case 2:
 197           dsp_add(sfwrite_perform, 4, x, sp[0]->s_vec,
 198                   sp[1]->s_vec, sp[0]->s_n);
 199           break;
 200      case 4:
 201           dsp_add(sfwrite_perform, 6, x, sp[0]->s_vec,
 202                   sp[1]->s_vec,
 203                   sp[2]->s_vec,
 204                   sp[3]->s_vec,
 205                   sp[0]->s_n);
 206           break;
 207      }
 208 }
 209
 210 static void sfwrite_free(t_sfwrite* x)
 211 {
 212      sfwrite_close(x);
 213 }
 214
 215
 216 static void *sfwrite_new(t_floatarg chan)
 217 {
 218     t_sfwrite *x = (t_sfwrite *)pd_new(sfwrite_class);
 219     t_int c = chan;
 220
 221     if (c<1 || c > MAX_CHANS) c = 1;
 222
 223     x->x_glist = (t_glist*) canvas_getcurrent();
 224     x->x_channels = c--;
 225     x->x_file=0;
 226     x->rec = 0;
 227     x->size = 0;
 228     x->x_blocked = 0;
 229     x->x_blockwarn = 10;
 230     while (c--) {
 231          inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_signal, &s_signal);
 232     }
 233
 234
 235     return (x);
 236 }
 237
 238 void sfwrite_tilde_setup(void)
 239 {
 240      sfwrite_class = class_new(gensym("sfwrite~"), (t_newmethod)sfwrite_new, (t_method)sfwrite_free,
 241         sizeof(t_sfwrite), 0,A_DEFFLOAT,0);
 242      class_addmethod(sfwrite_class,nullfn,gensym("signal"), 0);
 243      class_addmethod(sfwrite_class, (t_method) sfwrite_dsp, gensym("dsp"), 0);
 244      class_addmethod(sfwrite_class, (t_method) sfwrite_open, gensym("open"), A_SYMBOL,A_NULL);
 245      class_addmethod(sfwrite_class, (t_method) sfwrite_close, gensym("close"), 0);
 246     class_addmethod(sfwrite_class, (t_method)sfwrite_block,gensym("block"),A_DEFFLOAT,0);
 247      class_addfloat(sfwrite_class, sfwrite_float);
 248 }
 249