| /* |
| * BeOS audio play interface |
| * Copyright (c) 2000, 2001 Fabrice Bellard |
| * |
| * This file is part of FFmpeg. |
| * |
| * FFmpeg is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * FFmpeg is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with FFmpeg; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
| */ |
| |
| #include <signal.h> |
| #include <stdlib.h> |
| #include <stdio.h> |
| #include <string.h> |
| #include <unistd.h> |
| #include <sys/time.h> |
| |
| #include <Application.h> |
| #include <SoundPlayer.h> |
| |
| extern "C" { |
| #include "libavformat/avformat.h" |
| } |
| |
| #if HAVE_BSOUNDRECORDER |
| #include <SoundRecorder.h> |
| using namespace BPrivate::Media::Experimental; |
| #endif |
| |
| /* enable performance checks */ |
| //#define PERF_CHECK |
| |
| /* enable Media Kit latency checks */ |
| //#define LATENCY_CHECK |
| |
| #define AUDIO_BLOCK_SIZE 4096 |
| #define AUDIO_BLOCK_COUNT 8 |
| |
| #define AUDIO_BUFFER_SIZE (AUDIO_BLOCK_SIZE*AUDIO_BLOCK_COUNT) |
| |
| typedef struct { |
| int fd; // UNUSED |
| int sample_rate; |
| int channels; |
| int frame_size; /* in bytes ! */ |
| CodecID codec_id; |
| uint8_t buffer[AUDIO_BUFFER_SIZE]; |
| int buffer_ptr; |
| /* ring buffer */ |
| sem_id input_sem; |
| int input_index; |
| sem_id output_sem; |
| int output_index; |
| BSoundPlayer *player; |
| #if HAVE_BSOUNDRECORDER |
| BSoundRecorder *recorder; |
| #endif |
| int has_quit; /* signal callbacks not to wait */ |
| volatile bigtime_t starve_time; |
| } AudioData; |
| |
| static thread_id main_thid; |
| static thread_id bapp_thid; |
| static int own_BApp_created = 0; |
| static int refcount = 0; |
| |
| /* create the BApplication and Run() it */ |
| static int32 bapp_thread(void *arg) |
| { |
| new BApplication("application/x-vnd.ffmpeg"); |
| own_BApp_created = 1; |
| be_app->Run(); |
| /* kill the process group */ |
| // kill(0, SIGINT); |
| // kill(main_thid, SIGHUP); |
| return B_OK; |
| } |
| |
| /* create the BApplication only if needed */ |
| static void create_bapp_if_needed(void) |
| { |
| if (refcount++ == 0) { |
| /* needed by libmedia */ |
| if (be_app == NULL) { |
| bapp_thid = spawn_thread(bapp_thread, "ffmpeg BApplication", B_NORMAL_PRIORITY, NULL); |
| resume_thread(bapp_thid); |
| while (!own_BApp_created) |
| snooze(50000); |
| } |
| } |
| } |
| |
| static void destroy_bapp_if_needed(void) |
| { |
| if (--refcount == 0 && own_BApp_created) { |
| be_app->Lock(); |
| be_app->Quit(); |
| be_app = NULL; |
| } |
| } |
| |
| /* called back by BSoundPlayer */ |
| static void audioplay_callback(void *cookie, void *buffer, size_t bufferSize, const media_raw_audio_format &format) |
| { |
| AudioData *s; |
| size_t len, amount; |
| unsigned char *buf = (unsigned char *)buffer; |
| |
| s = (AudioData *)cookie; |
| if (s->has_quit) |
| return; |
| while (bufferSize > 0) { |
| #ifdef PERF_CHECK |
| bigtime_t t; |
| t = system_time(); |
| #endif |
| len = MIN(AUDIO_BLOCK_SIZE, bufferSize); |
| if (acquire_sem_etc(s->output_sem, len, B_CAN_INTERRUPT, 0LL) < B_OK) { |
| s->has_quit = 1; |
| s->player->SetHasData(false); |
| return; |
| } |
| amount = MIN(len, (AUDIO_BUFFER_SIZE - s->output_index)); |
| memcpy(buf, &s->buffer[s->output_index], amount); |
| s->output_index += amount; |
| if (s->output_index >= AUDIO_BUFFER_SIZE) { |
| s->output_index %= AUDIO_BUFFER_SIZE; |
| memcpy(buf + amount, &s->buffer[s->output_index], len - amount); |
| s->output_index += len-amount; |
| s->output_index %= AUDIO_BUFFER_SIZE; |
| } |
| release_sem_etc(s->input_sem, len, 0); |
| #ifdef PERF_CHECK |
| t = system_time() - t; |
| s->starve_time = MAX(s->starve_time, t); |
| #endif |
| buf += len; |
| bufferSize -= len; |
| } |
| } |
| |
| #if HAVE_BSOUNDRECORDER |
| /* called back by BSoundRecorder */ |
| static void audiorecord_callback(void *cookie, bigtime_t timestamp, void *buffer, size_t bufferSize, const media_multi_audio_format &format) |
| { |
| AudioData *s; |
| size_t len, amount; |
| unsigned char *buf = (unsigned char *)buffer; |
| |
| s = (AudioData *)cookie; |
| if (s->has_quit) |
| return; |
| |
| while (bufferSize > 0) { |
| len = MIN(bufferSize, AUDIO_BLOCK_SIZE); |
| //printf("acquire_sem(input, %d)\n", len); |
| if (acquire_sem_etc(s->input_sem, len, B_CAN_INTERRUPT, 0LL) < B_OK) { |
| s->has_quit = 1; |
| return; |
| } |
| amount = MIN(len, (AUDIO_BUFFER_SIZE - s->input_index)); |
| memcpy(&s->buffer[s->input_index], buf, amount); |
| s->input_index += amount; |
| if (s->input_index >= AUDIO_BUFFER_SIZE) { |
| s->input_index %= AUDIO_BUFFER_SIZE; |
| memcpy(&s->buffer[s->input_index], buf + amount, len - amount); |
| s->input_index += len - amount; |
| } |
| release_sem_etc(s->output_sem, len, 0); |
| //printf("release_sem(output, %d)\n", len); |
| buf += len; |
| bufferSize -= len; |
| } |
| } |
| #endif |
| |
| static int audio_open(AudioData *s, int is_output, const char *audio_device) |
| { |
| int p[2]; |
| int ret; |
| media_raw_audio_format format; |
| media_multi_audio_format iformat; |
| |
| #if !HAVE_BSOUNDRECORDER |
| if (!is_output) |
| return AVERROR(EIO); /* not for now */ |
| #endif |
| s->input_sem = create_sem(AUDIO_BUFFER_SIZE, "ffmpeg_ringbuffer_input"); |
| if (s->input_sem < B_OK) |
| return AVERROR(EIO); |
| s->output_sem = create_sem(0, "ffmpeg_ringbuffer_output"); |
| if (s->output_sem < B_OK) { |
| delete_sem(s->input_sem); |
| return AVERROR(EIO); |
| } |
| s->input_index = 0; |
| s->output_index = 0; |
| create_bapp_if_needed(); |
| s->frame_size = AUDIO_BLOCK_SIZE; |
| /* bump up the priority (avoid realtime though) */ |
| set_thread_priority(find_thread(NULL), B_DISPLAY_PRIORITY+1); |
| #if HAVE_BSOUNDRECORDER |
| if (!is_output) { |
| bool wait_for_input = false; |
| if (audio_device && !strcmp(audio_device, "wait:")) |
| wait_for_input = true; |
| s->recorder = new BSoundRecorder(&iformat, wait_for_input, "ffmpeg input", audiorecord_callback); |
| if (wait_for_input && (s->recorder->InitCheck() == B_OK)) { |
| s->recorder->WaitForIncomingConnection(&iformat); |
| } |
| if (s->recorder->InitCheck() != B_OK || iformat.format != media_raw_audio_format::B_AUDIO_SHORT) { |
| delete s->recorder; |
| s->recorder = NULL; |
| if (s->input_sem) |
| delete_sem(s->input_sem); |
| if (s->output_sem) |
| delete_sem(s->output_sem); |
| return AVERROR(EIO); |
| } |
| s->codec_id = (iformat.byte_order == B_MEDIA_LITTLE_ENDIAN)?CODEC_ID_PCM_S16LE:CODEC_ID_PCM_S16BE; |
| s->channels = iformat.channel_count; |
| s->sample_rate = (int)iformat.frame_rate; |
| s->frame_size = iformat.buffer_size; |
| s->recorder->SetCookie(s); |
| s->recorder->SetVolume(1.0); |
| s->recorder->Start(); |
| return 0; |
| } |
| #endif |
| format = media_raw_audio_format::wildcard; |
| format.format = media_raw_audio_format::B_AUDIO_SHORT; |
| format.byte_order = B_HOST_IS_LENDIAN ? B_MEDIA_LITTLE_ENDIAN : B_MEDIA_BIG_ENDIAN; |
| format.channel_count = s->channels; |
| format.buffer_size = s->frame_size; |
| format.frame_rate = s->sample_rate; |
| s->player = new BSoundPlayer(&format, "ffmpeg output", audioplay_callback); |
| if (s->player->InitCheck() != B_OK) { |
| delete s->player; |
| s->player = NULL; |
| if (s->input_sem) |
| delete_sem(s->input_sem); |
| if (s->output_sem) |
| delete_sem(s->output_sem); |
| return AVERROR(EIO); |
| } |
| s->player->SetCookie(s); |
| s->player->SetVolume(1.0); |
| s->player->Start(); |
| s->player->SetHasData(true); |
| return 0; |
| } |
| |
| static int audio_close(AudioData *s) |
| { |
| if (s->input_sem) |
| delete_sem(s->input_sem); |
| if (s->output_sem) |
| delete_sem(s->output_sem); |
| s->has_quit = 1; |
| if (s->player) { |
| s->player->Stop(); |
| } |
| if (s->player) |
| delete s->player; |
| #if HAVE_BSOUNDRECORDER |
| if (s->recorder) |
| delete s->recorder; |
| #endif |
| destroy_bapp_if_needed(); |
| return 0; |
| } |
| |
| /* sound output support */ |
| static int audio_write_header(AVFormatContext *s1) |
| { |
| AudioData *s = (AudioData *)s1->priv_data; |
| AVStream *st; |
| int ret; |
| |
| st = s1->streams[0]; |
| s->sample_rate = st->codec->sample_rate; |
| s->channels = st->codec->channels; |
| ret = audio_open(s, 1, NULL); |
| if (ret < 0) |
| return AVERROR(EIO); |
| return 0; |
| } |
| |
| static int audio_write_packet(AVFormatContext *s1, int stream_index, |
| const uint8_t *buf, int size, int64_t force_pts) |
| { |
| AudioData *s = (AudioData *)s1->priv_data; |
| int len, ret; |
| #ifdef LATENCY_CHECK |
| bigtime_t lat1, lat2; |
| lat1 = s->player->Latency(); |
| #endif |
| #ifdef PERF_CHECK |
| bigtime_t t = s->starve_time; |
| s->starve_time = 0; |
| printf("starve_time: %lld \n", t); |
| #endif |
| while (size > 0) { |
| int amount; |
| len = MIN(size, AUDIO_BLOCK_SIZE); |
| if (acquire_sem_etc(s->input_sem, len, B_CAN_INTERRUPT, 0LL) < B_OK) |
| return AVERROR(EIO); |
| amount = MIN(len, (AUDIO_BUFFER_SIZE - s->input_index)); |
| memcpy(&s->buffer[s->input_index], buf, amount); |
| s->input_index += amount; |
| if (s->input_index >= AUDIO_BUFFER_SIZE) { |
| s->input_index %= AUDIO_BUFFER_SIZE; |
| memcpy(&s->buffer[s->input_index], buf + amount, len - amount); |
| s->input_index += len - amount; |
| } |
| release_sem_etc(s->output_sem, len, 0); |
| buf += len; |
| size -= len; |
| } |
| #ifdef LATENCY_CHECK |
| lat2 = s->player->Latency(); |
| printf("#### BSoundPlayer::Latency(): before= %lld, after= %lld\n", lat1, lat2); |
| #endif |
| return 0; |
| } |
| |
| static int audio_write_trailer(AVFormatContext *s1) |
| { |
| AudioData *s = (AudioData *)s1->priv_data; |
| |
| audio_close(s); |
| return 0; |
| } |
| |
| /* grab support */ |
| |
| static int audio_read_header(AVFormatContext *s1, AVFormatParameters *ap) |
| { |
| AudioData *s = (AudioData *)s1->priv_data; |
| AVStream *st; |
| int ret; |
| |
| if (!ap || ap->sample_rate <= 0 || ap->channels <= 0) |
| return -1; |
| |
| st = av_new_stream(s1, 0); |
| if (!st) { |
| return AVERROR(ENOMEM); |
| } |
| s->sample_rate = ap->sample_rate; |
| s->channels = ap->channels; |
| |
| ret = audio_open(s, 0, s1->filename); |
| if (ret < 0) { |
| av_free(st); |
| return AVERROR(EIO); |
| } |
| /* take real parameters */ |
| st->codec->codec_type = CODEC_TYPE_AUDIO; |
| st->codec->codec_id = s->codec_id; |
| st->codec->sample_rate = s->sample_rate; |
| st->codec->channels = s->channels; |
| return 0; |
| av_set_pts_info(s1, 48, 1, 1000000); /* 48 bits pts in us */ |
| } |
| |
| static int audio_read_packet(AVFormatContext *s1, AVPacket *pkt) |
| { |
| AudioData *s = (AudioData *)s1->priv_data; |
| int size; |
| size_t len, amount; |
| unsigned char *buf; |
| status_t err; |
| |
| if (av_new_packet(pkt, s->frame_size) < 0) |
| return AVERROR(EIO); |
| buf = (unsigned char *)pkt->data; |
| size = pkt->size; |
| while (size > 0) { |
| len = MIN(AUDIO_BLOCK_SIZE, size); |
| //printf("acquire_sem(output, %d)\n", len); |
| while ((err=acquire_sem_etc(s->output_sem, len, B_CAN_INTERRUPT, 0LL)) == B_INTERRUPTED); |
| if (err < B_OK) { |
| av_free_packet(pkt); |
| return AVERROR(EIO); |
| } |
| amount = MIN(len, (AUDIO_BUFFER_SIZE - s->output_index)); |
| memcpy(buf, &s->buffer[s->output_index], amount); |
| s->output_index += amount; |
| if (s->output_index >= AUDIO_BUFFER_SIZE) { |
| s->output_index %= AUDIO_BUFFER_SIZE; |
| memcpy(buf + amount, &s->buffer[s->output_index], len - amount); |
| s->output_index += len-amount; |
| s->output_index %= AUDIO_BUFFER_SIZE; |
| } |
| release_sem_etc(s->input_sem, len, 0); |
| //printf("release_sem(input, %d)\n", len); |
| buf += len; |
| size -= len; |
| } |
| //XXX: add pts info |
| return 0; |
| } |
| |
| static int audio_read_close(AVFormatContext *s1) |
| { |
| AudioData *s = (AudioData *)s1->priv_data; |
| |
| audio_close(s); |
| return 0; |
| } |
| |
| static AVInputFormat audio_beos_demuxer = { |
| "audio_beos", |
| NULL_IF_CONFIG_SMALL("audio grab and output"), |
| sizeof(AudioData), |
| NULL, |
| audio_read_header, |
| audio_read_packet, |
| audio_read_close, |
| NULL, |
| AVFMT_NOFILE, |
| }; |
| |
| AVOutputFormat audio_beos_muxer = { |
| "audio_beos", |
| NULL_IF_CONFIG_SMALL("audio grab and output"), |
| "", |
| "", |
| sizeof(AudioData), |
| #ifdef WORDS_BIGENDIAN |
| CODEC_ID_PCM_S16BE, |
| #else |
| CODEC_ID_PCM_S16LE, |
| #endif |
| CODEC_ID_NONE, |
| audio_write_header, |
| audio_write_packet, |
| audio_write_trailer, |
| AVFMT_NOFILE, |
| }; |
| |
| extern "C" { |
| |
| int audio_init(void) |
| { |
| main_thid = find_thread(NULL); |
| av_register_input_format(&audio_beos_demuxer); |
| av_register_output_format(&audio_beos_muxer); |
| return 0; |
| } |
| |
| } // "C" |
| |