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 || (uint64_t)offset > membuf->length)
 102                 return -1;
 103             membuf->pos = offset;
 104             break;
 105
 106         case SEEK_CUR:
 107             if((offset >= 0 && (uint64_t)offset > membuf->length-membuf->pos) ||
 108                (offset < 0 && (uint64_t)(-offset) > membuf->pos))
 109                 return -1;
 110             membuf->pos += offset;
 111             break;
 112
 113         case SEEK_END:
 114             if(offset > 0 || (uint64_t)(-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         avformat_close_input(&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             avformat_close_input(&file->FmtCtx);
 209         }
 210         if(file->FmtCtx)
 211             avformat_free_context(file->FmtCtx);
 212         file->FmtCtx = NULL;
 213     }
 214
 215     free(file);
 216     return NULL;
 217 }
 218
 219 FilePtr openAVCustom(const char *name, void *user_data,
 220                      int (*read_packet)(void *user_data, uint8_t *buf, int buf_size),
 221                      int (*write_packet)(void *user_data, uint8_t *buf, int buf_size),
 222                      int64_t (*seek)(void *user_data, int64_t offset, int whence))
 223 {
 224     FilePtr file;
 225
 226     if(!done_init) {av_register_all();
 227     av_log_set_level(AV_LOG_ERROR);
 228     done_init = 1;}
 229
 230     if(!name)
 231         name = "";
 232
 233     file = (FilePtr)calloc(1, sizeof(*file));
 234     if(file && (file->FmtCtx=avformat_alloc_context()) != NULL)
 235     {
 236         file->FmtCtx->pb = avio_alloc_context(NULL, 0, 0, user_data,
 237                                               read_packet, write_packet, seek);
 238         if(file->FmtCtx->pb && avformat_open_input(&file->FmtCtx, name, NULL, NULL) == 0)
 239         {
 240             if(avformat_find_stream_info(file->FmtCtx, NULL) >= 0)
 241                 return file;
 242             avformat_close_input(&file->FmtCtx);
 243         }
 244         if(file->FmtCtx)
 245             avformat_free_context(file->FmtCtx);
 246         file->FmtCtx = NULL;
 247     }
 248
 249     free(file);
 250     return NULL;
 251 }
 252
 253
 254 void closeAVFile(FilePtr file)
 255 {
 256     size_t i;
 257
 258     if(!file) return;
 259
 260     for(i = 0;i < file->StreamsSize;i++)
 261     {
 262         StreamPtr stream = file->Streams[i];
 263
 264         while(stream->Packets)
 265         {
 266             struct PacketList *self;
 267
 268             self = stream->Packets;
 269             stream->Packets = self->next;
 270
 271             av_free_packet(&self->pkt);
 272             av_free(self);
 273         }
 274
 275         avcodec_close(stream->CodecCtx);
 276         av_free(stream->DecodedData);
 277         free(stream);
 278     }
 279     free(file->Streams);
 280
 281     avformat_close_input(&file->FmtCtx);
 282     free(file);
 283 }
 284
 285
 286 int getAVFileInfo(FilePtr file, int *numaudiostreams)
 287 {
 288     unsigned int i;
 289     int audiocount = 0;
 290
 291     if(!file) return 1;
 292     for(i = 0;i < file->FmtCtx->nb_streams;i++)
 293     {
 294         if(file->FmtCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_AUDIO)
 295             audiocount++;
 296     }
 297     *numaudiostreams = audiocount;
 298     return 0;
 299 }
 300
 301 StreamPtr getAVAudioStream(FilePtr file, int streamnum)
 302 {
 303     unsigned int i;
 304     if(!file) return NULL;
 305     for(i = 0;i < file->FmtCtx->nb_streams;i++)
 306     {
 307         if(file->FmtCtx->streams[i]->codec->codec_type != AVMEDIA_TYPE_AUDIO)
 308             continue;
 309
 310         if(streamnum == 0)
 311         {
 312             StreamPtr stream;
 313             AVCodec *codec;
 314             void *temp;
 315             size_t j;
 316
 317             /* Found the requested stream. Check if a handle to this stream
 318              * already exists and return it if it does */
 319             for(j = 0;j < file->StreamsSize;j++)
 320             {
 321                 if(file->Streams[j]->StreamIdx == (int)i)
 322                     return file->Streams[j];
 323             }
 324
 325             /* Doesn't yet exist. Now allocate a new stream object and fill in
 326              * its info */
 327             stream = (StreamPtr)calloc(1, sizeof(*stream));
 328             if(!stream) return NULL;
 329
 330             stream->parent = file;
 331             stream->CodecCtx = file->FmtCtx->streams[i]->codec;
 332             stream->StreamIdx = i;
 333
 334             /* Try to find the codec for the given codec ID, and open it */
 335             codec = avcodec_find_decoder(stream->CodecCtx->codec_id);
 336             if(!codec || avcodec_open2(stream->CodecCtx, codec, NULL) < 0)
 337             {
 338                 free(stream);
 339                 return NULL;
 340             }
 341
 342             /* Allocate space for the decoded data to be stored in before it
 343              * gets passed to the app */
 344             stream->DecodedData = (char*)av_malloc(AVCODEC_MAX_AUDIO_FRAME_SIZE);
 345             if(!stream->DecodedData)
 346             {
 347                 avcodec_close(stream->CodecCtx);
 348                 free(stream);
 349                 return NULL;
 350             }
 351
 352             /* Append the new stream object to the stream list. The original
 353              * pointer will remain valid if realloc fails, so we need to use
 354              * another pointer to watch for errors and not leak memory */
 355             temp = realloc(file->Streams, (file->StreamsSize+1) *
 356                                           sizeof(*file->Streams));
 357             if(!temp)
 358             {
 359                 avcodec_close(stream->CodecCtx);
 360                 av_free(stream->DecodedData);
 361                 free(stream);
 362                 return NULL;
 363             }
 364             file->Streams = (StreamPtr*)temp;
 365             file->Streams[file->StreamsSize++] = stream;
 366             return stream;
 367         }
 368         streamnum--;
 369     }
 370     return NULL;
 371 }
 372
 373 int getAVAudioInfo(StreamPtr stream, ALuint *rate, ALenum *channels, ALenum *type)
 374 {
 375     if(!stream || stream->CodecCtx->codec_type != AVMEDIA_TYPE_AUDIO)
 376         return 1;
 377
 378     /* Get the sample type for OpenAL given the format detected by ffmpeg. */
 379     if(stream->CodecCtx->sample_fmt == AV_SAMPLE_FMT_U8)
 380         *type = AL_UNSIGNED_BYTE_SOFT;
 381     else if(stream->CodecCtx->sample_fmt == AV_SAMPLE_FMT_S16)
 382         *type = AL_SHORT_SOFT;
 383     else if(stream->CodecCtx->sample_fmt == AV_SAMPLE_FMT_S32)
 384         *type = AL_INT_SOFT;
 385     else if(stream->CodecCtx->sample_fmt == AV_SAMPLE_FMT_FLT)
 386         *type = AL_FLOAT_SOFT;
 387     else if(stream->CodecCtx->sample_fmt == AV_SAMPLE_FMT_DBL)
 388         *type = AL_DOUBLE_SOFT;
 389     else
 390     {
 391         fprintf(stderr, "Unsupported ffmpeg sample format: %s\n",
 392                 av_get_sample_fmt_name(stream->CodecCtx->sample_fmt));
 393         return 1;
 394     }
 395
 396     /* Get the OpenAL channel configuration using the channel layout detected
 397      * by ffmpeg. NOTE: some file types may not specify a channel layout. In
 398      * that case, one must be guessed based on the channel count. */
 399     if(stream->CodecCtx->channel_layout == AV_CH_LAYOUT_MONO)
 400         *channels = AL_MONO_SOFT;
 401     else if(stream->CodecCtx->channel_layout == AV_CH_LAYOUT_STEREO)
 402         *channels = AL_STEREO_SOFT;
 403     else if(stream->CodecCtx->channel_layout == AV_CH_LAYOUT_QUAD)
 404         *channels = AL_QUAD_SOFT;
 405     else if(stream->CodecCtx->channel_layout == AV_CH_LAYOUT_5POINT1_BACK)
 406         *channels = AL_5POINT1_SOFT;
 407     else if(stream->CodecCtx->channel_layout == AV_CH_LAYOUT_7POINT1)
 408         *channels = AL_7POINT1_SOFT;
 409     else if(stream->CodecCtx->channel_layout == 0)
 410     {
 411         /* Unknown channel layout. Try to guess. */
 412         if(stream->CodecCtx->channels == 1)
 413             *channels = AL_MONO_SOFT;
 414         else if(stream->CodecCtx->channels == 2)
 415             *channels = AL_STEREO_SOFT;
 416         else
 417         {
 418             fprintf(stderr, "Unsupported ffmpeg raw channel count: %d\n",
 419                     stream->CodecCtx->channels);
 420             return 1;
 421         }
 422     }
 423     else
 424     {
 425         char str[1024];
 426         av_get_channel_layout_string(str, sizeof(str), stream->CodecCtx->channels,
 427                                      stream->CodecCtx->channel_layout);
 428         fprintf(stderr, "Unsupported ffmpeg channel layout: %s\n", str);
 429         return 1;
 430     }
 431
 432     *rate = stream->CodecCtx->sample_rate;
 433
 434     return 0;
 435 }
 436
 437
 438 /* Used by getAV*Data to search for more compressed data, and buffer it in the
 439  * correct stream. It won't buffer data for streams that the app doesn't have a
 440  * handle for. */
 441 static int getNextPacket(FilePtr file, int streamidx)
 442 {
 443     struct PacketList *packet;
 444
 445     packet = (struct PacketList*)av_malloc(sizeof(*packet));
 446     packet->next = NULL;
 447
 448 next_packet:
 449     while(av_read_frame(file->FmtCtx, &packet->pkt) >= 0)
 450     {
 451         StreamPtr *iter = file->Streams;
 452         StreamPtr *iter_end = iter + file->StreamsSize;
 453
 454         /* Check each stream the user has a handle for, looking for the one
 455          * this packet belongs to */
 456         while(iter != iter_end)
 457         {
 458             if((*iter)->StreamIdx == packet->pkt.stream_index)
 459             {
 460                 struct PacketList **last;
 461
 462                 last = &(*iter)->Packets;
 463                 while(*last != NULL)
 464                     last = &(*last)->next;
 465
 466                 *last = packet;
 467                 if((*iter)->StreamIdx == streamidx)
 468                     return 1;
 469
 470                 packet = (struct PacketList*)av_malloc(sizeof(*packet));
 471                 packet->next = NULL;
 472                 goto next_packet;
 473             }
 474             iter++;
 475         }
 476         /* Free the packet and look for another */
 477         av_free_packet(&packet->pkt);
 478     }
 479
 480     av_free(packet);
 481     return 0;
 482 }
 483
 484 void *getAVAudioData(StreamPtr stream, size_t *length)
 485 {
 486     int size;
 487     int len;
 488
 489     if(length) *length = 0;
 490
 491     if(!stream || stream->CodecCtx->codec_type != AVMEDIA_TYPE_AUDIO)
 492         return NULL;
 493
 494     stream->DecodedDataSize = 0;
 495
 496 next_packet:
 497     if(!stream->Packets && !getNextPacket(stream->parent, stream->StreamIdx))
 498         return NULL;
 499
 500     /* Decode some data, and check for errors */
 501     size = AVCODEC_MAX_AUDIO_FRAME_SIZE;
 502     while((len=avcodec_decode_audio3(stream->CodecCtx,
 503                                      (int16_t*)stream->DecodedData, &size,
 504                                      &stream->Packets->pkt)) == 0)
 505     {
 506         struct PacketList *self;
 507
 508         if(size > 0)
 509             break;
 510
 511         /* Packet went unread and no data was given? Drop it and try the next,
 512          * I guess... */
 513         self = stream->Packets;
 514         stream->Packets = self->next;
 515
 516         av_free_packet(&self->pkt);
 517         av_free(self);
 518
 519         if(!stream->Packets)
 520             goto next_packet;
 521
 522         size = AVCODEC_MAX_AUDIO_FRAME_SIZE;
 523     }
 524
 525     if(len < 0)
 526         return NULL;
 527
 528     if(len < stream->Packets->pkt.size)
 529     {
 530         /* Move the unread data to the front and clear the end bits */
 531         int remaining = stream->Packets->pkt.size - len;
 532         memmove(stream->Packets->pkt.data, &stream->Packets->pkt.data[len],
 533                 remaining);
 534         memset(&stream->Packets->pkt.data[remaining], 0,
 535                stream->Packets->pkt.size - remaining);
 536         stream->Packets->pkt.size -= len;
 537     }
 538     else
 539     {
 540         struct PacketList *self;
 541
 542         self = stream->Packets;
 543         stream->Packets = self->next;
 544
 545         av_free_packet(&self->pkt);
 546         av_free(self);
 547     }
 548
 549     if(size == 0)
 550         goto next_packet;
 551
 552     /* Set the output buffer size */
 553     stream->DecodedDataSize = size;
 554     if(length) *length = stream->DecodedDataSize;
 555
 556     return stream->DecodedData;
 557 }
 558
 559 size_t readAVAudioData(StreamPtr stream, void *data, size_t length)
 560 {
 561     size_t dec = 0;
 562
 563     if(!stream || stream->CodecCtx->codec_type != AVMEDIA_TYPE_AUDIO)
 564         return 0;
 565
 566     while(dec < length)
 567     {
 568         /* If there's no decoded data, find some */
 569         if(stream->DecodedDataSize == 0)
 570         {
 571             if(getAVAudioData(stream, NULL) == NULL)
 572                 break;
 573         }
 574
 575         if(stream->DecodedDataSize > 0)
 576         {
 577             /* Get the amount of bytes remaining to be written, and clamp to
 578              * the amount of decoded data we have */
 579             size_t rem = length-dec;
 580             if(rem > stream->DecodedDataSize)
 581                 rem = stream->DecodedDataSize;
 582
 583             /* Copy the data to the app's buffer and increment */
 584             if(data != NULL)
 585             {
 586                 memcpy(data, stream->DecodedData, rem);
 587                 data = (char*)data + rem;
 588             }
 589             dec += rem;
 590
 591             /* If there's any decoded data left, move it to the front of the
 592              * buffer for next time */
 593             if(rem < stream->DecodedDataSize)
 594                 memmove(stream->DecodedData, &stream->DecodedData[rem],
 595                         stream->DecodedDataSize - rem);
 596             stream->DecodedDataSize -= rem;
 597         }
 598     }
 599
 600     /* Return the number of bytes we were able to get */
 601     return dec;
 602 }
 603
 604 void *decodeAVAudioStream(StreamPtr stream, size_t *length)
 605 {
 606     char *outbuf = NULL;
 607     size_t buflen = 0;
 608     void *inbuf;
 609     size_t got;
 610
 611     *length = 0;
 612     if(!stream || stream->CodecCtx->codec_type != AVMEDIA_TYPE_AUDIO)
 613         return NULL;
 614
 615     while((inbuf=getAVAudioData(stream, &got)) != NULL && got > 0)
 616     {
 617         void *ptr;
 618
 619         ptr = realloc(outbuf, NextPowerOf2(buflen+got));
 620         if(ptr == NULL)
 621             break;
 622         outbuf = (char*)ptr;
 623
 624         memcpy(&outbuf[buflen], inbuf, got);
 625         buflen += got;
 626     }
 627     outbuf = (char*)realloc(outbuf, buflen);
 628
 629     *length = buflen;
 630     return outbuf;
 631 }