examples/alffmpeg.c

   1 /*
   2  * FFmpeg Decoder Helpers
   3  *
   4  * Copyright (c) 2011 by Chris Robinson <chris.kcat@gmail.com>
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  19  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  */
  24
  25 /* This file contains routines for helping to decode audio using libavformat
  26  * and libavcodec (ffmpeg). There's very little OpenAL-specific code here. */
  27
  28 #include <string.h>
  29 #include <stdlib.h>
  30 #include <stdio.h>
  31 #include <signal.h>
  32 #include <assert.h>
  33
  34 #include "AL/al.h"
  35 #include "AL/alc.h"
  36 #include "AL/alext.h"
  37
  38 #include "alhelpers.h"
  39 #include "alffmpeg.h"
  40
  41
  42 static size_t NextPowerOf2(size_t value)
  43 {
  44     size_t powerOf2 = 1;
  45
  46     if(value)
  47     {
  48         value--;
  49         while(value)
  50         {
  51             value >>= 1;
  52             powerOf2 <<= 1;
  53         }
  54     }
  55     return powerOf2;
  56 }
  57
  58
  59 struct MemData {
  60     char *buffer;
  61     size_t length;
  62     size_t pos;
  63 };
  64
  65 static int MemData_read(void *opaque, uint8_t *buf, int buf_size)
  66 {
  67     struct MemData *membuf = (struct MemData*)opaque;
  68     int rem = membuf->length - membuf->pos;
  69
  70     if(rem > buf_size)
  71         rem = buf_size;
  72
  73     memcpy(buf, &membuf->buffer[membuf->pos], rem);
  74     membuf->pos += rem;
  75
  76     return rem;
  77 }
  78
  79 static int MemData_write(void *opaque, uint8_t *buf, int buf_size)
  80 {
  81     struct MemData *membuf = (struct MemData*)opaque;
  82     int rem = membuf->length - membuf->pos;
  83
  84     if(rem > buf_size)
  85         rem = buf_size;
  86
  87     memcpy(&membuf->buffer[membuf->pos], buf, rem);
  88     membuf->pos += rem;
  89
  90     return rem;
  91 }
  92
  93 static int64_t MemData_seek(void *opaque, int64_t offset, int whence)
  94 {
  95     struct MemData *membuf = (struct MemData*)opaque;
  96
  97     whence &= ~AVSEEK_FORCE;
  98     switch(whence)
  99     {
 100         case SEEK_SET:
 101             if(offset < 0 || offset > membuf->length)
 102                 return -1;
 103             membuf->pos = offset;
 104             break;
 105
 106         case SEEK_CUR:
 107             if((offset >= 0 && offset > membuf->length-membuf->pos) ||
 108                (offset < 0 && offset < -membuf->pos))
 109                 return -1;
 110             membuf->pos += offset;
 111             break;
 112
 113         case SEEK_END:
 114             if(offset > 0 || offset < -membuf->length)
 115                 return -1;
 116             membuf->pos = membuf->length + offset;
 117             break;
 118
 119         case AVSEEK_SIZE:
 120             return membuf->length;
 121
 122         default:
 123             return -1;
 124     }
 125
 126     return membuf->pos;
 127 }
 128
 129
 130 struct PacketList {
 131     AVPacket pkt;
 132     struct PacketList *next;
 133 };
 134
 135 struct MyStream {
 136     AVCodecContext *CodecCtx;
 137     int StreamIdx;
 138
 139     struct PacketList *Packets;
 140
 141     char *DecodedData;
 142     size_t DecodedDataSize;
 143
 144     FilePtr parent;
 145 };
 146
 147 struct MyFile {
 148     AVFormatContext *FmtCtx;
 149
 150     StreamPtr *Streams;
 151     size_t StreamsSize;
 152
 153     struct MemData membuf;
 154 };
 155
 156
 157 static int done_init = 0;
 158
 159 FilePtr openAVFile(const char *fname)
 160 {
 161     FilePtr file;
 162
 163     /* We need to make sure ffmpeg is initialized. Optionally silence warning
 164      * output from the lib */
 165     if(!done_init) {av_register_all();
 166     av_log_set_level(AV_LOG_ERROR);
 167     done_init = 1;}
 168
 169     file = (FilePtr)calloc(1, sizeof(*file));
 170     if(file && avformat_open_input(&file->FmtCtx, fname, NULL, NULL) == 0)
 171     {
 172         /* After opening, we must search for the stream information because not
 173          * all formats will have it in stream headers */
 174         if(avformat_find_stream_info(file->FmtCtx, NULL) >= 0)
 175             return file;
 176         av_close_input_file(file->FmtCtx);
 177     }
 178
 179     free(file);
 180     return NULL;
 181 }
 182
 183 FilePtr openAVData(const char *name, char *buffer, size_t buffer_len)
 184 {
 185     FilePtr file;
 186
 187     if(!done_init) {av_register_all();
 188     av_log_set_level(AV_LOG_ERROR);
 189     done_init = 1;}
 190
 191     if(!name)
 192         name = "";
 193
 194     file = (FilePtr)calloc(1, sizeof(*file));
 195     if(file && (file->FmtCtx=avformat_alloc_context()) != NULL)
 196     {
 197         file->membuf.buffer = buffer;
 198         file->membuf.length = buffer_len;
 199         file->membuf.pos = 0;
 200
 201         file->FmtCtx->pb = avio_alloc_context(NULL, 0, 0, &file->membuf,
 202                                               MemData_read, MemData_write,
 203                                               MemData_seek);
 204         if(file->FmtCtx->pb && avformat_open_input(&file->FmtCtx, name, NULL, NULL) == 0)
 205         {
 206             if(avformat_find_stream_info(file->FmtCtx, NULL) >= 0)
 207                 return file;
 208             av_close_input_file(file->FmtCtx);
 209             file->FmtCtx = NULL;
 210         }
 211         if(file->FmtCtx)
 212             avformat_free_context(file->FmtCtx);
 213         file->FmtCtx = NULL;
 214     }
 215
 216     free(file);
 217     return NULL;
 218 }
 219
 220 FilePtr openAVCustom(const char *name, void *user_data,
 221                      int (*read_packet)(void *user_data, uint8_t *buf, int buf_size),
 222                      int (*write_packet)(void *user_data, uint8_t *buf, int buf_size),
 223                      int64_t (*seek)(void *user_data, int64_t offset, int whence))
 224 {
 225     FilePtr file;
 226
 227     if(!done_init) {av_register_all();
 228     av_log_set_level(AV_LOG_ERROR);
 229     done_init = 1;}
 230
 231     if(!name)
 232         name = "";
 233
 234     file = (FilePtr)calloc(1, sizeof(*file));
 235     if(file && (file->FmtCtx=avformat_alloc_context()) != NULL)
 236     {
 237         file->FmtCtx->pb = avio_alloc_context(NULL, 0, 0, user_data,
 238                                               read_packet, write_packet, seek);
 239         if(file->FmtCtx->pb && avformat_open_input(&file->FmtCtx, name, NULL, NULL) == 0)
 240         {
 241             if(avformat_find_stream_info(file->FmtCtx, NULL) >= 0)
 242                 return file;
 243             av_close_input_file(file->FmtCtx);
 244             file->FmtCtx = NULL;
 245         }
 246         if(file->FmtCtx)
 247             avformat_free_context(file->FmtCtx);
 248         file->FmtCtx = NULL;
 249     }
 250
 251     free(file);
 252     return NULL;
 253 }
 254
 255
 256 void closeAVFile(FilePtr file)
 257 {
 258     size_t i;
 259
 260     if(!file) return;
 261
 262     for(i = 0;i < file->StreamsSize;i++)
 263     {
 264         StreamPtr stream = file->Streams[i];
 265
 266         while(stream->Packets)
 267         {
 268             struct PacketList *self;
 269
 270             self = stream->Packets;
 271             stream->Packets = self->next;
 272
 273             av_free_packet(&self->pkt);
 274             av_free(self);
 275         }
 276
 277         avcodec_close(stream->CodecCtx);
 278         av_free(stream->DecodedData);
 279         free(stream);
 280     }
 281     free(file->Streams);
 282
 283     av_close_input_file(file->FmtCtx);
 284     free(file);
 285 }
 286
 287
 288 int getAVFileInfo(FilePtr file, int *numaudiostreams)
 289 {
 290     unsigned int i;
 291     int audiocount = 0;
 292
 293     if(!file) return 1;
 294     for(i = 0;i < file->FmtCtx->nb_streams;i++)
 295     {
 296         if(file->FmtCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_AUDIO)
 297             audiocount++;
 298     }
 299     *numaudiostreams = audiocount;
 300     return 0;
 301 }
 302
 303 StreamPtr getAVAudioStream(FilePtr file, int streamnum)
 304 {
 305     unsigned int i;
 306     if(!file) return NULL;
 307     for(i = 0;i < file->FmtCtx->nb_streams;i++)
 308     {
 309         if(file->FmtCtx->streams[i]->codec->codec_type != AVMEDIA_TYPE_AUDIO)
 310             continue;
 311
 312         if(streamnum == 0)
 313         {
 314             StreamPtr stream;
 315             AVCodec *codec;
 316             void *temp;
 317             size_t j;
 318
 319             /* Found the requested stream. Check if a handle to this stream
 320              * already exists and return it if it does */
 321             for(j = 0;j < file->StreamsSize;j++)
 322             {
 323                 if(file->Streams[j]->StreamIdx == (int)i)
 324                     return file->Streams[j];
 325             }
 326
 327             /* Doesn't yet exist. Now allocate a new stream object and fill in
 328              * its info */
 329             stream = (StreamPtr)calloc(1, sizeof(*stream));
 330             if(!stream) return NULL;
 331
 332             stream->parent = file;
 333             stream->CodecCtx = file->FmtCtx->streams[i]->codec;
 334             stream->StreamIdx = i;
 335
 336             /* Try to find the codec for the given codec ID, and open it */
 337             codec = avcodec_find_decoder(stream->CodecCtx->codec_id);
 338             if(!codec || avcodec_open(stream->CodecCtx, codec) < 0)
 339             {
 340                 free(stream);
 341                 return NULL;
 342             }
 343
 344             /* Allocate space for the decoded data to be stored in before it
 345              * gets passed to the app */
 346             stream->DecodedData = (char*)av_malloc(AVCODEC_MAX_AUDIO_FRAME_SIZE);
 347             if(!stream->DecodedData)
 348             {
 349                 avcodec_close(stream->CodecCtx);
 350                 free(stream);
 351                 return NULL;
 352             }
 353
 354             /* Append the new stream object to the stream list. The original
 355              * pointer will remain valid if realloc fails, so we need to use
 356              * another pointer to watch for errors and not leak memory */
 357             temp = realloc(file->Streams, (file->StreamsSize+1) *
 358                                           sizeof(*file->Streams));
 359             if(!temp)
 360             {
 361                 avcodec_close(stream->CodecCtx);
 362                 av_free(stream->DecodedData);
 363                 free(stream);
 364                 return NULL;
 365             }
 366             file->Streams = (StreamPtr*)temp;
 367             file->Streams[file->StreamsSize++] = stream;
 368             return stream;
 369         }
 370         streamnum--;
 371     }
 372     return NULL;
 373 }
 374
 375 int getAVAudioInfo(StreamPtr stream, ALuint *rate, ALenum *channels, ALenum *type)
 376 {
 377     if(!stream || stream->CodecCtx->codec_type != AVMEDIA_TYPE_AUDIO)
 378         return 1;
 379
 380     /* Get the sample type for OpenAL given the format detected by ffmpeg. */
 381     if(stream->CodecCtx->sample_fmt == AV_SAMPLE_FMT_U8)
 382         *type = AL_UNSIGNED_BYTE_SOFT;
 383     else if(stream->CodecCtx->sample_fmt == AV_SAMPLE_FMT_S16)
 384         *type = AL_SHORT_SOFT;
 385     else if(stream->CodecCtx->sample_fmt == AV_SAMPLE_FMT_S32)
 386         *type = AL_INT_SOFT;
 387     else if(stream->CodecCtx->sample_fmt == AV_SAMPLE_FMT_FLT)
 388         *type = AL_FLOAT_SOFT;
 389     else if(stream->CodecCtx->sample_fmt == AV_SAMPLE_FMT_DBL)
 390         *type = AL_DOUBLE_SOFT;
 391     else
 392     {
 393         fprintf(stderr, "Unsupported ffmpeg sample format: %s\n",
 394                 av_get_sample_fmt_name(stream->CodecCtx->sample_fmt));
 395         return 1;
 396     }
 397
 398     /* Get the OpenAL channel configuration using the channel layout detected
 399      * by ffmpeg. NOTE: some file types may not specify a channel layout. In
 400      * that case, one must be guessed based on the channel count. */
 401     if(stream->CodecCtx->channel_layout == AV_CH_LAYOUT_MONO)
 402         *channels = AL_MONO_SOFT;
 403     else if(stream->CodecCtx->channel_layout == AV_CH_LAYOUT_STEREO)
 404         *channels = AL_STEREO_SOFT;
 405     else if(stream->CodecCtx->channel_layout == AV_CH_LAYOUT_QUAD)
 406         *channels = AL_QUAD_SOFT;
 407     else if(stream->CodecCtx->channel_layout == AV_CH_LAYOUT_5POINT1_BACK)
 408         *channels = AL_5POINT1_SOFT;
 409     else if(stream->CodecCtx->channel_layout == AV_CH_LAYOUT_7POINT1)
 410         *channels = AL_7POINT1_SOFT;
 411     else if(stream->CodecCtx->channel_layout == 0)
 412     {
 413         /* Unknown channel layout. Try to guess. */
 414         if(stream->CodecCtx->channels == 1)
 415             *channels = AL_MONO_SOFT;
 416         else if(stream->CodecCtx->channels == 2)
 417             *channels = AL_STEREO_SOFT;
 418         else
 419         {
 420             fprintf(stderr, "Unsupported ffmpeg raw channel count: %d\n",
 421                     stream->CodecCtx->channels);
 422             return 1;
 423         }
 424     }
 425     else
 426     {
 427         char str[1024];
 428         av_get_channel_layout_string(str, sizeof(str), stream->CodecCtx->channels,
 429                                      stream->CodecCtx->channel_layout);
 430         fprintf(stderr, "Unsupported ffmpeg channel layout: %s\n", str);
 431         return 1;
 432     }
 433
 434     *rate = stream->CodecCtx->sample_rate;
 435
 436     return 0;
 437 }
 438
 439
 440 /* Used by getAV*Data to search for more compressed data, and buffer it in the
 441  * correct stream. It won't buffer data for streams that the app doesn't have a
 442  * handle for. */
 443 static int getNextPacket(FilePtr file, int streamidx)
 444 {
 445     struct PacketList *packet;
 446
 447     packet = (struct PacketList*)av_malloc(sizeof(*packet));
 448     packet->next = NULL;
 449
 450 next_packet:
 451     while(av_read_frame(file->FmtCtx, &packet->pkt) >= 0)
 452     {
 453         StreamPtr *iter = file->Streams;
 454         StreamPtr *iter_end = iter + file->StreamsSize;
 455
 456         /* Check each stream the user has a handle for, looking for the one
 457          * this packet belongs to */
 458         while(iter != iter_end)
 459         {
 460             if((*iter)->StreamIdx == packet->pkt.stream_index)
 461             {
 462                 struct PacketList **last;
 463
 464                 last = &(*iter)->Packets;
 465                 while(*last != NULL)
 466                     last = &(*last)->next;
 467
 468                 *last = packet;
 469                 if((*iter)->StreamIdx == streamidx)
 470                     return 1;
 471
 472                 packet = (struct PacketList*)av_malloc(sizeof(*packet));
 473                 packet->next = NULL;
 474                 goto next_packet;
 475             }
 476             iter++;
 477         }
 478         /* Free the packet and look for another */
 479         av_free_packet(&packet->pkt);
 480     }
 481
 482     av_free(packet);
 483     return 0;
 484 }
 485
 486 void *getAVAudioData(StreamPtr stream, size_t *length)
 487 {
 488     int size;
 489     int len;
 490
 491     if(length) *length = 0;
 492
 493     if(!stream || stream->CodecCtx->codec_type != AVMEDIA_TYPE_AUDIO)
 494         return NULL;
 495
 496     stream->DecodedDataSize = 0;
 497
 498 next_packet:
 499     if(!stream->Packets && !getNextPacket(stream->parent, stream->StreamIdx))
 500         return NULL;
 501
 502     /* Decode some data, and check for errors */
 503     size = AVCODEC_MAX_AUDIO_FRAME_SIZE;
 504     while((len=avcodec_decode_audio3(stream->CodecCtx,
 505                                      (int16_t*)stream->DecodedData, &size,
 506                                      &stream->Packets->pkt)) == 0)
 507     {
 508         struct PacketList *self;
 509
 510         if(size > 0)
 511             break;
 512
 513         /* Packet went unread and no data was given? Drop it and try the next,
 514          * I guess... */
 515         self = stream->Packets;
 516         stream->Packets = self->next;
 517
 518         av_free_packet(&self->pkt);
 519         av_free(self);
 520
 521         if(!stream->Packets)
 522             goto next_packet;
 523
 524         size = AVCODEC_MAX_AUDIO_FRAME_SIZE;
 525     }
 526
 527     if(len < 0)
 528         return NULL;
 529
 530     if(len < stream->Packets->pkt.size)
 531     {
 532         /* Move the unread data to the front and clear the end bits */
 533         int remaining = stream->Packets->pkt.size - len;
 534         memmove(stream->Packets->pkt.data, &stream->Packets->pkt.data[len],
 535                 remaining);
 536         memset(&stream->Packets->pkt.data[remaining], 0,
 537                stream->Packets->pkt.size - remaining);
 538         stream->Packets->pkt.size -= len;
 539     }
 540     else
 541     {
 542         struct PacketList *self;
 543
 544         self = stream->Packets;
 545         stream->Packets = self->next;
 546
 547         av_free_packet(&self->pkt);
 548         av_free(self);
 549     }
 550
 551     if(size == 0)
 552         goto next_packet;
 553
 554     /* Set the output buffer size */
 555     stream->DecodedDataSize = size;
 556     if(length) *length = stream->DecodedDataSize;
 557
 558     return stream->DecodedData;
 559 }
 560
 561 size_t readAVAudioData(StreamPtr stream, void *data, size_t length)
 562 {
 563     size_t dec = 0;
 564
 565     if(!stream || stream->CodecCtx->codec_type != AVMEDIA_TYPE_AUDIO)
 566         return 0;
 567
 568     while(dec < length)
 569     {
 570         /* If there's no decoded data, find some */
 571         if(stream->DecodedDataSize == 0)
 572         {
 573             if(getAVAudioData(stream, NULL) == NULL)
 574                 break;
 575         }
 576
 577         if(stream->DecodedDataSize > 0)
 578         {
 579             /* Get the amount of bytes remaining to be written, and clamp to
 580              * the amount of decoded data we have */
 581             size_t rem = length-dec;
 582             if(rem > stream->DecodedDataSize)
 583                 rem = stream->DecodedDataSize;
 584
 585             /* Copy the data to the app's buffer and increment */
 586             if(data != NULL)
 587             {
 588                 memcpy(data, stream->DecodedData, rem);
 589                 data = (char*)data + rem;
 590             }
 591             dec += rem;
 592
 593             /* If there's any decoded data left, move it to the front of the
 594              * buffer for next time */
 595             if(rem < stream->DecodedDataSize)
 596                 memmove(stream->DecodedData, &stream->DecodedData[rem],
 597                         stream->DecodedDataSize - rem);
 598             stream->DecodedDataSize -= rem;
 599         }
 600     }
 601
 602     /* Return the number of bytes we were able to get */
 603     return dec;
 604 }
 605
 606 void *decodeAVAudioStream(StreamPtr stream, size_t *length)
 607 {
 608     char *outbuf = NULL;
 609     size_t buflen = 0;
 610     void *inbuf;
 611     size_t got;
 612
 613     *length = 0;
 614     if(!stream || stream->CodecCtx->codec_type != AVMEDIA_TYPE_AUDIO)
 615         return NULL;
 616
 617     while((inbuf=getAVAudioData(stream, &got)) != NULL && got > 0)
 618     {
 619         void *ptr;
 620
 621         ptr = realloc(outbuf, NextPowerOf2(buflen+got));
 622         if(ptr == NULL)
 623             break;
 624         outbuf = (char*)ptr;
 625
 626         memcpy(&outbuf[buflen], inbuf, got);
 627         buflen += got;
 628     }
 629     outbuf = (char*)realloc(outbuf, buflen);
 630
 631     *length = buflen;
 632     return outbuf;
 633 }