source: src/io/sink_vorbis.c @ 59109e9

feature/autosink
Last change on this file since 59109e9 was 59109e9, checked in by Paul Brossier <piem@piem.org>, 20 months ago

[sink_vorbis] use AUBIO_STRERR

  • Property mode set to 100644
File size: 8.1 KB
Line 
1/*
2  Copyright (C) 2018 Paul Brossier <piem@aubio.org>
3
4  This file is part of aubio.
5
6  aubio is free software: you can redistribute it and/or modify
7  it under the terms of the GNU General Public License as published by
8  the Free Software Foundation, either version 3 of the License, or
9  (at your option) any later version.
10
11  aubio is distributed in the hope that it will be useful,
12  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  GNU General Public License for more details.
15
16  You should have received a copy of the GNU General Public License
17  along with aubio.  If not, see <http://www.gnu.org/licenses/>.
18
19*/
20
21/*
22  This file is largely inspired by `examples/encoder_example.c` in the
23  libvorbis source package (versions 1.3.5 and later) available online at
24  https://xiph.org/vorbis/
25*/
26
27#include "aubio_priv.h"
28
29#ifdef HAVE_VORBISENC
30
31#include "fmat.h"
32#include "io/ioutils.h"
33
34#include <vorbis/vorbisenc.h>
35#include <string.h> // strerror
36#include <errno.h> // errno
37#include <time.h> // time
38
39#define MAX_SIZE 4096
40
41struct _aubio_sink_vorbis_t {
42  FILE *fid;            // file id
43  ogg_stream_state os;  // stream
44  ogg_page og;          // page
45  ogg_packet op;        // data packet
46  vorbis_info vi;       // vorbis bitstream settings
47  vorbis_comment vc;    // user comment
48  vorbis_dsp_state vd;  // working state
49  vorbis_block vb;      // working space
50
51  uint_t samplerate;
52  uint_t channels;
53  char_t *path;
54};
55
56typedef struct _aubio_sink_vorbis_t aubio_sink_vorbis_t;
57
58uint_t aubio_sink_vorbis_preset_channels(aubio_sink_vorbis_t *s,
59    uint_t channels);
60uint_t aubio_sink_vorbis_preset_samplerate(aubio_sink_vorbis_t *s,
61    uint_t samplerate);
62uint_t aubio_sink_vorbis_open(aubio_sink_vorbis_t *s);
63uint_t aubio_sink_vorbis_close (aubio_sink_vorbis_t *s);
64void del_aubio_sink_vorbis (aubio_sink_vorbis_t *s);
65
66static uint_t aubio_sink_vorbis_write_page(aubio_sink_vorbis_t *s);
67
68aubio_sink_vorbis_t * new_aubio_sink_vorbis (const char_t *uri,
69    uint_t samplerate)
70{
71  aubio_sink_vorbis_t * s = AUBIO_NEW(aubio_sink_vorbis_t);
72
73  if (!uri) {
74    AUBIO_ERROR("sink_vorbis: Aborted opening null path\n");
75    goto failure;
76  }
77
78  s->path = AUBIO_ARRAY(char_t, strnlen(uri, PATH_MAX) + 1);
79  strncpy(s->path, uri, strnlen(uri, PATH_MAX) + 1);
80  s->path[strnlen(uri, PATH_MAX)] = '\0';
81
82  s->channels = 0;
83
84  if ((sint_t)samplerate == 0)
85    return s;
86
87  aubio_sink_vorbis_preset_samplerate(s, samplerate);
88  s->channels = 1;
89
90  if (aubio_sink_vorbis_open(s) != AUBIO_OK)
91    goto failure;
92
93  return s;
94
95failure:
96  del_aubio_sink_vorbis(s);
97  return NULL;
98}
99
100void del_aubio_sink_vorbis (aubio_sink_vorbis_t *s)
101{
102  if (s->fid) aubio_sink_vorbis_close(s);
103  // clean up
104  ogg_stream_clear(&s->os);
105  vorbis_block_clear(&s->vb);
106  vorbis_dsp_clear(&s->vd);
107  vorbis_comment_clear(&s->vc);
108  vorbis_info_clear(&s->vi);
109
110  if (s->path) AUBIO_FREE(s->path);
111  AUBIO_FREE(s);
112}
113
114uint_t aubio_sink_vorbis_open(aubio_sink_vorbis_t *s)
115{
116  float quality_mode = .9;
117
118  if (s->samplerate == 0 || s->channels == 0) return AUBIO_FAIL;
119
120  s->fid = fopen((const char *)s->path, "wb");
121  if (!s->fid) {
122    AUBIO_STRERR("sink_vorbis: Error opening file \'%s\' (%s)\n",
123        s->path, errorstr);
124    return AUBIO_FAIL;
125  }
126
127  vorbis_info_init(&s->vi);
128  if (vorbis_encode_init_vbr(&s->vi, s->channels, s->samplerate, quality_mode))
129  {
130    AUBIO_ERR("sink_vorbis: vorbis_encode_init_vbr failed\n");
131    return AUBIO_FAIL;
132  }
133
134  // add comment
135  vorbis_comment_init(&s->vc);
136  vorbis_comment_add_tag(&s->vc, "ENCODER", "aubio");
137
138  // initalise analysis and block
139  vorbis_analysis_init(&s->vd, &s->vi);
140  vorbis_block_init(&s->vd, &s->vb);
141
142  // pick randome serial number
143  srand(time(NULL));
144  ogg_stream_init(&s->os, rand());
145
146  // write header
147  {
148    ogg_packet header;
149    ogg_packet header_comm;
150    ogg_packet header_code;
151
152    vorbis_analysis_headerout(&s->vd, &s->vc, &header, &header_comm,
153        &header_code);
154
155    ogg_stream_packetin(&s->os, &header);
156    ogg_stream_packetin(&s->os, &header_comm);
157    ogg_stream_packetin(&s->os, &header_code);
158
159    // make sure audio data will start on a new page
160    while (1)
161    {
162      if (!ogg_stream_flush(&s->os, &s->og)) break;
163      if (aubio_sink_vorbis_write_page(s)) return AUBIO_FAIL;
164    }
165  }
166
167  return AUBIO_OK;
168}
169
170uint_t aubio_sink_vorbis_preset_samplerate(aubio_sink_vorbis_t *s,
171    uint_t samplerate)
172{
173  if (aubio_io_validate_samplerate("sink_vorbis", s->path, samplerate))
174    return AUBIO_FAIL;
175  s->samplerate = samplerate;
176  if (/* s->samplerate != 0 && */ s->channels != 0)
177    return aubio_sink_vorbis_open(s);
178  return AUBIO_OK;
179}
180
181uint_t aubio_sink_vorbis_preset_channels(aubio_sink_vorbis_t *s,
182    uint_t channels)
183{
184  if (aubio_io_validate_channels("sink_vorbis", s->path, channels)) {
185    return AUBIO_FAIL;
186  }
187  s->channels = channels;
188  // automatically open when both samplerate and channels have been set
189  if (s->samplerate != 0 /* && s->channels != 0 */) {
190    return aubio_sink_vorbis_open(s);
191  }
192  return AUBIO_OK;
193}
194
195uint_t aubio_sink_vorbis_get_samplerate(const aubio_sink_vorbis_t *s)
196{
197  return s->samplerate;
198}
199
200uint_t aubio_sink_vorbis_get_channels(const aubio_sink_vorbis_t *s)
201{
202  return s->channels;
203}
204
205static
206uint_t aubio_sink_vorbis_write_page(aubio_sink_vorbis_t *s) {
207  int result;
208  size_t wrote;
209  wrote = fwrite(s->og.header, 1, s->og.header_len, s->fid);
210  result = (wrote == (unsigned)s->og.header_len);
211  wrote = fwrite(s->og.body, 1, s->og.body_len,     s->fid);
212  result &= (wrote == (unsigned)s->og.body_len);
213  if (result == 0) {
214    AUBIO_STRERR("sink_vorbis: failed writing \'%s\' to disk (%s)\n",
215        s->path, errorstr);
216    return AUBIO_FAIL;
217  }
218  return AUBIO_OK;
219}
220
221static
222void aubio_sink_vorbis_write(aubio_sink_vorbis_t *s)
223{
224  // pre-analysis
225  while (vorbis_analysis_blockout(&s->vd, &s->vb) == 1) {
226
227    vorbis_analysis(&s->vb, NULL);
228    vorbis_bitrate_addblock(&s->vb);
229
230    while (vorbis_bitrate_flushpacket(&s->vd, &s->op))
231    {
232      ogg_stream_packetin(&s->os, &s->op);
233
234      while (1) {
235        if (!ogg_stream_pageout (&s->os, &s->og)) break;
236        aubio_sink_vorbis_write_page(s);
237        if (ogg_page_eos(&s->og)) break;
238      }
239    }
240  }
241}
242
243void aubio_sink_vorbis_do(aubio_sink_vorbis_t *s, fvec_t *write_data,
244    uint_t write)
245{
246  uint_t c, v;
247  uint_t length = aubio_sink_validate_input_length("sink_vorbis", s->path,
248      MAX_SIZE, write_data->length, write);
249  float **buffer = vorbis_analysis_buffer(&s->vd, (long)length);
250  // fill buffer
251  if (!write) {
252    return;
253  } else if (!buffer) {
254    AUBIO_WRN("sink_vorbis: failed fetching buffer of size %d\n", write);
255    return;
256  } else {
257    for (c = 0; c < s->channels; c++) {
258      for (v = 0; v < length; v++) {
259        buffer[c][v] = write_data->data[v];
260      }
261    }
262    // tell vorbis how many frames were written
263    vorbis_analysis_wrote(&s->vd, (long)length);
264  }
265  // write to file
266  aubio_sink_vorbis_write(s);
267}
268
269void aubio_sink_vorbis_do_multi(aubio_sink_vorbis_t *s, fmat_t *write_data,
270    uint_t write)
271{
272  uint_t c, v;
273  uint_t channels = aubio_sink_validate_input_channels("sink_vorbis", s->path,
274      s->channels, write_data->height);
275  uint_t length = aubio_sink_validate_input_length("sink_vorbis", s->path,
276      MAX_SIZE, write_data->length, write);
277  float **buffer = vorbis_analysis_buffer(&s->vd, (long)length);
278  // fill buffer
279  if (!write) {
280    return;
281  } else if (!buffer) {
282    AUBIO_WRN("sink_vorbis: failed fetching buffer of size %d\n", write);
283    return;
284  } else {
285    for (c = 0; c < channels; c++) {
286      for (v = 0; v < length; v++) {
287        buffer[c][v] = write_data->data[c][v];
288      }
289    }
290    // tell vorbis how many frames were written
291    vorbis_analysis_wrote(&s->vd, (long)length);
292  }
293
294  aubio_sink_vorbis_write(s);
295}
296
297uint_t aubio_sink_vorbis_close (aubio_sink_vorbis_t *s)
298{
299  if (!s->fid) return AUBIO_FAIL;
300  //mark the end of stream
301  vorbis_analysis_wrote(&s->vd, 0);
302
303  aubio_sink_vorbis_write(s);
304
305  if (s->fid && fclose(s->fid)) {
306    AUBIO_STRERR("sink_vorbis: Error closing file \'%s\' (%s)\n",
307        s->path, errorstr);
308    return AUBIO_FAIL;
309  }
310  s->fid = NULL;
311  return AUBIO_OK;
312}
313
314#endif /* HAVE_VORBISENC */
Note: See TracBrowser for help on using the repository browser.