Update to MPlayer SVN rev 29473 and FFmpeg SVN rev 19572.
[vaapi:athaifas-mplayer.git] / libao2 / ao_oss.c
1 /*
2  * OSS audio output driver
3  *
4  * This file is part of MPlayer.
5  *
6  * MPlayer is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * MPlayer is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License along
17  * with MPlayer; if not, write to the Free Software Foundation, Inc.,
18  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
19  */
20
21 #include <stdio.h>
22 #include <stdlib.h>
23
24 #include <sys/ioctl.h>
25 #include <unistd.h>
26 #include <sys/time.h>
27 #include <sys/types.h>
28 #include <sys/stat.h>
29 #include <fcntl.h>
30 #include <errno.h>
31 #include <string.h>
32
33 #include "config.h"
34 #include "mp_msg.h"
35 #include "mixer.h"
36 #include "help_mp.h"
37
38 #ifdef HAVE_SYS_SOUNDCARD_H
39 #include <sys/soundcard.h>
40 #else
41 #ifdef HAVE_SOUNDCARD_H
42 #include <soundcard.h>
43 #endif
44 #endif
45
46 #include "libaf/af_format.h"
47
48 #include "audio_out.h"
49 #include "audio_out_internal.h"
50
51 static const ao_info_t info =
52 {
53         "OSS/ioctl audio output",
54         "oss",
55         "A'rpi",
56         ""
57 };
58
59 /* Support for >2 output channels added 2001-11-25 - Steve Davies <steve@daviesfam.org> */
60
61 LIBAO_EXTERN(oss)
62
63 static int format2oss(int format)
64 {
65     switch(format)
66     {
67     case AF_FORMAT_U8: return AFMT_U8;
68     case AF_FORMAT_S8: return AFMT_S8;
69     case AF_FORMAT_U16_LE: return AFMT_U16_LE;
70     case AF_FORMAT_U16_BE: return AFMT_U16_BE;
71     case AF_FORMAT_S16_LE: return AFMT_S16_LE;
72     case AF_FORMAT_S16_BE: return AFMT_S16_BE;
73 #ifdef AFMT_S24_PACKED
74     case AF_FORMAT_S24_LE: return AFMT_S24_PACKED;
75 #endif
76 #ifdef AFMT_U32_LE
77     case AF_FORMAT_U32_LE: return AFMT_U32_LE;
78 #endif
79 #ifdef AFMT_U32_BE
80     case AF_FORMAT_U32_BE: return AFMT_U32_BE;
81 #endif
82 #ifdef AFMT_S32_LE
83     case AF_FORMAT_S32_LE: return AFMT_S32_LE;
84 #endif
85 #ifdef AFMT_S32_BE
86     case AF_FORMAT_S32_BE: return AFMT_S32_BE;
87 #endif
88 #ifdef AFMT_FLOAT
89     case AF_FORMAT_FLOAT_NE: return AFMT_FLOAT;
90 #endif
91     // SPECIALS
92     case AF_FORMAT_MU_LAW: return AFMT_MU_LAW;
93     case AF_FORMAT_A_LAW: return AFMT_A_LAW;
94     case AF_FORMAT_IMA_ADPCM: return AFMT_IMA_ADPCM;
95 #ifdef AFMT_MPEG
96     case AF_FORMAT_MPEG2: return AFMT_MPEG;
97 #endif
98 #ifdef AFMT_AC3
99     case AF_FORMAT_AC3: return AFMT_AC3;
100 #endif
101     }
102     mp_msg(MSGT_AO, MSGL_V, "OSS: Unknown/not supported internal format: %s\n", af_fmt2str_short(format));
103     return -1;
104 }
105
106 static int oss2format(int format)
107 {
108     switch(format)
109     {
110     case AFMT_U8: return AF_FORMAT_U8;
111     case AFMT_S8: return AF_FORMAT_S8;
112     case AFMT_U16_LE: return AF_FORMAT_U16_LE;
113     case AFMT_U16_BE: return AF_FORMAT_U16_BE;
114     case AFMT_S16_LE: return AF_FORMAT_S16_LE;
115     case AFMT_S16_BE: return AF_FORMAT_S16_BE;
116 #ifdef AFMT_S24_PACKED
117     case AFMT_S24_PACKED: return AF_FORMAT_S24_LE;
118 #endif
119 #ifdef AFMT_U32_LE
120     case AFMT_U32_LE: return AF_FORMAT_U32_LE;
121 #endif
122 #ifdef AFMT_U32_BE
123     case AFMT_U32_BE: return AF_FORMAT_U32_BE;
124 #endif
125 #ifdef AFMT_S32_LE
126     case AFMT_S32_LE: return AF_FORMAT_S32_LE;
127 #endif
128 #ifdef AFMT_S32_BE
129     case AFMT_S32_BE: return AF_FORMAT_S32_BE;
130 #endif
131 #ifdef AFMT_FLOAT
132     case AFMT_FLOAT: return AF_FORMAT_FLOAT_NE;
133 #endif
134     // SPECIALS
135     case AFMT_MU_LAW: return AF_FORMAT_MU_LAW;
136     case AFMT_A_LAW: return AF_FORMAT_A_LAW;
137     case AFMT_IMA_ADPCM: return AF_FORMAT_IMA_ADPCM;
138 #ifdef AFMT_MPEG
139     case AFMT_MPEG: return AF_FORMAT_MPEG2;
140 #endif
141 #ifdef AFMT_AC3
142     case AFMT_AC3: return AF_FORMAT_AC3;
143 #endif
144     }
145     mp_msg(MSGT_GLOBAL,MSGL_ERR,MSGTR_AO_OSS_UnknownUnsupportedFormat, format);
146     return -1;
147 }
148
149 static char *dsp=PATH_DEV_DSP;
150 static audio_buf_info zz;
151 static int audio_fd=-1;
152 static int prepause_space;
153
154 static const char *oss_mixer_device = PATH_DEV_MIXER;
155 static int oss_mixer_channel = SOUND_MIXER_PCM;
156
157 // to set/get/query special features/parameters
158 static int control(int cmd,void *arg){
159     switch(cmd){
160         case AOCONTROL_SET_DEVICE:
161             dsp=(char*)arg;
162             return CONTROL_OK;
163         case AOCONTROL_GET_DEVICE:
164             *(char**)arg=dsp;
165             return CONTROL_OK;
166 #ifdef SNDCTL_DSP_GETFMTS
167         case AOCONTROL_QUERY_FORMAT:
168         {
169             int format;
170             if (!ioctl(audio_fd, SNDCTL_DSP_GETFMTS, &format))
171                 if ((unsigned int)format & (unsigned long)arg)
172                     return CONTROL_TRUE;
173             return CONTROL_FALSE;
174         }
175 #endif
176         case AOCONTROL_GET_VOLUME:
177         case AOCONTROL_SET_VOLUME:
178         {
179             ao_control_vol_t *vol = (ao_control_vol_t *)arg;
180             int fd, v, devs;
181
182             if(ao_data.format == AF_FORMAT_AC3)
183                 return CONTROL_TRUE;
184
185             if ((fd = open(oss_mixer_device, O_RDONLY)) > 0)
186             {
187                 ioctl(fd, SOUND_MIXER_READ_DEVMASK, &devs);
188                 if (devs & (1 << oss_mixer_channel))
189                 {
190                     if (cmd == AOCONTROL_GET_VOLUME)
191                     {
192                         ioctl(fd, MIXER_READ(oss_mixer_channel), &v);
193                         vol->right = (v & 0xFF00) >> 8;
194                         vol->left = v & 0x00FF;
195                     }
196                     else
197                     {
198                         v = ((int)vol->right << 8) | (int)vol->left;
199                         ioctl(fd, MIXER_WRITE(oss_mixer_channel), &v);
200                     }
201                 }
202                 else
203                 {
204                     close(fd);
205                     return CONTROL_ERROR;
206                 }
207                 close(fd);
208                 return CONTROL_OK;
209             }
210         }
211         return CONTROL_ERROR;
212     }
213     return CONTROL_UNKNOWN;
214 }
215
216 // open & setup audio device
217 // return: 1=success 0=fail
218 static int init(int rate,int channels,int format,int flags){
219   char *mixer_channels [SOUND_MIXER_NRDEVICES] = SOUND_DEVICE_NAMES;
220   int oss_format;
221   char *mdev = mixer_device, *mchan = mixer_channel;
222
223   mp_msg(MSGT_AO,MSGL_V,"ao2: %d Hz  %d chans  %s\n",rate,channels,
224     af_fmt2str_short(format));
225
226   if (ao_subdevice) {
227     char *m,*c;
228     m = strchr(ao_subdevice,':');
229     if(m) {
230       c = strchr(m+1,':');
231       if(c) {
232         mchan = c+1;
233         c[0] = '\0';
234       }
235       mdev = m+1;
236       m[0] = '\0';
237     }
238     dsp = ao_subdevice;
239   }
240
241   if(mdev)
242     oss_mixer_device=mdev;
243   else
244     oss_mixer_device=PATH_DEV_MIXER;
245
246   if(mchan){
247     int fd, devs, i;
248
249     if ((fd = open(oss_mixer_device, O_RDONLY)) == -1){
250       mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_OSS_CantOpenMixer,
251         oss_mixer_device, strerror(errno));
252     }else{
253       ioctl(fd, SOUND_MIXER_READ_DEVMASK, &devs);
254       close(fd);
255
256       for (i=0; i<SOUND_MIXER_NRDEVICES; i++){
257         if(!strcasecmp(mixer_channels[i], mchan)){
258           if(!(devs & (1 << i))){
259             mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_OSS_ChanNotFound,mchan);
260             i = SOUND_MIXER_NRDEVICES+1;
261             break;
262           }
263           oss_mixer_channel = i;
264           break;
265         }
266       }
267       if(i==SOUND_MIXER_NRDEVICES){
268         mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_OSS_ChanNotFound,mchan);
269       }
270     }
271   } else
272     oss_mixer_channel = SOUND_MIXER_PCM;
273
274   mp_msg(MSGT_AO,MSGL_V,"audio_setup: using '%s' dsp device\n", dsp);
275   mp_msg(MSGT_AO,MSGL_V,"audio_setup: using '%s' mixer device\n", oss_mixer_device);
276   mp_msg(MSGT_AO,MSGL_V,"audio_setup: using '%s' mixer device\n", mixer_channels[oss_mixer_channel]);
277
278 #ifdef __linux__
279   audio_fd=open(dsp, O_WRONLY | O_NONBLOCK);
280 #else
281   audio_fd=open(dsp, O_WRONLY);
282 #endif
283   if(audio_fd<0){
284     mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_OSS_CantOpenDev, dsp, strerror(errno));
285     return 0;
286   }
287
288 #ifdef __linux__
289   /* Remove the non-blocking flag */
290   if(fcntl(audio_fd, F_SETFL, 0) < 0) {
291    mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_OSS_CantMakeFd, strerror(errno));
292    return 0;
293   }
294 #endif
295
296 #if defined(FD_CLOEXEC) && defined(F_SETFD)
297   fcntl(audio_fd, F_SETFD, FD_CLOEXEC);
298 #endif
299
300   if(format == AF_FORMAT_AC3) {
301     ao_data.samplerate=rate;
302     ioctl (audio_fd, SNDCTL_DSP_SPEED, &ao_data.samplerate);
303   }
304
305 ac3_retry:
306   ao_data.format=format;
307   oss_format=format2oss(format);
308   if (oss_format == -1) {
309 #if HAVE_BIGENDIAN
310     oss_format=AFMT_S16_BE;
311 #else
312     oss_format=AFMT_S16_LE;
313 #endif
314     format=AF_FORMAT_S16_NE;
315   }
316   if( ioctl(audio_fd, SNDCTL_DSP_SETFMT, &oss_format)<0 ||
317       oss_format != format2oss(format)) {
318     mp_msg(MSGT_AO,MSGL_WARN, MSGTR_AO_OSS_CantSet, dsp,
319             af_fmt2str_short(format), af_fmt2str_short(AF_FORMAT_S16_NE) );
320     format=AF_FORMAT_S16_NE;
321     goto ac3_retry;
322   }
323 #if 0
324   if(oss_format!=format2oss(format))
325         mp_msg(MSGT_AO,MSGL_WARN,"WARNING! Your soundcard does NOT support %s sample format! Broken audio or bad playback speed are possible! Try with '-af format'\n",audio_out_format_name(format));
326 #endif
327
328   ao_data.format = oss2format(oss_format);
329   if (ao_data.format == -1) return 0;
330
331   mp_msg(MSGT_AO,MSGL_V,"audio_setup: sample format: %s (requested: %s)\n",
332     af_fmt2str_short(ao_data.format), af_fmt2str_short(format));
333
334   ao_data.channels = channels;
335   if(format != AF_FORMAT_AC3) {
336     // We only use SNDCTL_DSP_CHANNELS for >2 channels, in case some drivers don't have it
337     if (ao_data.channels > 2) {
338       if ( ioctl(audio_fd, SNDCTL_DSP_CHANNELS, &ao_data.channels) == -1 ||
339            ao_data.channels != channels ) {
340         mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_OSS_CantSetChans, channels);
341         return 0;
342       }
343     }
344     else {
345       int c = ao_data.channels-1;
346       if (ioctl (audio_fd, SNDCTL_DSP_STEREO, &c) == -1) {
347         mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_OSS_CantSetChans, ao_data.channels);
348         return 0;
349       }
350       ao_data.channels=c+1;
351     }
352     mp_msg(MSGT_AO,MSGL_V,"audio_setup: using %d channels (requested: %d)\n", ao_data.channels, channels);
353     // set rate
354     ao_data.samplerate=rate;
355     ioctl (audio_fd, SNDCTL_DSP_SPEED, &ao_data.samplerate);
356     mp_msg(MSGT_AO,MSGL_V,"audio_setup: using %d Hz samplerate (requested: %d)\n",ao_data.samplerate,rate);
357   }
358
359   if(ioctl(audio_fd, SNDCTL_DSP_GETOSPACE, &zz)==-1){
360       int r=0;
361       mp_msg(MSGT_AO,MSGL_WARN,MSGTR_AO_OSS_CantUseGetospace);
362       if(ioctl(audio_fd, SNDCTL_DSP_GETBLKSIZE, &r)==-1){
363           mp_msg(MSGT_AO,MSGL_V,"audio_setup: %d bytes/frag (config.h)\n",ao_data.outburst);
364       } else {
365           ao_data.outburst=r;
366           mp_msg(MSGT_AO,MSGL_V,"audio_setup: %d bytes/frag (GETBLKSIZE)\n",ao_data.outburst);
367       }
368   } else {
369       mp_msg(MSGT_AO,MSGL_V,"audio_setup: frags: %3d/%d  (%d bytes/frag)  free: %6d\n",
370           zz.fragments, zz.fragstotal, zz.fragsize, zz.bytes);
371       if(ao_data.buffersize==-1) ao_data.buffersize=zz.bytes;
372       ao_data.outburst=zz.fragsize;
373   }
374
375   if(ao_data.buffersize==-1){
376     // Measuring buffer size:
377     void* data;
378     ao_data.buffersize=0;
379 #ifdef HAVE_AUDIO_SELECT
380     data=malloc(ao_data.outburst); memset(data,0,ao_data.outburst);
381     while(ao_data.buffersize<0x40000){
382       fd_set rfds;
383       struct timeval tv;
384       FD_ZERO(&rfds); FD_SET(audio_fd,&rfds);
385       tv.tv_sec=0; tv.tv_usec = 0;
386       if(!select(audio_fd+1, NULL, &rfds, NULL, &tv)) break;
387       write(audio_fd,data,ao_data.outburst);
388       ao_data.buffersize+=ao_data.outburst;
389     }
390     free(data);
391     if(ao_data.buffersize==0){
392         mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_OSS_CantUseSelect);
393         return 0;
394     }
395 #endif
396   }
397
398   ao_data.bps=ao_data.channels;
399   if(ao_data.format != AF_FORMAT_U8 && ao_data.format != AF_FORMAT_S8)
400     ao_data.bps*=2;
401
402   ao_data.outburst-=ao_data.outburst % ao_data.bps; // round down
403   ao_data.bps*=ao_data.samplerate;
404
405     return 1;
406 }
407
408 // close audio device
409 static void uninit(int immed){
410     if(audio_fd == -1) return;
411 #ifdef SNDCTL_DSP_SYNC
412     // to get the buffer played
413     if (!immed)
414         ioctl(audio_fd, SNDCTL_DSP_SYNC, NULL);
415 #endif
416 #ifdef SNDCTL_DSP_RESET
417     if (immed)
418         ioctl(audio_fd, SNDCTL_DSP_RESET, NULL);
419 #endif
420     close(audio_fd);
421     audio_fd = -1;
422 }
423
424 // stop playing and empty buffers (for seeking/pause)
425 static void reset(void){
426   int oss_format;
427     uninit(1);
428     audio_fd=open(dsp, O_WRONLY);
429     if(audio_fd < 0){
430         mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_OSS_CantReopen, strerror(errno));
431         return;
432     }
433
434 #if defined(FD_CLOEXEC) && defined(F_SETFD)
435   fcntl(audio_fd, F_SETFD, FD_CLOEXEC);
436 #endif
437
438   oss_format = format2oss(ao_data.format);
439   if(ao_data.format == AF_FORMAT_AC3)
440     ioctl (audio_fd, SNDCTL_DSP_SPEED, &ao_data.samplerate);
441   ioctl (audio_fd, SNDCTL_DSP_SETFMT, &oss_format);
442   if(ao_data.format != AF_FORMAT_AC3) {
443     if (ao_data.channels > 2)
444       ioctl (audio_fd, SNDCTL_DSP_CHANNELS, &ao_data.channels);
445     else {
446       int c = ao_data.channels-1;
447       ioctl (audio_fd, SNDCTL_DSP_STEREO, &c);
448     }
449     ioctl (audio_fd, SNDCTL_DSP_SPEED, &ao_data.samplerate);
450   }
451 }
452
453 // stop playing, keep buffers (for pause)
454 static void audio_pause(void)
455 {
456     prepause_space = get_space();
457     uninit(1);
458 }
459
460 // resume playing, after audio_pause()
461 static void audio_resume(void)
462 {
463     int fillcnt;
464     reset();
465     fillcnt = get_space() - prepause_space;
466     if (fillcnt > 0 && !(ao_data.format & AF_FORMAT_SPECIAL_MASK)) {
467       void *silence = calloc(fillcnt, 1);
468       play(silence, fillcnt, 0);
469       free(silence);
470     }
471 }
472
473
474 // return: how many bytes can be played without blocking
475 static int get_space(void){
476   int playsize=ao_data.outburst;
477
478 #ifdef SNDCTL_DSP_GETOSPACE
479   if(ioctl(audio_fd, SNDCTL_DSP_GETOSPACE, &zz)!=-1){
480       // calculate exact buffer space:
481       playsize = zz.fragments*zz.fragsize;
482       if (playsize > MAX_OUTBURST)
483         playsize = (MAX_OUTBURST / zz.fragsize) * zz.fragsize;
484       return playsize;
485   }
486 #endif
487
488     // check buffer
489 #ifdef HAVE_AUDIO_SELECT
490     {  fd_set rfds;
491        struct timeval tv;
492        FD_ZERO(&rfds);
493        FD_SET(audio_fd, &rfds);
494        tv.tv_sec = 0;
495        tv.tv_usec = 0;
496        if(!select(audio_fd+1, NULL, &rfds, NULL, &tv)) return 0; // not block!
497     }
498 #endif
499
500   return ao_data.outburst;
501 }
502
503 // plays 'len' bytes of 'data'
504 // it should round it down to outburst*n
505 // return: number of bytes played
506 static int play(void* data,int len,int flags){
507     if(len==0)
508         return len;
509     if(len>ao_data.outburst || !(flags & AOPLAY_FINAL_CHUNK)) {
510         len/=ao_data.outburst;
511         len*=ao_data.outburst;
512     }
513     len=write(audio_fd,data,len);
514     return len;
515 }
516
517 static int audio_delay_method=2;
518
519 // return: delay in seconds between first and last sample in buffer
520 static float get_delay(void){
521   /* Calculate how many bytes/second is sent out */
522   if(audio_delay_method==2){
523 #ifdef SNDCTL_DSP_GETODELAY
524       int r=0;
525       if(ioctl(audio_fd, SNDCTL_DSP_GETODELAY, &r)!=-1)
526          return ((float)r)/(float)ao_data.bps;
527 #endif
528       audio_delay_method=1; // fallback if not supported
529   }
530   if(audio_delay_method==1){
531       // SNDCTL_DSP_GETOSPACE
532       if(ioctl(audio_fd, SNDCTL_DSP_GETOSPACE, &zz)!=-1)
533          return ((float)(ao_data.buffersize-zz.bytes))/(float)ao_data.bps;
534       audio_delay_method=0; // fallback if not supported
535   }
536   return ((float)ao_data.buffersize)/(float)ao_data.bps;
537 }