src/stream.cpp

   1 /*
   2  * ALURE  OpenAL utility library
   3  * Copyright (c) 2009 by Chris Robinson.
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a copy
   6  * of this software and associated documentation files (the "Software"), to
   7  * deal in the Software without restriction, including without limitation the
   8  * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
   9  * sell copies of the Software, and to permit persons to whom the Software is
  10  * furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice shall be included in
  13  * all copies or substantial portions of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  18  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  21  * IN THE SOFTWARE.
  22  */
  23
  24 /* Title: Streaming */
  25
  26 #include "config.h"
  27
  28 #include "main.h"
  29
  30 #include <string.h>
  31
  32 #include <memory>
  33
  34 static bool SizeIsUS = false;
  35
  36 static alureStream *InitStream(alureStream *instream, ALsizei chunkLength, ALsizei numBufs, ALuint *bufs)
  37 {
  38     std::auto_ptr<alureStream> stream(instream);
  39     ALenum format;
  40     ALuint freq, blockAlign;
  41
  42     if(!stream->GetFormat(&format, &freq, &blockAlign))
  43     {
  44         SetError("Could not get stream format");
  45         return NULL;
  46     }
  47
  48     if(format == AL_NONE)
  49     {
  50         SetError("No valid format");
  51         return NULL;
  52     }
  53     if(blockAlign == 0)
  54     {
  55         SetError("Invalid block size");
  56         return NULL;
  57     }
  58     if(freq == 0)
  59     {
  60         SetError("Invalid sample rate");
  61         return NULL;
  62     }
  63
  64     ALuint framesPerBlock;
  65     DetectCompressionRate(format, &framesPerBlock);
  66     alureUInt64 len64 = (SizeIsUS ? (alureUInt64)chunkLength * freq / 1000000 / framesPerBlock * blockAlign :
  67                                     (alureUInt64)chunkLength);
  68     if(len64 > 0xFFFFFFFF)
  69     {
  70         SetError("Chunk length too large");
  71         return NULL;
  72     }
  73
  74     chunkLength = len64 - (len64%blockAlign);
  75     if(chunkLength <= 0)
  76     {
  77         SetError("Chunk length too small");
  78         return NULL;
  79     }
  80
  81     stream->chunkLen = chunkLength;
  82     stream->dataChunk = new ALubyte[stream->chunkLen];
  83
  84     alGenBuffers(numBufs, bufs);
  85     if(alGetError() != AL_NO_ERROR)
  86     {
  87         SetError("Buffer creation failed");
  88         return NULL;
  89     }
  90
  91     ALsizei filled;
  92     for(filled = 0;filled < numBufs;filled++)
  93     {
  94         ALuint got = stream->GetData(stream->dataChunk, stream->chunkLen);
  95         got -= got%blockAlign;
  96         if(got == 0) break;
  97
  98         alBufferData(bufs[filled], format, stream->dataChunk, got, freq);
  99     }
 100
 101     while(filled < numBufs)
 102     {
 103         alBufferData(bufs[filled], format, stream->dataChunk, 0, freq);
 104         filled++;
 105     }
 106     if(alGetError() != AL_NO_ERROR)
 107     {
 108         alDeleteBuffers(numBufs, bufs);
 109         alGetError();
 110
 111         SetError("Buffering error");
 112         return NULL;
 113     }
 114
 115     return stream.release();
 116 }
 117
 118
 119 extern "C" {
 120
 121 /* Function: alureStreamSizeIsMicroSec
 122  *
 123  * Specifies if the chunk size value given to the alureCreateStream functions
 124  * is in bytes (default) or microseconds. Specifying the size in microseconds
 125  * can help manage the time needed in between needed updates (since the format
 126  * and sample rate of the stream may not be known), while specifying the size
 127  * in bytes can help control memory usage.
 128  *
 129  * Returns:
 130  * Previously set value.
 131  *
 132  * *Version Added*: 1.1
 133  *
 134  * See Also:
 135  * <alureCreateStreamFromFile>, <alureCreateStreamFromMemory>,
 136  * <alureCreateStreamFromStaticMemory>, <alureCreateStreamFromCallback>
 137  */
 138 ALURE_API ALboolean ALURE_APIENTRY alureStreamSizeIsMicroSec(ALboolean useUS)
 139 {
 140     ALboolean old = (SizeIsUS ? AL_TRUE : AL_FALSE);
 141     SizeIsUS = !!useUS;
 142     return old;
 143 }
 144
 145 /* Function: alureCreateStreamFromFile
 146  *
 147  * Opens a file and sets it up for streaming. The given chunkLength is the
 148  * number of bytes, or microseconds worth of bytes if
 149  * <alureStreamSizeIsMicroSec> was last called with AL_TRUE, each buffer will
 150  * fill with. ALURE will optionally generate the specified number of buffer
 151  * objects, fill them with the beginning of the data, then place the new IDs
 152  * into the provided storage, before returning. Requires an active context.
 153  *
 154  * Returns:
 155  * An opaque handle used to control the opened stream, or NULL on error.
 156  *
 157  * See Also:
 158  * <alureStreamSizeIsMicroSec>, <alureCreateStreamFromMemory>,
 159  * <alureCreateStreamFromStaticMemory>, <alureCreateStreamFromCallback>
 160  */
 161 ALURE_API alureStream* ALURE_APIENTRY alureCreateStreamFromFile(const ALchar *fname, ALsizei chunkLength, ALsizei numBufs, ALuint *bufs)
 162 {
 163     if(alGetError() != AL_NO_ERROR)
 164     {
 165         SetError("Existing OpenAL error");
 166         return NULL;
 167     }
 168
 169     if(chunkLength < 0)
 170     {
 171         SetError("Invalid chunk length");
 172         return NULL;
 173     }
 174
 175     if(numBufs < 0)
 176     {
 177         SetError("Invalid buffer count");
 178         return NULL;
 179     }
 180
 181     alureStream *stream = create_stream(fname);
 182     if(!stream->IsValid())
 183     {
 184         delete stream;
 185         return NULL;
 186     }
 187
 188     return InitStream(stream, chunkLength, numBufs, bufs);
 189 }
 190
 191 /* Function: alureCreateStreamFromMemory
 192  *
 193  * Opens a file image from memory and sets it up for streaming, similar to
 194  * <alureCreateStreamFromFile>. The given data buffer can be safely deleted
 195  * after calling this function. Requires an active context.
 196  *
 197  * Returns:
 198  * An opaque handle used to control the opened stream, or NULL on error.
 199  *
 200  * See Also:
 201  * <alureStreamSizeIsMicroSec>, <alureCreateStreamFromFile>,
 202  * <alureCreateStreamFromStaticMemory>, <alureCreateStreamFromCallback>
 203  */
 204 ALURE_API alureStream* ALURE_APIENTRY alureCreateStreamFromMemory(const ALubyte *fdata, ALuint length, ALsizei chunkLength, ALsizei numBufs, ALuint *bufs)
 205 {
 206     if(alGetError() != AL_NO_ERROR)
 207     {
 208         SetError("Existing OpenAL error");
 209         return NULL;
 210     }
 211
 212     if(chunkLength < 0)
 213     {
 214         SetError("Invalid chunk length");
 215         return NULL;
 216     }
 217
 218     if(numBufs < 0)
 219     {
 220         SetError("Invalid buffer count");
 221         return NULL;
 222     }
 223
 224     if(length <= 0)
 225     {
 226         SetError("Invalid data length");
 227         return NULL;
 228     }
 229
 230     ALubyte *streamData = new ALubyte[length];
 231     memcpy(streamData, fdata, length);
 232
 233     MemDataInfo memData;
 234     memData.Data = streamData;
 235     memData.Length = length;
 236     memData.Pos = 0;
 237
 238     alureStream *stream = create_stream(memData);
 239     stream->data = streamData;
 240     if(!stream->IsValid())
 241     {
 242         delete stream;
 243         return NULL;
 244     }
 245
 246     return InitStream(stream, chunkLength, numBufs, bufs);
 247 }
 248
 249 /* Function: alureCreateStreamFromStaticMemory
 250  *
 251  * Identical to <alureCreateStreamFromMemory>, except the given memory is used
 252  * directly and not duplicated. As a consequence, the data buffer must remain
 253  * valid while the stream is alive. Requires an active context.
 254  *
 255  * Returns:
 256  * An opaque handle used to control the opened stream, or NULL on error.
 257  *
 258  * See Also:
 259  * <alureStreamSizeIsMicroSec>, <alureCreateStreamFromFile>,
 260  * <alureCreateStreamFromMemory>, <alureCreateStreamFromCallback>
 261  */
 262 ALURE_API alureStream* ALURE_APIENTRY alureCreateStreamFromStaticMemory(const ALubyte *fdata, ALuint length, ALsizei chunkLength, ALsizei numBufs, ALuint *bufs)
 263 {
 264     if(alGetError() != AL_NO_ERROR)
 265     {
 266         SetError("Existing OpenAL error");
 267         return NULL;
 268     }
 269
 270     if(chunkLength < 0)
 271     {
 272         SetError("Invalid chunk length");
 273         return NULL;
 274     }
 275
 276     if(numBufs < 0)
 277     {
 278         SetError("Invalid buffer count");
 279         return NULL;
 280     }
 281
 282     if(length <= 0)
 283     {
 284         SetError("Invalid data length");
 285         return NULL;
 286     }
 287
 288     MemDataInfo memData;
 289     memData.Data = fdata;
 290     memData.Length = length;
 291     memData.Pos = 0;
 292
 293     alureStream *stream = create_stream(memData);
 294     if(!stream->IsValid())
 295     {
 296         delete stream;
 297         return NULL;
 298     }
 299
 300     return InitStream(stream, chunkLength, numBufs, bufs);
 301 }
 302
 303 /* Function: alureCreateStreamFromCallback
 304  *
 305  * Creates a stream using the specified callback to retrieve data. Requires an
 306  * active context.
 307  *
 308  * Parameters:
 309  * callback - This is called when more data is needed from the stream. Up to
 310  *            the specified number of bytes should be written to the data
 311  *            pointer, and the number of bytes actually written should be
 312  *            returned. The number of bytes written must be block aligned for
 313  *            the format (eg. a multiple of 4 for AL_FORMAT_STEREO16), or an
 314  *            OpenAL error may occur during buffering.
 315  * userdata - A handle passed through to the callback.
 316  * format - The format of the data the callback will be giving. The format must
 317  *          be valid for the context.
 318  * samplerate - The sample rate (frequency) of the stream
 319  *
 320  * Returns:
 321  * An opaque handle used to control the opened stream, or NULL on error.
 322  *
 323  * See Also:
 324  * <alureStreamSizeIsMicroSec>, <alureCreateStreamFromFile>,
 325  * <alureCreateStreamFromMemory>, <alureCreateStreamFromStaticMemory>
 326  */
 327 ALURE_API alureStream* ALURE_APIENTRY alureCreateStreamFromCallback(
 328       ALuint (*callback)(void *userdata, ALubyte *data, ALuint bytes),
 329       void *userdata, ALenum format, ALuint samplerate,
 330       ALsizei chunkLength, ALsizei numBufs, ALuint *bufs)
 331 {
 332     if(alGetError() != AL_NO_ERROR)
 333     {
 334         SetError("Existing OpenAL error");
 335         return NULL;
 336     }
 337
 338     if(callback == NULL)
 339     {
 340         SetError("Invalid callback");
 341         return NULL;
 342     }
 343
 344     if(chunkLength < 0)
 345     {
 346         SetError("Invalid chunk length");
 347         return NULL;
 348     }
 349
 350     if(numBufs < 0)
 351     {
 352         SetError("Invalid buffer count");
 353         return NULL;
 354     }
 355
 356     UserCallbacks newcb;
 357     newcb.open_file = NULL;
 358     newcb.open_mem  = NULL;
 359     newcb.get_fmt   = NULL;
 360     newcb.decode    = callback;
 361     newcb.rewind    = NULL;
 362     newcb.close     = NULL;
 363
 364     alureStream *stream = create_stream(userdata, format, samplerate, newcb);
 365     return InitStream(stream, chunkLength, numBufs, bufs);
 366 }
 367
 368 /* Function: alureGetStreamFormat
 369  *
 370  * Retrieves the format, frequency, and block-alignment used for the given
 371  * stream. If a parameter is NULL, that value will not be returned.
 372  *
 373  * Returns:
 374  * AL_FALSE on error.
 375  *
 376  * *Version Added*: 1.1
 377  */
 378 ALURE_API ALboolean ALURE_APIENTRY alureGetStreamFormat(alureStream *stream,
 379     ALenum *format, ALuint *frequency, ALuint *blockAlign)
 380 {
 381     ALenum _fmt;
 382     ALuint _rate, _balign;
 383
 384     if(!alureStream::Verify(stream))
 385     {
 386         SetError("Invalid stream pointer");
 387         return AL_FALSE;
 388     }
 389
 390     if(!format) format = &_fmt;
 391     if(!frequency) frequency = &_rate;
 392     if(!blockAlign) blockAlign = &_balign;
 393
 394     if(!stream->GetFormat(format, frequency, blockAlign))
 395     {
 396         SetError("Could not get stream format");
 397         return AL_FALSE;
 398     }
 399
 400     return AL_TRUE;
 401 }
 402
 403 /* Function: alureBufferDataFromStream
 404  *
 405  * Buffers the given buffer objects with the next chunks of data from the
 406  * stream. The given buffer objects do not need to be ones given by the
 407  * alureCreateStreamFrom* functions. Requires an active context.
 408  *
 409  * Returns:
 410  * The number of buffers filled with new data, or -1 on error. If the value
 411  * returned is less than the number requested, the end of the stream has been
 412  * reached.
 413  */
 414 ALURE_API ALsizei ALURE_APIENTRY alureBufferDataFromStream(alureStream *stream, ALsizei numBufs, ALuint *bufs)
 415 {
 416     if(alGetError() != AL_NO_ERROR)
 417     {
 418         SetError("Existing OpenAL error");
 419         return -1;
 420     }
 421
 422     if(!alureStream::Verify(stream))
 423     {
 424         SetError("Invalid stream pointer");
 425         return -1;
 426     }
 427
 428     if(numBufs < 0)
 429     {
 430         SetError("Invalid buffer count");
 431         return -1;
 432     }
 433
 434     ALenum format;
 435     ALuint freq, blockAlign;
 436
 437     if(!stream->GetFormat(&format, &freq, &blockAlign))
 438     {
 439         SetError("Could not get stream format");
 440         return -1;
 441     }
 442
 443     ALsizei filled;
 444     for(filled = 0;filled < numBufs;filled++)
 445     {
 446         ALuint got = stream->GetData(stream->dataChunk, stream->chunkLen);
 447         got -= got%blockAlign;
 448         if(got == 0) break;
 449
 450         alBufferData(bufs[filled], format, stream->dataChunk, got, freq);
 451         if(alGetError() != AL_NO_ERROR)
 452         {
 453             SetError("Buffer load failed");
 454             return -1;
 455         }
 456     }
 457
 458     return filled;
 459 }
 460
 461 /* Function: alureRewindStream
 462  *
 463  * Rewinds the stream so that the next alureBufferDataFromStream call will
 464  * restart from the beginning of the audio file.
 465  *
 466  * Returns:
 467  * AL_FALSE on error.
 468  *
 469  * See Also:
 470  * <alureSetStreamOrder>
 471  */
 472 ALURE_API ALboolean ALURE_APIENTRY alureRewindStream(alureStream *stream)
 473 {
 474     if(!alureStream::Verify(stream))
 475     {
 476         SetError("Invalid stream pointer");
 477         return AL_FALSE;
 478     }
 479
 480     return stream->Rewind();
 481 }
 482
 483 /* Function: alureSetStreamOrder
 484  *
 485  * Skips the module decoder to the specified order, so following buffering
 486  * calls will decode from the specified order. For non-module formats, setting
 487  * order 0 is identical to rewinding the stream (other orders will fail).
 488  *
 489  * Returns:
 490  * AL_FALSE on error.
 491  *
 492  * *Version Added*: 1.1
 493  *
 494  * See Also:
 495  * <alureRewindStream>
 496  */
 497 ALURE_API ALboolean ALURE_APIENTRY alureSetStreamOrder(alureStream *stream, ALuint order)
 498 {
 499     if(!alureStream::Verify(stream))
 500     {
 501         SetError("Invalid stream pointer");
 502         return AL_FALSE;
 503     }
 504
 505     return stream->SetOrder(order);
 506 }
 507
 508 /* Function: alureDestroyStream
 509  *
 510  * Closes an opened stream. For convenience, it will also delete the given
 511  * buffer objects. The given buffer objects do not need to be ones given by the
 512  * alureCreateStreamFrom* functions. Requires an active context.
 513  *
 514  * Returns:
 515  * AL_FALSE on error.
 516  */
 517 ALURE_API ALboolean ALURE_APIENTRY alureDestroyStream(alureStream *stream, ALsizei numBufs, ALuint *bufs)
 518 {
 519     if(alGetError() != AL_NO_ERROR)
 520     {
 521         SetError("Existing OpenAL error");
 522         return AL_FALSE;
 523     }
 524
 525     if(numBufs < 0)
 526     {
 527         SetError("Invalid buffer count");
 528         return AL_FALSE;
 529     }
 530
 531     if(stream && !alureStream::Verify(stream))
 532     {
 533         SetError("Invalid stream pointer");
 534         return AL_FALSE;
 535     }
 536
 537     alDeleteBuffers(numBufs, bufs);
 538     if(alGetError() != AL_NO_ERROR)
 539     {
 540         SetError("Buffer deletion failed");
 541         return AL_FALSE;
 542     }
 543
 544     if(stream)
 545     {
 546         StopStream(stream);
 547         std::istream *f = stream->fstream;
 548         delete stream;
 549         delete f;
 550     }
 551     return AL_TRUE;
 552 }
 553
 554 }