purezen 0.0.2

Runtime for the Pure Data (Pd) audio programming language, implemented as an extensible audio library allowing full control over signal processing, message passing, and graph manipulation. Pure Data is a graph-based programming language environment creating interactive music and multimedia works.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

/*
 *  Copyright 2009,2010 Reality Jockey, Ltd.
 *                 info@rjdj.me
 *                 http://rjdj.me/
 *
 *  This file is part of ZenGarden.
 *
 *  ZenGarden 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 3 of the License, or
 *  (at your option) any later version.
 *
 *  ZenGarden 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 ZenGarden.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#include "MessageSoundfiler.h"
#include "MessageTable.h"
#include "PdGraph.h"

#include <sndfile.h>

message::Object *MessageSoundfiler::new_object(pd::Message *init_message, PdGraph *graph) {
  return new MessageSoundfiler(init_message, graph);
}

MessageSoundfiler::MessageSoundfiler(pd::Message *init_message, PdGraph *graph) : message::Object(1, 1, graph) {
  // TODO(mhroth)
}

MessageSoundfiler::~MessageSoundfiler() {
  // nothing to do
}

void MessageSoundfiler::process_message(int inlet_index, pd::Message *message)
{
  if (message->is_symbol_str(0, "read"))
  {
    int currentElementIndex;
    bool shouldResizeTable = false;
    char *tabName;
    char *soundfilePath;
    MessageTable *table;

    for (currentElementIndex = 1;
         currentElementIndex < message->get_num_elements();
         ++currentElementIndex)
    {
      if (message->is_symbol_str(currentElementIndex, "-resize"))
        shouldResizeTable = true;
      /* else if other flags... */
      else
        break;
    }
    if (message->get_num_elements() - currentElementIndex - 2 < 0)
    {
      graph->print_err("[soundfiler]: parameters are incorrect");
      return;
    }
    soundfilePath = message->get_symbol(currentElementIndex++);
    tabName = message->get_symbol(currentElementIndex++);
    if ((table = graph->get_table(tabName)) == NULL)
    {
      graph->print_err("[soundfiler]: table '%s' cannot be found", tabName);
      return;
    }
    SF_INFO sfInfo;
    char *fullPath = graph->resolveFullPath(soundfilePath);
    if (fullPath == NULL)
    {
      graph->print_err("[soundfiler]: file '%s' cannot be found.", soundfilePath);
      return;
    }

    SNDFILE *sndFile = sf_open(fullPath, SFM_READ, &sfInfo);
    if (sndFile == NULL)
    {
      graph->print_err("[soundfiler]: file %s cannot be opened.", fullPath);
      free(fullPath);
      return; // there was an error reading the file. Move on with life.
    }
    delete fullPath;

    // It is assumed that the channels are interleaved.
    int samplesPerChannel = static_cast<int>(sfInfo.frames);
    int bufferLength = samplesPerChannel * sfInfo.channels;
    // create a buffer in memory for the file data
    float *buffer = (float *) malloc(bufferLength * sizeof(float));
    sf_read_float(sndFile, buffer, bufferLength); // read the whole file into memory
    sf_close(sndFile); // release the handle to the file

    if (sfInfo.channels > 0) // sanity check
    {
      // get the table's buffer. Resize the buffer if necessary.
      int tableLength = samplesPerChannel;
      float *tableBuffer = shouldResizeTable ? table->resizeBuffer(samplesPerChannel) :
      table->getBuffer(&tableLength);
      if (tableLength > samplesPerChannel)
      {
        // avoid trying to read more into the table buffer than is available
        tableLength = samplesPerChannel;
      }

      // extract the first channel
      for (int i = 0, j = 0; i < bufferLength; i+=sfInfo.channels, j++)
      {
        tableBuffer[j] = buffer[i];
      }

      // extract the second channel (if it exists and if there is a table to write it to)
      if (sfInfo.channels > 1 &&
          (tabName = message->get_symbol(currentElementIndex++)) != NULL &&
          (table = graph->get_table(tabName)) != NULL)
      {
        tableLength = samplesPerChannel;
        tableBuffer = shouldResizeTable ? table->resizeBuffer(samplesPerChannel) :
        table->getBuffer(&tableLength);
        if (tableLength > samplesPerChannel)
        {
          // avoid trying to read more into the table buffer than is available
          tableLength = samplesPerChannel;
        }
        for (int i = 1, j = 0; i < bufferLength; i+=sfInfo.channels, j++)
          tableBuffer[j] = buffer[i];
      }
    }
    delete buffer;

    // send message with sample length when all tables have been filled
    pd::Message *outgoing_message = PD_MESSAGE_ON_STACK(1);
    outgoing_message->from_timestamp_and_float(message->get_timestamp(), samplesPerChannel);
    send_message(0, outgoing_message);
  }
  else if (message->is_symbol_str(0, "write"))
  {
    //Not implemented yet
    graph->print_err("[soundfiler]: The 'write' command is not supported yet.");
  }
}