src/stream.cpp

   1 /*
   2  * ALURE  OpenAL utility library
   3  * Copyright (C) 2009 by Chris Robinson.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  18  * Or go to http://www.gnu.org/copyleft/lgpl.html
  19  */
  20
  21 /* Title: Streaming */
  22
  23 #include "config.h"
  24
  25 #include "main.h"
  26
  27 #include <string.h>
  28
  29 #include <memory>
  30
  31 static alureStream *InitStream(alureStream *instream, ALsizei chunkLength, ALsizei numBufs, ALuint *bufs)
  32 {
  33     std::auto_ptr<alureStream> stream(instream);
  34     ALenum format;
  35     ALuint freq, blockAlign;
  36
  37     if(!stream->GetFormat(&format, &freq, &blockAlign))
  38     {
  39         SetError("Could not get stream format");
  40         return NULL;
  41     }
  42
  43     if(format == AL_NONE)
  44     {
  45         SetError("No valid format");
  46         return NULL;
  47     }
  48     if(blockAlign == 0)
  49     {
  50         SetError("Invalid block size");
  51         return NULL;
  52     }
  53     if(freq == 0)
  54     {
  55         SetError("Invalid sample rate");
  56         return NULL;
  57     }
  58
  59     chunkLength -= chunkLength%blockAlign;
  60     if(chunkLength <= 0)
  61     {
  62         SetError("Chunk length too small");
  63         return NULL;
  64     }
  65
  66     stream->chunkLen = chunkLength;
  67     stream->dataChunk = new ALubyte[stream->chunkLen];
  68
  69     alGenBuffers(numBufs, bufs);
  70     if(alGetError() != AL_NO_ERROR)
  71     {
  72         SetError("Buffer creation failed");
  73         return NULL;
  74     }
  75
  76     ALsizei filled;
  77     for(filled = 0;filled < numBufs;filled++)
  78     {
  79         ALuint got = stream->GetData(stream->dataChunk, stream->chunkLen);
  80         got -= got%blockAlign;
  81         if(got == 0) break;
  82
  83         alBufferData(bufs[filled], format, stream->dataChunk, got, freq);
  84         if(alGetError() != AL_NO_ERROR)
  85         {
  86             alDeleteBuffers(numBufs, bufs);
  87             alGetError();
  88
  89             SetError("Buffering error");
  90             return NULL;
  91         }
  92     }
  93
  94     while(filled < numBufs)
  95     {
  96         alBufferData(bufs[filled], format, stream->dataChunk, 0, freq);
  97         if(alGetError() != AL_NO_ERROR)
  98         {
  99             SetError("Buffer load failed");
 100             return NULL;
 101         }
 102         filled++;
 103     }
 104
 105     return stream.release();
 106 }
 107
 108
 109 extern "C" {
 110
 111 /* Function: alureCreateStreamFromFile
 112  *
 113  * Opens a file and sets it up for streaming. The given chunkLength is the
 114  * number of bytes each buffer will fill with. ALURE will optionally generate
 115  * the specified number of buffer objects, fill them with the beginning of the
 116  * data, then place the new IDs into the provided storage, before returning.
 117  * Requires an active context.
 118  *
 119  * Returns:
 120  * An opaque handle used to control the opened stream, or NULL on error.
 121  *
 122  * See Also:
 123  * <alureCreateStreamFromMemory>, <alureCreateStreamFromStaticMemory>,
 124  * <alureCreateStreamFromCallback>
 125  */
 126 ALURE_API alureStream* ALURE_APIENTRY alureCreateStreamFromFile(const ALchar *fname, ALsizei chunkLength, ALsizei numBufs, ALuint *bufs)
 127 {
 128     if(alGetError() != AL_NO_ERROR)
 129     {
 130         SetError("Existing OpenAL error");
 131         return NULL;
 132     }
 133
 134     if(chunkLength < 0)
 135     {
 136         SetError("Invalid chunk length");
 137         return NULL;
 138     }
 139
 140     if(numBufs < 0)
 141     {
 142         SetError("Invalid buffer count");
 143         return NULL;
 144     }
 145
 146     alureStream *stream = create_stream(fname);
 147     if(!stream->IsValid())
 148     {
 149         delete stream;
 150         return NULL;
 151     }
 152
 153     return InitStream(stream, chunkLength, numBufs, bufs);
 154 }
 155
 156 /* Function: alureCreateStreamFromMemory
 157  *
 158  * Opens a file image from memory and sets it up for streaming, similar to
 159  * alureCreateStreamFromFile. The given data buffer can be safely deleted after
 160  * calling this function. Requires an active context.
 161  *
 162  * Returns:
 163  * An opaque handle used to control the opened stream, or NULL on error.
 164  *
 165  * See Also:
 166  * <alureCreateStreamFromFile>, <alureCreateStreamFromStaticMemory>,
 167  * <alureCreateStreamFromCallback>
 168  */
 169 ALURE_API alureStream* ALURE_APIENTRY alureCreateStreamFromMemory(const ALubyte *fdata, ALuint length, ALsizei chunkLength, ALsizei numBufs, ALuint *bufs)
 170 {
 171     if(alGetError() != AL_NO_ERROR)
 172     {
 173         SetError("Existing OpenAL error");
 174         return NULL;
 175     }
 176
 177     if(chunkLength < 0)
 178     {
 179         SetError("Invalid chunk length");
 180         return NULL;
 181     }
 182
 183     if(numBufs < 0)
 184     {
 185         SetError("Invalid buffer count");
 186         return NULL;
 187     }
 188
 189     if(length <= 0)
 190     {
 191         SetError("Invalid data length");
 192         return NULL;
 193     }
 194
 195     ALubyte *streamData = new ALubyte[length];
 196     memcpy(streamData, fdata, length);
 197
 198     MemDataInfo memData;
 199     memData.Data = streamData;
 200     memData.Length = length;
 201     memData.Pos = 0;
 202
 203     alureStream *stream = create_stream(memData);
 204     stream->data = streamData;
 205     if(!stream->IsValid())
 206     {
 207         delete stream;
 208         return NULL;
 209     }
 210
 211     return InitStream(stream, chunkLength, numBufs, bufs);
 212 }
 213
 214 /* Function: alureCreateStreamFromStaticMemory
 215  *
 216  * Identical to alureCreateStreamFromMemory, except the given memory is used
 217  * directly and not duplicated. As a consequence, the data buffer must remain
 218  * valid while the stream is alive. Requires an active context.
 219  *
 220  * Returns:
 221  * An opaque handle used to control the opened stream, or NULL on error.
 222  *
 223  * See Also:
 224  * <alureCreateStreamFromFile>, <alureCreateStreamFromMemory>,
 225  * <alureCreateStreamFromCallback>
 226  */
 227 ALURE_API alureStream* ALURE_APIENTRY alureCreateStreamFromStaticMemory(const ALubyte *fdata, ALuint length, ALsizei chunkLength, ALsizei numBufs, ALuint *bufs)
 228 {
 229     if(alGetError() != AL_NO_ERROR)
 230     {
 231         SetError("Existing OpenAL error");
 232         return NULL;
 233     }
 234
 235     if(chunkLength < 0)
 236     {
 237         SetError("Invalid chunk length");
 238         return NULL;
 239     }
 240
 241     if(numBufs < 0)
 242     {
 243         SetError("Invalid buffer count");
 244         return NULL;
 245     }
 246
 247     if(length <= 0)
 248     {
 249         SetError("Invalid data length");
 250         return NULL;
 251     }
 252
 253     MemDataInfo memData;
 254     memData.Data = fdata;
 255     memData.Length = length;
 256     memData.Pos = 0;
 257
 258     alureStream *stream = create_stream(memData);
 259     if(!stream->IsValid())
 260     {
 261         delete stream;
 262         return NULL;
 263     }
 264
 265     return InitStream(stream, chunkLength, numBufs, bufs);
 266 }
 267
 268 /* Function: alureCreateStreamFromCallback
 269  *
 270  * Creates a stream using the specified callback to retrieve data. Requires an
 271  * active context.
 272  *
 273  * Parameters:
 274  * callback - This is called when more data is needed from the stream. Up to
 275  *            the specified number of bytes should be written to the data
 276  *            pointer, and the number of bytes actually written should be
 277  *            returned. The number of bytes written must be block aligned for
 278  *            the format (eg. a multiple of 4 for AL_FORMAT_STEREO16), or an
 279  *            OpenAL error may occur during buffering.
 280  * userdata - A handle passed through to the callback.
 281  * format - The format of the data the callback will be giving. The format must
 282  *          be valid for the context.
 283  * samplerate - The sample rate (frequency) of the stream
 284  *
 285  * Returns:
 286  * An opaque handle used to control the opened stream, or NULL on error.
 287  *
 288  * See Also:
 289  * <alureCreateStreamFromFile>, <alureCreateStreamFromMemory>,
 290  * <alureCreateStreamFromStaticMemory>
 291  */
 292 ALURE_API alureStream* ALURE_APIENTRY alureCreateStreamFromCallback(
 293       ALuint (*callback)(void *userdata, ALubyte *data, ALuint bytes),
 294       void *userdata, ALenum format, ALuint samplerate,
 295       ALsizei chunkLength, ALsizei numBufs, ALuint *bufs)
 296 {
 297     if(alGetError() != AL_NO_ERROR)
 298     {
 299         SetError("Existing OpenAL error");
 300         return NULL;
 301     }
 302
 303     if(callback == NULL)
 304     {
 305         SetError("Invalid callback");
 306         return NULL;
 307     }
 308
 309     if(chunkLength < 0)
 310     {
 311         SetError("Invalid chunk length");
 312         return NULL;
 313     }
 314
 315     if(numBufs < 0)
 316     {
 317         SetError("Invalid buffer count");
 318         return NULL;
 319     }
 320
 321     UserCallbacks newcb;
 322     newcb.open_file = NULL;
 323     newcb.open_mem  = NULL;
 324     newcb.get_fmt   = NULL;
 325     newcb.decode    = callback;
 326     newcb.rewind    = NULL;
 327     newcb.close     = NULL;
 328
 329     customStream *stream = new customStream(userdata, format, samplerate, newcb);
 330     return InitStream(stream, chunkLength, numBufs, bufs);
 331 }
 332
 333 /* Function: alureGetStreamFormat
 334  *
 335  * Retrieves the format, frequency, and block-alignment used for the given
 336  * stream. If a parameter is NULL, that value will not be returned.
 337  *
 338  * Returns:
 339  * AL_FALSE on error.
 340  */
 341 ALURE_API ALboolean ALURE_APIENTRY alureGetStreamFormat(alureStream *stream,
 342     ALenum *format, ALuint *frequency, ALuint *blockAlign)
 343 {
 344     ALenum _fmt;
 345     ALuint _rate, _balign;
 346
 347     if(!alureStream::Verify(stream))
 348     {
 349         SetError("Invalid stream pointer");
 350         return AL_FALSE;
 351     }
 352
 353     if(!format) format = &_fmt;
 354     if(!frequency) frequency = &_rate;
 355     if(!blockAlign) blockAlign = &_balign;
 356
 357     if(!stream->GetFormat(format, frequency, blockAlign))
 358     {
 359         SetError("Could not get stream format");
 360         return AL_FALSE;
 361     }
 362
 363     return AL_TRUE;
 364 }
 365
 366 /* Function: alureBufferDataFromStream
 367  *
 368  * Buffers the given buffer objects with the next chunks of data from the
 369  * stream. The given buffer objects do not need to be ones given by the
 370  * alureCreateStreamFrom* functions. Requires an active context.
 371  *
 372  * Returns:
 373  * The number of buffers filled with new data, or -1 on error. If the value
 374  * returned is less than the number requested, the end of the stream has been
 375  * reached.
 376  */
 377 ALURE_API ALsizei ALURE_APIENTRY alureBufferDataFromStream(alureStream *stream, ALsizei numBufs, ALuint *bufs)
 378 {
 379     if(alGetError() != AL_NO_ERROR)
 380     {
 381         SetError("Existing OpenAL error");
 382         return -1;
 383     }
 384
 385     if(!alureStream::Verify(stream))
 386     {
 387         SetError("Invalid stream pointer");
 388         return -1;
 389     }
 390
 391     if(numBufs < 0)
 392     {
 393         SetError("Invalid buffer count");
 394         return -1;
 395     }
 396
 397     ALenum format;
 398     ALuint freq, blockAlign;
 399
 400     if(!stream->GetFormat(&format, &freq, &blockAlign))
 401     {
 402         SetError("Could not get stream format");
 403         return -1;
 404     }
 405
 406     ALsizei filled;
 407     for(filled = 0;filled < numBufs;filled++)
 408     {
 409         ALuint got = stream->GetData(stream->dataChunk, stream->chunkLen);
 410         got -= got%blockAlign;
 411         if(got == 0) break;
 412
 413         alBufferData(bufs[filled], format, stream->dataChunk, got, freq);
 414         if(alGetError() != AL_NO_ERROR)
 415         {
 416             SetError("Buffer load failed");
 417             return -1;
 418         }
 419     }
 420
 421     return filled;
 422 }
 423
 424 /* Function: alureRewindStream
 425  *
 426  * Rewinds the stream so that the next alureBufferDataFromStream call will
 427  * restart from the beginning of the audio file.
 428  *
 429  * Returns:
 430  * AL_FALSE on error.
 431  *
 432  * See Also:
 433  * <alureSetStreamOrder>
 434  */
 435 ALURE_API ALboolean ALURE_APIENTRY alureRewindStream(alureStream *stream)
 436 {
 437     if(!alureStream::Verify(stream))
 438     {
 439         SetError("Invalid stream pointer");
 440         return AL_FALSE;
 441     }
 442
 443     return stream->Rewind();
 444 }
 445
 446 /* Function: alureSetStreamOrder
 447  *
 448  * Skips the module decoder to the specified order, so following buffering
 449  * calls will decode from the specified order. For non-module formats, setting
 450  * order 0 is identical to rewinding the stream (other orders will fail).
 451  *
 452  * Returns:
 453  * AL_FALSE on error.
 454  *
 455  * See Also:
 456  * <alureRewindStream>
 457  */
 458 ALURE_API ALboolean ALURE_APIENTRY alureSetStreamOrder(alureStream *stream, ALuint order)
 459 {
 460     if(!alureStream::Verify(stream))
 461     {
 462         SetError("Invalid stream pointer");
 463         return AL_FALSE;
 464     }
 465
 466     return stream->SetOrder(order);
 467 }
 468
 469 /* Function: alureDestroyStream
 470  *
 471  * Closes an opened stream. For convenience, it will also delete the given
 472  * buffer objects. The given buffer objects do not need to be ones given by the
 473  * alureCreateStreamFrom* functions. Requires an active context.
 474  *
 475  * Returns:
 476  * AL_FALSE on error.
 477  */
 478 ALURE_API ALboolean ALURE_APIENTRY alureDestroyStream(alureStream *stream, ALsizei numBufs, ALuint *bufs)
 479 {
 480     if(alGetError() != AL_NO_ERROR)
 481     {
 482         SetError("Existing OpenAL error");
 483         return AL_FALSE;
 484     }
 485
 486     if(numBufs < 0)
 487     {
 488         SetError("Invalid buffer count");
 489         return AL_FALSE;
 490     }
 491
 492     if(stream && !alureStream::Verify(stream))
 493     {
 494         SetError("Invalid stream pointer");
 495         return AL_FALSE;
 496     }
 497
 498     alDeleteBuffers(numBufs, bufs);
 499     if(alGetError() != AL_NO_ERROR)
 500     {
 501         SetError("Buffer deletion failed");
 502         return AL_FALSE;
 503     }
 504
 505     if(stream)
 506     {
 507         StopStream(stream);
 508         std::istream *f = stream->fstream;
 509         delete stream; delete f;
 510     }
 511     return AL_TRUE;
 512 }
 513
 514 }