2 * FFmpeg Decoder Helpers
4 * Copyright (c) 2011 by Chris Robinson <chris.kcat@gmail.com>
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:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
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
25 /* This file contains routines for helping to decode audio using libavformat
26 * and libavcodec (ffmpeg). There's very little OpenAL-specific code here. */
38 #include "alhelpers.h"
42 static size_t NextPowerOf2(size_t value
)
65 static int MemData_read(void *opaque
, uint8_t *buf
, int buf_size
)
67 struct MemData
*membuf
= (struct MemData
*)opaque
;
68 int rem
= membuf
->length
- membuf
->pos
;
73 memcpy(buf
, &membuf
->buffer
[membuf
->pos
], rem
);
79 static int MemData_write(void *opaque
, uint8_t *buf
, int buf_size
)
81 struct MemData
*membuf
= (struct MemData
*)opaque
;
82 int rem
= membuf
->length
- membuf
->pos
;
87 memcpy(&membuf
->buffer
[membuf
->pos
], buf
, rem
);
93 static int64_t MemData_seek(void *opaque
, int64_t offset
, int whence
)
95 struct MemData
*membuf
= (struct MemData
*)opaque
;
97 whence
&= ~AVSEEK_FORCE
;
101 if(offset
< 0 || (uint64_t)offset
> membuf
->length
)
103 membuf
->pos
= offset
;
107 if((offset
>= 0 && (uint64_t)offset
> membuf
->length
-membuf
->pos
) ||
108 (offset
< 0 && (uint64_t)(-offset
) > membuf
->pos
))
110 membuf
->pos
+= offset
;
114 if(offset
> 0 || (uint64_t)(-offset
) > membuf
->length
)
116 membuf
->pos
= membuf
->length
+ offset
;
120 return membuf
->length
;
132 struct PacketList
*next
;
136 AVCodecContext
*CodecCtx
;
139 struct PacketList
*Packets
;
142 size_t DecodedDataSize
;
148 AVFormatContext
*FmtCtx
;
153 struct MemData membuf
;
157 static int done_init
= 0;
159 FilePtr
openAVFile(const char *fname
)
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
);
169 file
= (FilePtr
)calloc(1, sizeof(*file
));
170 if(file
&& avformat_open_input(&file
->FmtCtx
, fname
, NULL
, NULL
) == 0)
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)
176 avformat_close_input(&file
->FmtCtx
);
183 FilePtr
openAVData(const char *name
, char *buffer
, size_t buffer_len
)
187 if(!done_init
) {av_register_all();
188 av_log_set_level(AV_LOG_ERROR
);
194 file
= (FilePtr
)calloc(1, sizeof(*file
));
195 if(file
&& (file
->FmtCtx
=avformat_alloc_context()) != NULL
)
197 file
->membuf
.buffer
= buffer
;
198 file
->membuf
.length
= buffer_len
;
199 file
->membuf
.pos
= 0;
201 file
->FmtCtx
->pb
= avio_alloc_context(NULL
, 0, 0, &file
->membuf
,
202 MemData_read
, MemData_write
,
204 if(file
->FmtCtx
->pb
&& avformat_open_input(&file
->FmtCtx
, name
, NULL
, NULL
) == 0)
206 if(avformat_find_stream_info(file
->FmtCtx
, NULL
) >= 0)
208 avformat_close_input(&file
->FmtCtx
);
211 avformat_free_context(file
->FmtCtx
);
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
))
226 if(!done_init
) {av_register_all();
227 av_log_set_level(AV_LOG_ERROR
);
233 file
= (FilePtr
)calloc(1, sizeof(*file
));
234 if(file
&& (file
->FmtCtx
=avformat_alloc_context()) != NULL
)
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)
240 if(avformat_find_stream_info(file
->FmtCtx
, NULL
) >= 0)
242 avformat_close_input(&file
->FmtCtx
);
245 avformat_free_context(file
->FmtCtx
);
254 void closeAVFile(FilePtr file
)
260 for(i
= 0;i
< file
->StreamsSize
;i
++)
262 StreamPtr stream
= file
->Streams
[i
];
264 while(stream
->Packets
)
266 struct PacketList
*self
;
268 self
= stream
->Packets
;
269 stream
->Packets
= self
->next
;
271 av_free_packet(&self
->pkt
);
275 avcodec_close(stream
->CodecCtx
);
276 av_free(stream
->DecodedData
);
281 avformat_close_input(&file
->FmtCtx
);
286 int getAVFileInfo(FilePtr file
, int *numaudiostreams
)
292 for(i
= 0;i
< file
->FmtCtx
->nb_streams
;i
++)
294 if(file
->FmtCtx
->streams
[i
]->codec
->codec_type
== AVMEDIA_TYPE_AUDIO
)
297 *numaudiostreams
= audiocount
;
301 StreamPtr
getAVAudioStream(FilePtr file
, int streamnum
)
304 if(!file
) return NULL
;
305 for(i
= 0;i
< file
->FmtCtx
->nb_streams
;i
++)
307 if(file
->FmtCtx
->streams
[i
]->codec
->codec_type
!= AVMEDIA_TYPE_AUDIO
)
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
++)
321 if(file
->Streams
[j
]->StreamIdx
== (int)i
)
322 return file
->Streams
[j
];
325 /* Doesn't yet exist. Now allocate a new stream object and fill in
327 stream
= (StreamPtr
)calloc(1, sizeof(*stream
));
328 if(!stream
) return NULL
;
330 stream
->parent
= file
;
331 stream
->CodecCtx
= file
->FmtCtx
->streams
[i
]->codec
;
332 stream
->StreamIdx
= i
;
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)
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
)
347 avcodec_close(stream
->CodecCtx
);
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
));
359 avcodec_close(stream
->CodecCtx
);
360 av_free(stream
->DecodedData
);
364 file
->Streams
= (StreamPtr
*)temp
;
365 file
->Streams
[file
->StreamsSize
++] = stream
;
373 int getAVAudioInfo(StreamPtr stream
, ALuint
*rate
, ALenum
*channels
, ALenum
*type
)
375 if(!stream
|| stream
->CodecCtx
->codec_type
!= AVMEDIA_TYPE_AUDIO
)
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
)
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
;
391 fprintf(stderr
, "Unsupported ffmpeg sample format: %s\n",
392 av_get_sample_fmt_name(stream
->CodecCtx
->sample_fmt
));
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)
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
;
418 fprintf(stderr
, "Unsupported ffmpeg raw channel count: %d\n",
419 stream
->CodecCtx
->channels
);
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
);
432 *rate
= stream
->CodecCtx
->sample_rate
;
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
441 static int getNextPacket(FilePtr file
, int streamidx
)
443 struct PacketList
*packet
;
445 packet
= (struct PacketList
*)av_malloc(sizeof(*packet
));
449 while(av_read_frame(file
->FmtCtx
, &packet
->pkt
) >= 0)
451 StreamPtr
*iter
= file
->Streams
;
452 StreamPtr
*iter_end
= iter
+ file
->StreamsSize
;
454 /* Check each stream the user has a handle for, looking for the one
455 * this packet belongs to */
456 while(iter
!= iter_end
)
458 if((*iter
)->StreamIdx
== packet
->pkt
.stream_index
)
460 struct PacketList
**last
;
462 last
= &(*iter
)->Packets
;
464 last
= &(*last
)->next
;
467 if((*iter
)->StreamIdx
== streamidx
)
470 packet
= (struct PacketList
*)av_malloc(sizeof(*packet
));
476 /* Free the packet and look for another */
477 av_free_packet(&packet
->pkt
);
484 void *getAVAudioData(StreamPtr stream
, size_t *length
)
489 if(length
) *length
= 0;
491 if(!stream
|| stream
->CodecCtx
->codec_type
!= AVMEDIA_TYPE_AUDIO
)
494 stream
->DecodedDataSize
= 0;
497 if(!stream
->Packets
&& !getNextPacket(stream
->parent
, stream
->StreamIdx
))
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)
506 struct PacketList
*self
;
511 /* Packet went unread and no data was given? Drop it and try the next,
513 self
= stream
->Packets
;
514 stream
->Packets
= self
->next
;
516 av_free_packet(&self
->pkt
);
522 size
= AVCODEC_MAX_AUDIO_FRAME_SIZE
;
528 if(len
< stream
->Packets
->pkt
.size
)
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
],
534 memset(&stream
->Packets
->pkt
.data
[remaining
], 0,
535 stream
->Packets
->pkt
.size
- remaining
);
536 stream
->Packets
->pkt
.size
-= len
;
540 struct PacketList
*self
;
542 self
= stream
->Packets
;
543 stream
->Packets
= self
->next
;
545 av_free_packet(&self
->pkt
);
552 /* Set the output buffer size */
553 stream
->DecodedDataSize
= size
;
554 if(length
) *length
= stream
->DecodedDataSize
;
556 return stream
->DecodedData
;
559 size_t readAVAudioData(StreamPtr stream
, void *data
, size_t length
)
563 if(!stream
|| stream
->CodecCtx
->codec_type
!= AVMEDIA_TYPE_AUDIO
)
568 /* If there's no decoded data, find some */
569 if(stream
->DecodedDataSize
== 0)
571 if(getAVAudioData(stream
, NULL
) == NULL
)
575 if(stream
->DecodedDataSize
> 0)
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
;
583 /* Copy the data to the app's buffer and increment */
586 memcpy(data
, stream
->DecodedData
, rem
);
587 data
= (char*)data
+ rem
;
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
;
600 /* Return the number of bytes we were able to get */
604 void *decodeAVAudioStream(StreamPtr stream
, size_t *length
)
612 if(!stream
|| stream
->CodecCtx
->codec_type
!= AVMEDIA_TYPE_AUDIO
)
615 while((inbuf
=getAVAudioData(stream
, &got
)) != NULL
&& got
> 0)
619 ptr
= realloc(outbuf
, NextPowerOf2(buflen
+got
));
624 memcpy(&outbuf
[buflen
], inbuf
, got
);
627 outbuf
= (char*)realloc(outbuf
, buflen
);