fix demuxing of XviD_with_3_AAC-HE_audio_streams.avi
[ffmpeg.git] / libavformat / beosaudio.cpp
1 /*
2  * BeOS audio play interface
3  * Copyright (c) 2000, 2001 Fabrice Bellard.
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Lesser General Public
7  * License as published by the Free Software Foundation; either
8  * version 2 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public
16  * License along with this library; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18  */
19
20 #include <signal.h>
21 #include <stdlib.h>
22 #include <stdio.h>
23 #include <string.h>
24 #include <unistd.h>
25 #include <sys/time.h>
26
27 #include <Application.h>
28 #include <SoundPlayer.h>
29
30 extern "C" {
31 #include "avformat.h"
32 }
33
34 #ifdef HAVE_BSOUNDRECORDER
35 #include <SoundRecorder.h>
36 using namespace BPrivate::Media::Experimental;
37 #endif
38
39 /* enable performance checks */
40 //#define PERF_CHECK
41
42 /* enable Media Kit latency checks */
43 //#define LATENCY_CHECK
44
45 #define AUDIO_BLOCK_SIZE 4096
46 #define AUDIO_BLOCK_COUNT 8
47
48 #define AUDIO_BUFFER_SIZE (AUDIO_BLOCK_SIZE*AUDIO_BLOCK_COUNT)
49
50 typedef struct {
51     int fd; // UNUSED
52     int sample_rate;
53     int channels;
54     int frame_size; /* in bytes ! */
55     CodecID codec_id;
56     uint8_t buffer[AUDIO_BUFFER_SIZE];
57     int buffer_ptr;
58     /* ring buffer */
59     sem_id input_sem;
60     int input_index;
61     sem_id output_sem;
62     int output_index;
63     BSoundPlayer *player;
64 #ifdef HAVE_BSOUNDRECORDER
65     BSoundRecorder *recorder;
66 #endif
67     int has_quit; /* signal callbacks not to wait */
68     volatile bigtime_t starve_time;
69 } AudioData;
70
71 static thread_id main_thid;
72 static thread_id bapp_thid;
73 static int own_BApp_created = 0;
74 static int refcount = 0;
75
76 /* create the BApplication and Run() it */
77 static int32 bapp_thread(void *arg)
78 {
79     new BApplication("application/x-vnd.ffmpeg");
80     own_BApp_created = 1;
81     be_app->Run();
82     /* kill the process group */
83 //    kill(0, SIGINT);
84 //    kill(main_thid, SIGHUP);
85     return B_OK;
86 }
87
88 /* create the BApplication only if needed */
89 static void create_bapp_if_needed(void)
90 {
91     if (refcount++ == 0) {
92         /* needed by libmedia */
93         if (be_app == NULL) {
94             bapp_thid = spawn_thread(bapp_thread, "ffmpeg BApplication", B_NORMAL_PRIORITY, NULL);
95             resume_thread(bapp_thid);
96             while (!own_BApp_created)
97                 snooze(50000);
98         }
99     }
100 }
101
102 static void destroy_bapp_if_needed(void)
103 {
104     if (--refcount == 0 && own_BApp_created) {
105         be_app->Lock();
106         be_app->Quit();
107         be_app = NULL;
108     }
109 }
110
111 /* called back by BSoundPlayer */
112 static void audioplay_callback(void *cookie, void *buffer, size_t bufferSize, const media_raw_audio_format &format)
113 {
114     AudioData *s;
115     size_t len, amount;
116     unsigned char *buf = (unsigned char *)buffer;
117
118     s = (AudioData *)cookie;
119     if (s->has_quit)
120         return;
121     while (bufferSize > 0) {
122 #ifdef PERF_CHECK
123         bigtime_t t;
124         t = system_time();
125 #endif
126         len = MIN(AUDIO_BLOCK_SIZE, bufferSize);
127         if (acquire_sem_etc(s->output_sem, len, B_CAN_INTERRUPT, 0LL) < B_OK) {
128             s->has_quit = 1;
129             s->player->SetHasData(false);
130             return;
131         }
132         amount = MIN(len, (AUDIO_BUFFER_SIZE - s->output_index));
133         memcpy(buf, &s->buffer[s->output_index], amount);
134         s->output_index += amount;
135         if (s->output_index >= AUDIO_BUFFER_SIZE) {
136             s->output_index %= AUDIO_BUFFER_SIZE;
137             memcpy(buf + amount, &s->buffer[s->output_index], len - amount);
138             s->output_index += len-amount;
139             s->output_index %= AUDIO_BUFFER_SIZE;
140         }
141         release_sem_etc(s->input_sem, len, 0);
142 #ifdef PERF_CHECK
143         t = system_time() - t;
144         s->starve_time = MAX(s->starve_time, t);
145 #endif
146         buf += len;
147         bufferSize -= len;
148     }
149 }
150
151 #ifdef HAVE_BSOUNDRECORDER
152 /* called back by BSoundRecorder */
153 static void audiorecord_callback(void *cookie, bigtime_t timestamp, void *buffer, size_t bufferSize, const media_multi_audio_format &format)
154 {
155     AudioData *s;
156     size_t len, amount;
157     unsigned char *buf = (unsigned char *)buffer;
158
159     s = (AudioData *)cookie;
160     if (s->has_quit)
161         return;
162
163     while (bufferSize > 0) {
164         len = MIN(bufferSize, AUDIO_BLOCK_SIZE);
165         //printf("acquire_sem(input, %d)\n", len);
166         if (acquire_sem_etc(s->input_sem, len, B_CAN_INTERRUPT, 0LL) < B_OK) {
167             s->has_quit = 1;
168             return;
169         }
170         amount = MIN(len, (AUDIO_BUFFER_SIZE - s->input_index));
171         memcpy(&s->buffer[s->input_index], buf, amount);
172         s->input_index += amount;
173         if (s->input_index >= AUDIO_BUFFER_SIZE) {
174             s->input_index %= AUDIO_BUFFER_SIZE;
175             memcpy(&s->buffer[s->input_index], buf + amount, len - amount);
176             s->input_index += len - amount;
177         }
178         release_sem_etc(s->output_sem, len, 0);
179         //printf("release_sem(output, %d)\n", len);
180         buf += len;
181         bufferSize -= len;
182     }
183 }
184 #endif
185
186 static int audio_open(AudioData *s, int is_output, const char *audio_device)
187 {
188     int p[2];
189     int ret;
190     media_raw_audio_format format;
191     media_multi_audio_format iformat;
192
193 #ifndef HAVE_BSOUNDRECORDER
194     if (!is_output)
195         return -EIO; /* not for now */
196 #endif
197     s->input_sem = create_sem(AUDIO_BUFFER_SIZE, "ffmpeg_ringbuffer_input");
198     if (s->input_sem < B_OK)
199         return -EIO;
200     s->output_sem = create_sem(0, "ffmpeg_ringbuffer_output");
201     if (s->output_sem < B_OK) {
202         delete_sem(s->input_sem);
203         return -EIO;
204     }
205     s->input_index = 0;
206     s->output_index = 0;
207     create_bapp_if_needed();
208     s->frame_size = AUDIO_BLOCK_SIZE;
209     /* bump up the priority (avoid realtime though) */
210     set_thread_priority(find_thread(NULL), B_DISPLAY_PRIORITY+1);
211 #ifdef HAVE_BSOUNDRECORDER
212     if (!is_output) {
213         bool wait_for_input = false;
214         if (audio_device && !strcmp(audio_device, "wait:"))
215             wait_for_input = true;
216         s->recorder = new BSoundRecorder(&iformat, wait_for_input, "ffmpeg input", audiorecord_callback);
217         if (wait_for_input && (s->recorder->InitCheck() == B_OK)) {
218             s->recorder->WaitForIncomingConnection(&iformat);
219         }
220         if (s->recorder->InitCheck() != B_OK || iformat.format != media_raw_audio_format::B_AUDIO_SHORT) {
221             delete s->recorder;
222             s->recorder = NULL;
223             if (s->input_sem)
224                 delete_sem(s->input_sem);
225             if (s->output_sem)
226                 delete_sem(s->output_sem);
227             return -EIO;
228         }
229         s->codec_id = (iformat.byte_order == B_MEDIA_LITTLE_ENDIAN)?CODEC_ID_PCM_S16LE:CODEC_ID_PCM_S16BE;
230         s->channels = iformat.channel_count;
231         s->sample_rate = (int)iformat.frame_rate;
232         s->frame_size = iformat.buffer_size;
233         s->recorder->SetCookie(s);
234         s->recorder->SetVolume(1.0);
235         s->recorder->Start();
236         return 0;
237     }
238 #endif
239     format = media_raw_audio_format::wildcard;
240     format.format = media_raw_audio_format::B_AUDIO_SHORT;
241     format.byte_order = B_HOST_IS_LENDIAN ? B_MEDIA_LITTLE_ENDIAN : B_MEDIA_BIG_ENDIAN;
242     format.channel_count = s->channels;
243     format.buffer_size = s->frame_size;
244     format.frame_rate = s->sample_rate;
245     s->player = new BSoundPlayer(&format, "ffmpeg output", audioplay_callback);
246     if (s->player->InitCheck() != B_OK) {
247         delete s->player;
248         s->player = NULL;
249         if (s->input_sem)
250             delete_sem(s->input_sem);
251         if (s->output_sem)
252             delete_sem(s->output_sem);
253         return -EIO;
254     }
255     s->player->SetCookie(s);
256     s->player->SetVolume(1.0);
257     s->player->Start();
258     s->player->SetHasData(true);
259     return 0;
260 }
261
262 static int audio_close(AudioData *s)
263 {
264     if (s->input_sem)
265         delete_sem(s->input_sem);
266     if (s->output_sem)
267         delete_sem(s->output_sem);
268     s->has_quit = 1;
269     if (s->player) {
270         s->player->Stop();
271     }
272     if (s->player)
273         delete s->player;
274 #ifdef HAVE_BSOUNDRECORDER
275     if (s->recorder)
276         delete s->recorder;
277 #endif
278     destroy_bapp_if_needed();
279     return 0;
280 }
281
282 /* sound output support */
283 static int audio_write_header(AVFormatContext *s1)
284 {
285     AudioData *s = (AudioData *)s1->priv_data;
286     AVStream *st;
287     int ret;
288
289     st = s1->streams[0];
290     s->sample_rate = st->codec->sample_rate;
291     s->channels = st->codec->channels;
292     ret = audio_open(s, 1, NULL);
293     if (ret < 0)
294         return -EIO;
295     return 0;
296 }
297
298 static int audio_write_packet(AVFormatContext *s1, int stream_index,
299                               const uint8_t *buf, int size, int64_t force_pts)
300 {
301     AudioData *s = (AudioData *)s1->priv_data;
302     int len, ret;
303 #ifdef LATENCY_CHECK
304 bigtime_t lat1, lat2;
305 lat1 = s->player->Latency();
306 #endif
307 #ifdef PERF_CHECK
308     bigtime_t t = s->starve_time;
309     s->starve_time = 0;
310     printf("starve_time: %lld    \n", t);
311 #endif
312     while (size > 0) {
313         int amount;
314         len = MIN(size, AUDIO_BLOCK_SIZE);
315         if (acquire_sem_etc(s->input_sem, len, B_CAN_INTERRUPT, 0LL) < B_OK)
316             return -EIO;
317         amount = MIN(len, (AUDIO_BUFFER_SIZE - s->input_index));
318         memcpy(&s->buffer[s->input_index], buf, amount);
319         s->input_index += amount;
320         if (s->input_index >= AUDIO_BUFFER_SIZE) {
321             s->input_index %= AUDIO_BUFFER_SIZE;
322             memcpy(&s->buffer[s->input_index], buf + amount, len - amount);
323             s->input_index += len - amount;
324         }
325         release_sem_etc(s->output_sem, len, 0);
326         buf += len;
327         size -= len;
328     }
329 #ifdef LATENCY_CHECK
330 lat2 = s->player->Latency();
331 printf("#### BSoundPlayer::Latency(): before= %lld, after= %lld\n", lat1, lat2);
332 #endif
333     return 0;
334 }
335
336 static int audio_write_trailer(AVFormatContext *s1)
337 {
338     AudioData *s = (AudioData *)s1->priv_data;
339
340     audio_close(s);
341     return 0;
342 }
343
344 /* grab support */
345
346 static int audio_read_header(AVFormatContext *s1, AVFormatParameters *ap)
347 {
348     AudioData *s = (AudioData *)s1->priv_data;
349     AVStream *st;
350     int ret;
351
352     if (!ap || ap->sample_rate <= 0 || ap->channels <= 0)
353         return -1;
354
355     st = av_new_stream(s1, 0);
356     if (!st) {
357         return -ENOMEM;
358     }
359     s->sample_rate = ap->sample_rate;
360     s->channels = ap->channels;
361
362     ret = audio_open(s, 0, ap->device);
363     if (ret < 0) {
364         av_free(st);
365         return -EIO;
366     }
367     /* take real parameters */
368     st->codec->codec_type = CODEC_TYPE_AUDIO;
369     st->codec->codec_id = s->codec_id;
370     st->codec->sample_rate = s->sample_rate;
371     st->codec->channels = s->channels;
372     return 0;
373     av_set_pts_info(s1, 48, 1, 1000000);  /* 48 bits pts in us */
374 }
375
376 static int audio_read_packet(AVFormatContext *s1, AVPacket *pkt)
377 {
378     AudioData *s = (AudioData *)s1->priv_data;
379     int size;
380     size_t len, amount;
381     unsigned char *buf;
382     status_t err;
383
384     if (av_new_packet(pkt, s->frame_size) < 0)
385         return -EIO;
386     buf = (unsigned char *)pkt->data;
387     size = pkt->size;
388     while (size > 0) {
389         len = MIN(AUDIO_BLOCK_SIZE, size);
390         //printf("acquire_sem(output, %d)\n", len);
391         while ((err=acquire_sem_etc(s->output_sem, len, B_CAN_INTERRUPT, 0LL)) == B_INTERRUPTED);
392         if (err < B_OK) {
393             av_free_packet(pkt);
394             return -EIO;
395         }
396         amount = MIN(len, (AUDIO_BUFFER_SIZE - s->output_index));
397         memcpy(buf, &s->buffer[s->output_index], amount);
398         s->output_index += amount;
399         if (s->output_index >= AUDIO_BUFFER_SIZE) {
400             s->output_index %= AUDIO_BUFFER_SIZE;
401             memcpy(buf + amount, &s->buffer[s->output_index], len - amount);
402             s->output_index += len-amount;
403             s->output_index %= AUDIO_BUFFER_SIZE;
404         }
405         release_sem_etc(s->input_sem, len, 0);
406         //printf("release_sem(input, %d)\n", len);
407         buf += len;
408         size -= len;
409     }
410     //XXX: add pts info
411     return 0;
412 }
413
414 static int audio_read_close(AVFormatContext *s1)
415 {
416     AudioData *s = (AudioData *)s1->priv_data;
417
418     audio_close(s);
419     return 0;
420 }
421
422 static AVInputFormat audio_in_format = {
423     "audio_device",
424     "audio grab and output",
425     sizeof(AudioData),
426     NULL,
427     audio_read_header,
428     audio_read_packet,
429     audio_read_close,
430     NULL,
431     AVFMT_NOFILE,
432 };
433
434 AVOutputFormat audio_out_format = {
435     "audio_device",
436     "audio grab and output",
437     "",
438     "",
439     sizeof(AudioData),
440 #ifdef WORDS_BIGENDIAN
441     CODEC_ID_PCM_S16BE,
442 #else
443     CODEC_ID_PCM_S16LE,
444 #endif
445     CODEC_ID_NONE,
446     audio_write_header,
447     audio_write_packet,
448     audio_write_trailer,
449     AVFMT_NOFILE,
450 };
451
452 extern "C" {
453
454 int audio_init(void)
455 {
456     main_thid = find_thread(NULL);
457     av_register_input_format(&audio_in_format);
458     av_register_output_format(&audio_out_format);
459     return 0;
460 }
461
462 } // "C"
463